ESP32/components/u8g2/sys/arm/stm32l031x4/drv8871/main.c

/* 

  drv8871 DC motor

  Example for the STM32L031 Eval Board with 128x64 OLED at PA13/PA14
  
  IN_A: PA1 / AF2: TIM2_CH2
  IN_B: PB1 / AF?: TIM2_CH4
  VarRes: PA5 / ADC CH5
  Voltage sense: PA6 / ADC CH6
  0.2ms IRQ: PA7 (TIM22_CH2) (optional)
  
  
  IN_A	IN_B	OUT_A	OUT_B
  1		0		1		0
  0		1		0		1	
  0		0		0		0	
  1		1		HiZ		HiZ
  
  
  state machine
  
      
      
  
  
*/

#include <stdio.h>
#include "stm32l031xx.h"
#include "delay.h"
#include "u8g2.h"

/*=======================================================================*/
/* external functions */
uint8_t u8x8_gpio_and_delay_stm32l0(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr);

/*=======================================================================*/
/* global variables */

u8g2_t u8g2;                    // u8g2 object
uint8_t u8g2_x, u8g2_y;         // current position on the screen

volatile unsigned long SysTickCount = 0;

/*=======================================================================*/
/* I2C */

volatile unsigned char i2c_mem[256];     /* contains data, which read or written */
volatile unsigned char i2c_idx;                  /* the current index into i2c_mem */
volatile unsigned char i2c_is_write_idx;                  /* write state */

/*
  i2c_mem[0]		input: speed
  i2c_mem[1]		not used

  i2c_mem[2] = adc_diff_noise_per_sample_raw & 255		// small value: stop, high value: running
  i2c_mem[3] = adc_diff_noise_per_sample_raw>>8;
  i2c_mem[4] = adc_diff_noise_per_sample_filt & 255		// small value: stop, high value: running
  i2c_mem[5] = adc_diff_noise_per_sample_filt>>8;
  i2c_mem[6] = adc_max_raw & 255;		// speed value, higher values are slower
  i2c_mem[7] = adc_max_raw>>8;			// speed value, higher values are slower
  i2c_mem[8] = adc_max_filt & 255;			// speed value, higher values are slower
  i2c_mem[9] = adc_max_filt>>8;			// speed value, higher values are slower


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

void __attribute__ ((interrupt, used)) SysTick_Handler(void)
{
  SysTickCount++;  
}



void setHSIClock()
{
  
  /* test if the current clock source is something else than HSI */
  if ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_HSI) 
  {
    /* enable HSI */
    RCC->CR |= RCC_CR_HSION;    
    /* wait until HSI becomes ready */
    while ( (RCC->CR & RCC_CR_HSIRDY) == 0 )
      ;      
 
    /* enable the HSI "divide by 4" bit */
    RCC->CR |= (uint32_t)(RCC_CR_HSIDIVEN);
    /* wait until the "divide by 4" flag is enabled */
    while((RCC->CR & RCC_CR_HSIDIVF) == 0)
      ;
    
       
    /* then use the HSI clock */
    RCC->CFGR = (RCC->CFGR & (uint32_t) (~RCC_CFGR_SW)) | RCC_CFGR_SW_HSI; 
    
    /* wait until HSI clock is used */
    while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_HSI)
      ;
  }
  
  /* disable PLL */
  RCC->CR &= (uint32_t)(~RCC_CR_PLLON);
  /* wait until PLL is inactive */
  while((RCC->CR & RCC_CR_PLLRDY) != 0)
    ;

  /* set latency to 1 wait state */
  FLASH->ACR |= FLASH_ACR_LATENCY;
  
  /* At this point the HSI runs with 4 MHz */
  /* Multiply by 16 device by 2 --> 32 MHz */
  RCC->CFGR = (RCC->CFGR & (~(RCC_CFGR_PLLMUL| RCC_CFGR_PLLDIV ))) | (RCC_CFGR_PLLMUL16 | RCC_CFGR_PLLDIV2); 
  
  /* enable PLL */
  RCC->CR |= RCC_CR_PLLON; 
  
  /* wait until the PLL is ready */
  while ((RCC->CR & RCC_CR_PLLRDY) == 0)
    ;

  /* use the PLL has clock source */
  RCC->CFGR |= (uint32_t) (RCC_CFGR_SW_PLL); 
  /* wait until the PLL source is active */
  while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL) 
    ;

  SystemCoreClockUpdate();				/* Update SystemCoreClock global variable */  
}

/*
  Enable several power regions: PWR, GPIOA

  This must be executed after each reset.
*/
void startUp(void)
{  
  RCC->IOPENR |= RCC_IOPENR_IOPAEN;		/* Enable clock for GPIO Port A */
  RCC->APB1ENR |= RCC_APB1ENR_PWREN;	/* enable power interface (PWR) */
  PWR->CR |= PWR_CR_DBP;				/* activate write access to RCC->CSR and RTC */  
  
  SysTick->LOAD = (SystemCoreClock/1000)*50 - 1;   /* 50ms task */
  SysTick->VAL = 0;
  SysTick->CTRL = 7;   /* enable, generate interrupt (SysTick_Handler), do not divide by 2 */      
}

/*=======================================================================*/
/* u8x8 display procedures */

void initDisplay(void)
{
  
  /* setup display */
  u8g2_Setup_ssd1306_i2c_128x64_noname_f(&u8g2, U8G2_R2, u8x8_byte_sw_i2c, u8x8_gpio_and_delay_stm32l0);
  u8g2_InitDisplay(&u8g2);
  u8g2_SetPowerSave(&u8g2, 0);
  u8g2_SetFont(&u8g2, u8g2_font_6x12_tf);
  u8g2_ClearBuffer(&u8g2);
  u8g2_DrawStr(&u8g2, 0,12, "STM32L031");
  u8g2_DrawStr(&u8g2, 0,24, u8x8_u8toa(SystemCoreClock/1000000, 2));
  u8g2_DrawStr(&u8g2, 20,24, "MHz");
  u8g2_SendBuffer(&u8g2);
  
  u8g2_x = 0;
  u8g2_y = 0;  
}


void outChar(uint8_t c)
{
  u8g2_x+=u8g2_DrawGlyph(&u8g2, u8g2_x, u8g2_y, c);
}

void outStr(const char *s)
{
  while( *s )
    outChar(*s++);
}

void outHexHalfByte(uint8_t b)
{
  b &= 0x0f;
  if ( b < 10 )
    outChar(b+'0');
  else
    outChar(b+'a'-10);
}

