Indent src/main.cpp with 2-ws draft

Sun, 25 Oct 2020 22:45:24 +0100

author
David Douard <david.douard@sdf3.org>
date
Sun, 25 Oct 2020 22:45:24 +0100
changeset 35
b2dca6b935bb
parent 34
94ab7ff42a1b
child 36
a6c7292742a0

Indent src/main.cpp with 2-ws

src/main.cpp file | annotate | diff | comparison | revisions
--- a/src/main.cpp	Sun Oct 25 22:17:15 2020 +0100
+++ b/src/main.cpp	Sun Oct 25 22:45:24 2020 +0100
@@ -36,19 +36,20 @@
 
 QEI qenc(KP_ENC1, KP_ENC2, NC, 16);
 volatile uint8_t knob;
+bool shift;  // true when kp is shifted, cleared by command 0x01 from Unit
 volatile bool splashscreen;
 
 
 typedef enum {
-  KEY_NONE=0,
-  KEY_PRESSED,
-  KEY_RELEASED
+		KEY_NONE=0,
+		KEY_PRESSED,
+		KEY_RELEASED
 } key_event_t;
 
 typedef struct keycode {
-  uint8_t row;
-  uint8_t col;
-  key_event_t keyevent;
+	uint8_t row;
+	uint8_t col;
+	key_event_t keyevent;
 } keycode_t;
 
 //volatile keycode_t cur_keycode;
@@ -59,44 +60,44 @@
 #define KP_NROWS 4
 #define KP_NCOLS 5
 DigitalIn kp_rows[KP_NROWS] = {
-  KP_R0,
-  KP_R1,
-  KP_R2,
-  KP_R3
+		KP_R0,
+		KP_R1,
+		KP_R2,
+		KP_R3
 };
 
 DigitalOut kp_columns[KP_NCOLS] = {
-  KP_C0, KP_C1,
-  KP_C2, KP_C3,
-  KP_C4
+		KP_C0, KP_C1,
+		KP_C2, KP_C3,
+		KP_C4
 };
 
 /* mapping (RxC)
-0x2 0x00:  View
-0x1 0x01:  Mon
-3x3 0x02:  Sto/Rcl
-0x0 0x03:  Scan
-1x2 0x04:  Alarm
-1x1 0x05:  Mx+B
-1x0 0x06:  Measure
-2x0 0x07:  Interval
-3x2 0x08:  Card Reset
-3x1 0x09:  Close
-3x0 0x0A:  Open
-0x3 0x0B:  Read
-2x3 0x0C:  Shift
-1x3 0x0D:  Write
-0x4 0x0E:  Left
-1x4 0x0F:  Right
-2x2 0x10:  Advanced
-2x1 0x11:  Step
+	 0x2 0x00:  View
+	 0x1 0x01:  Mon
+	 3x3 0x02:  Sto/Rcl
+	 0x0 0x03:  Scan
+	 1x2 0x04:  Alarm
+	 1x1 0x05:  Mx+B
+	 1x0 0x06:  Measure
+	 2x0 0x07:  Interval
+	 3x2 0x08:  Card Reset
+	 3x1 0x09:  Close
+	 3x0 0x0A:  Open
+	 0x3 0x0B:  Read
+	 2x3 0x0C:  Shift
+	 1x3 0x0D:  Write
+	 0x4 0x0E:  Left
+	 1x4 0x0F:  Right
+	 2x2 0x10:  Advanced
+	 2x1 0x11:  Step
 */
 
 uint8_t kp_mapping[KP_NROWS][KP_NCOLS] = { // [row][column]
-  {0x03, 0x01, 0x00, 0x0B, 0x0E},
-  {0x06, 0x05, 0x04, 0x0D, 0x0F},
-  {0x07, 0x11, 0x10, 0x0C, 0xFF},
-  {0x0A, 0x09, 0x08, 0x02, 0xFF}
+		{0x03, 0x01, 0x00, 0x0B, 0x0E},
+		{0x06, 0x05, 0x04, 0x0D, 0x0F},
+		{0x07, 0x11, 0x10, 0x0C, 0xFF},
+		{0x0A, 0x09, 0x08, 0x02, 0xFF}
 };
 
 
