px4io code style

apps/px4io/adc.c

@@ -87,12 +87,16 @@ adc_init(void)
 #ifdef ADC_CR2_CAL
 	rCR2 |= ADC_CR2_RSTCAL;
 	up_udelay(1);
+
 	if (rCR2 & ADC_CR2_RSTCAL)
 		return -1;
+
 	rCR2 |= ADC_CR2_CAL;
 	up_udelay(100);
+
 	if (rCR2 & ADC_CR2_CAL)
 		return -1;
+
 #endif
 
 	/* arbitrarily configure all channels for 55 cycle sample time */
@@ -146,6 +150,7 @@ adc_measure(unsigned channel)
 
 	/* wait for the conversion to complete */
 	hrt_abstime now = hrt_absolute_time();
+
 	while (!(rSR & ADC_SR_EOC)) {
 
 		/* never spin forever - this will give a bogus result though */

apps/px4io/comms.c

@@ -253,10 +253,12 @@ comms_handle_command(const void *buffer, size_t length)
 	if (new_servo_rate > 500) {
 		new_servo_rate = 500;
 	}
+
 	/* reject slower than 50 Hz updates */
 	if (new_servo_rate < 50) {
 		new_servo_rate = 50;
 	}
+
 	if (system_state.servo_rate != new_servo_rate) {
 		up_pwm_servo_set_rate(new_servo_rate);
 		system_state.servo_rate = new_servo_rate;
@@ -277,17 +279,21 @@ comms_handle_command(const void *buffer, size_t length)
 			case 0:
 				POWER_ACC1(cmd->relay_state[i]);
 				break;
+
 			case 1:
 				POWER_ACC2(cmd->relay_state[i]);
 				break;
+
 			case 2:
 				POWER_RELAY1(cmd->relay_state[i]);
 				break;
+
 			case 3:
 				POWER_RELAY2(cmd->relay_state[i]);
 				break;
 			}
 		}
+
 		system_state.relays[i] = cmd->relay_state[i];
 	}
 

apps/px4io/controls.c

@@ -121,6 +121,7 @@ controls_main(void)
 		if (system_state.rc_channel_data[4] > RC_CHANNEL_HIGH_THRESH) {
 			/* force manual input override */
 			system_state.mixer_manual_override = true;
+
 		} else {
 			/* override not engaged, use FMU */
 			system_state.mixer_manual_override = false;

apps/px4io/safety.c

@@ -159,6 +159,7 @@ safety_check_button(void *arg)
 
 	} else if (system_state.arm_ok) {
 		pattern = LED_PATTERN_FMU_ARMED;
+
 	} else if (system_state.vector_flight_mode_ok) {
 		pattern = LED_PATTERN_VECTOR_FLIGHT_MODE_OK;
 	}

apps/px4io/sbus.c

@@ -88,6 +88,7 @@ sbus_init(const char *device)
 		last_rx_time = hrt_absolute_time();
 
 		debug("S.Bus: ready");
+
 	} else {
 		debug("S.Bus: open failed");
 	}
@@ -117,6 +118,7 @@ sbus_input(void)
 	 * if we didn't drop bytes...
 	 */
 	now = hrt_absolute_time();