void outHex8(uint8_t b)
{
  outHexHalfByte(b >> 4);
  outHexHalfByte(b);
}

void outHex16(uint16_t v)
{
  outHex8(v>>8);
  outHex8(v);
}

void outHex32(uint32_t v)
{
  outHex16(v>>16);
  outHex16(v);
}

void setRow(uint8_t r)
{
  u8g2_x = 0;
  u8g2_y = r;
}

/*=======================================================================*/
/* ADC Init */

void initADC(void)
{
  //__disable_irq();
  
  /* ADC and DMA Clock Enable */
  
  RCC->APB2ENR |= RCC_APB2ENR_ADCEN;	/* enable ADC clock */
  RCC->AHBENR |= RCC_AHBENR_DMAEN; 	/* enable DMA clock */
  __NOP();								/* let us wait for some time */
  __NOP();								/* let us wait for some time */  
  
  /* ADC Reset */
  
  RCC->APB2RSTR |= RCC_APB2RSTR_ADCRST;
  __NOP();								/* let us wait for some time */
  __NOP();								/* let us wait for some time */
  RCC->APB2RSTR &= ~RCC_APB2RSTR_ADCRST;
  __NOP();								/* let us wait for some time */
  __NOP();								/* let us wait for some time */
 
  /* ADC Basic Setup */
  
  ADC1->IER = 0;						/* do not allow any interrupts */
  ADC1->CFGR2 &= ~ADC_CFGR2_CKMODE;	/* select HSI16 clock */
  ADC1->CFGR1 = ADC_CFGR1_RES_1;		/* 8 bit resolution */

  
  ADC1->CR |= ADC_CR_ADVREGEN;				/* enable ADC voltage regulator, probably not required, because this is automatically activated */
  ADC->CCR |= ADC_CCR_VREFEN; 			/* Wake-up the VREFINT */  
  ADC->CCR |= ADC_CCR_TSEN; 			/* Wake-up the temperature sensor */  

  __NOP();								/* let us wait for some time */
  __NOP();								/* let us wait for some time */

  /* CALIBRATION */
  
  if ((ADC1->CR & ADC_CR_ADEN) != 0) /* clear ADEN flag if required */
  {
  /* is this correct? i think we must use the disable flag here */
    ADC1->CR &= (uint32_t)(~ADC_CR_ADEN);
  }
  ADC1->CR |= ADC_CR_ADCAL; 				/* start calibration */
  while ((ADC1->ISR & ADC_ISR_EOCAL) == 0) 	/* wait for clibration finished */
  {
  }
  ADC1->ISR |= ADC_ISR_EOCAL; 			/* clear the status flag, by writing 1 to it */
  __NOP();								/* not sure why, but some nop's are required here, at least 4 of them */
  __NOP();
  __NOP();
  __NOP();
  __NOP();
  __NOP();

}


/*=======================================================================*/
/* ADC Subtasks */

#define ADC_SUB_TASK_NONE 0
#define ADC_SUB_TASK_STOP_ADC 1
#define ADC_SUB_TASK_ENABLE_ADC 2
#define ADC_SUB_TASK_DISABLE_ADC 3
#define ADC_SUB_TASK_CONVERSION 4

#define ADC_SUB_STATE_INIT 0
#define ADC_SUB_STATE_ACTIVE 1
#define ADC_SUB_STATE_DONE 2

volatile uint8_t adc_sub_task = ADC_SUB_TASK_NONE;
volatile uint8_t adc_sub_state = ADC_SUB_STATE_INIT;
uint16_t adc_result = 0;

int adcIsSubDone(void)
{
  if ( adc_sub_state == ADC_SUB_STATE_DONE )
    return 1;
  if ( adc_sub_task == ADC_SUB_TASK_NONE )
    return 1;
  return 0;
}

/*
  int adcStartSubTask(uint8_t msg)

  Args:
    msg: One of ADC_SUB_TASK_STOP_ADC, ADC_SUB_TASK_ENABLE_ADC, ADC_SUB_TASK_DISABLE_ADC

  Returns:
    0 if there is any other subtask active
  
*/
int adcStartSubTask(uint8_t msg)
{
  if ( adcIsSubDone() == 0 )
    return 0;
  adc_sub_task = msg;
  adc_sub_state = ADC_SUB_STATE_INIT;
  return 1;
}

/*
  void adcExecSub(void)

  Desc:
    Executes any active ADC subtask. This can be executed inside an interrupt.
  
*/
void adcExecSub(void)
{
  switch(adc_sub_task)
  {
    case ADC_SUB_TASK_STOP_ADC:
      switch(adc_sub_state)
      {
	case ADC_SUB_STATE_INIT:
	  /* STOP ANY ADC CONVERSION */
	  ADC1->CR |= ADC_CR_ADSTP;
	  adc_sub_state = ADC_SUB_STATE_ACTIVE;
	  /* fall through */
	case ADC_SUB_STATE_ACTIVE:
	  if ( (ADC1->CR & ADC_CR_ADSTP) == 0 )
	    adc_sub_state = ADC_SUB_STATE_DONE;
	  break;
      }      
      break;
    case ADC_SUB_TASK_ENABLE_ADC:
      switch(adc_sub_state)
      {
	case ADC_SUB_STATE_INIT:
	  /* ENABLE ADC (but do not start) */
	  /* after the ADC is enabled, it must not be reconfigured */
	  ADC1->ISR |= ADC_ISR_ADRDY; 			/* clear ready flag */
	  ADC1->CR |= ADC_CR_ADEN; 			/* enable ADC */
	  adc_sub_state = ADC_SUB_STATE_ACTIVE;
	  /* fall through */
	case ADC_SUB_STATE_ACTIVE:
	  if ( (ADC1->ISR & ADC_ISR_ADRDY) != 0 )
	    adc_sub_state = ADC_SUB_STATE_DONE;
	  break;
      }      
      break;
    case ADC_SUB_TASK_DISABLE_ADC:
      switch(adc_sub_state)
      {
	case ADC_SUB_STATE_INIT:
	  /* required to change the configuration of the ADC */
	  /* Check for the ADEN flag. */
	  /* Setting ADDIS will fail if the ADC is alread disabled. */
	  if ((ADC1->CR & ADC_CR_ADEN) == 0) 
	  {
	    adc_sub_state = ADC_SUB_STATE_DONE;
	  }
	  else
	  {
	    ADC1->CR |= ADC_CR_ADDIS;
	    if ( (ADC1->CR & ADC_CR_ADDIS) == 0 )
	      adc_sub_state = ADC_SUB_STATE_DONE;
	    else
	      adc_sub_state = ADC_SUB_STATE_ACTIVE;
	  }
	  break;
	case ADC_SUB_STATE_ACTIVE:
	  if ((ADC1->CR & ADC_CR_ADEN) == 0) 
	  {
	    adc_sub_state = ADC_SUB_STATE_DONE;
	  }
	  if ( (ADC1->CR & ADC_CR_ADDIS) == 0 )
	  {
	    adc_sub_state = ADC_SUB_STATE_DONE;
	  }
	  break;
      }      
      break;
    case ADC_SUB_TASK_CONVERSION:
      switch(adc_sub_state)
      {
	case ADC_SUB_STATE_INIT:
	  ADC1->CR |= ADC_CR_ADSTART; /* start the ADC conversion */	
	  adc_sub_state = ADC_SUB_STATE_ACTIVE;
	  /* fall through */
	case ADC_SUB_STATE_ACTIVE:
	  if ( (ADC1->ISR & ADC_ISR_EOC) != 0 )
	  {
	    adc_sub_state = ADC_SUB_STATE_DONE;
	    adc_result = ADC1->DR;
	  }
	  break;
      }      
      break;
  }
}