@@ -111,84 +112,84 @@
 
 void timeout_h() {
 #if defined(HAS_LED)
-  led = !led;
+	led = !led;
 #endif
 }
 
 typedef struct _DSP
 {
-  uint8_t cmd;
-  uint8_t color;
-  uint8_t bgcolor;
-  uint8_t x0;
-  uint8_t y0;
-  uint8_t fmt; // 0x01=>ascii, 0x02=>hex, 0x04=>bits, 0x08=>flags, 0x80=>ignore
-  uint8_t maxsize;
-  uint8_t width;
-  const unsigned char* font;
-  char buffer[MAX_BUFF+1];
+	uint8_t cmd;
+	uint8_t color;
+	uint8_t bgcolor;
+	uint8_t x0;
+	uint8_t y0;
+	uint8_t fmt; // 0x01=>ascii, 0x02=>hex, 0x04=>bits, 0x08=>flags, 0x80=>ignore
+	uint8_t maxsize;
+	uint8_t width;
+	const unsigned char* font;
+	char buffer[MAX_BUFF+1];
 } DSP;
 
 static DSP table[] =
 {
-  { 0x00, 0xF, 0x0,  0,  0, 0x01, MAX_BUFF, 245, Mono19x27}, // main display
-  { 0x0C, 0xF, 0x0,196, 34, 0x01, 3,        45,  Mono15x22}, // channels display
-  { 0x0A, 0xF, 0x0,  0, 57, 0x08, 4,        0, Terminal6x8}, // flags + bits
+		{ 0x00, 0xF, 0x0,  0,  0, 0x01, MAX_BUFF, 245, Mono19x27}, // main display
+		{ 0x0C, 0xF, 0x0,196, 34, 0x01, 3,        45,  Mono15x22}, // channels display
+		{ 0x0A, 0xF, 0x0,  0, 57, 0x08, 4,        0, Terminal6x8}, // flags + bits
 };
 
 // 9x10
 const unsigned char icon_alarm[] __attribute__((aligned (2))) =
 {
-  0x1c, 0x0,
-  0x3e, 0x0,
-  0x7f, 0x0,
-  0x7f, 0x0,
-  0x7f, 0x0,
-  0x7f, 0x0,
-  0x7f, 0x0,
-  0x7f, 0x0,
-  0xff, 0x80,
-  0x10, 0x0
+		0x1c, 0x0,
+		0x3e, 0x0,
+		0x7f, 0x0,
+		0x7f, 0x0,
+		0x7f, 0x0,
+		0x7f, 0x0,
+		0x7f, 0x0,
+		0x7f, 0x0,
+		0xff, 0x80,
+		0x10, 0x0
 };
 
 const unsigned char icon_curve[] __attribute__((aligned (2))) =
 {
-  0x80, 0x0,
-  0x80, 0x0,
-  0x80, 0x80,
-  0x81, 0x0,
-  0x9e, 0x0,
-  0xa0, 0x0,
-  0xc0, 0x0,
-  0x80, 0x0,
-  0x80, 0x0,
-  0xff, 0x80
- };
+		0x80, 0x0,
+		0x80, 0x0,
+		0x80, 0x80,
+		0x81, 0x0,
+		0x9e, 0x0,
+		0xa0, 0x0,
+		0xc0, 0x0,
+		0x80, 0x0,
+		0x80, 0x0,
+		0xff, 0x80
+};
 
 typedef struct _FLAG
 {
-  uint8_t flag;
-  uint8_t x;
-  uint8_t y;
-  bool reverse;
-  const char* msg;
-  const unsigned char* icon;
+	uint8_t flag;
+	uint8_t x;
+	uint8_t y;
+	bool reverse;
+	const char* msg;
+	const unsigned char* icon;
 } FLAG;
 
 typedef struct _FRAME
 {
-  uint16_t flag;
-  uint8_t x0;
-  uint8_t y0;
-  uint8_t x1;
-  uint8_t y1;
+	uint16_t flag;
+	uint8_t x0;
+	uint8_t y0;
+	uint8_t x1;
+	uint8_t y1;
 } FRAME;
 
 static const FLAG flags[] =
-  {
+{
     // flag, zone, x0, y0, reverse, msg, icon
     // right-side icons area
-  { 0x00, 246, 0,  false, NULL, icon_alarm}, // F1.0
+		{ 0x00, 246, 0,  false, NULL, icon_alarm}, // F1.0
     { 0x01, 246, 11, false, NULL, icon_curve}, // F1.1
 
     // F1.2 == Channel frame
@@ -227,7 +228,7 @@
     { 0x11, 154+24, 17+20, false, "4"},      // F2.1
     { 0x04, 154+30, 17+20, false, "L"},      // F1.4
 
-  };
+};
 
 static const FRAME zones[] =
 { // flag, x0, y0, x1, y1
@@ -242,13 +243,13 @@
     { 0x100, 129, 28, 159, 54}, // flags col5
 
 //    { 0x8000, 0, 55, 255, 63}, // flags bits display area
-  };
+};
 
 static const FRAME frames[] =
-  {
+{
     { 0x02, 194, 30, 243, 53}, // F1.2 - channel frame
     { 0x07, 151, 30, 192, 46}, // F1.7 - alarm frame
-  };
+};
 
 
 #ifdef DEBUG
@@ -256,17 +257,17 @@
 DigitalOut dbgpin(DBGPIN);
 inline void pulse(uint8_t count=1, bool stayup=false)
 {
-  dbgpin = 0;
-  wait_us(2);
-  while (count--)
-  {
-    dbgpin = 1;
-    wait_us(2);
-    dbgpin = 0;
-    wait_us(2);
- }
-  if (stayup)
-    dbgpin = 1;
+	dbgpin = 0;
+	wait_us(2);
+	while (count--)
+	{
+		dbgpin = 1;
+		wait_us(2);
+		dbgpin = 0;
+		wait_us(2);
+	}
+	if (stayup)
+		dbgpin = 1;
 }
 #else
 inline void pulse(uint8_t count=1, bool stayup=false)
