Cleanup

Author: vedderb

applications/app.c

@@ -51,7 +51,7 @@ void app_set_configuration(app_configuration *conf) {
 
 	app_ppm_stop();
 	app_adc_stop();
-	app_uartcomm_stop(0);
+	app_uartcomm_stop(UART_PORT_COMM_HEADER);
 	app_nunchuk_stop();
 	app_balance_stop();
 	app_pas_stop();
@@ -84,19 +84,19 @@ void app_set_configuration(app_configuration *conf) {
 
 	case APP_UART:
 		hw_stop_i2c();
-		app_uartcomm_start(0);
+		app_uartcomm_start(UART_PORT_COMM_HEADER);
 		break;
 
 	case APP_PPM_UART:
 		hw_stop_i2c();
 		app_ppm_start();
-		app_uartcomm_start(0);
+		app_uartcomm_start(UART_PORT_COMM_HEADER);
 		break;
 
 	case APP_ADC_UART:
 		hw_stop_i2c();
 		app_adc_start(false);
-		app_uartcomm_start(0);
+		app_uartcomm_start(UART_PORT_COMM_HEADER);
 		break;
 
 	case APP_NUNCHUK:
@@ -107,7 +107,7 @@ void app_set_configuration(app_configuration *conf) {
 		app_balance_start();
 		if(appconf.imu_conf.type == IMU_TYPE_INTERNAL){
 			hw_stop_i2c();
-			app_uartcomm_start(0);
+			app_uartcomm_start(UART_PORT_COMM_HEADER);
 		}
 		break;
 
@@ -141,8 +141,8 @@ void app_set_configuration(app_configuration *conf) {
 	app_ppm_configure(&appconf.app_ppm_conf);
 	app_adc_configure(&appconf.app_adc_conf);
 	app_pas_configure(&appconf.app_pas_conf);
-	app_uartcomm_configure(appconf.app_uart_baudrate, true, 0);
-	app_uartcomm_configure(0, appconf.permanent_uart_enabled, 1);
+	app_uartcomm_configure(appconf.app_uart_baudrate, true, UART_PORT_COMM_HEADER);
+	app_uartcomm_configure(0, appconf.permanent_uart_enabled, UART_PORT_BUILTIN);
 	app_nunchuk_configure(&appconf.app_chuk_conf);
 
 #ifdef APP_CUSTOM_TO_USE

applications/app.h

@@ -43,12 +43,17 @@ float app_adc_get_voltage(void);
 float app_adc_get_decoded_level2(void);
 float app_adc_get_voltage2(void);
 
+typedef enum {
+	UART_PORT_COMM_HEADER = 0,
+	UART_PORT_BUILTIN,
+	UART_PORT_EXTRA_HEADER
+} UART_PORT;
+
 void app_uartcomm_initialize(void);
-void app_uartcomm_start(unsigned int port_number);
-void app_uartcomm_stop(unsigned int port_number);
-void app_uartcomm_configure(uint32_t baudrate, bool permanent_enabled, unsigned int port_number);
-void app_uartcomm_send_packet(unsigned char *data, unsigned int len,  unsigned int port_number);
-void app_uartcomm_send_packet_p(unsigned char *data, unsigned int len);
+void app_uartcomm_start(UART_PORT port_number);
+void app_uartcomm_stop(UART_PORT port_number);
+void app_uartcomm_configure(uint32_t baudrate, bool permanent_enabled, UART_PORT port_number);
+void app_uartcomm_send_packet(unsigned char *data, unsigned int len,  UART_PORT port_number);
 
 void app_nunchuk_start(void);
 void app_nunchuk_stop(void);

applications/app_uartcomm.c

@@ -50,10 +50,10 @@ static volatile bool uart_is_running[UART_NUMBER] = {false};
 static mutex_t send_mutex[UART_NUMBER];
 static bool send_mutex_init_done[UART_NUMBER] = {false};
 static SerialConfig uart_cfg[UART_NUMBER] = {{
-											  BAUDRATE,
-											  0,
-											  USART_CR2_LINEN,
-											  0
+		BAUDRATE,
+		0,
+		USART_CR2_LINEN,
+		0
 }};
 
 // Different for Rx and Tx because it is possible for hardware to use different UART driver
@@ -67,48 +67,51 @@ static PACKET_STATE_t packet_state[UART_NUMBER];
 
 // Private functions
 static void process_packet(unsigned char *data, unsigned int len, unsigned int port_number);
-static void write_packet(unsigned char *data, unsigned int , unsigned int port_number);
+static void write_packet(unsigned char *data, unsigned int len, unsigned int port_number);
 
 static void process_packet_1(unsigned char *data, unsigned int len) {process_packet(data,len,0);}
 static void write_packet_1(unsigned char *data, unsigned int len) {write_packet(data,len,0);}
-static void send_packet_1(unsigned char *data, unsigned int len) {app_uartcomm_send_packet(data,len,0);}
+static void send_packet_1(unsigned char *data, unsigned int len) {app_uartcomm_send_packet(data,len,UART_PORT_COMM_HEADER);}
 
 static void process_packet_2(unsigned char *data, unsigned int len) {process_packet(data,len,1);}
 static void write_packet_2(unsigned char *data, unsigned int len) {write_packet(data,len,1);}
-static void send_packet_2(unsigned char *data, unsigned int len) {app_uartcomm_send_packet(data,len,1);}
+static void send_packet_2(unsigned char *data, unsigned int len) {app_uartcomm_send_packet(data,len,UART_PORT_BUILTIN);}
 
 static void process_packet_3(unsigned char *data, unsigned int len) {process_packet(data,len,2);}
 static void write_packet_3(unsigned char *data, unsigned int len) {write_packet(data,len,2);}
-static void send_packet_3(unsigned char *data, unsigned int len) {app_uartcomm_send_packet(data,len,2);}
+static void send_packet_3(unsigned char *data, unsigned int len) {app_uartcomm_send_packet(data,len,UART_PORT_EXTRA_HEADER);}
 
 typedef void (*data_func) (unsigned char *data, unsigned int len);
 static data_func write_functions[3] = {write_packet_1, write_packet_2, write_packet_3};
 static data_func process_functions[3] = {process_packet_1, process_packet_2, process_packet_3};
 static data_func send_functions[3] = {send_packet_1, send_packet_2, send_packet_3};
 
 static void write_packet(unsigned char *data, unsigned int len, unsigned int port_number) {
-	if(port_number >= UART_NUMBER){
+	if (port_number >= UART_NUMBER) {
 		return;
 	}
+
 	if (uart_is_running[port_number]) {
 		sdWrite(serialPortDriverTx[port_number], data, len);
 	}
 }
+
 static void process_packet(unsigned char *data, unsigned int len, unsigned int port_number) {
-	if(port_number >= UART_NUMBER){
+	if (port_number >= UART_NUMBER) {
 		return;
 	}
+
 	commands_process_packet(data, len, send_functions[port_number]);
 }
 
-
 void app_uartcomm_initialize(void) {
 	serialPortDriverTx[0] = &HW_UART_DEV;
 	serialPortDriverRx[0] = &HW_UART_DEV;
 	uart_cfg[0].speed =  BAUDRATE;
 	RxGpioPort[0] = HW_UART_RX_PORT; RxGpioPin[0]  = HW_UART_RX_PIN;
 	TxGpioPort[0] = HW_UART_TX_PORT; TxGpioPin[0]  = HW_UART_TX_PIN;
 	gpioAF[0] = HW_UART_GPIO_AF;
+
 #ifdef HW_UART_P_DEV
 #ifdef HW_UART_P_DEV_TX
 	serialPortDriverTx[1] = &HW_UART_P_DEV_TX;
@@ -121,6 +124,7 @@ void app_uartcomm_initialize(void) {
 	TxGpioPort[1] = HW_UART_P_TX_PORT; TxGpioPin[1] = HW_UART_P_TX_PIN;
 	gpioAF[1] = HW_UART_P_GPIO_AF;
 #endif
+
 #ifdef HW_UART_3_DEV
 	serialPortDriverTx[2] =  &HW_UART_3_DEV;
 	serialPortDriverRx[2] = &HW_UART_3_DEV;
@@ -131,32 +135,34 @@ void app_uartcomm_initialize(void) {
 #endif
 }
 
-void app_uartcomm_start(unsigned int port_number) {
+void app_uartcomm_start(UART_PORT port_number) {
 	if(port_number >= UART_NUMBER){
 		return;
 	}
 
 	packet_init(write_functions[port_number], process_functions[port_number], &packet_state[port_number]);
+
 	if (!thread_is_running) {
 		chThdCreateStatic(packet_process_thread_wa, sizeof(packet_process_thread_wa),
-						  NORMALPRIO, packet_process_thread, NULL);
+				NORMALPRIO, packet_process_thread, NULL);
 		thread_is_running = true;
 	}
+
 	sdStart(serialPortDriverRx[port_number], &uart_cfg[port_number]);
 	sdStart(serialPortDriverTx[port_number], &uart_cfg[port_number]);
 	uart_is_running[port_number] = true;
+
 	palSetPadMode(TxGpioPort[port_number], TxGpioPin[port_number], PAL_MODE_ALTERNATE(gpioAF[port_number]) |
-				  PAL_STM32_OSPEED_HIGHEST |
-				  PAL_STM32_PUDR_PULLUP);
+			PAL_STM32_OSPEED_HIGHEST | PAL_STM32_PUDR_PULLUP);
 	palSetPadMode(RxGpioPort[port_number], RxGpioPin[port_number], PAL_MODE_ALTERNATE(gpioAF[port_number]) |
-				  PAL_STM32_OSPEED_HIGHEST |
-				  PAL_STM32_PUDR_PULLUP);
+			PAL_STM32_OSPEED_HIGHEST | PAL_STM32_PUDR_PULLUP);
 }
 
-void app_uartcomm_stop(unsigned int port_number) {
-	if(port_number >= UART_NUMBER){
+void app_uartcomm_stop(UART_PORT port_number) {
+	if(port_number >= UART_NUMBER) {
 		return;
 	}
+
 	if (uart_is_running[port_number]) {
 		sdStop(serialPortDriverRx[port_number]);
 		sdStop(serialPortDriverTx[port_number]);
@@ -167,29 +173,34 @@ void app_uartcomm_stop(unsigned int port_number) {
 	// Notice that the processing thread is kept running in case this call is made from it.
 }
 
-void app_uartcomm_send_packet(unsigned char *data, unsigned int len, unsigned int port_number) {
-	if(port_number >= UART_NUMBER){
+void app_uartcomm_send_packet(unsigned char *data, unsigned int len, UART_PORT port_number) {
+	if (port_number >= UART_NUMBER) {
 		return;
 	}
+
 	if (!send_mutex_init_done[port_number]) {
 		chMtxObjectInit(&send_mutex[port_number]);
 		send_mutex_init_done[port_number] = true;
 	}
+
 	chMtxLock(&send_mutex[port_number]);
 	packet_send_packet(data, len, &packet_state[port_number]);
 	chMtxUnlock(&send_mutex[port_number]);
 }
 
-void app_uartcomm_configure(uint32_t baudrate, bool enabled, unsigned int port_number) {
-	if(port_number >= UART_NUMBER){
+void app_uartcomm_configure(uint32_t baudrate, bool enabled, UART_PORT port_number) {
+	if (port_number >= UART_NUMBER) {
 		return;
 	}
-	if(baudrate>0){
+
+	if (baudrate > 0) {
 		uart_cfg[port_number].speed = baudrate;
 	}
+
 	if (thread_is_running && uart_is_running[port_number]) {
 		sdStart(serialPortDriverRx[port_number], &uart_cfg[port_number]);
 	}
+
 	if (enabled) {
 		palSetPadMode(TxGpioPort[port_number], TxGpioPin[port_number], PAL_MODE_ALTERNATE(gpioAF[port_number]) |
 					  PAL_STM32_OSPEED_HIGHEST |
@@ -205,13 +216,17 @@ void app_uartcomm_configure(uint32_t baudrate, bool enabled, unsigned int port_n
 
 static THD_FUNCTION(packet_process_thread, arg) {
 	(void)arg;
+
 	chRegSetThreadName("uartcomm proc");
+
 	event_listener_t el[UART_NUMBER];
 	for(int port_number = 0; port_number < UART_NUMBER; port_number++) {
 		chEvtRegisterMaskWithFlags(&(*serialPortDriverRx[port_number]).event, &el[port_number], EVENT_MASK(0), CHN_INPUT_AVAILABLE);
 	}
+
 	for(;;) {
 		chEvtWaitAnyTimeout(ALL_EVENTS, ST2MS(10));
+
 		bool rx = true;
 		while (rx) {
 			rx = false;

commands.c

@@ -1450,9 +1450,9 @@ void commands_set_ble_name(char* name) {
 	buffer[ind++] = '\0';
 
 #ifdef HW_UART_P_DEV
-	app_uartcomm_send_packet(buffer, ind, 1);
+	app_uartcomm_send_packet(buffer, ind, UART_PORT_BUILTIN);
 #else
-	app_uartcomm_send_packet(buffer, ind, 0);
+	app_uartcomm_send_packet(buffer, ind, UART_PORT_COMM_HEADER);
 #endif
 }
 
@@ -1469,9 +1469,9 @@ void commands_set_ble_pin(char* pin) {
 	ind += pin_len;
 	buffer[ind++] = '\0';
 #ifdef HW_UART_P_DEV
-	app_uartcomm_send_packet(buffer, ind, 1);
+	app_uartcomm_send_packet(buffer, ind, UART_PORT_BUILTIN);
 #else
-	app_uartcomm_send_packet(buffer, ind, 0);
+	app_uartcomm_send_packet(buffer, ind, UART_PORT_COMM_HEADER);
 #endif
 }
 

conf_general.h

@@ -24,7 +24,7 @@
 #define FW_VERSION_MAJOR			5
 #define FW_VERSION_MINOR			03
 // Set to 0 for building a release and iterate during beta test builds
-#define FW_TEST_VERSION_NUMBER		1
+#define FW_TEST_VERSION_NUMBER		2
 
 #include "datatypes.h"
 
@@ -72,10 +72,10 @@
 // Mark3 version of HW60 with power switch and separate NRF UART.
 //#define HW60_IS_MK3
 //#define HW60_IS_MK4
-//#define HW60_IS_MK5
+#define HW60_IS_MK5
 
-//#define HW_SOURCE "hw_60.c"
-//#define HW_HEADER "hw_60.h"
+#define HW_SOURCE "hw_60.c"
+#define HW_HEADER "hw_60.h"
 
 //#define HW_SOURCE "hw_r2.c"
 //#define HW_HEADER "hw_r2.h"
@@ -148,10 +148,9 @@
 //#define HW_SOURCE "hw_stormcore_100d.c"
 //#define HW_HEADER "hw_stormcore_100d.h"
 
-#define HW_VER_IS_60D_PLUS
-#define HW_SOURCE "hw_stormcore_60d.c"
-#define HW_HEADER "hw_stormcore_60d.h"
-
+//#define HW_VER_IS_60D_PLUS
+//#define HW_SOURCE "hw_stormcore_60d.c"
+//#define HW_HEADER "hw_stormcore_60d.h"
 
 //#define HW_SOURCE "hw_stormcore_100s.c"
 //#define HW_HEADER "hw_stormcore_100s.h"
@@ -188,18 +187,13 @@
 /*
  * Select default user motor configuration
  */
-//#include			"mcconf_sten.h"
-//#include			"mcconf_sp_540kv.h"
-//#include			"mcconf_castle_2028.h"
-//#include			"mcconf_ellwee.h"
 //#include			"conf_test.h"
 
 /*
  * Select default user app configuration
  */
 //#include			"appconf_example_ppm.h"
 //#include			"appconf_custom.h"
-//#include			"appconf_ellwee.h"
 
 /*
  * Set APP_CUSTOM_TO_USE to the name of the main C file of the custom application.