/* STOP ANY ADC CONVERSION */
void stopADC(void)
{
  //ADC1->CR |= ADC_CR_ADSTP;
  //while(ADC1->CR & ADC_CR_ADSTP)
  //  ;
  
  while( adcStartSubTask(ADC_SUB_TASK_STOP_ADC) == 0 )
    adcExecSub();
  
  while( adcIsSubDone() == 0 )
    adcExecSub();
}

/* CONFIGURATION with ADEN=0 */
/* required to change the configuration of the ADC */
void disableADC(void)
{
  /* Check for the ADEN flag. */
  /* Setting ADDIS will fail if the ADC is alread disabled: The while loop will not terminate */
#ifdef xxxx
  if ((ADC1->CR & ADC_CR_ADEN) != 0) 
  {
    /* is this correct? i think we must use the disable flag here */
    ADC1->CR |= ADC_CR_ADDIS;
    while(ADC1->CR & ADC_CR_ADDIS)
      ;
  }
#endif

  while( adcStartSubTask(ADC_SUB_TASK_DISABLE_ADC) == 0 )
    adcExecSub();
  
  while( adcIsSubDone() == 0 )
    adcExecSub();

}

/* ENABLE ADC (but do not start) */
/* after the ADC is enabled, it must not be reconfigured */
void enableADC(void)
{
  //ADC1->ISR |= ADC_ISR_ADRDY; 			/* clear ready flag */
  //ADC1->CR |= ADC_CR_ADEN; 			/* enable ADC */
  //while ((ADC1->ISR & ADC_ISR_ADRDY) == 0) /* wait for ADC */
  //{
  //}

  while( adcStartSubTask(ADC_SUB_TASK_ENABLE_ADC) == 0 )
    adcExecSub();
  
  while( adcIsSubDone() == 0 )
    adcExecSub();
  
}


/*=======================================================================*/
/* ADC Single Conversion: 8 bit resolution */


/*
  ch0   PA0     pin 6
  ch1   PA1     pin 7
  ch2   PA2     pin 8
  ch3   PA3     pin 9
  ch4   PA4     pin 10
  ch5   PA5     pin 11
  ch6   PA6     pin 12
  ch7   PA7     pin 13
  ch8   PB0     -
  ch9   PB1     pin 14


  ch 0..15: 	GPIO
  ch 16:		???
  ch 17:		vref (bandgap)
  ch18:		temperature sensor

  returns 8 bit result, right aligned 
*/

uint8_t adc_single_conversion_channel = 5;
volatile uint8_t adc_single_conversion_state = 0;
uint16_t adc_single_conversion_result;

int adcStartSingleConversion(uint8_t channel)
{
  if ( adc_single_conversion_state != 0 )
    return 0;
  adc_single_conversion_state = 1;
  adc_single_conversion_channel = channel;
  return 1;
}

void adcExecSingleConversion(void)
{
  switch(adc_single_conversion_state)
  {
    case 1:
      if ( adcStartSubTask(ADC_SUB_TASK_STOP_ADC) == 0 )
      {
	adcExecSub();
	break;
      }
      adc_single_conversion_state++;
      /* fall through */
    case 2:
      if ( adcIsSubDone() == 0 )
      {
	adcExecSub();
	break;
      }
      adc_single_conversion_state++;
      /* fall through */
    case 3:
      if ( adcStartSubTask(ADC_SUB_TASK_DISABLE_ADC) == 0 )
      {
	adcExecSub();
	break;
      }
      adc_single_conversion_state++;
      /* fall through */
    case 4:
      if ( adcIsSubDone() == 0 )
      {
	adcExecSub();
	break;
      }
      
      /* CONFIGURE ADC */
      
      //ADC1->CFGR1 &= ~ADC_CFGR1_EXTEN;	/* software enabled conversion start */
      //ADC1->CFGR1 &= ~ADC_CFGR1_ALIGN;		/* right alignment */
      ADC1->CFGR1 = ADC_CFGR1_RES_1;		/* 8 bit resolution */
      //ADC1->SMPR |= ADC_SMPR_SMP_0 | ADC_SMPR_SMP_1 | ADC_SMPR_SMP_2; /* Select a sampling mode of 111 (very slow)*/
      ADC1->SMPR  = 0;
      
      adc_single_conversion_state++;
      /* fall through */
    case 5:
      if ( adcStartSubTask(ADC_SUB_TASK_ENABLE_ADC) == 0 )
      {
	adcExecSub();
	break;
      }
      adc_single_conversion_state++;
      /* fall through */
    case 6:
      if ( adcIsSubDone() == 0 )
      {
	adcExecSub();
	break;
      }
      
      ADC1->CHSELR = 1<<adc_single_conversion_channel; 				/* Select channel (can be done also if ADC is enabled) */
      adc_single_conversion_state++;
      /* fall through */      
    case 7:
      if ( adcStartSubTask(ADC_SUB_TASK_CONVERSION) == 0 )
      {
	adcExecSub();
	break;
      }
      adc_single_conversion_state++;
      /* fall through */
    case 8:
      if ( adcIsSubDone() == 0 )
      {
	adcExecSub();
	break;
      }
      adc_single_conversion_result = adc_result;
      adc_single_conversion_state = 0;
      break;
  }
}