@@ -284,536 +285,545 @@
 void show(uint8_t, const char*, uint8_t);
 
 /*
-#if defined(HAVE_PC)
-FileHandle *mbed::mbed_override_console(int fd)
-{
-    return static_cast<FileHandle*> (&pc);
-}
-#endif
+	#if defined(HAVE_PC)
+	FileHandle *mbed::mbed_override_console(int fd)
+	{
+	return static_cast<FileHandle*> (&pc);
+	}
+	#endif
 */
 
 void setup() {
 #if defined(HAVE_PC)
 #if   defined(TARGET_NUCLEO_F446RE)
-  pc.set_baud(115200);
+	pc.set_baud(115200);
 #endif
 
 /*
-#if  defined(TARGET_HP34970_FP_F303RD)
+	#if  defined(TARGET_HP34970_FP_F303RD)
   pc.init();
   pc.connect();
-#endif
+	#endif
 */
 #endif
 
-  printf("\n\nSETUP\n");
-  printf("  System Core Clock = %.3f MHZ\r\n",
-     (float)SystemCoreClock/1000000);
+	printf("\n\nSETUP\n");
+	printf("  System Core Clock = %.3f MHZ\r\n",
+				 (float)SystemCoreClock/1000000);
 
-  /*
-#if defined(HAS_LED)
-  printf("Attaching Led 1: %d\n", LED1);
-  blinker.attach(callback(timeout_h), 0.5f);
-#endif
-  */
+	/*
+		#if defined(HAS_LED)
+		printf("Attaching Led 1: %d\n", LED1);
+		blinker.attach(callback(timeout_h), 0.5f);
+		#endif
+	*/
 
-  hp = NULL;
+	hp = NULL;
 #if defined(TARGET_NUCLEO_F446RE)
-  printf("Serial communication pins\r\n");
-  printf("     USBRX=%d\r\n", USBRX);
-  printf("     USBTX=%d\r\n", USBTX);
+	printf("Serial communication pins\r\n");
+	printf("     USBRX=%d\r\n", USBRX);
+	printf("     USBTX=%d\r\n", USBTX);
 #endif
 #if defined(TARGET_HP34970_FP_F303RD)
-  printf("Serial communication via USB\r\n");
+	printf("Serial communication via USB\r\n");
 #endif
 
-  printf("Setup HP communication pins\r\n");
-  printf("     HP_RX=%d\r\n", HP_RX);
-  DigitalIn(HP_RX).mode(PullDown);
-  printf("     HP_TX=%d\r\n", HP_TX);
-  DigitalOut(HP_TX).write(1);
-  printf("     HP_RST=%d\r\n", HP_RST);
-  DigitalIn(HP_RST).mode(PullDown);
+	printf("Setup HP communication pins\r\n");
+	printf("     HP_RX=%d\r\n", HP_RX);
+	DigitalIn(HP_RX).mode(PullDown);
+	printf("     HP_TX=%d\r\n", HP_TX);
+	DigitalOut(HP_TX).write(1);
+	printf("     HP_RST=%d\r\n", HP_RST);
+	DigitalIn(HP_RST).mode(PullDown);
 
-  printf("  setup QEI pins\r\n");
-  printf("     ENC1=%d\r\n", KP_ENC1);
-  DigitalIn(KP_ENC1).mode(PullDown);
-  printf("     ENC2=%d\r\n", KP_ENC2);
-  DigitalIn(KP_ENC2).mode(PullDown);
-  qenc.attach(&qei_cb);
+	printf("  setup QEI pins\r\n");
+	printf("     ENC1=%d\r\n", KP_ENC1);
+	DigitalIn(KP_ENC1).mode(PullDown);
+	printf("     ENC2=%d\r\n", KP_ENC2);
+	DigitalIn(KP_ENC2).mode(PullDown);
+	qenc.attach(&qei_cb);
 
-  printf("  setup Keypad\r\n");
-  //cur_keycode.keyevent = KEY_NONE;
+	printf("  setup Keypad\r\n");
+	//cur_keycode.keyevent = KEY_NONE;
 
-  kpad = new Keypad(KP_NROWS, kp_rows, KP_NCOLS, kp_columns);
-  printf("  attach Keypad callbacks\r\n");
-  kpad->attach(&kp_cb, &kr_cb);
-  printf("  start Keypad\r\n");
-  kpad->start();
+	shift = false;
+	kpad = new Keypad(KP_NROWS, kp_rows, KP_NCOLS, kp_columns);
+	printf("  attach Keypad callbacks\r\n");
+	kpad->attach(&kp_cb, &kr_cb);
+	printf("  start Keypad\r\n");
+	kpad->start();
 
-  printf("Setup OLED display\r\n");
-  // init the LCD
-  printf("     DSP_MOSI=%d\r\n", DSP_MOSI);
-  printf("     DSP_MISO=%d\r\n", DSP_MISO);
-  printf("     DSP_SCLK=%d\r\n", DSP_SCLK);
-  printf("     DSP_CS=%d\r\n", DSP_CS);
-  printf("     DSP_RST=%d\r\n", DSP_RST);
-  printf("     DSP_DC=%d\r\n", DSP_DC);
-  dsp = new SSD1322(20000000, DSP_MOSI, DSP_MISO, DSP_SCLK, DSP_CS,
-        DSP_RST, DSP_DC, "SSD1322");
+	printf("Setup OLED display\r\n");
+	// init the LCD
+	printf("     DSP_MOSI=%d\r\n", DSP_MOSI);
+	printf("     DSP_MISO=%d\r\n", DSP_MISO);
+	printf("     DSP_SCLK=%d\r\n", DSP_SCLK);
+	printf("     DSP_CS=%d\r\n", DSP_CS);
+	printf("     DSP_RST=%d\r\n", DSP_RST);
+	printf("     DSP_DC=%d\r\n", DSP_DC);
+	dsp = new SSD1322(20000000, DSP_MOSI, DSP_MISO, DSP_SCLK, DSP_CS,
+										DSP_RST, DSP_DC, "SSD1322");
 
-  printf("  configure DSP\r\n");
-  dsp->background(Black);    // set background to black
-  dsp->foreground(0xF);
-  dsp->cls();
+	printf("  configure DSP\r\n");
+	dsp->background(Black);    // set background to black
+	dsp->foreground(0xF);
+	dsp->cls();
 
-  //curcmd = 0xFF;
-  curchar = 0;
-  nchars = 0;
+	//curcmd = 0xFF;
+	curchar = 0;
+	nchars = 0;
 
-  for (uint8_t i=0; i<sizeof(table)/sizeof(table[0]); ++i)
-    memset(table[i].buffer, 0, MAX_BUFF+1);
+	for (uint8_t i=0; i<sizeof(table)/sizeof(table[0]); ++i)
+		memset(table[i].buffer, 0, MAX_BUFF+1);
 
-  printf("  display splash screen\r\n");
-  dsp->locate(30, 10);
-  dsp->set_font((unsigned char*)Mono19x27);
-  dsp->printf("HP34970A");
-  dsp->set_font((unsigned char*)Terminal6x8);
-  dsp->locate(90, 40);
-  dsp->printf("David Douard");
-  dsp->locate(0, 52);
-  dsp->printf("Clock = %d ", SystemCoreClock);
+	printf("  display splash screen\r\n");
+	dsp->locate(30, 10);
+	dsp->set_font((unsigned char*)Mono19x27);
+	dsp->printf("HP34970A");
+	dsp->set_font((unsigned char*)Terminal6x8);
+	dsp->locate(90, 40);
+	dsp->printf("David Douard");
+	dsp->locate(0, 52);
+	dsp->printf("Clock = %d ", SystemCoreClock);
 
-  RCC_OscInitTypeDef cfg;
-  HAL_RCC_GetOscConfig(&cfg);
-  if (cfg.HSEState == RCC_HSE_BYPASS)
-    dsp->printf("HSE:EXT ");
-  else if (cfg.HSEState == RCC_HSE_ON)
-    dsp->printf("HSE:XTAL ");
-  else
-    dsp->printf("HSE:OFF ");
+	RCC_OscInitTypeDef cfg;
+	HAL_RCC_GetOscConfig(&cfg);
+	if (cfg.HSEState == RCC_HSE_BYPASS)
+		dsp->printf("HSE:EXT ");
+	else if (cfg.HSEState == RCC_HSE_ON)
+		dsp->printf("HSE:XTAL ");
+	else
+		dsp->printf("HSE:OFF ");
 
-  if (cfg.HSIState == RCC_HSI_ON)
-    dsp->printf("HSI:ON ");
-  else
-    dsp->printf("HSI:OFF ");
+	if (cfg.HSIState == RCC_HSI_ON)
+		dsp->printf("HSI:ON ");
+	else
+		dsp->printf("HSI:OFF ");
 
-  dsp->copy_to_lcd();
+	dsp->copy_to_lcd();
 
-  printf("Starting LCD thread\r\n");
-  tdsp.start(&copy_to_lcd);
+	printf("Starting LCD thread\r\n");
+	tdsp.start(&copy_to_lcd);
 
-  printf("Starting Event thread\r\n");
-  tloop.start(&loop);
+	printf("Starting Event thread\r\n");
+	tloop.start(&loop);
 
-  /*
-  dsp->clrbuff();
-  show(0x00, "HH:MM:\tSS\t:mmmm", 15); // main dsp
-  show(0x0C, "888", 3); // channel dsp
-  show(0x0A, "\xFF\xFF\xFF\xFF", 4); // all flags
-  */
+	/*
+		dsp->clrbuff();
+		show(0x00, "HH:MM:\tSS\t:mmmm", 15); // main dsp
+		show(0x0C, "888", 3); // channel dsp
+		show(0x0A, "\xFF\xFF\xFF\xFF", 4); // all flags
+	*/
 
-  printf("Attaching timers\r\n");
-  splashscreen = true;
-  splashscreen_timer.attach(callback(&end_splashscreen), 2);
-  rst.fall(&reset_irq);
+	printf("Attaching timers\r\n");
+	splashscreen = true;
+	splashscreen_timer.attach(callback(&end_splashscreen), 2);
+	rst.fall(&reset_irq);
 
-  printf("SETUP DONE\r\n");
+	printf("SETUP DONE\r\n");
 }
 
 void end_splashscreen(void)
 {
-  // print is forbidden here because we are in an ISR context here
-  //printf("End of splash screen CB\r\n");
-  splashscreen = false;
+	// print is forbidden here because we are in an ISR context here
+	//printf("End of splash screen CB\r\n");
+	splashscreen = false;
 }
 
 void reset_irq(void)
 {
-  rst_delay.attach(callback(&reset), 0.1);
+	rst_delay.attach(callback(&reset), 0.1);
 }
 
 void reset(void)
 {
-  if (DigitalIn(HP_RST).read() == 0) {
-    if (hp == NULL) {
-      printf("setup HP communication handler\r\n");
-      hp = new HPSerial(HP_TX, HP_RX);
-    }
+	if (DigitalIn(HP_RST).read() == 0) {
+		if (hp == NULL) {
+			printf("setup HP communication handler\r\n");
+			hp = new HPSerial(HP_TX, HP_RX);
+		}
 
-    printf("!! RST !! (gstate=%d, state=%d)\r\n",
-     hp->gstate(), hp->state());
-    //printf("Value is ... %X\n", hp->search());
-    hp->startup();
-  }
+		printf("!! RST !! (gstate=%d, state=%d)\r\n",
+					 hp->gstate(), hp->state());
+		//printf("Value is ... %X\n", hp->search());
+		hp->startup();
+	}
 }
 
 void copy_to_lcd(void) {
-  //uint8_t mask=1;
+	//uint8_t mask=1;
 
-  while(1) {
-    pulse(0, true);
-    if ((splashscreen == false) && (must_refresh)) {
-      must_refresh = 0;
-      //Thread::wait(20); // give a bit of time for some more cmds
-      dsp->copy_to_lcd();
-    }
+	while(1) {
+		pulse(0, true);
+		if ((splashscreen == false) && (must_refresh)) {
+			must_refresh = 0;
+			//Thread::wait(20); // give a bit of time for some more cmds
+			dsp->copy_to_lcd();
+		}
 
-    /*
-    if (must_refresh & mask) {
-      for(uint8_t i=0; i<sizeof(zones)/sizeof(zones[0]); i++)
-  if (zones[i].flag == mask) {
-    dsp->copy_to_lcd(zones[i].x0/4, (zones[i].x1+3)/4,
-        zones[i].y0,   zones[i].y1);
-    must_refresh &= ~mask;
-    break;
-  }
-    }
-    mask = mask << 1;
-    if (mask == 0) {
-      mask = 1;
-    }
-    */
-    pulse(0, false);
+		/*
+			if (must_refresh & mask) {
+			for(uint8_t i=0; i<sizeof(zones)/sizeof(zones[0]); i++)
+			if (zones[i].flag == mask) {
+			dsp->copy_to_lcd(zones[i].x0/4, (zones[i].x1+3)/4,
+			zones[i].y0,   zones[i].y1);
+			must_refresh &= ~mask;
+			break;
+			}
+			}
+			mask = mask << 1;
+			if (mask == 0) {
+			mask = 1;
+			}
+		*/
+		pulse(0, false);
 
-  ThisThread::sleep_for(30);
-  }
+		ThisThread::sleep_for(30);
+	}
 }
 
 void show(uint8_t cmd, const char *intxt, uint8_t nchar=0)
 {
-  uint8_t i;
-  // uint8_t len;
-  uint16_t bgcolor, fgcolor;
-  char *oldv;
-  // char *txt;
-  char *txtp;
-  static char txt[256];
+	uint8_t i;
+	// uint8_t len;
+	uint16_t bgcolor, fgcolor;
+	char *oldv;
+	// char *txt;
+	char *txtp;
+	static char txt[256];
 
 
-  if (cmd == 0xFF) // cls
-  {
-    dsp->clrbuff();
-  }
-  else
-  {
-    //txt = (char *)malloc(strlen(intxt)+1);
-    strcpy(txt, intxt);
-    txtp = txt;
+	if (cmd == 0xFF) // cls
+	{
+		dsp->clrbuff();
+	}
+	else
+	{
+		//txt = (char *)malloc(strlen(intxt)+1);
+		strcpy(txt, intxt);
+		txtp = txt;
 
-    pulse(1, true);
+		pulse(1, true);
 
-    // len = MAX_BUFF;
+		// len = MAX_BUFF;
 
-    for (i=0; i<sizeof(table)/sizeof(table[0]); ++i) {
-      if (table[i].cmd == cmd) {
-        bgcolor = table[i].bgcolor;
-        fgcolor = table[i].color;
-        dsp->background(bgcolor);
-        dsp->foreground(fgcolor);
-        dsp->set_font((unsigned char*) table[i].font);
-        oldv = table[i].buffer;
+		for (i=0; i<sizeof(table)/sizeof(table[0]); ++i) {
+			if (table[i].cmd == cmd) {
+				bgcolor = table[i].bgcolor;
+				fgcolor = table[i].color;
+				dsp->background(bgcolor);
+				dsp->foreground(fgcolor);
+				dsp->set_font((unsigned char*) table[i].font);
+				oldv = table[i].buffer;
 
-        dsp->locate(table[i].x0, table[i].y0);
+				dsp->locate(table[i].x0, table[i].y0);
 
-        if (table[i].fmt & 0x01)  // ASCII text
-        {
-          if (strncmp(oldv, txt, table[i].maxsize) != 0)
-          {
-            if (table[i].width > 0)
-              dsp->fillrect(table[i].x0,
-                      table[i].y0,
-                      table[i].x0 + table[i].width,
-                      table[i].y0 + table[i].font[2],
-                      bgcolor);
-            for (uint8_t k=0; ;k++)
-            {
-              if (txtp[k] == 0x00)
-              {
-                dsp->printf(txtp);
-                break;
-              }
-              if (txtp[k] == 0x09)
-              { // \t is a special char for 'unselected' display value
-                txtp[k] = 0x00;
-                dsp->printf(txtp);
+				if (table[i].fmt & 0x01)  // ASCII text
+				{
+					if (strncmp(oldv, txt, table[i].maxsize) != 0)
+					{
+						if (table[i].width > 0)
+							dsp->fillrect(table[i].x0,
+														table[i].y0,
+														table[i].x0 + table[i].width,
+														table[i].y0 + table[i].font[2],
+														bgcolor);
+						for (uint8_t k=0; ;k++)
+						{
+							if (txtp[k] == 0x00)
+							{
+								dsp->printf(txtp);
+								break;
+							}
+							if (txtp[k] == 0x09)
+							{ // \t is a special char for 'unselected' display value
+								txtp[k] = 0x00;
+								dsp->printf(txtp);
 
-                if (fgcolor == table[i].color)
-                  fgcolor /= 2;
-                else
-                  fgcolor = table[i].color;
-                dsp->foreground(fgcolor);
-                txtp = &(txtp[k+1]);
-                k = 0;
-              }
-            }
-            if (cmd == 0x00) // main area
-              must_refresh |= 0x01;
-            if (cmd == 0x0C) // channels area
-              must_refresh |= 0x04;
-          }
-        }
-        /*
-          if (table[i].fmt & 0x02 ) {
-          // hex
-          for (uint8_t j=0;; j++) {
-          if (txt[j] == 0x00)
-          break;
-          dsp->printf("%02X ", txt[j]);
-          }
-          for (uint8_t j=3*strlen(txt); j<table[i].maxsize; j++)
-          dsp->printf(" ");
-          }
-        */
-        if (table[i].fmt & 0x08 )  // flag indicators
-        {
-          // flags
-          for (uint8_t j=0; j<max(nchar, table[i].maxsize) ; j++)
-          {
-            for (uint8_t k=0; k<8; k++)
-            {
-              if (1)
-              { //(txt[j] & (1 << k) ) != (oldv[j] & (1 << k))) {
-                for (uint8_t l=0;
-                     l<(sizeof(flags)/sizeof(flags[0])); ++l)
-                {
-                  if (flags[l].flag == ((j<<4) + k)) {
-                    if (txtp[j] & (1 << k))
-                    {
-                      dsp->foreground(flags[l].reverse ? bgcolor : fgcolor);
-                      dsp->background(flags[l].reverse ? fgcolor : bgcolor);
-                    }
-                    else
-                    {
-                      dsp->foreground(bgcolor);
-                      dsp->background(bgcolor);
-                    }
-                    if (flags[l].msg != NULL)
-                    { // a string
-                      dsp->locate(flags[l].x, flags[l].y);
-                      dsp->printf(flags[l].msg);}
-                    else
-                    { // an icon
-                      Bitmap_s pic = {9, 10, 2, (char*) flags[l].icon};
-                      dsp->Bitmap_BW(pic, flags[l].x, flags[l].y);
-                    }
-                    must_refresh = 1; //|= zones[m].flag;
-                    break;
-                  }
-                }
-              }
-            }
-          }
+								if (fgcolor == table[i].color)
+									fgcolor /= 2;
+								else
+									fgcolor = table[i].color;
+								dsp->foreground(fgcolor);
+								txtp = &(txtp[k+1]);
+								k = 0;
+							}
+						}
+						if (cmd == 0x00) // main area
+							must_refresh |= 0x01;
+						if (cmd == 0x0C) // channels area
+							must_refresh |= 0x04;
+					}
+				}
+				/*
+					if (table[i].fmt & 0x02 ) {
+					// hex
+					for (uint8_t j=0;; j++) {
+					if (txt[j] == 0x00)
+					break;
+					dsp->printf("%02X ", txt[j]);
+					}
+					for (uint8_t j=3*strlen(txt); j<table[i].maxsize; j++)
+					dsp->printf(" ");
+					}
+				*/
+				if (table[i].fmt & 0x08 )  // flag indicators
+				{
+					// flags
+					for (uint8_t j=0; j<max(nchar, table[i].maxsize) ; j++)
+					{
+						for (uint8_t k=0; k<8; k++)
+						{
+							if (1)
+							{ //(txt[j] & (1 << k) ) != (oldv[j] & (1 << k))) {
+								for (uint8_t l=0;
+										 l<(sizeof(flags)/sizeof(flags[0])); ++l)
+								{
+									if (flags[l].flag == ((j<<4) + k)) {
+										if (txtp[j] & (1 << k))
+										{
+											dsp->foreground(flags[l].reverse ? bgcolor : fgcolor);
+											dsp->background(flags[l].reverse ? fgcolor : bgcolor);
+										}
+										else
+										{
+											dsp->foreground(bgcolor);
+											dsp->background(bgcolor);
+										}
+										if (flags[l].msg != NULL)
+										{ // a string
+											dsp->locate(flags[l].x, flags[l].y);
+											dsp->printf(flags[l].msg);}
+										else
+										{ // an icon
+											Bitmap_s pic = {9, 10, 2, (char*) flags[l].icon};
+											dsp->Bitmap_BW(pic, flags[l].x, flags[l].y);
+										}
+										must_refresh = 1; //|= zones[m].flag;
+										break;
+									}
+								}
+							}
+						}
+					}
 
-          // draw frames (Alarm and Channel)
-          for (uint8_t l=0;
-               l<(sizeof(frames)/sizeof(frames[0])); ++l)
-          {
-            uint16_t color;
-            if (frames[l].flag & txt[0]) // frame flags are on the 1st byte only
-              color = fgcolor/6;
-            else
-              color = bgcolor;
-            dsp->hline(frames[l].x0+1, frames[l].x0+3, frames[l].y0, color);
-            dsp->hline(frames[l].x1-3, frames[l].x1-1, frames[l].y0, color);
-            dsp->hline(frames[l].x0+1, frames[l].x1-1, frames[l].y1, color);
+					// draw frames (Alarm and Channel)
+					for (uint8_t l=0;
+							 l<(sizeof(frames)/sizeof(frames[0])); ++l)
+					{
+						uint16_t color;
+						if (frames[l].flag & txt[0]) // frame flags are on the 1st byte only
+							color = fgcolor/6;
+						else
+							color = bgcolor;
+						dsp->hline(frames[l].x0+1, frames[l].x0+3, frames[l].y0, color);
+						dsp->hline(frames[l].x1-3, frames[l].x1-1, frames[l].y0, color);
+						dsp->hline(frames[l].x0+1, frames[l].x1-1, frames[l].y1, color);
 
-            dsp->vline(frames[l].x0, frames[l].y0+1, frames[l].y1-1, color);
-            dsp->vline(frames[l].x1, frames[l].y0+1, frames[l].y1-1, color);
-          }
-        }
+						dsp->vline(frames[l].x0, frames[l].y0+1, frames[l].y1-1, color);
+						dsp->vline(frames[l].x1, frames[l].y0+1, frames[l].y1-1, color);
+					}
+				}
 
-        for(uint8_t j=0; j<table[i].maxsize; j++)
-          oldv[j] = txt[j];
-        break;
-      }
-    }
-    //free(txt);
-    //dsp->copy_to_lcd();
-    pulse(1, false);
-  }
+				for(uint8_t j=0; j<table[i].maxsize; j++)
+					oldv[j] = txt[j];
+				break;
+			}
+		}
+		//free(txt);
+		//dsp->copy_to_lcd();
+		pulse(1, false);
+	}
 }
 
 void test_dsp()
 {
-  const FRAME *z;
-  printf("TEST DSP\r\n");
-  dsp->cls();
-  printf("TEST DSP #2\r\n");
-  show(0x00, "8g8g8g8g8g8g8", 13); // main dsp
-  show(0x0C, "888", 3); // channel dsp
-  show(0x0A, "\xFF\xFF\xFF\xFF", 4); // all flags
-  dsp->copy_to_lcd();
-  ThisThread::sleep_for(3);
-  dsp->cls();
-  printf("TEST DSP #3\r\n");
+	const FRAME *z;
+	printf("TEST DSP\r\n");
+	dsp->cls();
+	printf("TEST DSP #2\r\n");
+	show(0x00, "8g8g8g8g8g8g8", 13); // main dsp
+	show(0x0C, "888", 3); // channel dsp
+	show(0x0A, "\xFF\xFF\xFF\xFF", 4); // all flags
+	dsp->copy_to_lcd();
+	ThisThread::sleep_for(3);
+	dsp->cls();
+	printf("TEST DSP #3\r\n");
 
-  for (uint8_t i=0; i<(sizeof(zones)/sizeof(zones[0])); i++)
-    {
-      z = &zones[i];
-      dsp->fillrect(z->x0, z->y0, z->x1, z->y1, 4+i);
-      dsp->locate(z->x0+1, z->y0+1);
-      dsp->printf("%d", i);
-    }
+	for (uint8_t i=0; i<(sizeof(zones)/sizeof(zones[0])); i++)
+	{
+		z = &zones[i];
+		dsp->fillrect(z->x0, z->y0, z->x1, z->y1, 4+i);
+		dsp->locate(z->x0+1, z->y0+1);
+		dsp->printf("%d", i);
+	}
 
-  /*
-  for (uint8_t i=0; i<(sizeof(zones)/sizeof(zones[0])); i++)
-    {
-      z = &zones[i];
-      printf("Zone %d [%x]: %d, %d, %d, %d\n", i, z->flag,
-    z->x0, z->y0, z->x1, z->y1);
-      must_refresh = z->flag;
-      wait(1);
-    }
-  printf("Done\n");
-  wait(2);
-  printf("Copy ALL\n");
-  dsp->copy_to_lcd();
-  */
-  ThisThread::sleep_for(2);
-  dsp->cls();
-  printf("TEST DSP DONE\r\n");
+	/*
+		for (uint8_t i=0; i<(sizeof(zones)/sizeof(zones[0])); i++)
+		{
+		z = &zones[i];
+		printf("Zone %d [%x]: %d, %d, %d, %d\n", i, z->flag,
+		z->x0, z->y0, z->x1, z->y1);
+		must_refresh = z->flag;
+		wait(1);
+		}
+		printf("Done\n");
+		wait(2);
+		printf("Copy ALL\n");
+		dsp->copy_to_lcd();
+	*/
+	ThisThread::sleep_for(2);
+	dsp->cls();
+	printf("TEST DSP DONE\r\n");
 }
 
 
 void loop()
 { // run over and over
-  keycode_t key;
+	keycode_t key;
 
-  unsigned int err[8];
-  for (uint8_t i=0; i<8; i++)
-    err[i] = 0;
-  int p, pp;  // rot encoder pulse counters
-  p = 0;
-  pp = 0;
+	unsigned int err[8];
+	for (uint8_t i=0; i<8; i++)
+		err[i] = 0;
+	int p, pp;  // rot encoder pulse counters
+	p = 0;
+	pp = 0;
 
-  while(1) {
-    p = qenc.getPulses();
-    if (p != pp)
-  {
-    dsp->locate(0, 0);
-    dsp->printf("Pulses = %d  ", p);
-      dsp->copy_to_lcd();
-    pp = p;
-    }
+	while(1) {
+		p = qenc.getPulses();
+		if (p != pp)
+		{
+			dsp->locate(0, 0);
+			dsp->printf("Pulses = %d  ", p);
+			dsp->copy_to_lcd();
+			pp = p;
+		}
 
-    if (knob != 0)
-  {
-    if (hp != NULL)
-    {
-    printf("Sending keycode %X\r\n", knob);
-    hp->sendkey(knob);
-    printf("   DONE\r\n");
-    }
-    else
-    {
-      dsp->locate(70, 0);
-      dsp->printf("Knob = %X  ", knob);
-      dsp->copy_to_lcd();
-    }
-    knob = 0;
-  }
+		if (knob != 0)
+		{
+			if (hp != NULL)
+			{
+				printf("Sending keycode %X\r\n", knob);
+				hp->sendkey(knob);
+				printf("   DONE\r\n");
+			}
+			else
+			{
+				dsp->locate(70, 0);
+				dsp->printf("Knob = %X  ", knob);
+				dsp->copy_to_lcd();
+			}
+			knob = 0;
+		}
 
-    if (!key_buf.empty()) //cur_keycode.keyevent != KEY_NONE)
-	{
-	  key_buf.pop(key);
-	  printf("Keycode %dx%d: %s\r\n",
-			 key.row, key.col, key.keyevent==KEY_PRESSED?"pressed":"released");
-	  if (hp != NULL) {
-		hp->sendkey(kp_mapping[key.row][key.col]);
-	  }
-	  else
-	  {
-		dsp->locate(140, 0);
-		dsp->printf("KC: %dx%d[%X] %s",
-					key.row, key.col, kp_mapping[key.row][key.col],
-					key.keyevent==KEY_PRESSED?"PRE":"REL");
-		dsp->copy_to_lcd();
-	  }
-	  // cur_keycode.keyevent = KEY_NONE;
-  }
+		if (!key_buf.empty()) //cur_keycode.keyevent != KEY_NONE)
+		{
+			key_buf.pop(key);
+			printf("Keycode %dx%d: %s\r\n",
+						 key.row, key.col, key.keyevent==KEY_PRESSED?"pressed":"released");
+			if (hp != NULL) {
+				uint8_t keycode = kp_mapping[key.row][key.col];
+				if (key.keyevent == KEY_RELEASED)
+					keycode |= 0x40;  // bit 6: key relased
+				if (shift)
+					keycode |= 0x20;  // bit 5: key shifted
+
+				hp->sendkey(kp_mapping[key.row][key.col]);
+			}
+			else
+			{
+				dsp->locate(140, 0);
+				dsp->printf("KC: %dx%d[0x%s%X] %s",
+										key.row, key.col,
+										kp_mapping[key.row][key.col] <= 0x0F ? "0" : "",
+										kp_mapping[key.row][key.col],
+										key.keyevent==KEY_PRESSED ? "PRE" : "REL");
+				dsp->copy_to_lcd();
+			}
+			// cur_keycode.keyevent = KEY_NONE;
+		}
 
 
-    if ((hp != NULL) && (hp->cmd_available()))
-      {
-    HPSerial::CMD cmd;
-    if (hp->pop(cmd))
-        {
+		if ((hp != NULL) && (hp->cmd_available()))
+		{
+			HPSerial::CMD cmd;
+			if (hp->pop(cmd))
+			{
 #if defined(HAS_LED)
-      led = 1;
+				led = 1;
 #endif
-        for (uint8_t i=0; i<7; i++)
-            if (hp->nerrors(i) > err[i]) {
-            printf("ERR: %d/%d/%d/%d/%d/%d/%d\r\n",
-               hp->nerrors(0),
-               hp->nerrors(1),
-               hp->nerrors(2),
-               hp->nerrors(3),
-               hp->nerrors(4),
-               hp->nerrors(5),
-               hp->nerrors(6)
-               );
-            break;
-          }
-          for (uint8_t i=0; i<7; i++)
-            err[i] = hp->nerrors(i);
+				for (uint8_t i=0; i<7; i++)
+					if (hp->nerrors(i) > err[i]) {
+						printf("ERR: %d/%d/%d/%d/%d/%d/%d\r\n",
+									 hp->nerrors(0),
+									 hp->nerrors(1),
+									 hp->nerrors(2),
+									 hp->nerrors(3),
+									 hp->nerrors(4),
+									 hp->nerrors(5),
+									 hp->nerrors(6)
+									 );
+						break;
+					}
+				for (uint8_t i=0; i<7; i++)
+					err[i] = hp->nerrors(i);
 
-          printf("CMD[%d] %02X", (int)cmd.id, cmd.cmd);
+				printf("CMD[%d] %02X", (int)cmd.id, cmd.cmd);
 
-          if ((cmd.cmd == 0x00) || (cmd.cmd == 0x0C))
-            printf(": '%s'\r\n", cmd.value);
-          else {
-          printf(":");
-            for (uint8_t i=0; i<cmd.size; i++)
-            printf("%02x ", cmd.value[i]);
-            printf("\r\n");
-        }
-          show(cmd.cmd, cmd.value, cmd.size);
+				if ((cmd.cmd == 0x00) || (cmd.cmd == 0x0C))
+					printf(": '%s'\r\n", cmd.value);
+				else {
+					printf(":");
+					for (uint8_t i=0; i<cmd.size; i++)
+						printf("%02x ", cmd.value[i]);
+					printf("\r\n");
+				}
+				show(cmd.cmd, cmd.value, cmd.size);
 #if defined(HAS_LED)
-      led = 0;
+				led = 0;
 #endif
-        }
-    }
-  //else
-  ThisThread::sleep_for(1);
-  }
+			}
+		}
+		//else
+		ThisThread::sleep_for(1);
+	}
 }
 
 void qei_cb(int dir)
 {
-  if(dir == 1) // turn right
-    knob = 0x80;
-  else         // turn left
-  knob = 0x81;  // 83?
+	if(dir == 1) // turn right
+		knob = 0x80;
+	else         // turn left
+		knob = 0x81;  // 83?
 }
 
 void kp_cb(uint8_t row, uint8_t col)
 {
-  keycode_t key;
-    key.row = row;
-    key.col = col;
-    key.keyevent = KEY_PRESSED;
-  if(!key_buf.full())
-    key_buf.push(key);
+	keycode_t key;
+	key.row = row;
+	key.col = col;
+	key.keyevent = KEY_PRESSED;
+	if(!key_buf.full())
+		key_buf.push(key);
 }
 
 void kr_cb(uint8_t row, uint8_t col)
 {
-  keycode_t key;
-    key.row = row;
-    key.col = col;
-    key.keyevent = KEY_RELEASED;
-  if(!key_buf.full())
-    key_buf.push(key);
+	keycode_t key;
+	key.row = row;
+	key.col = col;
+	key.keyevent = KEY_RELEASED;
+	if(!key_buf.full())
+		key_buf.push(key);
 }
 
 int main()
 {
-  setup();
-  printf("Main loop (noop)\r\n");
-  while(1)
-  {
-    timeout_h();
-    ThisThread::sleep_for(1);
-  }
+	setup();
+	printf("Main loop (noop)\r\n");
+	while(1)
+	{
+		timeout_h();
+		ThisThread::sleep_for(1);
+	}
 }

mercurial