ikosi_1.ino

/*

  ikosi_1.ino
  
  requires valid "key_to_LED_map" and "gel" arrays generated by ikosi_train.ino
  
  
  Includes:
    - WS2812 (Data output at GPIO PA7)
    - Sensor key read
    - Sensor key mapping and learn mode

  Linux:
    stty -F /dev/ttyUSB0 sane 115200 && cat /dev/ttyUSB0
    or stty -F /dev/ttyUSB0 sane 115200 igncr  && cat /dev/ttyUSB0
    screen /dev/ttyUSB0  115200 (terminate with "C-a k" or "C-a \")
    minicom -D /dev/ttyUSB0  -b 115200 (terminate with "C-a x", change CR mode: "C-a u", disable HW control flow!)


  ToDo:
    Implement a eoChangeColor function
      inital color is 0,0,0
      fade to new color 0,0,0 with tick cnt
      
      B12, D10

*/

#include <stdarg.h>

/*================================================*/
/* configuration */

/* As soon as the user select a key, then the corresponding edge will become this color */
/* if all rgb values are 0, then there will be no automatic key highlightning */
uint8_t sensor_key_select_color_r = 0;
uint8_t sensor_key_select_color_g = 0;
uint8_t sensor_key_select_color_b = 0;

/* if a edge is black, then it is replaced with this color */
uint8_t black_replacement_r = 20;
uint8_t black_replacement_g = 30;
uint8_t black_replacement_b = 20;

/* player 1 color */
uint8_t p1_r = 0;
uint8_t p1_g = 0;
uint8_t p1_b = 250;

/* player 1 correct edge indication color */
uint8_t p1v_r = 0;
uint8_t p1v_g = 150;
uint8_t p1v_b = 250;

/* illegal edge for player 1 */
uint8_t p1i_r = 0;
uint8_t p1i_g = 0;
uint8_t p1i_b = 250;

/* player 2 color */
uint8_t p2_r = 250;
uint8_t p2_g = 0;
uint8_t p2_b = 0;

/* player 2 correct edge indication color */
uint8_t p2v_r = 250;
uint8_t p2v_g = 150;
uint8_t p2v_b = 0;

/* illegal edge for player 2 */
uint8_t p2i_r = 250;
uint8_t p2i_g = 0;
uint8_t p2i_b = 0;


/*================================================*/
/* GEL Array: Graph definitions */

/* graph element struct (actually it is the edge of the ikosidodecaeder */
struct ge_struct
{
  int16_t led;               // led number, LED can be derived via key_to_LED_map[key]
  int16_t key;              // index into touch_status_list[] 
  int16_t pentagon;     // pentagon number, starts with 0
  int16_t triangle;        // triangle number, starts with 0
  int16_t next[6];          // each ikosidodecaeder has six neighbour edges
  /*
    if edge is assumed to be part of a pentagon then
      next[0] is previous clock wise edge of the pentagon
      next[5] is next clock wise edge of the pentagon
    if edge is assumed to be part of a triangle then
      next[3] is previous clock wise edge of the triangle
      next[2] is next clock wise edge of the triangle
    next[1] and next[4] describe the 10-edge ring of the ikosidodecaedron
      Looping over that ring is a little bit more complicated, because the next
      position is devinde alternating between next[1] and next[4]
        pos = gel[pos].next[4];
        for( i = 1; i < 10; i++ )
        {
          if ( (i & 1) != 0 )
            pos = gel[pos].next[1];
          else
            pos = gel[pos].next[4];
        }
  */
};

/*
low cap warning for key 14 (B9), cap=9, sensor might be disconnected
low cap warning for key 29 (C8), cap=9, sensor might be disconnected
low cap warning for key 36 (D1), cap=11, sensor might be disconnected
low cap warning for key 40 (D5), cap=11, sensor might be disconnected

low cap warning for key 12 (B7), cap=14, sensor might be disconnected
low cap warning for key 36 (D1), cap=6, sensor might be disconnected
low cap warning for key 38 (D3), cap=14, sensor might be disconnected
low cap warning for key 39 (D4), cap=13, sensor might be disconnected
low cap warning for key 40 (D5), cap=6, sensor might be disconnected
low cap warning for key 46 (D11), cap=5, sensor might be disconnected
low cap warning for key 47 (D12), cap=14, sensor might be disconnected
low cap warning for key 56 (E5), cap=13, sensor might be disconnected
low cap warning for key 62 (E11), cap=13, sensor might be disconnected


*/

/* gel is learned by ikosi_learn.ino, result has to be inserted here */
struct ge_struct gel[60] = {
{36,0 /* A2 */,0,0,{-1,-1,53,-1,-1,27}}
,{51,1 /* A3 */,0,1,{-1,-1,7,-1,-1,0}}
,{21,2 /* A4 */,1,2,{-1,-1,18,-1,-1,26}}
,{25,3 /* A5 */,1,3,{-1,-1,34,-1,-1,2}}
,{20,5 /* A8 */,2,4,{-1,-1,26,-1,-1,44}}
,{17,6 /* A15 */,3,5,{-1,-1,15,-1,-1,28}}
,{44,7 /* B0 */,0,6,{-1,-1,41,-1,-1,51}}
,{59,8 /* B1 */,4,1,{-1,-1,46,-1,-1,59}}
,{8,9 /* B3 */,5,7,{-1,-1,9,-1,-1,54}}
,{56,10 /* B5 */,6,7,{-1,-1,50,-1,-1,13}}
,{58,11 /* B6 */,6,8,{-1,-1,14,-1,-1,12}}
,{4,12 /* B7 */,6,9,{-1,-1,37,-1,-1,9}}
,{48,13 /* B8 */,6,10,{-1,-1,49,-1,-1,11}}
,{7,14 /* B9 */,6,11,{-1,-1,24,-1,-1,10}}
,{49,15 /* B10 */,4,8,{-1,-1,32,-1,-1,17}}
,{19,16 /* B11 */,7,5,{-1,-1,43,-1,-1,31}}
,{63,18 /* B13 */,8,12,{-1,-1,59,-1,-1,22}}
,{55,19 /* B14 */,4,11,{-1,-1,13,-1,-1,45}}
,{22,21 /* C0 */,9,2,{-1,-1,23,-1,-1,29}}
,{41,22 /* C1 */,10,13,{-1,-1,45,-1,-1,36}}
,{28,23 /* C2 */,2,14,{-1,-1,27,-1,-1,4}}
,{5,24 /* C3 */,3,15,{-1,-1,48,-1,-1,5}}
,{46,25 /* C4 */,8,6,{-1,-1,6,-1,-1,57}}
,{11,26 /* C5 */,3,2,{-1,-1,2,-1,-1,21}}
,{57,27 /* C6 */,5,11,{-1,-1,17,-1,-1,8}}
,{31,28 /* C7 */,2,16,{-1,-1,55,-1,-1,41}}
,{12,29 /* C8 */,1,4,{-1,-1,56,-1,-1,38}}
,{27,30 /* C9 */,0,14,{-1,-1,38,-1,-1,6}}
,{14,31 /* C10 */,3,17,{-1,-1,40,-1,-1,56}}
,{24,32 /* C11 */,9,3,{-1,-1,3,-1,-1,47}}
,{38,33 /* C12 */,1,0,{-1,-1,0,-1,-1,3}}
,{2,34 /* C13 */,7,15,{-1,-1,21,-1,-1,42}}
,{62,35 /* D0 */,8,8,{-1,-1,10,-1,-1,16}}
,{32,36 /* D1 */,11,10,{-1,-1,12,-1,-1,55}}
,{37,37 /* D2 */,10,3,{-1,-1,29,-1,-1,53}}
,{40,38 /* D3 */,5,18,{-1,-1,47,-1,-1,58}}
,{42,39 /* D4 */,10,18,{-1,-1,35,-1,-1,34}}
,{15,40 /* D5 */,11,9,{-1,-1,52,-1,-1,33}}
,{26,41 /* D6 */,1,14,{-1,-1,20,-1,-1,30}}
,{9,42 /* D7 */,9,19,{-1,-1,54,-1,-1,48}}
,{16,44 /* D9 */,11,17,{-1,-1,44,-1,-1,43}}
,{45,46 /* D11 */,2,6,{-1,-1,22,-1,-1,20}}
,{3,47 /* D12 */,7,19,{-1,-1,39,-1,-1,50}}
,{30,48 /* D13 */,11,5,{-1,-1,5,-1,-1,37}}
,{0,49 /* D14 */,2,17,{-1,-1,28,-1,-1,25}}
,{53,50 /* D15 */,4,13,{-1,-1,58,-1,-1,7}}
,{52,53 /* E2 */,10,1,{-1,-1,1,-1,-1,19}}
,{39,54 /* E3 */,9,18,{-1,-1,36,-1,-1,39}}
,{10,55 /* E4 */,9,15,{-1,-1,31,-1,-1,18}}
,{47,56 /* E5 */,8,10,{-1,-1,33,-1,-1,32}}
,{6,57 /* E6 */,7,7,{-1,-1,8,-1,-1,52}}
,{50,58 /* E7 */,0,12,{-1,-1,16,-1,-1,1}}
,{1,59 /* E8 */,7,9,{-1,-1,11,-1,-1,15}}
,{43,60 /* E9 */,10,0,{-1,-1,30,-1,-1,46}}
,{23,61 /* E10 */,5,19,{-1,-1,42,-1,-1,35}}
,{18,62 /* E11 */,11,16,{-1,-1,57,-1,-1,40}}
,{13,63 /* E12 */,3,4,{-1,-1,4,-1,-1,23}}
,{29,64 /* E13 */,8,16,{-1,-1,25,-1,-1,49}}
,{54,65 /* E14 */,5,13,{-1,-1,19,-1,-1,24}}
,{60,66 /* E15 */,4,12,{-1,-1,51,-1,-1,14}}
};



/*================================================*/

typedef int (*eo_cb)(struct _eo_struct *eo, unsigned msg, unsigned arg);

/*================================================*/
/* Wrapper for Arduino Serial.print to have something like printf() for debugging */

void p(const char *fmt, ...)
{
  static char s[1024];
  va_list va;
  va_start(va, fmt);
  vsnprintf(s, 1024, fmt, va);
  va_end(va);
  Serial.print(s);
}

/* same as p() but adds a line feed at the end */
void pn(const char *fmt, ...)
{
  static char s[1024];
  va_list va;
  va_start(va, fmt);
  vsnprintf(s, 1024, fmt, va);
  va_end(va);
  Serial.print(s);
  Serial.print("\n");
}


/*================================================*/
/* 
  Interface to the 16x16 LED Matrix (64 LEDs, 4 unused)
  Each LED includes a WS2812 controller (WS2812 Interface) 
  
  The WS2812 receives input via SPI bus.
  The SPI bis is "misused" to generate the required wave form for the WS2812
  4 Bit in the SPI Bus are used to sent one bit of information to the 64x WS2812 
  controller.

  Assumptions:
    SystemCoreClock: 168 MHz
    APB2: 84Mhz 

  SPI Clock BR = 100 --> Clock Divide by 32 --> 84 / 32 = 2.625 MHz --> 380ns

  per bit:
    0: 1000 --> 380ns pulse for the WS2812 (logical 0 bit)
    1: 1100 --> 760ns pulse for the WS2812 (logical 1 bit)
  
  Each SPI word is 16 bit in size: We can transfer 4 bits per SPI word.
  
*/