uint16_t getADC(uint8_t ch)
{
  while( adcStartSingleConversion(ch) == 0)
    adcExecSingleConversion();
  while( adc_single_conversion_state != 0 )
    adcExecSingleConversion();
  return adc_single_conversion_result;
}



/*=======================================================================*/
/* ADC Multi (DMA) Conversion: 12 bit resolution */

uint8_t adc_multi_conversion_channel = 6;
volatile uint8_t adc_multi_conversion_state = 0;
uint16_t adc_multi_conversion_count = 256;
uint16_t *adc_multi_conversion_buffer = NULL;

int adcStartMultiConversion(uint8_t channel, uint16_t cnt, uint16_t *buf)
{
  if ( adc_multi_conversion_state != 0 )
    return 0;
  adc_multi_conversion_state = 1;
  adc_multi_conversion_channel = channel;
  adc_multi_conversion_count = cnt;
  adc_multi_conversion_buffer = buf;
  return 1;
}


void adcExecMultiConversion(void)
{
  switch(adc_multi_conversion_state)
  {
    case 1:
      if ( adcStartSubTask(ADC_SUB_TASK_STOP_ADC) == 0 )
      {
	adcExecSub();
	break;
      }
      adc_multi_conversion_state++;
      /* fall through */
    case 2:
      if ( adcIsSubDone() == 0 )
      {
	adcExecSub();
	break;
      }
      adc_multi_conversion_state++;
      /* fall through */
    case 3:
      if ( adcStartSubTask(ADC_SUB_TASK_DISABLE_ADC) == 0 )
      {
	adcExecSub();
	break;
      }
      adc_multi_conversion_state++;
      /* fall through */
    case 4:
      if ( adcIsSubDone() == 0 )
      {
	adcExecSub();
	break;
      }
      
      /* CONFIGURE ADC */

      /* disable and reset to defaults */
      DMA1_Channel1->CCR = 0;
      
      /* defaults: 
	  - 8 Bit access	--> will be changed below
	  - read from peripheral	--> ok
	  - none-circular mode  --> ok
	  - no increment mode   --> will be changed below
      */
      
      
      DMA1_Channel1->CNDTR = adc_multi_conversion_count;                                        /* buffer size */
      DMA1_Channel1->CPAR = (uint32_t)&(ADC1->DR);                     /* source value */
      //  DMA1_Channel1->CPAR = (uint32_t)&(GPIOA->ODR);                    /* source value */
      DMA1_Channel1->CMAR = (uint32_t)adc_multi_conversion_buffer;                   /* destination memory */

      DMA1_CSELR->CSELR &= ~DMA_CSELR_C1S;         /* 0000: select ADC for DMA CH 1 (this is reset default) */
      DMA1_CSELR->CSELR &= ~DMA_CSELR_C2S;         /* 0000: select ADC for DMA CH 2 (this is reset default) */
      
      DMA1_Channel1->CCR |= DMA_CCR_MINC;		/* increment memory */   
      DMA1_Channel1->CCR |= DMA_CCR_MSIZE_0;		/* 01: 16 Bit access */   
      DMA1_Channel1->CCR |= DMA_CCR_PSIZE_0;		/* 01: 16 Bit access */   
      
      DMA1_Channel1->CCR |= DMA_CCR_EN;                /* enable */

      
      /* 
	detect rising edge on external trigger (ADC_CFGR1_EXTEN_0)
	recive trigger from TIM2 (ADC_CFGR1_EXTSEL_1)  
	8 Bit resolution (ADC_CFGR1_RES_1)
      
	Use DMA one shot mode and enable DMA (ADC_CFGR1_DMAEN)
	Once DMA is finished, it will disable continues mode (ADC_CFGR1_CONT)
      */
      
      
      ADC1->CFGR1 = 
	    ADC_CFGR1_CONT				/* continues mode */
	    | ADC_CFGR1_EXTEN_0 	/* rising edge */
	//    | ADC_CFGR1_EXTEN_1 			/*  */	    
	    | ADC_CFGR1_EXTSEL_1 			/* TIM2 */
    //	| ADC_CFGR1_RES_1				/* 8 Bit resolution, no value means 12 bit */
	    | ADC_CFGR1_DMAEN;			/* enable generation of DMA requests */

      //ADC1->SMPR |= ADC_SMPR_SMP_0 | ADC_SMPR_SMP_1 | ADC_SMPR_SMP_2; 
      //ADC1->SMPR = ADC_SMPR_SMP_1 ; 
      //ADC1->SMPR = ADC_SMPR_SMP_0 | ADC_SMPR_SMP_1 ; 
      ADC1->SMPR = ADC_SMPR_SMP_2 ; 
      
      /*
	12.5 + 8.5 = 21 ADC Cycles pre ADC sampling
	4 MHz / 21 cycle / 256 = 744 Hz
      */
      adc_multi_conversion_state++;
      /* fall through */
    case 5:
      if ( adcStartSubTask(ADC_SUB_TASK_ENABLE_ADC) == 0 )
      {
	adcExecSub();
	break;
      }
      adc_multi_conversion_state++;
      /* fall through */
    case 6:
      if ( adcIsSubDone() == 0 )
      {
	adcExecSub();
	break;
      }
      
      ADC1->CHSELR = 1<<adc_multi_conversion_channel; 				/* Select channel (can be done also if ADC is enabled) */
      /* conversion will be started automatically with rising edge of TIM2, yet ADSTART is still required */
      ADC1->CR |= ADC_CR_ADSTART; /* start the ADC conversion */
      adc_multi_conversion_state++;
      
      /* fall through */      
    case 7:
      if ( DMA1_Channel1->CNDTR > 0 )
	break;
      adc_multi_conversion_state = 0;
      break;
  }
}


/* 12 bit resolution */
void scanADC(uint8_t ch, uint16_t cnt, uint16_t *buf)
{
  while( adcStartMultiConversion(ch, cnt, buf) == 0)
    adcExecMultiConversion();
  while( adc_multi_conversion_state != 0 )
    adcExecMultiConversion();
}



/*=======================================================================*/
/*
  5000Hz Data Acquisition

  Acqusition:
  1./2. Read DC Motor Voltage into buffer 1
  3./4. Read DC Motor Voltage into buffer 2   
  5./6. Read signle ADC from the variable resistor 
  parallel: Calculate noise via difference signal


*/

volatile uint16_t adc_variable_resistor_value = 0;
volatile uint8_t adc_acquisition_state = 0;
volatile uint8_t adc_calculation_state = 0;

