first version of s-LCD3 implementation working

applications/app_ev.c

@@ -312,6 +312,36 @@ static THD_FUNCTION(ev_thread, arg) {
 		}
 
 
+		// display output
+		battery_level battery = BORDER_FLASHING;
+
+		if(mcconf->l_min_vin < mcconf->l_max_vin) {
+			float bat_level = (GET_INPUT_VOLTAGE() - mcconf->l_min_vin) / (mcconf->l_max_vin - mcconf->l_min_vin);
+
+			if(bat_level >= 0.7) {
+				battery = B4_BARS;
+			} else if(bat_level >= 0.5) {
+				battery = B3_BARS;
+			} else if(bat_level >= 0.4) {
+				battery = B2_BARS;
+			} else if(bat_level >= 0.3) {
+				battery = B1_BAR;
+			} else if(bat_level < 0) {
+				battery = BORDER_FLASHING;
+			} else {
+				battery = EMPTY_BOX;
+			}
+		}
+
+		uint16_t wheel_rot_period = 0;
+
+		//lcd_set_data(GET_INPUT_VOLTAGE() * mc_interface_get_tot_current_in_filtered(), 500, 0, pwr > 0.01, false, false);
+		lcd_set_data(GET_INPUT_VOLTAGE() * mc_interface_get_tot_current_in_filtered(),
+					 wheel_rot_period, 0, battery, pwr > 0.01, false, false);
+
+
+
+
 
 		// check safe start, if the output has not been zero for long enough
 		if (ms_without_power < MIN_MS_WITHOUT_POWER ) {
@@ -361,5 +391,7 @@ static THD_FUNCTION(ev_thread, arg) {
 				mc_interface_set_current(current);
 			}
 		}
+
+
 	}
 }

s_lcd3.c

@@ -23,12 +23,14 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "hw.h"
 #include "s_lcd3.h"
 #include "mc_interface.h"
+#include "commands.h"
 
 #include <string.h>
 
 // settings
 #define BAUDRATE						9600
 #define SERIAL_RX_BUFFER_SIZE			48
+#define PACKET_MAX_PL_LEN				13
 
 // Threads
 static THD_FUNCTION(packet_process_thread, arg);
@@ -44,6 +46,13 @@ static volatile bool is_running = false;
 static volatile lcd_rx_data lcd_data_rx;
 static volatile lcd_tx_data lcd_data_tx;
 