struct _ws2812_spi
{
  volatile uint8_t *spi_data;
  volatile uint32_t byte_cnt;    // remaining bytes
  volatile uint32_t b;    // the current byte
  volatile uint32_t bit_cnt;
  volatile uint32_t post_data_wait;
  volatile uint32_t isr_cnt;
  volatile uint32_t spi_status_register;
  volatile uint32_t isr_ticks;
  volatile uint32_t max_isr_ticks;
  volatile int in_progress;
};
typedef struct _ws2812_spi ws2812_spi_t;
ws2812_spi_t ws2812_spi;

void ws2812_spi_init(void)
{
  ws2812_spi.isr_cnt = 0;  
  RCC->APB2ENR |= RCC_APB2ENR_SPI1EN;
  delay(1);
  SPI1->CR1 = 0;  /* disable SPI */
  SPI1->I2SCFGR = 0;  /* no I2S */
  SPI1->CR2 = 0; /* disable interrupts */

  /* PA7, AF5 --> SPI1 MOSI */

  GPIOA->MODER &= ~GPIO_MODER_MODER7;
  GPIOA->MODER |= GPIO_MODER_MODER7_1; /* alternate function mode */
  GPIOA->OTYPER &= ~GPIO_OTYPER_OT7;  /* push pull */
  GPIOA->PUPDR &= ~GPIO_PUPDR_PUPD7;  /* no pullup/pulldown */
  GPIOA->AFR[0] &= ~GPIO_AFRL_AFSEL7;
  GPIOA->AFR[0] |= GPIO_AFRL_AFSEL7_2 | GPIO_AFRL_AFSEL7_0; /* configure AF5, bitmask 0101 */
  NVIC_SetPriority(SPI1_IRQn, 2);  /* 0: highes priority, 3: lowest priority */
  NVIC_EnableIRQ(SPI1_IRQn);    
}

/*
  This SPI handler will do an online conversion of the bit values to the WS2812B format 
  4 bits of data are converted into two bytes (16 bit) of data
  This procedure is time critical: 64 Sys-Clock-Cycle per SPI bit 64*16 = 1024 Clock Cycles
  ==> Upper Limit for this procedure are 1024 clock cycles
*/
extern "C" void __attribute__ ((interrupt)) SPI1_IRQHandler(void)
{
  ws2812_spi.spi_status_register = SPI1->SR;
  ws2812_spi.isr_cnt++;

  if ( (ws2812_spi.spi_status_register & SPI_SR_TXE) == 0 ) 
    return;

  if ( ws2812_spi.byte_cnt > 0 || ws2812_spi.bit_cnt > 0 )
  {
    uint16_t d = 0x4444;
    uint16_t b;
    
    if ( ws2812_spi.bit_cnt == 0 )
    {
      ws2812_spi.b = *ws2812_spi.spi_data;
      ws2812_spi.spi_data++;
      ws2812_spi.byte_cnt--;
      ws2812_spi.bit_cnt = 2;
    }
    
    b = ws2812_spi.b;
    if ( b & 128 )
      d |= 0x2000;
    if ( b & 64 )
      d |= 0x0200;
    if ( b & 32 )
      d |= 0x0020;
    if ( b & 16 )
      d |= 0x0002;
    b <<= 4;
    ws2812_spi.b = b;
    
    SPI1->DR = d;
    ws2812_spi.bit_cnt--;
  }
  else
  {
    if ( ws2812_spi.post_data_wait > 0 )
    {
      /* wait for 50us, this are 125 SPI clocks (each is 0.4us) --> send 128 bits, 8x 16 Bit words */
      SPI1->DR = 0;
      ws2812_spi.post_data_wait--;
    }
    else
    {      
      /* ensure, that the SCK goes to low after the byte transfer... */
      
      /* disable interrupt, needs to be re-enabled whenever new data should be transmitted */
      SPI1->CR2 = 0;
      ws2812_spi.in_progress = 0;
    }
  } 
}

void ws2812_spi_out(uint8_t *data, int cnt)
{
  /* wait until data is transmitted */
  if ( ws2812_spi.in_progress != 0 )
  {
    while( ws2812_spi.in_progress != 0 )
      ;
    delay(1);
  }
  SPI1->CR1 = 0;    /* disable SPI1 */
  SPI1->CR1 = 0
    | SPI_CR1_DFF   /* select 16 bit data format */
    | SPI_CR1_BR_2  /* 100: divide by 32 */
    | SPI_CR1_MSTR  /* master transmit */
    | SPI_CR1_SSM   /* SW Slave Management */
    | SPI_CR1_SSI   /* Internal Slave Select */
    | SPI_CR1_BIDIMODE /* select single line (Master: MOSI pin) bidirectional mode */
    | SPI_CR1_BIDIOE   /* select transmit mode*/
    ;
  SPI1->CR2 = 0
    | SPI_CR2_TXEIE /* buffer empty interrupt */
    ;
  ws2812_spi.spi_data = data;
  ws2812_spi.byte_cnt = cnt;
  ws2812_spi.bit_cnt = 0;
  ws2812_spi.post_data_wait = 9;    /* 8 would be sufficient, use 9 to be on the safe side */
  ws2812_spi.in_progress  = 1;
  SPI1->CR1 |= SPI_CR1_SPE;   /* enable SPI */
  /* load first byte, so that the TXRDY interrupt will be generated */
  /* this is just a zero byte and is ignored by the WS2812B */
  SPI1->DR = 0;  
}

/*================================================*/
/* 
  RGB Matrix Procedure
  
  "Matrix" is misleading: Although the hardware is a 16x16 matrix, the
  LEDs of that matrix are accessed by there sequence number (0...63)

  The RGB Matrix is build on top of the WS2812 procedures.
  
  One RGB Matrix "Plane": Contains the RGB information for 64 LEDs.
  
  There are several special planes:
  LEDMatrixData: This is the plane, which is set to the 16x16 LED Matrix by
    the WS2812 procedures
  LEDPlaneMatrixData: This is an array with multiple planes (LED_PLANE_CNT)
  The idea is to add the RGB values of all the planes in "LEDPlaneMatrixData" 
  and store the resulting RGB value in LEDMatrixData (sendAllPlanes()).
  
  LEDPlaneMatrixData[0] is an exception: none-zero values
  are copied to LEDMatrixData without adding more data.
  LEDPlaneMatrixData[0] will stay zero except fo the element which has
  been touched by the user. So LEDPlaneMatrixData[0] will give
  immediate feedback to the user, which element has been pressed.
  
  Current plane usage:
  
  LEDPlaneMatrixData[0]         Cursor, not used any more
  LEDPlaneMatrixData[1]         Edge Objects (eol)
  LEDPlaneMatrixData[2]         Edge Objects (eol)
  LEDPlaneMatrixData[4]         Fixed Colors
  
  
*/

/* number of LEDs per plane */
#define LED_CNT 64
/* number of planes. RGB value of each plane are added and sent to the target */
#define LED_PLANE_CNT 4

uint8_t LEDMatrixData[LED_CNT*3];
uint8_t LEDPlaneMatrixData[LED_PLANE_CNT][LED_CNT*3];

void initLEDMatrix(void)
{
  ws2812_spi_init();
}

void sendLEDMatrix(void)
{
  ws2812_spi_out(LEDMatrixData, LED_CNT*3);
}

/*
  Sum up planes 1 to LED_PLANE_CNT-1.
  Plane 0 will overwrite the result and replace the result if the RGB value in 
  plane 0 is not black (plane 0 overrides all other planes).
  The result is sent to the RGB 16x16 matrix
*/
void sendAllPlanes(void)
{
  int i, plane;
  unsigned v;
  for( i = 0; i < 64*3; i+=3 )
  {
    LEDMatrixData[i] = 0;
    LEDMatrixData[i+1] = 0;
    LEDMatrixData[i+2] = 0;
    
    /*
      Sum up all RGB channels from all planes.
      Summed up RGB values are limited to white
      Start with the highest plane.
      The lowest plane 0 may discard all calculations are overwrite
      the color if the RGB color is not black in plane 0.
    */
    for( plane = LED_PLANE_CNT-1; plane >= 0; plane-- )
    {
      if ( plane == 0 )
      {
        if ( LEDPlaneMatrixData[plane][i] == 0 
            && LEDPlaneMatrixData[plane][i+1] == 0 
            && LEDPlaneMatrixData[plane][i+2] == 0  )
        {
          /* do nothing */
        }
        else
        {
          /* replace color */
          LEDMatrixData[i] = LEDPlaneMatrixData[plane][i];
          LEDMatrixData[i+1] = LEDPlaneMatrixData[plane][i+1];
          LEDMatrixData[i+2] = LEDPlaneMatrixData[plane][i+2];          
        }
      }
      else
      {
        /* green */
        v = LEDMatrixData[i] + LEDPlaneMatrixData[plane][i];
        if ( v >= 255 )
          v = 255;
        LEDMatrixData[i] = v;
        /* red */
        v = LEDMatrixData[i+1] + LEDPlaneMatrixData[plane][i+1];
        if ( v >= 255 )
          v = 255;
        LEDMatrixData[i+1] = v;
        /* blue */
        v = LEDMatrixData[i+2] + LEDPlaneMatrixData[plane][i+2];
        if ( v >= 255 )
          v = 255;
        LEDMatrixData[i+2] = v;
      }
    }
  }
  
  /* consider only LEDs which are in use */
  for( int j = 0; j < 60; j++ )
  {
    i = gel[j].led*3;
    /* replace full black by the replacement color */
    if ( LEDMatrixData[i] == 0 && LEDMatrixData[i+1] == 0 && LEDMatrixData[i+2] == 0 )
    {
      LEDMatrixData[i+0] = black_replacement_g;
      LEDMatrixData[i+1] = black_replacement_r;
      LEDMatrixData[i+2] = black_replacement_b;
    }
  }
  
  sendLEDMatrix();
}

void clearPlane(unsigned plane)
{
  int i;
  if ( plane < LED_PLANE_CNT )
  {
    for( i = 0; i < 64*3; i++ )
    {
      LEDPlaneMatrixData[plane][i] = 0;
    }
  }
}

/*
  void clearAllPlanes(void)
  
  Description:
    Clear all planes with black color.

*/
void clearAllPlanes(void)
{
  int plane;
  for( plane = 0; plane < LED_PLANE_CNT; plane++ )
    clearPlane(plane);
}

void clearAllPlanesExceptZero(void)
{
  int plane;
  for( plane = 1; plane < LED_PLANE_CNT; plane++ )
    clearPlane(plane);
}

/*
  void setPlaneRGB(unsigned plane, uint8_t pos, uint8_t r, uint8_t g, uint8_t b)
  
  Description:
    Set a single color in a plane.
    Plane 0 is special: If plane 0 color is not black, than this color will
    overwrite all other colors.
    Colors in all other planes above 0 (1..LED_PLANE_CNT-1) are summed up
    
  Args:
    plane:      0..LED_PLANE_CNT-1
    pos:      LED number, either from the "key_to_LED_map[]" array or the "gel.led" member.
    r           Red channel of the LED color (0..255)
    g           Green channel of the LED color (0..255)
    b           Blue channel of the LED color (0..255)  
*/
void setPlaneRGB(unsigned plane, uint8_t pos, uint8_t r, uint8_t g, uint8_t b)
{
  if ( plane < LED_PLANE_CNT )
  {
    if ( pos < 64 )
    {
      LEDPlaneMatrixData[plane][pos*3] = g;
      LEDPlaneMatrixData[plane][pos*3+1] = r;
      LEDPlaneMatrixData[plane][pos*3+2] = b;
    }
  }
}