+
 	if ((now - last_rx_time) > 3000) {
 		if (partial_frame_count > 0) {
 			sbus_frame_drops++;
@@ -133,6 +135,7 @@ sbus_input(void)
 	/* if the read failed for any reason, just give up here */
 	if (ret < 1)
 		goto out;
+
 	last_rx_time = now;
 
 	/*
@@ -144,7 +147,7 @@ sbus_input(void)
 	 * If we don't have a full frame, return
 	 */
 	if (partial_frame_count < SBUS_FRAME_SIZE)
-	 	goto out;
+		goto out;
 
 	/*
 	 * Great, it looks like we might have a frame.  Go ahead and
@@ -178,22 +181,22 @@ struct sbus_bit_pick {
 	uint8_t lshift;
 };
 static const struct sbus_bit_pick sbus_decoder[SBUS_INPUT_CHANNELS][3] = {
-/*  0 */ { { 0, 0, 0xff, 0},{ 1, 0, 0x07, 8},{ 0, 0, 0x00,  0} },
-/*  1 */ { { 1, 3, 0x1f, 0},{ 2, 0, 0x3f, 5},{ 0, 0, 0x00,  0} },
-/*  2 */ { { 2, 6, 0x03, 0},{ 3, 0, 0xff, 2},{ 4, 0, 0x01, 10} },
-/*  3 */ { { 4, 1, 0x7f, 0},{ 5, 0, 0x0f, 7},{ 0, 0, 0x00,  0} },
-/*  4 */ { { 5, 4, 0x0f, 0},{ 6, 0, 0x7f, 4},{ 0, 0, 0x00,  0} },
-/*  5 */ { { 6, 7, 0x01, 0},{ 7, 0, 0xff, 1},{ 8, 0, 0x03,  9} },
-/*  6 */ { { 8, 2, 0x3f, 0},{ 9, 0, 0x1f, 6},{ 0, 0, 0x00,  0} },
-/*  7 */ { { 9, 5, 0x07, 0},{10, 0, 0xff, 3},{ 0, 0, 0x00,  0} },
-/*  8 */ { {11, 0, 0xff, 0},{12, 0, 0x07, 8},{ 0, 0, 0x00,  0} },
-/*  9 */ { {12, 3, 0x1f, 0},{13, 0, 0x3f, 5},{ 0, 0, 0x00,  0} },
-/* 10 */ { {13, 6, 0x03, 0},{14, 0, 0xff, 2},{15, 0, 0x01, 10} },
-/* 11 */ { {15, 1, 0x7f, 0},{16, 0, 0x0f, 7},{ 0, 0, 0x00,  0} },
-/* 12 */ { {16, 4, 0x0f, 0},{17, 0, 0x7f, 4},{ 0, 0, 0x00,  0} },
-/* 13 */ { {17, 7, 0x01, 0},{18, 0, 0xff, 1},{19, 0, 0x03,  9} },
-/* 14 */ { {19, 2, 0x3f, 0},{20, 0, 0x1f, 6},{ 0, 0, 0x00,  0} },
-/* 15 */ { {20, 5, 0x07, 0},{21, 0, 0xff, 3},{ 0, 0, 0x00,  0} }
+	/*  0 */ { { 0, 0, 0xff, 0}, { 1, 0, 0x07, 8}, { 0, 0, 0x00,  0} },
+	/*  1 */ { { 1, 3, 0x1f, 0}, { 2, 0, 0x3f, 5}, { 0, 0, 0x00,  0} },
+	/*  2 */ { { 2, 6, 0x03, 0}, { 3, 0, 0xff, 2}, { 4, 0, 0x01, 10} },
+	/*  3 */ { { 4, 1, 0x7f, 0}, { 5, 0, 0x0f, 7}, { 0, 0, 0x00,  0} },
+	/*  4 */ { { 5, 4, 0x0f, 0}, { 6, 0, 0x7f, 4}, { 0, 0, 0x00,  0} },
+	/*  5 */ { { 6, 7, 0x01, 0}, { 7, 0, 0xff, 1}, { 8, 0, 0x03,  9} },
+	/*  6 */ { { 8, 2, 0x3f, 0}, { 9, 0, 0x1f, 6}, { 0, 0, 0x00,  0} },
+	/*  7 */ { { 9, 5, 0x07, 0}, {10, 0, 0xff, 3}, { 0, 0, 0x00,  0} },
+	/*  8 */ { {11, 0, 0xff, 0}, {12, 0, 0x07, 8}, { 0, 0, 0x00,  0} },
+	/*  9 */ { {12, 3, 0x1f, 0}, {13, 0, 0x3f, 5}, { 0, 0, 0x00,  0} },
+	/* 10 */ { {13, 6, 0x03, 0}, {14, 0, 0xff, 2}, {15, 0, 0x01, 10} },
+	/* 11 */ { {15, 1, 0x7f, 0}, {16, 0, 0x0f, 7}, { 0, 0, 0x00,  0} },
+	/* 12 */ { {16, 4, 0x0f, 0}, {17, 0, 0x7f, 4}, { 0, 0, 0x00,  0} },
+	/* 13 */ { {17, 7, 0x01, 0}, {18, 0, 0xff, 1}, {19, 0, 0x03,  9} },
+	/* 14 */ { {19, 2, 0x3f, 0}, {20, 0, 0x1f, 6}, { 0, 0, 0x00,  0} },
+	/* 15 */ { {20, 5, 0x07, 0}, {21, 0, 0xff, 3}, { 0, 0, 0x00,  0} }
 };
 
 static void
@@ -207,7 +210,7 @@ sbus_decode(hrt_abstime frame_time)
 
 	/* if the failsafe or connection lost bit is set, we consider the frame invalid */
 	if ((frame[23] & (1 << 2)) && /* signal lost */
-		(frame[23] & (1 << 3))) { /* failsafe */
+	    (frame[23] & (1 << 3))) { /* failsafe */
 
 		/* actively announce signal loss */
 		system_state.rc_channels = 0;
@@ -218,7 +221,7 @@ sbus_decode(hrt_abstime frame_time)
 	last_frame_time = frame_time;
 
 	unsigned chancount = (PX4IO_INPUT_CHANNELS > SBUS_INPUT_CHANNELS) ?
-		SBUS_INPUT_CHANNELS : PX4IO_INPUT_CHANNELS;
+			     SBUS_INPUT_CHANNELS : PX4IO_INPUT_CHANNELS;
 
 	/* use the decoder matrix to extract channel data */
 	for (unsigned channel = 0; channel < chancount; channel++) {
@@ -236,6 +239,7 @@ sbus_decode(hrt_abstime frame_time)
 				value |= piece;
 			}
 		}
+
 		/* convert 0-2048 values to 1000-2000 ppm encoding in a very sloppy fashion */
 		system_state.rc_channel_data[channel] = (value / 2) + 998;
 	}