+unsigned char rx_buffer[PACKET_MAX_PL_LEN];
+unsigned char tx_buffer[PACKET_MAX_PL_LEN];
+unsigned int rx_data_ptr;
+unsigned char crc;
+
+// Prototypes
+void send_lcd_data(void);
 
 
 /*
@@ -112,9 +121,10 @@ static UARTConfig uart_cfg = {
 
 void s_lcd3_start() {
 
-	const volatile mc_configuration *mcconf = mc_interface_get_configuration();
+	//const volatile mc_configuration *mcconf = mc_interface_get_configuration();
 
-	lcd_data_tx.power = GET_INPUT_VOLTAGE() * mc_interface_get_tot_current_in_filtered();
+	//lcd_data_tx.power = GET_INPUT_VOLTAGE() * mc_interface_get_tot_current_in_filtered();
+	lcd_data_tx.power = 0;
 	lcd_data_tx.battery_lvl = BORDER_FLASHING;
 	lcd_data_tx.error_info  = 0;
 	lcd_data_tx.motor_temperature = 23;
@@ -143,28 +153,109 @@ void s_lcd3_start() {
 }
 
 void s_lcd3_stop() {
-
 	uartStop(&HW_UART_DEV);
 	palSetPadMode(HW_UART_TX_PORT, HW_UART_TX_PIN, PAL_MODE_INPUT_PULLUP);
 	palSetPadMode(HW_UART_RX_PORT, HW_UART_RX_PIN, PAL_MODE_INPUT_PULLUP);
-
 }
 
 
 const volatile lcd_rx_data* s_lcd3_get_data() {
 	return &lcd_data_rx;
 }
 
-void lcd_set_data(uint16_t wheel_rotation_period, uint8_t error_display,
+void lcd_set_data(uint16_t power, uint16_t wheel_rotation_period, uint8_t error_display,
+				  battery_level battery,
 				  bool anim_throttle, bool cruise, bool assist) {
-
+	lcd_data_tx.power = power;
 	lcd_data_tx.wheel_rotation_period = wheel_rotation_period;
 	lcd_data_tx.error_info = error_display;
+	lcd_data_tx.battery_lvl = battery;
 	lcd_data_tx.show_animated_circle = anim_throttle;
 	lcd_data_tx.show_assist = assist;
 	lcd_data_tx.show_cruise_control = cruise;
 }
 
+void send_lcd_data() {
+	tx_buffer[0] = 0x41;
+	tx_buffer[1] = lcd_data_tx.battery_lvl;
+	tx_buffer[2] = 0x24;
+	tx_buffer[3] = lcd_data_tx.wheel_rotation_period >> 8;
+	tx_buffer[4] = lcd_data_tx.wheel_rotation_period & 0xff;
+	tx_buffer[5] = lcd_data_tx.error_info;
+
+	tx_buffer[7] = lcd_data_tx.show_animated_circle | lcd_data_tx.show_cruise_control << 3 | lcd_data_tx.show_assist << 4;
+	tx_buffer[8] = lcd_data_tx.power / 7;
+	tx_buffer[9] = lcd_data_tx.motor_temperature - 15;
+	tx_buffer[10] = 0x00;
+	tx_buffer[11] = 0x00;
+
+	// CRC
+	//tx_buffer[6] = tx_buffer[0] ^ tx_buffer[1] ^ tx_buffer[2] ^ tx_buffer[3] ^ tx_buffer[4] ^ tx_buffer[5] ^ tx_buffer[7] ^ tx_buffer[8] ^ tx_buffer[9];
+	tx_buffer[6] = tx_buffer[1] ^ 0x24 ^ tx_buffer[3] ^ tx_buffer[4] ^ tx_buffer[5] ^ tx_buffer[7] ^ tx_buffer[8] ^ tx_buffer[9];
+
+	commands_printf("send: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", tx_buffer[0], tx_buffer[1], tx_buffer[2], tx_buffer[3], tx_buffer[4],
+																			   tx_buffer[5], tx_buffer[6], tx_buffer[7], tx_buffer[8], tx_buffer[9]);
+
+	// Wait for the previous transmission to finish.
+	while (HW_UART_DEV.txstate == UART_TX_ACTIVE) {
+		chThdSleep(1);
+	}
+
+	uartStartSend(&HW_UART_DEV, 12, tx_buffer);
+}
+
+
+void process_byte(uint8_t rx_data) {
+
+	rx_buffer[rx_data_ptr++] = rx_data;
+
+	if (rx_data_ptr == 13) {
+
+		if(rx_buffer[11] == 0x32 && rx_buffer[12] == 0x0E) {
+
+
+			lcd_data_rx.power_monitoring_p5 = rx_buffer[0];
+			lcd_data_rx.headlight = (rx_buffer[1] & 0x80) >> 7;
+			lcd_data_rx.assist_level = (rx_buffer[1] & 0x07);
+
+			lcd_data_rx.max_speed = ((rx_buffer[2] & 0xF8) >> 3 | (rx_buffer[4] & 0x20)) + 10;
+			lcd_data_rx.wheel_size = (rx_buffer[2] & 0x07) << 2 | (rx_buffer[4] & 0xC0) >> 6;
+
+			lcd_data_rx.pulse_per_revolution_p2 = (rx_buffer[4] & 0x07);
+			lcd_data_rx.pas_mode_p3 = (rx_buffer[4] & 0x08) >> 3;
+			lcd_data_rx.throttle_needs_pas_p4 = (rx_buffer[4] & 0x10) >> 4;
+
+			lcd_data_rx.motor_characteristic_p1 = rx_buffer[3];
+
+			//uint8_t crc = rx_buffer[5];
+
+
+			lcd_data_rx.pas_sensor_mode_c1 = (rx_buffer[6] & 0x38) >> 3;
+			lcd_data_rx.motor_phase_classification_c2 = rx_buffer[6] & 0x07;
+
+			lcd_data_rx.max_current_adjust_c5 = rx_buffer[7] & 0x0f;
+			lcd_data_rx.pas_tuning_c14 = (rx_buffer[7] & 0x60) >> 5;
+
+			lcd_data_rx.throttle_mode_c4 = (rx_buffer[8] & 0xE0) >> 5;
+
+
+			commands_printf("p5: %d, light: %d  assist: %d, maxspd: %d, wheelsize: %d, ppr_p2: %d, pasmode_p3: %d, "
+					"throttleneedpas_p4: %d, motorchar_p1: %d, passensmode_c1: %d, phase_c2: %d, maxcurre_c5: %d, thromo_c4: %d, "
+					"pastune_c14: %d ", lcd_data_rx.power_monitoring_p5,
+										  lcd_data_rx.headlight,
+										  lcd_data_rx.assist_level, lcd_data_rx.max_speed, lcd_data_rx.wheel_size, lcd_data_rx.pulse_per_revolution_p2,
+										  lcd_data_rx.pas_mode_p3, lcd_data_rx.throttle_needs_pas_p4, lcd_data_rx.motor_characteristic_p1,
+										  lcd_data_rx.pas_sensor_mode_c1, lcd_data_rx.motor_phase_classification_c2, lcd_data_rx.max_current_adjust_c5,
+										  lcd_data_rx.throttle_mode_c4, lcd_data_rx.pas_tuning_c14);
+			send_lcd_data();
+
+		}
+
+
+		rx_data_ptr = 0;
+	}
+
+}
 
 
 static THD_FUNCTION(packet_process_thread, arg) {
@@ -179,22 +270,7 @@ static THD_FUNCTION(packet_process_thread, arg) {
 
 		while (serial_rx_read_pos != serial_rx_write_pos) {
 
-			uint8_t byte = serial_rx_buffer[serial_rx_read_pos++];
-
-			if(byte == 0x0e) {
-				//probably last byte. check previous byte
-				int8_t pos = serial_rx_read_pos-1;
-				if(pos == -1) {
-					pos = SERIAL_RX_BUFFER_SIZE-1;
-				}
-
-				if(serial_rx_buffer[pos] == 0x32) {
-
-
-				}
-
-			}
-
+			process_byte(serial_rx_buffer[serial_rx_read_pos++]);
 
 
 			if (serial_rx_read_pos == SERIAL_RX_BUFFER_SIZE) {

s_lcd3.h

@@ -64,18 +64,20 @@ typedef struct
     uint8_t motor_phase_classification_c2;
     uint8_t throttle_mode_c4;
     uint8_t max_current_adjust_c5;
+    uint8_t pas_tuning_c14;
 
 
 } lcd_rx_data;
 
 typedef enum {
-	EMPTY_BOX,
-	BORDER_FLASHING,
-	ANIMATED_CHARGING,
-	EMPTY,
-	B1_BAR,
-	B2_BARS,
-	B4_BARS
+	EMPTY_BOX = 0,
+	BORDER_FLASHING = 1,
+	ANIMATED_CHARGING = 2,
+	EMPTY = 3,
+	B1_BAR = 4,
+	B2_BARS = 8,
+	B3_BARS = 12,
+	B4_BARS = 16
 } battery_level;
 
 typedef struct {
@@ -93,5 +95,8 @@ void s_lcd3_start(void);
 void s_lcd3_stop(void);
 
 void s_lcd3_work(void);
+const volatile lcd_rx_data* s_lcd3_get_data(void);
+void lcd_set_data(uint16_t power, uint16_t wheel_rotation_period, uint8_t error_display,
+				  battery_level battery, bool anim_throttle, bool cruise, bool assist);
 
 #endif