/* https://stackoverflow.com/questions/3018313/algorithm-to-convert-rgb-to-hsv-and-hsv-to-rgb-in-range-0-255-for-both */
void hsv_to_rgb(uint8_t h, uint8_t s, uint8_t v, uint8_t *r, uint8_t *g, uint8_t *b)
{
    uint8_t region, remainder, p, q, t;

    if (s == 0)
    {
        *r = v;
        *g = v;
        *b = v;
        return ;
    }

    region = h / 43;
    remainder = (h - (region * 43)) * 6; 

    p = (v * (uint16_t)(255 - s)) >> 8;
    q = (v * (uint16_t)(255 - ((s * remainder) >> 8))) >> 8;
    t = (v * (uint16_t)(255 - ((s * (uint16_t)(255 - remainder)) >> 8))) >> 8;

    switch (region)
    {
        case 0:
            *r = v; *g = t; *b = p;
            break;
        case 1:
            *r = q; *g = v; *b = p;
            break;
        case 2:
            *r = p; *g = v; *b = t;
            break;
        case 3:
            *r = p; *g = q; *b = v;
            break;
        case 4:
            *r = t; *g = p; *b = v;
            break;
        default:
            *r = v; *g = p; *b = q;
            break;
    }
}

/*
  void setPlaneHSV(unsigned plane, uint8_t pos, uint8_t h, uint8_t s, uint8_t v)
  
  Description:
    Set a single color in a plane.
    Plane 0 is special: If plane 0 color is not black, than this color will
    overwrite all other colors.
    Colors in all other planes above 0 (1..LED_PLANE_CNT-1) are summed up
    
  Args:
    plane:      0..LED_PLANE_CNT-1
    pos:      LED number, either from the "key_to_LED_map[]" array or the "gel.led" member.
    h           Hue of the LED color (0..255)
    s           Saturation of the LED color (0..255)
    v           Value (brightness) of the LED color (0..255)      
*/
void setPlaneHSV(unsigned plane, uint8_t pos, uint8_t h, uint8_t s, uint8_t v)
{
  hsv_to_rgb(h, s, v, 
    &(LEDPlaneMatrixData[plane][pos*3+1]), 
    &(LEDPlaneMatrixData[plane][pos*3]), 
    &(LEDPlaneMatrixData[plane][pos*3+2]));
}


/*================================================*/
/*
  Low level touch sensor procedures
  
    - There are 60 touch sensors (one for each edge of the ikosidodecaedron)
    - Each of the 60 touch sensors is mapped to a LED (key_to_LED_map[])
    - Each sensor in connected to one GPIO
    - Possible GPIOs are listed in "touch_status_list"
    - The size of "touch_status_list" is TOUCH_KEY_CNT
    - Not all entries in "touch_status_list" are used.
    - The key pressed/release value is an index int touch_status_list.
    - The key value is a number between 0 and TOUCH_KEY_CNT-1.
    - The key value might be larger than 59 because there are some unused GPIOs in "touch_status_list"
    
    The sensor algorithm is based on the discharge time of a GPIO:
      1. Step: Charge the GPIO with some current
      2. Step: Disconnnect charge and measure discharge time
      3. Step: If discarge time is lower then a given threshold, then it is assumed that the sensor is pressed
    
    The measure algorithm combines GPIOs from several GPIO Ports (contains 16 GPIO pins)
    to a single measure run. As a consequence, the measure has to happen only
    once for all GPIOs of a single GPIO Port.
      - Each GPIO Port contains 16 GPIO pins
      - This controller contains 5 GPIO Ports (up to 5x16 = 80 GPIOs)
      - The measure algorithm will use the touch_measure_list
  
*/

#define TOUCH_KEY_STATUS_RELEASED 0
#define TOUCH_KEY_STATUS_RP_DEBOUNCE1 1
#define TOUCH_KEY_STATUS_PRESSED 10
#define TOUCH_KEY_STATUS_PR_DEBOUNCE1 11

/* 
  the following value defines the sensitivity 
  higher values: less sensitive 
  lower values: more sensitive, but risk of faulty detects
*/
#define TOUCH_KEY_MIN_TH_DELTA_CAP 12

/* list of all GPIO lines, used as a sensor key */
struct touch_status_struct {
  GPIO_TypeDef *gpio; /* e.g. GPIOB */
  uint16_t pin;   /* pin number within that GPIO block (0..15) */
  uint16_t arduino_pin;         /* arduino pin number */
  uint16_t min_cap;   /* automatically calculated, typical values seem to be 18..19 */
  uint16_t threshold_cap;   /* if the cap value is below this value, then an untouched touch pad is assumed, use 0 for default */
  uint16_t status;
  uint32_t time;
};

/* helper struct, used to measure up to 16 GPIO lines. This struct will refer to "touch_status_struct" */
struct touch_measure_struct {
  GPIO_TypeDef *gpio; /* e.g. GPIOB */
  uint16_t mask;    /* each set pin means, that this GPIO should be considered */
  int16_t touch_status_index[16];    /* index into the touch status list, negative value means, that the pin is not used (0 in the mask) */
};



/* Touch Sensor */