#define BUF_MUL 2

uint16_t adc_buf[128*BUF_MUL];
uint16_t adc_buf2[128*BUF_MUL];
uint16_t adc_diff[128*BUF_MUL];
uint32_t adc_diff_sum_tmp = 0;
uint16_t adc_diff_sum_cnt = 0;
volatile uint32_t adc_diff_sum = 0;
volatile uint16_t adc_diff_noise_per_sample_raw = 0;		// scaled by 8 bits
volatile uint16_t adc_diff_noise_per_sample_filt = 0;		// scaled by 8 bits
volatile uint16_t adc_max_tmp = 0;
volatile uint16_t adc_max_raw = 0;
volatile uint16_t adc_max_filt = 0;
volatile uint16_t adc_calculation_pos;

/* 128*BUF_MUL / ADC_CALC_PER_STEP must have no reminder */
#define ADC_CALC_PER_STEP 32
void adcExecAcquisition(void)
{
  uint16_t i;
  uint16_t a, b, d, z;
  switch(adc_acquisition_state)
  {
    case 1:
      if ( adcStartMultiConversion(6, 128*BUF_MUL, adc_buf) == 0)
      {
	adcExecMultiConversion();
	break;
      }
      adc_acquisition_state++;
      /* fall through */
    case 2:
      if ( adc_multi_conversion_state != 0 )
      {
	adcExecMultiConversion();
	break;
      }
      adc_acquisition_state++;
      /* fall through */
    case 3:
      if ( adcStartMultiConversion(6, 128*BUF_MUL, adc_buf2) == 0)
      {
	adcExecMultiConversion();
	break;
      }
      adc_acquisition_state++;
      /* fall through */
    case 4:
      if ( adc_multi_conversion_state != 0 )
      {
	adcExecMultiConversion();
	break;
      }
      adc_acquisition_state++;
      adc_calculation_state = 1;
      adc_calculation_pos = 0;
      adc_diff_sum_tmp = 0;
      adc_diff_sum_cnt = 0;
      adc_max_tmp = 0;
      /* fall through */
    case 5:
      if ( adcStartSingleConversion(5) == 0)
      {
	adcExecSingleConversion();
	break;
      }
      adc_acquisition_state++;
      /* fall through */
    case 6:
      if ( adc_single_conversion_state != 0 )
      {
	adcExecSingleConversion();
	break;
      }
      adc_variable_resistor_value = adc_single_conversion_result;
      adc_acquisition_state++;
      /* fall through */
    case 7:
      if ( adc_calculation_state >= 2 )		// wait for calculation
      {
	adc_acquisition_state = 1;
	adc_calculation_state = 0;
      }
      break;
  }
  
  switch(adc_calculation_state)
  {
    case 1:      
      i = adc_calculation_pos;
      adc_calculation_pos += ADC_CALC_PER_STEP;
      if ( adc_calculation_pos >= 128U*BUF_MUL )
	adc_calculation_pos = 128U*BUF_MUL;
      while( i < adc_calculation_pos )
      {
	a = adc_buf[i];
	b = adc_buf2[i];
	if ( a > b )
	  d = a - b;
	else
	  d = b - a;
	/* ignore values around 0 and very large differences (spikes) 
	  At least values 0 and 1 for a should be ignored.
	  Height of the spices is not really clear. 
	*/
	if ( a > 4 && b > 4 && d < 24)
	{
	  adc_diff_sum_tmp += d;
	  adc_diff_sum_cnt++;
	  z = a + b;
	  z >>= 1;
	  if ( adc_max_tmp < z )
	    adc_max_tmp = z;
	}
	adc_diff[i] = d;
	i++;
      }
      
      if ( adc_calculation_pos >= 128U*BUF_MUL )
      {
	adc_calculation_pos = 0;
	adc_diff_sum = adc_diff_sum_tmp;
	adc_diff_noise_per_sample_raw = (adc_diff_sum_tmp * 256UL)/adc_diff_sum_cnt;
	i2c_mem[2] = adc_diff_noise_per_sample_raw & 255;
	i2c_mem[3] = adc_diff_noise_per_sample_raw>>8;
	/*
	  this is a strong low-pass filter
	  currently the filter value is calculated with 100Hz (every 5th duty cycle)
	  3V DC Motor: adc_diff_noise_per_sample_filt < 0x0600 stop, adc_diff_noise_per_sample_filt > 0x0700 running
	*/
        adc_diff_noise_per_sample_filt = (((((1UL<<5) - 1)*(uint32_t)adc_diff_noise_per_sample_filt)) + (uint32_t)((1*adc_diff_noise_per_sample_raw)))>>5; 
	i2c_mem[4] = adc_diff_noise_per_sample_filt & 255;
	i2c_mem[5] = adc_diff_noise_per_sample_filt>>8;
	
	/*
	  low-pass filter for the max value of the ADC.
	  If the DC motor rotates, then the max value indicates speed: lower values are faster, higher values are slower
	  3V DC Motor: values are from 0x0160 (fastest) to >0x4b0 (almost stopped)
	*/
	adc_max_raw = adc_max_tmp;
	i2c_mem[6] = adc_max_raw & 255;
	i2c_mem[7] = adc_max_raw>>8;
	
        adc_max_filt = (((((1UL<<5) - 1)*(uint32_t)adc_max_filt)) + (uint32_t)((1*adc_max_raw))) >> 5; 
	i2c_mem[8] = adc_max_filt & 255;
	i2c_mem[9] = adc_max_filt>>8;
	
        adc_calculation_state++;
      }
      break;
  }
  
}



/*=======================================================================*/
/* TIM2: PWM signal for the DC Motor */
//#define TIM_CYCLE_TIME 5355
/* 7950 --> 500Hz */
#define TIM_CYCLE_TIME 7950
#define TIM_CYCLE_UPPER_SKIP 100
#define TIM_CYCLE_LOWER_SKIP 200


void initTIM2(uint8_t is_gpio_a)
{
  /* enable clock for TIM2 */
  RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;
  
  /* prescalar for AHB and APB1 */
  
  /* reselt defaults for HPRE and PPRE1: no clock division */
  // RCC->CFGR &= ~RCC_CFGR_HPRE;
  // RCC->CFGR |= RCC_CFGR_HPRE_DIV1;
  // RCC->CFGR &= ~RCC_CFGR_PPRE1;
  // RCC->CFGR |= RCC_CFGR_PPRE1_DIV1;
  
  /* configure GPIOA PA1 for TIM2 */
  GPIOA->MODER &= ~GPIO_MODER_MODE1;	/* clear mode for PA1 */  
  GPIOA->MODER |= GPIO_MODER_MODE1_1;  /* alt fn */
  GPIOA->OTYPER &= ~GPIO_OTYPER_OT_1;    /* push-pull */
  GPIOA->AFR[0] &= ~(15<<4);            /* Clear Alternate Function PA1 */
  GPIOA->AFR[0] |= 2<<4;                   /* AF2 Alternate Function PA1 */

  /* configure GPIOA PB1 for TIM2 */
  GPIOB->MODER &= ~GPIO_MODER_MODE1;	/* clear mode for PB1 */  
  GPIOB->MODER |= GPIO_MODER_MODE1_1;  /* alt fn */
  GPIOB->OTYPER &= ~GPIO_OTYPER_OT_1;    /* push-pull */
  GPIOB->AFR[0] &= ~(15<<4);            /* Clear Alternate Function PB1 */
  GPIOB->AFR[0] |= 5<<4;                   /* AF5 Alternate Function PB1 */

  /* TIM2 configure */
  /* disable all interrupts */
  //TIM2->DIER = 0;             /* 0 is reset default value */
  
  /* clear everything, including the "Update disable" flag, so that updates */
  /* are generated */
  // TIM2->CR1 = 0;             /* 0 is reset default value */
  //TIM2->CR1 |= TIM_CR1_ARPE;  // ARR is not modified so constant update is ok
  /* Update request by manual UG bit setting or slave controller */
  /* both is not required here */
  /* so, update request by couter over/underflow remains */
  //TIM2->CR1 |= TIM_CR1_URS;             /* only udf/ovf generae events */
  
  TIM2->CR2 |= TIM_CR2_MMS_1;		/* Update event for TRGO */
  
  TIM2->ARR = TIM_CYCLE_TIME;                         /* total cycle count */
  TIM2->CCR2 = 1024;                            /* duty cycle for channel 2 (PA1) */
  TIM2->CCR4 = 1024;                            /* duty cycle for channel 4 (PB1) */
  
  //TIM2->CCMR1 &= ~TIM_CCMR1_OC2CE;      /* disable clear output compare 2 **/
  TIM2->CCMR1 |= TIM_CCMR1_OC2M;            /* all 3 bits set: PWM Mode 2 */
  TIM2->CCMR1 |= TIM_CCMR1_OC2PE;            /* preload enable CCR2 is preloaded*/
  TIM2->CCER |= TIM_CCER_CC2P;                     /* polarity 0: normal (reset default) / 1: inverted*/

  TIM2->CCMR2 |= TIM_CCMR2_OC4M;            /* all 3 bits set: PWM Mode 2 */
  TIM2->CCMR2 |= TIM_CCMR2_OC4PE;            /* preload enable CCR2 is preloaded*/
  TIM2->CCER |= TIM_CCER_CC4P;                     /* polarity 0: normal (reset default) / 1: inverted*/
  
  
  
  if ( is_gpio_a )
    TIM2->CCER |= TIM_CCER_CC2E;                     /* set output enable for channel 2 */
  else
    TIM2->CCER |= TIM_CCER_CC4E;                     /* set output enable for channel 4 */
  
  TIM2->PSC = 7;						/* divide by 8 */

  
  TIM2->CR1 |= TIM_CR1_CEN;            /* counter enable */
  
  /*
    TIM2 cycle:
    32000000Hz / 5355 / 8 = 747 Hz  
  */
}

void setTIM2RawDuty(uint32_t duty_cycle, uint8_t is_gpio_a)
{
  TIM2->CCR2 = duty_cycle;
  TIM2->CCR4 = duty_cycle;
  
  if ( is_gpio_a )
  {
    TIM2->CCMR1 |= TIM_CCMR1_OC2M;            /* all 3 bits set: PWM Mode 2 */
    TIM2->CCER |= TIM_CCER_CC2E;                     /* set output enable for channel 2 */
    
    //TIM2->CCER &= ~TIM_CCER_CC4E;                     /* set output disable for channel 4 */    
    TIM2->CCMR2 &= ~TIM_CCMR2_OC4M_1;            /* Mode 101 force high */

  }
  else
  {
    TIM2->CCMR2 |= TIM_CCMR2_OC4M;            /* all 3 bits set: PWM Mode 2 */
    TIM2->CCER |= TIM_CCER_CC4E;                     /* set output enable for channel 4 */
    
    //TIM2->CCER &= ~TIM_CCER_CC2E;                     /* set output disable for channel 2 */
    TIM2->CCMR1 &= ~TIM_CCMR1_OC2M_1;            /* Mode 101 force high */
  }
}




/*=======================================================================*/
/* TIM22 */

/* 
  TIM22: 0.2ms IRQ 

  Assumptions:
    APB2: 32MHz
    GPIO A anabled
*/
void initTIM22(void)
{
  RCC->APB2ENR |= RCC_APB2ENR_TIM22EN;
  
  /* configure GPIOA PA7 for TIM2 CH2*/
  GPIOA->MODER &= ~GPIO_MODER_MODE7;	/* clear mode for PA1 */  
  GPIOA->MODER |= GPIO_MODER_MODE7_1;  /* alt fn */
  GPIOA->OTYPER &= ~GPIO_OTYPER_OT_7;    /* push-pull */
  GPIOA->AFR[0] &= ~(15<<28);            /* Clear Alternate Function PA7 */
  //GPIOA->AFR[0] |= 5<<28;                   /* AF5 Alternate Function PA7 NOTE: OUTPUT at PA7 influences ADC! */
  
  TIM22->CR2 |= TIM_CR2_MMS_1;		/* Update event for TRGO */
  TIM22->ARR = 6400;				/* 0.2ms (5000Hz) with 32MHz */
  TIM22->CCR2 = 2000;                            /* duty cycle for channel 2 (PA7) */
  
  TIM22->CCMR1 |= TIM_CCMR1_OC2M;            /* all 3 bits set: PWM Mode 2 */
  TIM22->CCMR1 |= TIM_CCMR1_OC2PE;            /* preload enable --> more accurate duty cycle visible */
  TIM22->CCER |= TIM_CCER_CC2E;                     /* set output enable for channel 2 */
  TIM22->CCER |= TIM_CCER_CC2P;                     /* polarity 0: normal (reset default) / 1: inverted*/
  TIM22->PSC = 0;						/* divide by 1 */
    
  TIM22->DIER |= TIM_DIER_UIE;			/* enable TIM22 update interrupt: call TIM22_IRQHandler on reload */

  /* enable IRQ in NVIC */
  NVIC_SetPriority(TIM22_IRQn, 0);
  NVIC_EnableIRQ(TIM22_IRQn);
  
  
  TIM22->CR1 |= TIM_CR1_CEN;            /* counter enable */
  
  adc_acquisition_state = 1;			/* enable data acquisition */

}