/*
  the touch status list contains a list of all possible sensor inputs
  some of the ports can be commented if they are used for otherwise
  
  The index into touch_status_list is refered as "key" in this software.
*/
struct touch_status_struct touch_status_list[] =  {
  //{ GPIOA, 0, PA0, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  //{ GPIOA, 1, PA1, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},  
  { GPIOA, 2, PA2, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOA, 3, PA3, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOA, 4, PA4, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOA, 5, PA5, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOA, 6, PA6, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  //{ GPIOA, 7, PA7, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},  // MOSI for LED matrix
  { GPIOA, 8, PA8, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  //{ GPIOA, 9, PA9, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},    // for USART, not on header
  //{ GPIOA, 10, PA10, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},   // for USART, not on header
  
  //{ GPIOA, 11, PA11, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},   // for USART
  //{ GPIOA, 12, PA12, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},   // for USART
  //{ GPIOA, 13, PA13, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},  // SWDIO
  //{ GPIOA, 14, PA14, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},   // SWDCLK
  { GPIOA, 15, PA15, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},

  { GPIOB, 0, PB0, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 1, PB1, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  //{ GPIOB, 2, PB2, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 3, PB3, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  //{ GPIOB, 4, PB4, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  
  { GPIOB, 5, PB5, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 6, PB6, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 7, PB7, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 8, PB8, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 9, PB9, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 10, PB10, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 11, PB11, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 12, PB12, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 13, PB13, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 14, PB14, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOB, 15, PB15, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  
  { GPIOC, 0, PC0, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 1, PC1, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 2, PC2, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 3, PC3, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 4, PC4, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 5, PC5, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 6, PC6, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 7, PC7, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 8, PC8, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 9, PC9, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 10, PC10, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 11, PC11, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 12, PC12, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOC, 13, PC13, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0}, 
  //{ GPIOC, 14, PC14, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},  // not available on Header
  //{ GPIOC, 15, PC15, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0}, // not available on Header

  { GPIOD, 0, PD0 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 1, PD1 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 2, PD2 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 3, PD3 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 4, PD4 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 5, PD5 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 6, PD6 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 7, PD7 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 8, PD8 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 9, PD9 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 10, PD10 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 11, PD11 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 12, PD12 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 13, PD13 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 14, PD14 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOD, 15, PD15 , 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},

  { GPIOE, 0, PE0, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 1, PE1, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 2, PE2, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 3, PE3, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 4, PE4, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 5, PE5, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 6, PE6, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 7, PE7, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 8, PE8, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 9, PE9, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 10, PE10, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 11, PE11, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 12, PE12, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 13, PE13, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 14, PE14, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  { GPIOE, 15, PE15, 0, 0, TOUCH_KEY_STATUS_RELEASED, 0},
  
};

#define TOUCH_KEY_CNT (sizeof(touch_status_list)/sizeof(struct touch_status_struct))
//#define TOUCH_KEY_CNT 5

/* maps a key (index into touch_status_list) to a RGB LED number, -1 means, that this key is not used */
/* the key_to_LED_map can be trained/learns with ikosi_learn.ino */

int16_t key_to_LED_map[TOUCH_KEY_CNT]={
/*0:*/36,51,21,25,-1,20,17,44,59,8,
/*10:*/56,58,4,48,7,49,19,-1,63,55,
/*20:*/-1,22,41,28,5,46,11,57,31,12,
/*30:*/27,14,24,38,2,62,32,37,40,42,
/*40:*/15,26,9,-1,16,-1,45,3,30,0,
/*50:*/53,-1,-1,52,39,10,47,6,50,1,
/*60:*/43,23,18,13,29,54,60};  

#define TOUCH_MEASURE_CNT 5 /* GPIOA .. GPIOE */
struct touch_measure_struct touch_measure_list[TOUCH_MEASURE_CNT];

#define TOUCH_IO_SAMPLE_COUNT 128   /* do not change: this must match the generated sample statements */
uint16_t touch_io_sample_array[TOUCH_IO_SAMPLE_COUNT];


/*================================================*/
/*
  the following two procedures will establish the links between "touch_measure_list" and "touch_status_list"
  called by buildTouchMeasureList()
*/

void fillTouchMeasure(struct touch_measure_struct *m, GPIO_TypeDef *gpio)
{
  int i;
  
  m->gpio = gpio;
  m->mask = 0;
  for( i = 0; i < 16; i++ )
    m->touch_status_index[i] = -1;
    
  for( i = 0; i < TOUCH_KEY_CNT; i++ )
  {
    if ( touch_status_list[i].gpio == gpio )
    {
      m->mask |= 1 << touch_status_list[i].pin;
      m->touch_status_index[touch_status_list[i].pin] = i;
    }
  }
}

/*
  Prepare the touch_measure_list[] by filling in values from touch_status_list[].
  Called once during startup of the controller.
*/
void buildTouchMeasureList(void)
{
  fillTouchMeasure(touch_measure_list+0, GPIOA);
  fillTouchMeasure(touch_measure_list+1, GPIOB);
  fillTouchMeasure(touch_measure_list+2, GPIOC);
  fillTouchMeasure(touch_measure_list+3, GPIOD);
  fillTouchMeasure(touch_measure_list+4, GPIOE);  
}



/*
  const char *getGPIONameByKey(int key)
  
  Description:
    Return the GPIO number of the uC port to which the key (sensor) is connected.
    This should look like "B14" or similar.
    "key" is an index into "touch_status_list"
    This is used for debugging and called by getKeyInfoString()
    
  Args:
    key: Index into touch_status_list[] (the pressed/released sensor key)
    
  Returns:
    Statiic string with the GPIO Name to which the given sensor key is connected
*/
const char *getGPIONameByKey(int key)
{
  static char name[16];
  strcpy(name, "?");
  if ( touch_status_list[key].gpio == GPIOA ) strcpy(name, "A");
  if ( touch_status_list[key].gpio == GPIOB ) strcpy(name, "B");
  if ( touch_status_list[key].gpio == GPIOC ) strcpy(name, "C");
  if ( touch_status_list[key].gpio == GPIOD ) strcpy(name, "D");
  if ( touch_status_list[key].gpio == GPIOE ) strcpy(name, "E");
  sprintf(name+1, "%d", touch_status_list[key].pin);
  return name;
}

/*
  const char *getKeyInfoString(int key)
  
  Description:
    Return an string which describes the key enclosed in [ ].
    It contains the key number, the GPIO port of the key and the mapped LED number.
    "key" is an index into "touch_status_list"
    
  Args:
    key: Index into touch_status_list[] (the pressed/released sensor key)
    
  Returns:
    Statiic string with technical description for the given key
*/
const char *getKeyInfoString(int key)
{
  static char s[32];    /* max 23 */
  strcpy(s, "[");
  strcat(s, "key=");
  sprintf(s+strlen(s), "%d", key);
  strcat(s, " io=");
  strcat(s, getGPIONameByKey(key));
  strcat(s, " led=");
  sprintf(s+strlen(s), "%d]", key_to_LED_map[key]);
  return s;
}

/*
  get the key (index into "touch_status_list") for a given led
  return -1 if the LED can't be controlled
  Inverse operation of key_to_LED_map[] 
  OBSOLETE?
*/
/*
int getKeyByLED(int led)
{
  int i;
  for( i = 0; i < TOUCH_KEY_CNT; i++ )
    if ( key_to_LED_map[i] == led )
      return i;
  return -1;
}
*/

/*
  returns the number of sensor keys assigned, should be 60 
  If this is not 60, then the software has to be stopped.
*/
int16_t getAssignedKeyCount(void)
{
  int16_t i;
  int16_t cnt = 0;
  for( i = 0; i < TOUCH_KEY_CNT; i++ )
    if ( key_to_LED_map[i] >= 0 )
      cnt++;
  return cnt;
}

/*================================================*/
/* hardware self test for the sensor keys */

int executeKeySelfTest(void)
{
  int i, j;
  int is_error = 0;
  char keyname[16];
  for( i = 0; i < TOUCH_KEY_CNT; i++ )
  {
    strcpy(keyname, getGPIONameByKey(i));

    pinMode(touch_status_list[i].arduino_pin, OUTPUT);
    
    digitalWrite(touch_status_list[i].arduino_pin, 0);
    for( j = 0; j < TOUCH_KEY_CNT; j++ )
    {   
      if ( j != i ) pinMode(touch_status_list[i].arduino_pin, INPUT_PULLUP);
    }
    for( j = 0; j < TOUCH_KEY_CNT; j++ )
    {   
      if ( j != i ) 
        if ( digitalRead(touch_status_list[i].arduino_pin) == 0 )
          pn("short circuit between key %d (%s) and %d (%s) found", i, keyname, j, getGPIONameByKey(j)), is_error=1;
    }
    
    digitalWrite(touch_status_list[i].arduino_pin, 1);
    for( j = 0; j < TOUCH_KEY_CNT; j++ )
    {   
      if ( j != i ) pinMode(touch_status_list[i].arduino_pin, INPUT_PULLDOWN);
    }
    for( j = 0; j < TOUCH_KEY_CNT; j++ )
    {   
      if ( j != i ) 
        if ( digitalRead(touch_status_list[i].arduino_pin) != 0 )
          pn("short circuit between key %d (%s) and %d (%s) found", i, keyname, j, getGPIONameByKey(j)), is_error=1;
    }
  }
  return is_error;
}

int checkCapValues(void)
{
  int i;
  for( i = 0; i < TOUCH_KEY_CNT; i++ )
  {
    //if ( touch_status_list[i].min_cap < 15 )
    if ( key_to_LED_map[i] >= 0 )
    {
      if ( touch_status_list[i].min_cap < 15 )
      {
        pn("low cap warning for key %d (%s), cap=%d, sensor might be disconnected", 
          i, getGPIONameByKey(i),  touch_status_list[i].min_cap );
      }
    }
  }
  return 1;
}

/*================================================*/

volatile int current_key = -1; // contains the current pressed key as global variable, assigned in signalKeyPressEvent() and signalKeyReleasedEvent() procedures.

/*

  void signalKeyPressEvent(int key, uint16_t cap)

  called by updateTouchStatus(), which is called by updateTouchKeys().

*/
void signalKeyPressEvent(int key, uint16_t cap)
{
  /*
  pn("min cap=%d threshold=%d current cap=%d %s pressed", 
    touch_status_list[key].min_cap,
    touch_status_list[key].threshold_cap,
    cap,
    getKeyInfoString(key));
  */
  
  setPlaneRGB(0, key_to_LED_map[key], sensor_key_select_color_r, sensor_key_select_color_g, sensor_key_select_color_b);  
  current_key = key;
}


/*
  void signalKeyReleasedEvent(int key)

  called by updateTouchStatus(), which is called by updateTouchKeys().
*/
void signalKeyReleasedEvent(int key)
{
  /*
    pn("%s released", getKeyInfoString(key));
  */
  setPlaneRGB(0, key_to_LED_map[key], 0, 0, 0);  
  current_key = -1;
}

/*
  Update status of one key, based on the current measured capacitance value
  key is an index into "touch_status_list" array (0 .. TOUCH_KEY_CNT-1].
  Status is updated within "touch_status_list".
 
  updateTouchStatus() is called by updateTouchKeys().
*/
void updateTouchStatus(int key, uint16_t cap)
{
  struct touch_status_struct *s = touch_status_list+key;

  if ( s->min_cap == 0 )
  {
    s->min_cap = cap;
  }
  else if ( s->min_cap > cap )
  {
    s->min_cap = cap;
  }
  s->threshold_cap = s->min_cap + TOUCH_KEY_MIN_TH_DELTA_CAP;
  
  switch(s->status)
  {
    case TOUCH_KEY_STATUS_RELEASED:
      if ( cap >= s->threshold_cap )
        s->status = TOUCH_KEY_STATUS_RP_DEBOUNCE1;
      break;
    case TOUCH_KEY_STATUS_RP_DEBOUNCE1:
      if ( cap >= s->threshold_cap )
      {
        s->status = TOUCH_KEY_STATUS_PRESSED;
        s->time = millis();
        signalKeyPressEvent(key, cap);
      }
      else
        s->status = TOUCH_KEY_STATUS_RELEASED;
      break;
    case TOUCH_KEY_STATUS_PRESSED:
      if ( cap < s->threshold_cap )
        s->status = TOUCH_KEY_STATUS_PR_DEBOUNCE1;
      break;
    case TOUCH_KEY_STATUS_PR_DEBOUNCE1:
      if ( cap < s->threshold_cap )
      {
        s->status = TOUCH_KEY_STATUS_RELEASED;
        signalKeyReleasedEvent(key);
        s->time = 0;
      }
      else
        s->status = TOUCH_KEY_STATUS_PRESSED;      
      break;
    default:
      s->status = TOUCH_KEY_STATUS_RELEASED;
      break;
  }
}

/*================================================*/
/* Sensor detection Algorithm */

/*

 Do a binary search in the global iosample array.
 Look for a 1 to 0 transition and return the position of the 1-0 transition (the first 0 value)
 mask: only one bit should be set here, 
  which must be the bit for which the 1 to 0 transition will be searched

 returns:
  0 if all bits are 0
  1..TOUCH_IO_SAMPLE_COUNT-1 for the initial number of 1 found
  TOUCH_IO_SAMPLE_COUNT if all bits are 1

  called by getTouchCapForPortPins()

*/
uint32_t getTo0PosByBinarySearch(uint16_t mask)
{
  uint16_t l = 0;
  uint16_t r = TOUCH_IO_SAMPLE_COUNT-1;
  uint32_t mid;
  while(l < r) 
  {
    mid = l+(r-l)/2;
    if ( touch_io_sample_array[mid] & mask )
      l = mid+1;
    else
      r = mid-1;
  }
  if ( l >= TOUCH_IO_SAMPLE_COUNT ) return TOUCH_IO_SAMPLE_COUNT;
  if ( touch_io_sample_array[l] & mask ) return l+1;
  return l;
}

/*

  Measure the capacitance at the touch sensor keys. 
  Do this for the specified port. Selected pins of that port are measured in parallel.

  Args:
    gpio: GPIO port for which the measure should happen
    selectMask: consider only pins where the bit is set inside mask
    changeTo0Cnt: For each of the selected GPIO ports of selected GPIO block, this will contain the 1-0 transition time. 
      A key is detected if this 1-0 transition time is small.
      
  Called by
    updateTouchKeys()
  
*/
void getTouchCapForPortPins(GPIO_TypeDef *gpio, uint16_t selectMask, uint16_t changeTo0Cnt[16])
{
  uint16_t *s = touch_io_sample_array;
  uint32_t m01 = selectMask; 

  // interleave with zero bits
  // https://graphics.stanford.edu/~seander/bithacks.html#InterleaveBMN
  m01 = ( m01 | ( m01 << 8 )) & 0x00ff00ff;
  m01 = ( m01 | ( m01 << 4 )) & 0x0f0f0f0f;
  m01 = ( m01 | ( m01 << 2 )) & 0x33333333;
  m01 = ( m01 | ( m01 << 1 )) & 0x55555555;

  uint32_t m10 = m01<<1;
  uint32_t m11 = m01 | m10;

  gpio->MODER &= ~m11;            /* 00: clear modes of all related pins to zero */
  gpio->MODER |= m01;             /* 01: output mode */
  gpio->OTYPER &= ~m11;           /* 00: push pull */
  gpio->OSPEEDR |= m11;           /* 11: very fast */
  gpio->PUPDR &= ~m11;            /* 00: clear */
  gpio->PUPDR |= m10;             /* 10: pull down */
  /* it is assumed, that the alt function is 0000 */
  
  gpio->BSRR = selectMask;      /* high output */

  /* wait for some time to charge the touch sensor */
  __NOP(); __NOP(); __NOP(); __NOP();  __NOP(); __NOP(); __NOP(); __NOP();
  __NOP(); __NOP(); __NOP(); __NOP();  __NOP(); __NOP(); __NOP(); __NOP();
  __NOP(); __NOP(); __NOP(); __NOP();  __NOP(); __NOP(); __NOP(); __NOP();
  __NOP(); __NOP(); __NOP(); __NOP();  __NOP(); __NOP(); __NOP(); __NOP();

#define GPIO_ALLSAMPLE_LINE *s++ = gpio->IDR;

#define GPIO_ALLSAMPLE_LINE2 GPIO_ALLSAMPLE_LINE GPIO_ALLSAMPLE_LINE
#define GPIO_ALLSAMPLE_LINE4 GPIO_ALLSAMPLE_LINE2 GPIO_ALLSAMPLE_LINE2
#define GPIO_ALLSAMPLE_LINE8 GPIO_ALLSAMPLE_LINE4 GPIO_ALLSAMPLE_LINE4
#define GPIO_ALLSAMPLE_LINE16 GPIO_ALLSAMPLE_LINE8 GPIO_ALLSAMPLE_LINE8
#define GPIO_ALLSAMPLE_LINE32 GPIO_ALLSAMPLE_LINE16 GPIO_ALLSAMPLE_LINE16
#define GPIO_ALLSAMPLE_LINE64 GPIO_ALLSAMPLE_LINE32 GPIO_ALLSAMPLE_LINE32
#define GPIO_ALLSAMPLE_LINE128 GPIO_ALLSAMPLE_LINE64 GPIO_ALLSAMPLE_LINE64

  /* generate all 128 GPIO read statements, disable interrupts during this GPIO read */
  __disable_irq();
  gpio->MODER &= ~m11;    /* change to input */
  GPIO_ALLSAMPLE_LINE128
  __enable_irq();
  
  /* data is now in the iosample array */
  
  for( uint16_t i = 0; i < 16; i++ )
  {
    if ( selectMask & (1<<i) )  
      changeTo0Cnt[i] = getTo0PosByBinarySearch(1<<i);
    else
      changeTo0Cnt[i] = 0;
  }  
}

/*
  
  void updateTouchKeys(void)
  
  Description:
    Calculate the status of ALL touch senser keys by calling getTouchCapForPortPins()
    This will call signalKeyPressEvent() and signalKeyReleasedEvent() procedures.
    This function must be called in order to detect any key press/release on the sensor keys.
  
*/
void updateTouchKeys(void)
{
  uint16_t changeTo0Cnt[16];
  int i, pin, key;
  
  /* Loop over GPIOA ... GPIOE */
  for( i = 0; i < TOUCH_MEASURE_CNT; i++ ) 
  {
    /* measure all active pins of the given port */
    getTouchCapForPortPins(touch_measure_list[i].gpio, touch_measure_list[i].mask, changeTo0Cnt);
    
    /* update individual keys and inform the application */
    for( pin = 0; pin < 16; pin++ )
    {
      key = touch_measure_list[i].touch_status_index[pin];
      if ( changeTo0Cnt[pin] > 0 && key >= 0 )
      {
        updateTouchStatus(key, changeTo0Cnt[pin]);
      }
    }
  }
}


/*================================================*/

uint16_t getGELPosByKey(uint16_t key)
{
  uint16_t pos;
  for( pos = 0; pos < 60; pos++ )
    if ( gel[pos].key == key )
      return pos;
  return -1;
}


/*
  check for a next loop with element at gel_pos with the given index (ge.next[index]).
  index is 5 for pentagon
  return value:
    -1 if no loop exists
    >= 0 for any loop count (5 for pentagon)
*/
int checkNextLoop(int index, int gel_pos)
{
  int cnt = 1;
  int pos = gel_pos;
  for(;;)
  {
    if ( gel[pos].next[index] < 0 )
      return -1;
    if ( gel[pos].next[index] == gel_pos )
      return cnt;
    if ( cnt > 60 )
      return cnt;
    pos = gel[pos].next[index];
    cnt++;
  }
}

/*
  calculate next 0, 1, 3 & 4
  this function must be called only if isGELPentagonCorrect() and isGELTriangleCorrect() return true

  for( i = 0; i < 60; i++)
    gel[gel[i].next[5]].next[0] = i;

  next[4] = next[5].next[2]
  next[1] = next[0].next[3]

*/
void calculateOtherNextGELValues(void)
{
  int i, j;
  /* get previous pentagon edge */
  for( i = 0; i < 60; i++)
    if ( gel[i].next[5] >= 0 )
      gel[gel[i].next[5]].next[0] = i;
      
  /* get previous triangle edge */
  for( i = 0; i < 60; i++)
    if ( gel[i].next[2] >= 0 )
      gel[gel[i].next[2]].next[3] = i;

  for( i = 0; i < 60; i++)
    if ( gel[i].next[5] >= 0 )
      gel[i].next[4] = gel[gel[i].next[5]].next[2];
      
  for( i = 0; i < 60; i++)
    if ( gel[i].next[0] >= 0 )
      gel[i].next[1] = gel[gel[i].next[0]].next[3];  
}

/*
  check whether pentagon information in GEL is correct.
  Used during startup to check if there is something wrong
*/
int isGELPentagonCorrect(void)
{
  int pos;
  for( pos = 0; pos < 60; pos++ )
  {
    if ( gel[pos].pentagon < 0 )
      return 0;         /* pentagon number missing: not correct */
    if ( checkNextLoop(5, pos) != 5 )
      return 0;         /* loop is not a pentagon: not correct */
  }
  return 1;     /* pentagon information is correct in GEL */
}


/*
  check whether pentagon information in GEL is correct.
  Used during startup to decide whether to stop the startup.
  This procedure will just use next[5] and the pentagon number.
*/
int isGELTriangleCorrect(void)
{
  int pos;
  for( pos = 0; pos < 60; pos++ )
  {
    if ( gel[pos].triangle < 0 )
      return 0;         /* triangle number missing: not correct */
    if ( checkNextLoop(2, pos) != 3 )
      return 0;         /* loop is not a triangle: not correct */
  }
  return 1;     /* triangle information is correct in GEL */
}

/*================================================*/
/*
  geco (GEL Color)
  
  This is an addon for the GE-List.
  There is one geco object for each graph element in GEL
  geco elements will use plane 3
    
*/
#define GECO_PLANE 3

struct _geco_struct
{

  /* current color */
  uint8_t r;    /* red */
  uint8_t g;    /* green */
  uint8_t b;    /* blue */
  
  /* transition colors */
  uint8_t sr;    /* start red */
  uint8_t sg;    /* start green */
  uint8_t sb;    /* start blue */

  uint8_t er;    /* end red */
  uint8_t eg;    /* end green */
  uint8_t eb;    /* end blue */
  
  uint16_t trans_total_time;
  uint16_t trans_current_time;

  /* blink */
  
  uint8_t ur;    /* upper red */
  uint8_t ug;    /* upper green */
  uint8_t ub;    /* upper blue */

  uint8_t lr;    /* upper red */
  uint8_t lg;    /* upper green */
  uint8_t lb;    /* upper blue */
  
  /* fade up and down time, blink is disabled if both are 0 */
  uint16_t to_upper_blink_time;          /* total period time of the blink is to_upper_blink_time+to_lower_blink_time */
  uint16_t to_lower_blink_time;          /* total period time of the blink is to_upper_blink_time+to_lower_blink_time */
  
  /* additional information */
  uint16_t player;      /* set by / belongs to player */
  uint16_t is_visited;  /* used by DFS algorithms */
};
typedef struct _geco_struct geco_struct;

geco_struct gecol[60];


/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* calculate any color transition and assign the color to the GECO_PLANE */
void gecolCalculateTransition(int pos)
{
  geco_struct *geco = &(gecol[pos]);
  if (  geco->trans_current_time >= geco->trans_total_time )
  {
    /* end is reached */
    geco->r = geco->er;
    geco->g = geco->eg;
    geco->b = geco->eb;
  }
  else
  {
    geco->r = ((uint32_t)geco->sr*(geco->trans_total_time - geco->trans_current_time))/geco->trans_total_time 
                  + ((uint32_t)geco->er*geco->trans_current_time)/geco->trans_total_time;
    geco->g = ((uint32_t)geco->sg*(geco->trans_total_time - geco->trans_current_time))/geco->trans_total_time 
                  + ((uint32_t)geco->eg*geco->trans_current_time)/geco->trans_total_time;
    geco->b = ((uint32_t)geco->sb*(geco->trans_total_time - geco->trans_current_time))/geco->trans_total_time 
                  + ((uint32_t)geco->eb*geco->trans_current_time)/geco->trans_total_time;
  }

  setPlaneRGB(GECO_PLANE, gel[pos].led, geco->r, geco->g, geco->b);
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  called by gecolStep()
*/
void gecolDoTransitionStep(int pos)
{
  geco_struct *geco = &(gecol[pos]);
  if (  geco->trans_current_time < geco->trans_total_time )
    geco->trans_current_time++;
  gecolCalculateTransition(pos); 
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* 
    Assign a target color. This color is not assigned immediatly, but it instead faded from the existing color to the new color
    pos:        gel index
    time:       number of ticks for the transition

    This procedure is also called by the blink procesures
*/  
void gecolSetColor(int pos, uint16_t time, uint8_t r, uint8_t g, uint8_t b)
{
  geco_struct *geco = &(gecol[pos]);
  geco->sr = geco->r;
  geco->sg = geco->g;
  geco->sb = geco->b;
  geco->er = r;
  geco->eg = g;
  geco->eb = b;
  geco->trans_current_time = 0;
  geco->trans_total_time = time;  
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  called by gecolStep()
*/
void gecolDoBlinkStep(int pos)
{
  geco_struct *geco = &(gecol[pos]);
  if ( geco->to_lower_blink_time == 0 && geco->to_upper_blink_time == 0 )
    return;
  
  if ( geco->r == geco->ur && geco->g == geco->ug  && geco->b == geco->ub )
  {
    gecolSetColor(pos, geco->to_lower_blink_time, geco->lr, geco->lg, geco->lb );
  }
  else if ( geco->r == geco->lr && geco->g == geco->lg  && geco->b == geco->lb )
  {
    gecolSetColor(pos, geco->to_upper_blink_time, geco->ur, geco->ug, geco->ub );
  }
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  let an edge blink with given color and speed until gecolStopBlink() is called
*/
void gecolSetBlink(int pos, uint16_t fade_up, uint16_t fade_down, uint8_t ur, uint8_t ug, uint8_t ub, uint8_t lr, uint8_t lg, uint8_t lb )
{
  geco_struct *geco = &(gecol[pos]);
  
  geco->ur = ur;
  geco->ug = ug;
  geco->ub = ub;
  geco->lr = lr;
  geco->lg = lg;
  geco->lb = lb;
  
  geco->to_upper_blink_time = fade_up;
  geco->to_lower_blink_time = fade_down;  

  gecolSetColor(pos, geco->to_upper_blink_time, geco->ur, geco->ug, geco->ub );
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  stop linking after gecolSetBlink has been called
*/
void gecolStopBlink(int pos)
{
  geco_struct *geco = &(gecol[pos]);
  geco->to_upper_blink_time = 0;
  geco->to_lower_blink_time = 0;  
  gecolSetColor(pos, geco->to_upper_blink_time, geco->ur, geco->ug, geco->ub );
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  update all gecol objects 
  
  needs to be called during main loop
*/
void gecolStep(void)
{
  int i;
  for( i = 0; i < 60; i++ )
  {
    gecolDoTransitionStep(i);
    gecolDoBlinkStep(i);
  }
}



/*================================================*/
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  EOL = Edge Object List
*/

typedef struct _eo_struct eo_struct;

/*
  return 0: msg not handled
*/

/*
  create
    EO_MSG_INIT
    
    EO_MSG_DRAW
    EO_MSG_TICK
    ...
    EO_MSG_DRAW
    EO_MSG_TICK
    
    if  ( acnt == 0 )
      EO_MSG_CLOSE
    
*/

#define EO_MSG_NONE 0
#define EO_MSG_INIT 1
#define EO_MSG_CLOSE 2
#define EO_MSG_DRAW 3
#define EO_MSG_SELECT 4
#define EO_MSG_TICK 5


struct _eo_struct
{
  /* callback for this object */
  eo_cb cb;
  
  /* 
    active count: 
    0: Object not active and can be reused
    any other value: A count value, which might be reduced by the cb
    Assigning 0 to this value will do a self destruction of the object
    
    During create, the acnt value will be assigned to eo->acnt and eo->initial_acnt.
    The callback function should only modify acnt and should treat initial_acnt as read only.
  */
  uint16_t acnt;
  uint16_t initial_acnt;  /* read only for the callback function */
  
  /* optional argument, used as intensity value sometimes */
  uint16_t oarg; 
  
  /* internal variable */
  uint16_t i;
  
  /* reference position within gel */
  uint16_t gpos;

  /* reference color of the object */
  uint8_t p;    /* plane */
  uint8_t r;    /* red */
  uint8_t g;    /* green */
  uint8_t b;    /* blue */
  
};



#define EOL_CNT 64

eo_struct eol[EOL_CNT];

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
int eoDefaultCB(struct _eo_struct *eo, unsigned msg, unsigned arg)
{
  //pn("eoDefaultCB called msg=%d", msg);
  switch(msg)
  {
    case EO_MSG_DRAW:
      return 1;
    case EO_MSG_TICK:
      return 1;
    case EO_MSG_SELECT:
      return 1;
    case EO_MSG_INIT:
      return 1;
    case EO_MSG_CLOSE:
      return 1;
  }
  return 0;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  Prototype:
    void eolClear(void)
  Description:
    Clear all edge objects in the edge object list (EOL).
    This will be called during init only.
    No callback functions are called
  Args:
    -
  Returns:
    -
*/
void eolClear(void)
{
  int i;
  for( i = 0; i < EOL_CNT; i++ )
  {
    eol[i].acnt = 0;
    eol[i].cb = eoDefaultCB;
  }
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  Prototype:
    int eolFindInactive(void)
  Description:
    Find an unused edge object within the edge object list (EOL).
    Returns an index into the global array eol[].
  Args:
    -
  Returns:
    -1 if no unused object is available otherwise the index of the unused object.
  Note:
    Probably, it is better to use 'eolGetInactive()'. 
    However in most cases just use 'eolCreate()', which will call 'eolGetInactive()', which in turn will call this function.
*/
int eolLastPos = 0;
int eolFindInactive(void)
{
  int i;
  //pn("eolFindInactive start");
  
  if ( eolLastPos >= EOL_CNT )
    eolLastPos = 0;
  
  for( i = eolLastPos; i < EOL_CNT; i++ )
  {
    if ( eol[i].acnt == 0 )
    {
      eolLastPos = i;
      //pn("eolFindInactive found1 = %d", i);
      return i;
    }
  }

  //pn("eolFindInactive middle");

  for( i = 0; i < eolLastPos; i++ )
  {
    if ( eol[i].acnt == 0 )
    {
      eolLastPos = i;
      //pn("eolFindInactive found2 = %d", i);
      return i;
    }
  }
  
  //pn("eolFindInactive not found");
  return -1;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  Prototype:
    int eolSendMsg(int epos, unsigned msg, unsigned arg)
  Description:
    Send 'msg' to edge object 'epos' with argument 'arg'
  Args:
    epos:       Index into global edge object list eol[]
    msg:        Message sent to the edge object
      EO_MSG_NONE 0
      EO_MSG_INIT 1
      EO_MSG_CLOSE 2
      EO_MSG_DRAW 3
      EO_MSG_SELECT 4
      EO_MSG_TICK 5
    arg:        Optional argument, meaning defined by the message
  Returns:
    0 if epos is illegal or the referenced edge object is inactive.
    Otherwise the the return value of the callback function is returned (where again 0 means, that the msg is not handled)
*/
int eolSendMsg(int epos, unsigned msg, unsigned arg)
{
  if ( epos < 0 )
    return 0;
  if ( epos >= EOL_CNT )
    return 0;
  if ( eol[epos].acnt == 0 )
    return 0;
  return eol[epos].cb(eol+epos, msg, arg);
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  Prototype:
    void eolSendCloseMsg(int epos)
  Description:
    Send 'EO_MSG_CLOSE' to edge object 'epos'. The edge object will be deactivated and
    the callback function will be set to the default function.
    A callback function should never call this procedure inside the code which handles EO_MSG_CLOSE.
    While handling E_MSG_TICK, just set 'acnt' to 0. EO_MSG_CLOSE will be automatically called as soon as acnt is set to 0
  Args:
    epos:       Index into global edge object list eol[]
  Returns:
    -
*/
void eolSendCloseMsg(int epos)
{
  if ( epos < 0 )
    return;
  if ( epos >= EOL_CNT )
    return;
    
  eolSendMsg(epos, EO_MSG_CLOSE, 0);
  eol[epos].acnt = 0;
  eol[epos].cb = eoDefaultCB;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  Prototype:
    int eolSendAllMsg(unsigned msg, unsigned arg)
  Description:
    Similar to 'eolSendMsg()' but will sent the message to all active edge objects.
    Additionally: If, after sending the message, acnt becomes 0, then the close message is sent.
  Args:
    msg:        Message sent to the edge object
      EO_MSG_NONE 0
      EO_MSG_INIT 1
      EO_MSG_CLOSE 2
      EO_MSG_DRAW 3
      EO_MSG_SELECT 4
      EO_MSG_TICK 5
    arg:        Optional argument, meaning defined by the message
  Returns:
    The number of edge objects which got called.
*/
int eolSendAllMsg(unsigned msg, unsigned arg)
{
  int i, cnt = 0;
  for( i = 0; i < EOL_CNT; i++ )
  {
    if ( eol[i].acnt != 0 )
    {
      cnt++;
      eolSendMsg(i, msg, arg);
      if ( eol[i].acnt == 0 )
        eolSendCloseMsg(i);
    }
  }
  return cnt;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  Prototype:
    int eolSendAllDraw(void)
  Description:
    Send EO_MSG_DRAW to all active edge objects.
  Args:
    -
  Returns:
    The number of edge objects which got called.
*/
int eolSendAllDraw(void)
{
  return eolSendAllMsg(EO_MSG_DRAW, 0);
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  Prototype:
    int eolSendAllTick(void)
  Description:
    Send EO_MSG_TICK to all active edge objects.
  Args:
    -
  Returns:
    The number of edge objects which got called.
*/
int eolSendAllTick(void)
{
  return eolSendAllMsg(EO_MSG_TICK, 0);
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  Prototype:
    int eolFindInactive(void)
  Description:
    Forcefully get an inactive edge object.
    Same as eolFindInactive() but will make an active object inactive.
    Returns an index into the global array eol[].
  Args:
    -
  Returns:
    The index of the unused object.
*/
int eolGetInactive(void)
{
  int epos = eolFindInactive();
  //pn("eolGetInactive epos=%d", epos);
  if ( epos >= 0 )
    return epos;
  eolLastPos++;
  if ( eolLastPos >= EOL_CNT )
    eolLastPos = 0;    
  eolSendCloseMsg(eolLastPos);
  return eolLastPos;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  Prototype:
    int eolFindByGELPos(uint16_t gpos)
  Description:
    Search for an edge object with the given gel index.
    Returns an index into the global array eol[].
  Args:
    gpos:       Index into global gel[] array.
  Returns:
    -1, of no such edge object was found, otherwise an index into the global array eol[].
*/
int eolFindByGELPos(uint16_t gpos)
{
  int i;
  for( i = 0; i < EOL_CNT; i++ )
  {
    if ( eol[i].gpos == gpos )
    {
      return i;
    }
  }
  return -1;
}



/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
  Prototype:
    int eolCreate(eo_cb cb, uint16_t acnt, uint16_t oarg, uint16_t gpos, uint8_t plane, uint8_t r, uint8_t g, uint8_t b)
  Description:
    Create a new edge object and return the index number of the newly created edge object.
    This function can not fail, always a new object is returned.
  Args:
    cb:         Callback function
    acnt:       Active count. Must be > 1 (0 will be automatically changed to 1)
    oarg        Optional argument (sometimes used as intensity)
    gpos:       Index into global gel[] array: The reference edge for this edge object.
    plane:      The plane into which this object will be rendered
    r,g,b:      Color of the edge object.
  Returns:
    index into the global array eol[].
*/
int eolCreate(eo_cb cb, uint16_t acnt, uint16_t oarg, uint16_t gpos, uint8_t plane, uint8_t r, uint8_t g, uint8_t b)
{
  int epos = eolGetInactive();
  if ( acnt == 0 )
    acnt = 1;
  eol[epos].cb = cb;
  eol[epos].initial_acnt = acnt;
  eol[epos].acnt = acnt;
  eol[epos].oarg = oarg;
  eol[epos].gpos = gpos;
  eol[epos].p = plane;
  eol[epos].r = r;
  eol[epos].g = g;
  eol[epos].b =b;
  eol[epos].i = 0;
  //pn("eolCreate epos=%d eol[epos].acnt=%d", epos, eol[epos].acnt);
  eolSendMsg(epos, EO_MSG_INIT, 0);
  return epos;
}

/*================================================*/

/* intensity: 0...256 */
void eoDrawRGB(struct _eo_struct *eo, unsigned intensity)
{
  setPlaneRGB(eo->p, gel[eo->gpos].led, 
    (eo->r*intensity)>>8,
    (eo->g*intensity)>>8, 
    (eo->b*intensity)>>8   );  
}

void eoDrawGELRGB(struct _eo_struct *eo, unsigned gpos, unsigned intensity)
{
  setPlaneRGB(eo->p, gel[gpos].led, 
    (eo->r*intensity)>>8,
    (eo->g*intensity)>>8, 
    (eo->b*intensity)>>8   );  
}


/*================================================*/

/*
  x: position on the ring: 0..255
  w: width of the trapezoid, 0..255
  r: length of left and right ramp, 0..255 ( but usually <30 )

  for w=10, r = 20
  x=0 --> 255
  x=5 --> 255
  x=240 --> 255
  x=255 --> 255
     (upper part of the trapezoid is between 255-w/2 .. 255 and 0 .. w/2)
  x=20 --> around 128
  x=31 --> 0
    The rising ramp is from 255-w/2-r to 255-r 
    The falling ramp is from w/2 to w/2+r
    
  Probably it is more a bathtub function
    0..w/2        high
    w/2..w/2+r    falling
    w/2+r .. 255-w/2-r  zero
    255-w/2-r..255-w/2 rising
    255-w/2 .. 255 high
*/
uint8_t trapezoid_fn(uint8_t x, uint8_t w, uint8_t r)
{
  uint8_t tu;
  uint8_t tl = 0;
  uint8_t yu;
  uint8_t yl;
  if ( w == 0 )
    return 0;
  if ( w == 255 )
    return 255;
  tu = w+1;
  
  tu/=2;
  if ( x <= tu )
    return 255;
  tl -= tu;
  if ( x >= tl )
    return 255;

  if ( x > tu+r )
    yu = 0;
  else
    yu = (((unsigned)tu+r-x)*(unsigned)256)/(unsigned)r;
  
  if ( x < tl-r )
    yl = 0;
  else
    yl = (((unsigned)x-tl+r)*(unsigned)256)/(unsigned)r;
  
  if ( yu > yl )
    return yu;
  return yl;
}

/*
  offset: 0..255
*/
void eoDrawTrapezoidPentagon(struct _eo_struct *eo, uint8_t master_brightness, uint8_t offset, uint8_t w, uint8_t r)
{
  unsigned i;
  uint8_t x, y;
  unsigned gpos = eo->gpos;
  for( i = 0; i < 5; i++ )
  {
    x = ( i * 256 ) / 5 + offset;
    y = trapezoid_fn(x, w, r);
    y = ((unsigned)y * (unsigned)master_brightness ) / (unsigned)255;
    eoDrawGELRGB(eo, gpos, y);
    gpos = gel[gpos].next[5];
  }
}

void eoDrawTrapezoidRing(struct _eo_struct *eo, uint8_t master_brightness, uint8_t offset, uint8_t w, uint8_t r)
{
  unsigned i;
  uint8_t x, y;
  unsigned pos = eo->gpos;
  
  for( i = 0; i < 10; i++ )
  {
    x = ( i * 256 ) / 10 + offset;
    y = trapezoid_fn(x, w, r);
    y = ((unsigned)y * (unsigned)master_brightness ) / (unsigned)255;
    eoDrawGELRGB(eo, pos, y);
    
    /* looping over the outer ring requires alternating use of next[1] and next[4] */
    if ( (i & 1) != 0 )
      pos = gel[pos].next[1];
    else
      pos = gel[pos].next[4];
  }
}

void eoDrawTrapezoidInvRing(struct _eo_struct *eo, uint8_t master_brightness, uint8_t offset, uint8_t w, uint8_t r)
{
  unsigned i;
  uint8_t x, y;
  unsigned pos = eo->gpos;
  
  for( i = 0; i < 10; i++ )
  {
    x = ( i * 256 ) / 10 + offset;
    y = trapezoid_fn(x, w, r);
    y = ((unsigned)y * (unsigned)master_brightness ) / (unsigned)255;
    eoDrawGELRGB(eo, pos, y);
    
    /* looping over the outer ring requires alternating use of next[1] and next[4] */
    if ( (i & 1) == 0 )
      pos = gel[pos].next[1];
    else
      pos = gel[pos].next[4];
  }
}

/*================================================*/

/*
  acnt: 0xffff --> no fade out, any other value: fade out (300 seems to be a second or so)
  oarg: max intensity (<= 256 )
  gpos: used
  plane, r, g, b: used

  int eolCreate(eo_cb cb, uint16_t acnt, uint16_t oarg, uint16_t gpos, uint8_t plane, uint8_t r, uint8_t g, uint8_t b)
  eolCreate(eoEdgeBlinkCB, 1, 200, gpos, 1, 200, 200, 200)

*/
int eoEdgeBlinkCB(struct _eo_struct *eo, unsigned msg, unsigned arg)
{
  const uint16_t period_in_ticks = 150;
  unsigned intensity = 0;
  switch(msg)
  {
    case EO_MSG_DRAW:
      /* derive intensity from the ticks */
      if ( eo->i < period_in_ticks/2 )
      {
        intensity = period_in_ticks/2 - eo->i;
      }
      else
      {
        intensity =  eo->i - period_in_ticks/2;
      }
      
      /* intensity is now between 0 and period_in_ticks/2 */ 
      /* scale intensity to 0..eo->oarg (intentionall oversized */
      intensity = (intensity*eo->oarg)/(period_in_ticks/2);
      if ( intensity > 256 )
        intensity = 256;        
      if ( eo->acnt != 0x0ffff )
        intensity = ((uint32_t)intensity*(uint32_t)eo->acnt)/(uint32_t)eo->initial_acnt;
      if ( intensity > 256 )
        intensity = 256;
        
      /* draw the edge */
      eoDrawRGB(eo, intensity);
      return 1;
    case EO_MSG_TICK:
      eo->i++;
      if ( eo->i >= period_in_ticks )
        eo->i = 0;
      if ( eo->acnt != 0x0ffff && eo->acnt > 0)
        eo->acnt--;
      return 1;
    case EO_MSG_SELECT:
      return 1;
    case EO_MSG_INIT:
      return 1;
    case EO_MSG_CLOSE:
      eoDrawRGB(eo, 0);
      return 1;
  }
  return 0;
}


/*
  acnt: 0xffff --> no fade out, any other value: fade out (300 seems to be a second or so)
  oarg: max intensity (<= 256 )
  gpos: used
  plane, r, g, b: used
  
  int eolCreate(eo_cb cb, uint16_t acnt, uint16_t oarg, uint16_t gpos, uint8_t plane, uint8_t r, uint8_t g, uint8_t b)
  
  eolCreate(eoRotatingPentagonCB, 1500, 1500, pos, 2, 200, 0, 200);

*/

int eoRotatingPentagonCB(struct _eo_struct *eo, unsigned msg, unsigned arg)
{
  const uint16_t period_in_ticks = 300;
  uint8_t intensity = 0;
  switch(msg)
  {
    case EO_MSG_DRAW:
      intensity = 255; 
        
      if ( eo->acnt != 0x0ffff )
        intensity = ((uint32_t)intensity*(uint32_t)eo->acnt)/(uint32_t)eo->initial_acnt;
      if ( intensity > 255 )
        intensity = 255;

      eoDrawTrapezoidPentagon(eo, intensity, (eo->i*255)/period_in_ticks, 255/7, 255/5);

      return 1;
    case EO_MSG_TICK:
      eo->i++;
      if ( eo->i >= period_in_ticks )
        eo->i = 0;
      if ( eo->acnt != 0x0ffff && eo->acnt > 0)
        eo->acnt--;
      return 1;
    case EO_MSG_SELECT:
      return 1;
    case EO_MSG_INIT:
      return 1;
    case EO_MSG_CLOSE:
      eoDrawRGB(eo, 0);
      return 1;
  }
  return 0;
}


/*
    eolCreate(eoRotatingRingCB, 1500, 0, pos, 2, 200, 0, 200);
*/

int eoRotatingRingCB(struct _eo_struct *eo, unsigned msg, unsigned arg)
{
  const uint16_t period_in_ticks = 400;
  uint8_t intensity = 0;
  switch(msg)
  {
    case EO_MSG_DRAW:
      intensity = 255; 
        
      if ( eo->acnt != 0x0ffff )
        intensity = ((uint32_t)intensity*(uint32_t)eo->acnt)/(uint32_t)eo->initial_acnt;
      if ( intensity > 255 )
        intensity = 255;

      eoDrawTrapezoidRing(eo, intensity, (eo->i*255)/period_in_ticks, 255/9, 255/7);

      return 1;
    case EO_MSG_TICK:
      eo->i++;
      if ( eo->i >= period_in_ticks )
        eo->i = 0;
      if ( eo->acnt != 0x0ffff && eo->acnt > 0)
        eo->acnt--;
      return 1;
    case EO_MSG_SELECT:
      return 1;
    case EO_MSG_INIT:
      return 1;
    case EO_MSG_CLOSE:
      eoDrawRGB(eo, 0);
      return 1;
  }
  return 0;
}

int eoInvRotatingRingCB(struct _eo_struct *eo, unsigned msg, unsigned arg)
{
  const uint16_t period_in_ticks = 400;
  uint8_t intensity = 0;
  switch(msg)
  {
    case EO_MSG_DRAW:
      intensity = 255; 
        
      if ( eo->acnt != 0x0ffff )
        intensity = ((uint32_t)intensity*(uint32_t)eo->acnt)/(uint32_t)eo->initial_acnt;
      if ( intensity > 255 )
        intensity = 255;

      eoDrawTrapezoidInvRing(eo, intensity, (eo->i*255)/period_in_ticks, 255/9, 255/7);

      return 1;
    case EO_MSG_TICK:
      eo->i++;
      if ( eo->i >= period_in_ticks )
        eo->i = 0;
      if ( eo->acnt != 0x0ffff && eo->acnt > 0)
        eo->acnt--;
      return 1;
    case EO_MSG_SELECT:
      return 1;
    case EO_MSG_INIT:
      return 1;
    case EO_MSG_CLOSE:
      eoDrawRGB(eo, 0);
      return 1;
  }
  return 0;
}

/*================================================*/

/* 
  lpg longest path game 
  
  player number:
    0: not a player
    1: Player 1
    2: Player 2
    
  Ring animation always shows the current player color
  Fast white blink: Illegal move
  Slow player color blink: valid move

  elements of the gel[] array:
  struct ge_struct
  {
    int16_t led;               // led number, LED can be derived via key_to_LED_map[key]
    int16_t key;              // index into touch_status_list[] 
    int16_t pentagon;     // pentagon number, starts with 0
    int16_t triangle;        // triangle number, starts with 0
    int16_t next[6];          // each ikosidodecaeder has six neighbour edges
  }

  elements of the gecol[] array:
  struct _geco_struct
  {
    ...
    uint16_t player;      // set by / belongs to player, 0=not owned, 1:player1, 2:player2
    uint16_t is_visited;
  };


*/

int lpg_half_move_count = 0;
uint8_t lpg_bfs_queue_list[60];
int lpg_bfs_queue_size = 0;

void lpgClearVisited(void)
{
  int i;
  for( i = 0; i < 60; i++ )
    gecol[i].is_visited = 0;
}


int lpgGetShortestPathSizeToMostDistantEdgeBFSByPos(int pos, uint16_t player)
{
  int i;
  int next;
  int longest_path_size = 1;
  int is_one_more_added = 0;
  
  if ( gecol[pos].player != player )    /* extra check: return 0 if player is not owner of root edge */
    return 0;

  lpgClearVisited();

  gecol[pos].is_visited = 1;            /* mark root as visited */
  lpg_bfs_queue_size = 0;              /* clear the BFS queue */
  lpg_bfs_queue_list[lpg_bfs_queue_size++] = pos;        /* add root to the queue */

  while( lpg_bfs_queue_size > 0 && longest_path_size < 35 )
  {
    pos = lpg_bfs_queue_list[--lpg_bfs_queue_size];
    is_one_more_added = 0;
    for( i = 0; i < 6; i++ )      
    {
      next = gel[pos].next[i];
      if ( gecol[next].player == player )
      {
        if ( gecol[next].is_visited == 0 )
        {
          gecol[next].is_visited = 1;
          lpg_bfs_queue_list[lpg_bfs_queue_size++] = next;        /* put next edue into the queue */          
          is_one_more_added = 1;
        }
      }
    }
    if ( is_one_more_added )
      longest_path_size++;      
  }
  return longest_path_size;
}



int lpgGetLongestShortestPath(uint16_t player)
{
  int i;
  int curr = 0;
  int max = 0;
  /*
    loop over all edges of the given player
    calculate the longest path for that position and return the maximum longest path
  */
  for( i = 0; i < 60; i++ )
    if ( gecol[i].player == player )
    {
      curr = lpgGetShortestPathSizeToMostDistantEdgeBFSByPos(i, player);
      if ( max < curr )
        max = curr;
    }
    return max;
}

void lpgDoPlayerRingAnimation(int pos, uint16_t player)
{
  if ( player == 1 )
  {
    eolCreate(eoRotatingRingCB, 200, 0, pos, 1, p1_r, p1_g, p1_b);
    eolCreate(eoInvRotatingRingCB, 200, 0, pos, 2, p1_r, p1_g, p1_b);
  }
  else if ( player == 2 )
  {
    eolCreate(eoRotatingRingCB, 200, 0, pos, 1, p2_r, p2_g, p2_b);
    eolCreate(eoInvRotatingRingCB, 200, 0, pos, 2, p2_r, p2_g, p2_b);
  }
}

void lpgSetPlayerColor(int pos, uint16_t player)
{
  uint16_t fade_time = 100;
  if ( player == 1 )
  {
    gecolSetColor(pos, fade_time, p1_r, p1_g, p1_b);
  }
  else if ( player == 2 )
  {
    gecolSetColor(pos, fade_time, p2_r, p2_g, p2_b);
  }
  else
  {
    gecolSetColor(pos, fade_time, 0, 0, 0);                /* no player */
  }
}

int lpgIsValidPlayerPosition(int pos, uint16_t player)
{
  /* the new position is invalid if it is already occupied */
  if ( gecol[pos].player != 0 )
    return 0;
  
  /* Move is invalid if there is no nearby edge if the same player. */
  /* This check does not apply to the first two moves */
  if ( lpg_half_move_count >= 2 )
  {
    int i;
    for( i = 0; i < 6; i++ )
      if ( gecol[gel[pos].next[i]].player == player )
        break;
    if ( i >= 6 )
      return 0;         /* no nearby edge fount: invalid */
  }
  
  return 1;
}


void lpgSetPlayerValidBlink(int pos, uint16_t player)
{
  lpgDoPlayerRingAnimation(pos, player);       /* show current player ring animation */
  if ( player == 1 )
    gecolSetBlink(pos, 70, 70, p1_r, p1_g, p1_b, 0,0,0 );
  else
    gecolSetBlink(pos, 70, 70, p2_r, p2_g, p2_b, 0,0,0 );
}

void lpgSetPlayerInvalidBlink(int pos, uint16_t player)
{
  int i;
  uint8_t r, g, b;
  if ( player == 1 )
  {
    r = p1v_r;
    g = p1v_g;
    b = p1v_b;
  }
  else
  {
    r = p2v_r;
    g = p2v_g;
    b = p2v_b;
  }
  

  /* let all valid edges blink with the valid color for the player */
  for( i = 0; i < 60; i++ )
  {
    if ( lpgIsValidPlayerPosition(i, player) != 0 )
      if ( i != pos )
        eolCreate(eoEdgeBlinkCB, 600, 200, i, 1, r, g, b);  // eolCreate(eo_cb cb, uint16_t acnt, uint16_t oarg, uint16_t gpos, uint8_t plane, uint8_t r, uint8_t g, uint8_t b)
  }       

  /* illegal blink color for the player */
  if ( player == 1 )
    gecolSetBlink(pos, 20, 20, p1i_r,p1i_g,p1i_b, 200,200,200);
  else
    gecolSetBlink(pos, 20, 20, p2i_r,p2i_g,p2i_b, 200,200,200);
}

int lpgGetLegalMoveCnt(uint16_t player)
{
  int i;
  int cnt = 0;
  for( i = 0; i < 60; i++ )
  {
    if ( lpgIsValidPlayerPosition(i, player) != 0 )
      cnt++;
  }
  return cnt;
}

void lpgSetPlayerBlink(int pos, uint16_t player)
{
  if ( lpgIsValidPlayerPosition(pos, player) )
    lpgSetPlayerValidBlink(pos, player);
  else
    lpgSetPlayerInvalidBlink(pos, player);
}

/*
  returns 1 if the player was valid at the position 
*/
int lpgStopPlayerBlink(int pos, uint16_t player)
{
  if ( lpgIsValidPlayerPosition(pos, player) )
  {
    lpgDoPlayerRingAnimation(pos, player);       /* show current player ring animation */
    gecolStopBlink(pos); 
    gecol[pos].player = player;
    lpgSetPlayerColor(pos, player);
    return 1;
  }
  
  gecolStopBlink(pos); 
  /* restore original player color */
  lpgSetPlayerColor(pos, gecol[pos].player);  
  return 0;
}

void lpgBlinkWinner(uint16_t player)
{
  int i;
  for( i = 0; i < 60; i++ )
  {
    if ( gecol[i].player == player )
      if ( player == 1 )
        gecolSetBlink(i, 100, 100, p1_r,p1_g,p1_b, 100,100,100);
      else
        gecolSetBlink(i, 100, 100, p2_r,p2_g,p2_b, 100,100,100);
  }
}

/* get AI move */
int lpgAIMove(uint16_t player)
{
  int i, j;
  int rate = 0;
  int best_rate = 0;
  int best_pos = -1;
  int myOwnNextEdgesCnt;
  for( i = 0; i < 60; i++ )
  {
    if ( lpgIsValidPlayerPosition(i, player) != 0 )
    {
      myOwnNextEdgesCnt = 0;
      for( j = 0; j < 6;j++ )
      {
        if ( gecol[gel[i].next[j]].player == player )
          myOwnNextEdgesCnt++;        
      }
      rate = 6-myOwnNextEdgesCnt;
      if ( best_rate < rate )
      {
        best_rate = rate;
        best_pos = i;
      }
    }
  }
  return best_pos;
}



/*================================================*/

int gameStateMachine(void)
{
  static int state = 0;
  static int last_key = current_key;
  static uint16_t current_player = 0;
  static unsigned long t = 0;
  
  uint16_t pos = 0;



  switch(state)
  {
    case 0:
      state = 1;
      last_key = -1;
      current_player = 1;
      lpg_half_move_count = 0;
      clearAllPlanes();
      
      for( int i = 0; i < 60; i++ )
      {
        gecolStopBlink(i);
        gecolSetColor(i, 50, 0, 0, 0 );
      }
      
      t = millis();     // assign current system time in milliseconds
      break;
    case 1:
      if ( current_key >= 0 )
      {
        pn("GEL Show %s", getKeyInfoString(current_key));
        uint16_t i;

        pos = getGELPosByKey(current_key);
        
        // eolSendCloseMsg(eolFindByGELPos(pos));        
        //eolCreate(eoEdgeBlinkCB, 0xffff, 1500, pos, 2, 200, 200, 200);
        //eolCreate(eoRotatingPentagonCB, 1500, 1500, pos, 2, 200, 0, 200);
        
        
        lpgSetPlayerBlink( pos,  current_player );

        last_key = current_key;
        state = 2;
        pn("key %d start", current_key);
      }
      else
      {
        /*
        if ( t+1000 < millis() )
        {
          pos = lpgAIMove(current_player);
          last_key = gel[pos].key;      // simulate the key press for state 2
          lpgSetPlayerBlink( pos,  current_player );
          pn("AI move for player %d, edge %d, key=%d", current_player, pos, last_key);
          state = 2;
        }
        */
      }
      break;
    case 2:
      if ( last_key>= 0 && last_key != current_key )
      {
        pos = getGELPosByKey(last_key);
        pn("key %d end", last_key);
        if ( lpgStopPlayerBlink(pos, current_player) )
        {
          if ( current_player == 1 )
            current_player = 2;
          else
            current_player = 1;
            
          lpg_half_move_count++;
          
          pn("Longest Shortest Path Player 1: %d", lpgGetLongestShortestPath(1) );
          pn("Longest Shortest Path Player 2: %d", lpgGetLongestShortestPath(2) );
        }
        
        last_key = -1;
        if ( lpgGetLegalMoveCnt(1) == 0 || lpgGetLegalMoveCnt(2) == 0 )
        {
          int points1 = lpgGetLongestShortestPath(1);
          int points2 = lpgGetLongestShortestPath(2);
          
          if ( points1 >= points2 )
            lpgBlinkWinner(1);
          if ( points2 >= points1 )
            lpgBlinkWinner(2);
          pn("Game Ended");            
          state = 3; // end of game
        }
        else
        {
          t = millis();
          state = 1;
        }        
      }
      break;
    case 3: // game ended: wait for key press
      if ( current_key >= 0 )
      {
        pn("GEL Show %s", getKeyInfoString(current_key));
        last_key = current_key;
        state = 4;
        pn("Game Restart, Button Press Detected");
      }
      break;
    case 4: // wait for key release
      if  ( last_key>= 0 && last_key != current_key )
      {
        pn("Game Restart");
        last_key = -1;
        state = 0;
      }
    
      break;
  }
  return 0;
}


/*================================================*/
/* setup() and loop() */

#define MASTER_MODE_NONE 0
#define MASTER_MODE_LEARN_KEY_LED_MAP 1
#define MASTER_MODE_LEARN_PENTAGON 2
#define MASTER_MODE_LEARN_TRIANGLE 3
#define MASTER_MODE_GAME_ENGINE 4

uint8_t master_mode = MASTER_MODE_NONE;

// the setup function runs once when you press reset or power the board

void setup(void) 
{
  //Serial.begin(9600);
  Serial.begin(115200);
  
  delay(1200);
  
  pn("buildTouchMeasureList");
  buildTouchMeasureList();
  
  pn("initLEDMatrix");
  initLEDMatrix();
  clearAllPlanes();
  eolClear();

  pn("Hardware Self Test");
  executeKeySelfTest();

  // initialize digital pin LED_BUILTIN as an output.
  pinMode(PA1, OUTPUT);
  for( int i = 0; i < TOUCH_KEY_CNT; i++ )
  {
    pinMode(touch_status_list[i].arduino_pin, OUTPUT);
  }


  if (  getAssignedKeyCount() < 60 )
  {
    pn("Key LED mapping is wrong, uC halt.");
    for(;;)
      ;
  }

  /* check for disconnected sensor keys */

  updateTouchKeys();
  checkCapValues();

  pn("Setup done");

  if ( isGELPentagonCorrect() == 0 )
  {
    pn("Graph structure (Pentagon) is wrong, uC halt.");
    for(;;)
      ;
  }
  
  if ( isGELTriangleCorrect() == 0 )
  {
    pn("Graph structure (Triangles) is wrong, uC halt.");
    for(;;)
      ;
  }
  else
  {
    pn("GEL show mode started");
    master_mode = MASTER_MODE_GAME_ENGINE;
    //pn("Default mode started");
  }

  calculateOtherNextGELValues();
}


// the loop function runs over and over again forever
void loop() 
{
  updateTouchKeys();
  clearAllPlanesExceptZero();
  eolSendAllDraw();
  eolSendAllTick();
  gecolStep();
  sendAllPlanes();

  switch(master_mode)
  {
    case MASTER_MODE_LEARN_KEY_LED_MAP:
        master_mode = MASTER_MODE_NONE;
      break;
    case MASTER_MODE_LEARN_PENTAGON:
        master_mode = MASTER_MODE_NONE;
      break;    
    case MASTER_MODE_LEARN_TRIANGLE:
        master_mode = MASTER_MODE_NONE;
      break;
    case MASTER_MODE_GAME_ENGINE:
      if ( gameStateMachine() != 0 )
      {
        master_mode = MASTER_MODE_NONE;
      }
      break;
  }
  
  if ( (millis() & 0x01ff) < 0xff )
  {
    digitalWrite(PA1, HIGH);   // turn the LED on (HIGH is the voltage level)
  }
  else
  {
    digitalWrite(PA1, LOW);    // turn the LED off by making the voltage LOW
  }
}