volatile uint16_t adc_max;

void __attribute__ ((interrupt, used)) TIM22_IRQHandler(void)
{
  
/*
  the following loop requires about 5000 clock cycles 1/3 of the IRQ time:
  
  uint16_t i;
  adc_max = 0;
  for( i = 0; i < 256; i++ )
  {
    adc_max += TIM22->CNT;
  }
*/

  adcExecAcquisition();

  TIM22->CCR2 = TIM22->CNT;		/* store the current count value in compare register: duty cycle signals load */
  TIM22->SR &= ~TIM_SR_UIF;			/* clear interrupt */
}


/*=======================================================================*/
/* I2C */

volatile uint16_t i2c_total_irq_cnt;
volatile uint16_t i2c_TXIS_cnt;
volatile uint16_t i2c_RXNE_cnt;


void i2c_mem_reset_write(void)
{
  i2c_is_write_idx = 1;  
}

void i2c_mem_init(void)
{
  i2c_idx = 0;
  i2c_mem_reset_write();
}

void i2c_mem_set_index(unsigned char value)
{
  i2c_idx = value;
  i2c_is_write_idx = 0;
}

void i2c_mem_write_via_index(unsigned char value)
{
  if ( i2c_idx == 0 )
  {
    /* additionall put this byte into the queue */
    //addCmdToGPIOQueue(value);
  }
  i2c_mem[i2c_idx++] = value;
}

unsigned char i2c_mem_read(void)
{
  i2c_mem_reset_write();
  i2c_idx++;
  return i2c_mem[i2c_idx];
}

void i2c_mem_write(unsigned char value)
{
  if ( i2c_is_write_idx != 0 )
  {
    i2c_mem_set_index(value);
  }
  else
  {
    i2c_is_write_idx = 0;
    i2c_mem_write_via_index(value);
  }
}



/* address: I2C address multiplied by 2 */
/* Pins PA9 (SCL) and PA10 (SDA) */
void i2c_hw_init(unsigned char address)
{
  RCC->APB1ENR |= RCC_APB1ENR_I2C1EN;		/* Enable clock for I2C */
  RCC->IOPENR |= RCC_IOPENR_IOPAEN;		/* Enable clock for GPIO Port A */
  
    __NOP();                                                          /* extra delay for clock stabilization required? */
    __NOP();


  /* configure io */
  GPIOA->MODER &= ~GPIO_MODER_MODE9;	/* clear mode for PA9 */  
  GPIOA->MODER |= GPIO_MODER_MODE9_1;  /* alt fn */
  GPIOA->OTYPER |= GPIO_OTYPER_OT_9;    /* open drain */
  GPIOA->AFR[1] &= ~(15<<4);            /* Clear Alternate Function PA9 */
  GPIOA->AFR[1] |= 1<<4;                   /* I2C Alternate Function PA9 */
  
  GPIOA->MODER &= ~GPIO_MODER_MODE10;	/* clear mode for PA10 */  
  GPIOA->MODER |= GPIO_MODER_MODE10_1;  /* alt fn */
  GPIOA->OTYPER |= GPIO_OTYPER_OT_10;    /* open drain */
  GPIOA->AFR[1] &= ~(15<<8);            /* Clear Alternate Function PA10 */
  GPIOA->AFR[1] |= 1<<8;            /* I2C Alternate Function PA10 */
  
  
  RCC->CCIPR &= ~RCC_CCIPR_I2C1SEL;                      /* write 00 to the I2C clk selection register */
  RCC->CCIPR |= RCC_CCIPR_I2C1SEL_0;                      /* select system clock (01) */
  
  /* I2C init flow chart: Clear PE bit */
  
  I2C1->CR1 &= ~I2C_CR1_PE;             
  
  /* I2C init flow chart: Configure filter */
  
  /* leave at defaults */

  /* I2C init flow chart: Configure timing */
  /*
    standard mode 100kHz configuration
    SYSCLK = I2CCLK = 32 MHz
    PRESC = 6           bits 28..31
    SCLL = 0x13         bits 0..7
    SCLH = 0x0f         bits 8..15
    SDADEL = 0x02       bits 16..19
    SCLDEL = 0x04       bits 20..23
  */
  I2C1->TIMINGR = 0x60420f13;
  
  /* I2C init flow chart: Configure NOSTRECH */
  
  I2C1->CR1 |= I2C_CR1_NOSTRETCH;

  /* I2C init flow chart: Enable I2C */
  
  I2C1->CR1 |= I2C_CR1_PE;


  /* disable OAR1 for reconfiguration */
  I2C1->OAR1 &= ~I2C_OAR1_OA1EN;
  
  I2C1->OAR1 = address;
  
  I2C1->OAR1 |= I2C_OAR1_OA1EN;


  /* enable interrupts */
  I2C1->CR1 |= I2C_CR1_STOPIE;
  I2C1->CR1 |= I2C_CR1_NACKIE;
  //I2C1->CR1 |= I2C_CR1_ADDRIE;
  I2C1->CR1 |= I2C_CR1_RXIE;
  I2C1->CR1 |= I2C_CR1_TXIE;
  
  

  /* load first value into TXDR register */
  I2C1->TXDR = i2c_mem[i2c_idx];


  /* enable IRQ in NVIC */
  NVIC_SetPriority(I2C1_IRQn, 0);
  NVIC_EnableIRQ(I2C1_IRQn);


  
}

void i2c_init(unsigned char address)
{
  i2c_mem_init();
  i2c_mem[0] = 0x080;  /* stop */
  i2c_hw_init(address);
}


void __attribute__ ((interrupt, used)) I2C1_IRQHandler(void)
{
  unsigned long isr = I2C1->ISR;

  i2c_total_irq_cnt ++;
  
  if ( isr & I2C_ISR_TXIS )
  {
    i2c_TXIS_cnt++;
    I2C1->TXDR = i2c_mem_read();
  }
  else if ( isr & I2C_ISR_RXNE )
  {
    i2c_RXNE_cnt++;
    i2c_mem_write(I2C1->RXDR);
    I2C1->ISR |= I2C_ISR_TXE;           // allow overwriting the TCDR with new data
    I2C1->TXDR = i2c_mem[i2c_idx];
  }
  else if ( isr & I2C_ISR_STOPF )
  {
    I2C1->ICR = I2C_ICR_STOPCF;
    I2C1->ISR |= I2C_ISR_TXE;           // allow overwriting the TCDR with new data
    I2C1->TXDR = i2c_mem[i2c_idx];
    i2c_mem_reset_write();
  }
  else if ( isr & I2C_ISR_NACKF )
  {
    I2C1->ICR = I2C_ICR_NACKCF;
    I2C1->ISR |= I2C_ISR_TXE;           // allow overwriting the TCDR with new data
    I2C1->TXDR = i2c_mem[i2c_idx];
    i2c_mem_reset_write();
  }
  else if ( isr & I2C_ISR_ADDR )
  {
    /* not required, the addr match interrupt is not enabled */
    I2C1->ICR = I2C_ICR_ADDRCF;
    I2C1->ISR |= I2C_ISR_TXE;           // allow overwriting the TCDR with new data
    I2C1->TXDR = i2c_mem[i2c_idx];
    i2c_mem_reset_write();
  }
 
  /* if at any time the addr match is set, clear the flag */
  /* not sure, whether this is required */
  if ( isr & I2C_ISR_ADDR )
  {
    I2C1->ICR = I2C_ICR_ADDRCF;
  }
    
}



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


int main()
{
  uint16_t adc_value = 0x80;
  uint16_t old_adc_value = 0x0ffff;
  uint16_t tim_duty;
  uint16_t zero_pos;
  uint16_t i;
  u8g2_uint_t y, yy;
  uint8_t is_i2c = 0;
  
  setHSIClock();        /* enable 32 MHz Clock */
  startUp();               /* enable systick irq and several power regions  */
  i2c_init(40*2);	/* activage I2C, adr = 40 */
  initDisplay();          /* aktivate display */
  initADC();

  RCC->IOPENR |= RCC_IOPENR_IOPAEN;		/* Enable clock for GPIO Port A */
  RCC->IOPENR |= RCC_IOPENR_IOPBEN;		/* Enable clock for GPIO Port B */
  __NOP();
  __NOP();
  
  GPIOA->MODER &= ~GPIO_MODER_MODE1;	/* clear mode for PA1 */
  GPIOA->MODER |= GPIO_MODER_MODE1_0;	/* Output mode for PA1 */
  GPIOA->OTYPER &= ~GPIO_OTYPER_OT_1;	/* no Push/Pull for PA1 */
  GPIOA->OSPEEDR &= ~GPIO_OSPEEDER_OSPEED1;	/* low speed for PA1 */
  GPIOA->PUPDR &= ~GPIO_PUPDR_PUPD1;	/* no pullup/pulldown for PA1 */
  GPIOA->BSRR = GPIO_BSRR_BS_1;		/* atomic set PA1 */

  GPIOB->MODER &= ~GPIO_MODER_MODE1;	/* clear mode for PB1 */
  GPIOB->MODER |= GPIO_MODER_MODE1_0;	/* Output mode for PB1 */
  //GPIOB->OTYPER &= ~GPIO_OTYPER_OT_1;	/* no Push/Pull for PB1 */
  GPIOB->OSPEEDR &= ~GPIO_OSPEEDER_OSPEED1;	/* low speed for PB1 */
  GPIOB->PUPDR &= ~GPIO_PUPDR_PUPD1;	/* no pullup/pulldown for PB1 */
  GPIOB->BSRR = GPIO_BSRR_BR_1;		/* atomic reset PB1 */


  initTIM2(1);
  initTIM22();
  
  

  for(;;)
  {
    
    u8g2_ClearBuffer(&u8g2);
   

    
    if ( is_i2c != 0 )
    {
      adc_value = i2c_mem[0];
    }
    else
    {
      if ( i2c_mem[0] != 0x080 )
      {
	adc_value = i2c_mem[0];
	is_i2c = 1;
      }
      else
      {
	adc_value = adc_variable_resistor_value;
      }
    }
    
    if ( old_adc_value != adc_value )
    {
      
      if ( adc_value >= 0x080 )
      {
	tim_duty = ((uint32_t)((adc_value-0x080)*2)*((uint32_t)TIM_CYCLE_TIME-TIM_CYCLE_UPPER_SKIP-TIM_CYCLE_LOWER_SKIP))>>8;
	tim_duty += TIM_CYCLE_LOWER_SKIP;      
	setTIM2RawDuty(tim_duty, 1);
      }
      else
      {
	tim_duty = ((uint32_t)((0x080 - adc_value)*2)*((uint32_t)TIM_CYCLE_TIME-TIM_CYCLE_UPPER_SKIP-TIM_CYCLE_LOWER_SKIP))>>8;
	tim_duty += TIM_CYCLE_LOWER_SKIP;      
	setTIM2RawDuty(tim_duty, 0);
      }
      old_adc_value = adc_value;
    }
    

    yy = 60;
    
    zero_pos = ((uint32_t)tim_duty * (uint32_t)256) / (uint32_t)TIM_CYCLE_TIME;
    zero_pos +=4;
    zero_pos += (256-zero_pos)>>6;

    setRow(10); outHex16(adc_value); 
    outStr(" "); outHex16(adc_diff_noise_per_sample_filt); 
    //outStr(" ");  outHex16(adc_diff_sum_cnt); 
    outStr(" ");  outHex16(adc_max_raw); 
    outStr(" ");  outHex16(adc_max_filt); 
    //outStr("|"); outHex8(adc_buf[zero_pos/2]); outStr("|"); outHex8(adc_buf[zero_pos]); 
    
    u8g2_DrawVLine(&u8g2, zero_pos/2, yy-7, 15);
    u8g2_DrawVLine(&u8g2, zero_pos/4, yy-7, 15);
    for( i = 0; i < 128; i++ )
    {
      y = 60-(adc_buf[i*BUF_MUL]>>5);
      //y = 60-(adc_diff[i*BUF_MUL]>>2);
      u8g2_DrawPixel(&u8g2, i, y);
      if ( y < yy )
	u8g2_DrawVLine(&u8g2, i, y, yy-y+1);
      else
	u8g2_DrawVLine(&u8g2, i, yy, y-yy+1);
      yy = y;
    }

    u8g2_SendBuffer(&u8g2);
    
  }
  return 0;
}