WebSVN – DashDisplay – Diff – /trunk/Src/main.c

 /* USER CODE BEGIN Includes */
 #include "ap_math.h"
 #include "serial.h"
 #include "SSD1306.h"
+#include "Font.h"
 #include "dials.h"
 #include "switches.h"
 #include <math.h>
 #include "plx.h"
 /* USER CODE END Includes */
 /* Private variables ---------------------------------------------------------*/
-ADC_HandleTypeDef hadc1;
 SPI_HandleTypeDef hspi1;
 UART_HandleTypeDef huart1;
 UART_HandleTypeDef huart2;
 /* USER CODE BEGIN PV */
 /* Private variables ---------------------------------------------------------*/
+#define MAXRDG 10
+int OldObservation[2] =
+{ -1, -1 }; // illegal initial value
+int OldObservationIndex[2] =
+{ -1, -1 }; // if more than one sensor this will be printed
+int16_t dial0[2] =
+{ 0, 0 };
+int16_t dial1[2] =
+{ -1, -1 };
+union
+{
+        PLX_SensorInfo Sensor[MAXRDG];
+        char Bytes[MAXRDG * sizeof(PLX_SensorInfo)];
+} Data;
+int Max[MAXRDG];
+int Min[MAXRDG];
+int PLXItems;
 /* USER CODE END PV */
 /* Private function prototypes -----------------------------------------------*/
 void
-SystemClock_Config (void);
+SystemClock_Config(void);
 void
-Error_Handler (void);
+Error_Handler(void);
 static void
-MX_GPIO_Init (void);
+MX_GPIO_Init(void);
 static void
-MX_ADC1_Init (void);
+MX_SPI1_Init(void);
 static void
-MX_SPI1_Init (void);
+MX_USART2_UART_Init(void);
 static void
-MX_USART2_UART_Init (void);
-static void
-MX_USART1_UART_Init (void);
+MX_USART1_UART_Init(void);
 /* USER CODE BEGIN PFP */
 /* Private function prototypes -----------------------------------------------*/
 /* USER CODE END PFP */
 /* USER CODE BEGIN 0 */
 /* dummy function */
-void
-_init (void)
+void _init(void)
+{
+}
+// the dial is the switch number we are using.
+// suppress is the ItemIndex we wish to suppress on this display
+int  DisplayCurrent(int dial,int suppress)
+{
+        char buff[10];
+        int i;
+        select_display(dial); // pick the display we are using
+        int ItemIndex = dial_pos[dial];
+        // wrap around count if dial too far to the right
+        if (ItemIndex >= PLXItems)
+        {
+                dial_pos[dial] = 0;
+                ItemIndex = 0;
+        }
+        if (ItemIndex < 0)
+        {
+                ItemIndex = 0;
+                dial_pos[dial] = 0;
+        }
+        // check for item suppression
+        if(ItemIndex == suppress)
+        {
+                dial1[dial] = -1;
+                OldObservation[dial] = -1;
+                OldObservationIndex[dial] = -1;
+                 drawLine(0,0,127,63,1);
+        //      display();
+                return -1; // we suppressed this display
+        }
+        // do not try to convert if no items in buffer
+        if (PLXItems > 0)
+        {
+                int DataVal = ConvPLX(Data.Sensor[ItemIndex].ReadingH,
+                                Data.Sensor[ItemIndex].ReadingL); // data reading
+                int Observation = ConvPLX(Data.Sensor[ItemIndex].AddrH,
+                                Data.Sensor[ItemIndex].AddrL);
+                int ObservationIndex = ConvPLX(0, Data.Sensor[ItemIndex].Instance);
+                // now to convert the readings and format strings
+                // find out limits
+                char * msg;
+                int len;
+                if (Observation < PLX_MAX_OBS)
+                {
+                        if (Observation != OldObservation[dial]
+                                        || ObservationIndex != OldObservationIndex[dial])
+                        {
+                                dial1[dial] = -1;
+                                clearDisplay();
+                                dial_draw_scale(
+                                                DisplayInfo[Observation].Low
+                                                                / DisplayInfo[Observation].TickScale,
+                                                DisplayInfo[Observation].High
+                                                                / DisplayInfo[Observation].TickScale, 16, 1);
+                                if (ObservationIndex > 0)
+                                {
+                                        len = 5;
+                                        buff[6] = ObservationIndex + '1';
+                                }
+                                else
+                                {
+                                        len = 6;
+                                }
+                                {
+                                        msg = DisplayInfo[Observation].name;
+                                }
+                                for (i = 0; i < len; i++)
+                                {
+                                        buff[i] = msg[i];
+                                }
+                                print_large_string(buff, 32, 48, 6); // this prints spaces for \0 at end of string
+                                OldObservation[dial] = Observation;
+                                OldObservationIndex[dial] = ObservationIndex;
+                                //
+                                display();
+                        }
+                        double max_rdg;
+                        double min_rdg;
+                        double cur_rdg;
+                        int int_rdg;
+                        max_rdg = ConveriMFDRaw2Data(Observation,
+                                        DisplayInfo[Observation].Units, Max[ItemIndex]);
+                        min_rdg = ConveriMFDRaw2Data(Observation,
+                                        DisplayInfo[Observation].Units, Min[ItemIndex]);
+                        cur_rdg = ConveriMFDRaw2Data(Observation,
+                                        DisplayInfo[Observation].Units, DataVal);
+                        cur_rdg /= DisplayInfo[Observation].TickScale;
+                        int dp_pos;  // where to print the decimal place
+                        switch (DisplayInfo[Observation].DP)
+                        {
+                        case 0:
+                                int_rdg = (int) (cur_rdg);
+                                dp_pos = 100;
+                                break;
+                        case 1:
+                                int_rdg = (int) (cur_rdg * 10.0);
+                                dp_pos = 3;
+                                break;
+                        case 2:
+                                int_rdg = (int) (cur_rdg * 100.0);
+                                dp_pos = 2;
+                                break;
+                        }
+                        cur_rdg -= DisplayInfo[Observation].Low;
+                        cur_rdg = 100 * cur_rdg
+                                        / (DisplayInfo[Observation].High
+                                                        - DisplayInfo[Observation].Low);
+                        dial0[dial] = (int) cur_rdg;
+                        /* old needle un-draw */
+                        if (dial1[dial] >= 0)
+                        {
+                                dial_draw_needle(dial1[dial]);
+                        }
+                        dial_draw_needle(dial0[dial]);
+                        // print value overlaid by needle
+                        // this is actual reading
+                        print_digits(64 - 16, 30, 4, dp_pos, int_rdg);
+                        dial1[dial] = dial0[dial];
+                        display();
+                }
+        }
+        return ItemIndex;
+}
 /* USER CODE END 0 */
-int
-main (void)
+int main(void)
+{
-  /* USER CODE BEGIN 1 */
+        /* USER CODE BEGIN 1 */
-  GPIO_InitTypeDef GPIO_InitStruct;
+        GPIO_InitTypeDef GPIO_InitStruct;
-  __HAL_RCC_SPI1_CLK_ENABLE()
+        __HAL_RCC_SPI1_CLK_ENABLE()
-  ;
+        ;
-  __HAL_RCC_USART1_CLK_ENABLE()
+        __HAL_RCC_USART1_CLK_ENABLE()
-  ; // PLX main port
+        ; // PLX main port
-  __HAL_RCC_USART2_CLK_ENABLE()
+        __HAL_RCC_USART2_CLK_ENABLE()
-  ; // debug port
+        ; // debug port
-  /* USER CODE END 1 */
+        /* USER CODE END 1 */
-  /* MCU Configuration----------------------------------------------------------*/
+        /* MCU Configuration----------------------------------------------------------*/
-  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
+        /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
-  HAL_Init ();
+        HAL_Init();
-  /* Configure the system clock */
+        /* Configure the system clock */
-  SystemClock_Config ();
+        SystemClock_Config();
-  /* Initialize all configured peripherals */
+        /* Initialize all configured peripherals */
-  MX_GPIO_Init ();
+        MX_GPIO_Init();
-  // MX_ADC1_Init();
-  MX_SPI1_Init ();
+        MX_SPI1_Init();
-  MX_USART2_UART_Init ();
+        MX_USART2_UART_Init();
-  MX_USART1_UART_Init ();
+        MX_USART1_UART_Init();
-  /* USER CODE BEGIN 2 */
+        /* USER CODE BEGIN 2 */
-  /* Need to set AF mode for output pins DURR. */
+        /* Need to set AF mode for output pins DURR. */
-  /* SPI bus AF pin selects */
+        /* SPI bus AF pin selects */
-  GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
+        GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
-  GPIO_InitStruct.Pin = GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_7;
+        GPIO_InitStruct.Pin = GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_7;
-  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
-  HAL_GPIO_Init (GPIOA, &GPIO_InitStruct);
+        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-  /* USART2 AF pin selects */
+        /* USART2 AF pin selects */
-  GPIO_InitStruct.Pin = GPIO_PIN_2;
+        GPIO_InitStruct.Pin = GPIO_PIN_2;
-  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
-  HAL_GPIO_Init (GPIOA, &GPIO_InitStruct);
+        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-  /* USART1 AF pin selects */
+        /* USART1 AF pin selects */
-  GPIO_InitStruct.Pin = GPIO_PIN_9;
+        GPIO_InitStruct.Pin = GPIO_PIN_9;
-  HAL_GPIO_Init (GPIOA, &GPIO_InitStruct);
+        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-  /* Turn on USART2 IRQ  */
+        /* Turn on USART2 IRQ  */
-  HAL_NVIC_SetPriority (USART2_IRQn, 4, 0);
+        HAL_NVIC_SetPriority(USART2_IRQn, 4, 0);
-  HAL_NVIC_EnableIRQ (USART2_IRQn);
+        HAL_NVIC_EnableIRQ(USART2_IRQn);
-  /* Turn on USART1 IRQ */
+        /* Turn on USART1 IRQ */
-  HAL_NVIC_SetPriority (USART1_IRQn, 2, 0);
+        HAL_NVIC_SetPriority(USART1_IRQn, 2, 0);
-  HAL_NVIC_EnableIRQ (USART1_IRQn);
+        HAL_NVIC_EnableIRQ(USART1_IRQn);
-  /* setup the USART control blocks */
+        /* setup the USART control blocks */
-  init_usart_ctl (&uc1, huart1.Instance);
+        init_usart_ctl(&uc1, huart1.Instance);
-  init_usart_ctl (&uc2, huart2.Instance);
+        init_usart_ctl(&uc2, huart2.Instance);
-  EnableSerialRxInterrupt (&uc1);
+        EnableSerialRxInterrupt(&uc1);
-  EnableSerialRxInterrupt (&uc2);
+        EnableSerialRxInterrupt(&uc2);
-  ap_init (); // set up the approximate math library
+        ap_init(); // set up the approximate math library
-  int disp;
+        int disp;
-  ssd1306_begin (1, 0);
+        ssd1306_begin(1, 0);
 // static const int xp = 128 - 42;
-  for (disp = 0; disp < 2; disp++)
+        for (disp = 0; disp < 2; disp++)
-    {
+        {
-      select_display (disp);
+                select_display(disp);
-      clearDisplay ();
+                clearDisplay();
-      dim (0);
+                dim(0);
-      //font_puts(
+                //font_puts(
-      //                "Hello world !!\rThis text is a test of the text rendering library in a 5*7 font");
+                //              "Hello world !!\rThis text is a test of the text rendering library in a 5*7 font");
-      dial_origin (64, 60);
+                dial_origin(64, 60);
-      dial_size (60);
+                dial_size(60);
-      dial_draw_scale (10, 16, 16, 2);
+                dial_draw_scale(0, 10, 16, 5);
-      display ();
-    }
-  InitSwitches ();
-  select_display (0);
-  /* USER CODE END 2 */
-  /* Infinite loop */
-  /* USER CODE BEGIN WHILE */
-  uint32_t Ticks = HAL_GetTick () + 100;
-  int16_t dial0 = 0;
-  int16_t dial1 = -1;
-  int c = 0;
-  int i;
-  char buff[10];
-  // PLX decoder protocol
-#define MAXRDG 10
-  char PLXPacket = 0;
-  union
-  {
-    PLX_SensorInfo Sensor[MAXRDG];
-    char Bytes[MAXRDG * sizeof(PLX_SensorInfo)];
-  } Data;
+                display();
-  int Max[MAXRDG];
-  int Min[MAXRDG];
-  for (i = 0; i < MAXRDG; i++)
-    {
-      Max[i] = 0;
-      Min[i] = 0xFFF; // 12 bit max value
-    }
-  int PLXPtr;
-  int PLXItems;
+        }
-  int OldObservation = -1; // illegal initial value
-  int OldObservationIndex = -1; // if more than one sensor this will be printed
-  while (1)
-    {
-// poll switches
-      HandleSwitches ();
+        InitSwitches();
-      int ItemIndex = dial_pos[0];
+        /* USER CODE END 2 */
+        /* Infinite loop */
+        /* USER CODE BEGIN WHILE */
-      uint16_t cc = SerialCharsReceived (&uc1);
+        uint32_t Ticks = HAL_GetTick() + 100;
+        int i;
+        // PLX decoder protocol
+        char PLXPacket = 0;
-      for (i = 0; i < cc; i++)
+        for (i = 0; i < MAXRDG; i++)
+        {
-          char c = GetCharSerial (&uc1);
-          if (c == PLX_Start) // at any time if the start byte appears, reset the pointers
-            {
+                Max[i] = 0;
-              PLXPtr = 0;    // reset the pointer
+                Min[i] = 0xFFF; // 12 bit max value
-              PLXPacket = 1;
-              continue;
-            }
-          if (c == PLX_Stop)
-            {
-              // we can now decode the selected parameter
-              PLXPacket = 0;
-              PLXItems = PLXPtr / sizeof(PLX_SensorInfo); // total
-              // saturate the rotary switch position
-              if (ItemIndex > PLXItems)
-                {
-                  dial_pos[0] = PLXItems;
-                  ItemIndex = PLXItems;
-                }
+        }
-              int DataVal;
+        int PLXPtr = 0;
-              // process min/max
-              for (i = 0; i < PLXItems; i++)
-                {
-                  DataVal = ConvPLX (Data.Sensor[i].ObsH, Data.Sensor[i].ObsL);
-                  if (DataVal > Max[i])
-                    {
-                      Max[i] = DataVal;
-                    }
-                  if (DataVal < Min[i])
-                    {
-                      Min[i] = DataVal;
-                    }
-                }
-              DataVal = ConvPLX (Data.Sensor[ItemIndex].ObsH,
-                                 Data.Sensor[ItemIndex].ObsL);   // data reading
-              int Observation = ConvPLX (Data.Sensor[ItemIndex].ObsH,
-                                         Data.Sensor[ItemIndex].ObsL);
-              int ObservationIndex = ConvPLX (0,
-                                              Data.Sensor[ItemIndex].ObsIndex);
-              // now to convert the readings and format strings
-              // find out limits
+        while (1)
+        {
-              char * msg;
+// poll switches
-              int len;
+                HandleSwitches();
+                uint16_t cc = SerialCharsReceived(&uc1);
+                int chr;
-              if (Observation < PLX_MAX_OBS)
+                for (chr = 0; chr < cc; chr++)
+                {
-                  if (Observation != OldObservation
-                      || ObservationIndex != OldObservationIndex)
-                    {
-                      dial1 = -1;
-                      clearDisplay();
+                        char c = GetCharSerial(&uc1);
-                      dial_draw_scale (
-                          DisplayInfo[Observation].Low
-                              / DisplayInfo[Observation].TickScale,
-                          DisplayInfo[Observation].High
-                              / DisplayInfo[Observation].TickScale,
+                        if (c == PLX_Start) // at any time if the start byte appears, reset the pointers
-, 1);
-                      if (ObservationIndex > 0)
+                        {
-                          len = 5;
+                                PLXPtr = 0;    // reset the pointer
-                          buff[6] = ObservationIndex + '1';
+                                PLXPacket = 1;
+                        }
-                      else
+                        else if (c == PLX_Stop)
+                        {
+                                if (PLXPacket)
+                                {
+                                        // we can now decode the selected parameter
+                                        PLXItems = PLXPtr / sizeof(PLX_SensorInfo); // total
+                                        // saturate the rotary switch position
+                                        int DataVal;
+                                        // process min/max
+                                        for (i = 0; i < PLXItems; i++)
+                                        {
+                                                DataVal = ConvPLX(Data.Sensor[i].ReadingH,
+                                                                Data.Sensor[i].ReadingL);
+                                                if (DataVal > Max[i])
+                                                {
+                                                        Max[i] = DataVal;
+                                                }
+                                                if (DataVal < Min[i])
+                                                {
+                                                        Min[i] = DataVal;
+                                                }
+                                        }
+                                        // now to display the information
+                                        int suppress = DisplayCurrent(0,-1);
+                                        DisplayCurrent(1,suppress);
+                                }
-                          len = 6;
+                                PLXPtr = 0;
+                                PLXPacket = 0;
+                        }
+                        else if (c > PLX_Stop) // illegal char, restart reading
+                        {
-                          msg = DisplayInfo[Observation].name;
+                                PLXPacket = 0;
+                                PLXPtr = 0;
+                        }
-                      for (i = 0; i < len; i++)
+                        else if (PLXPtr < sizeof(Data.Bytes))
+                        {
-                          buff[i] = msg[i];
+                                Data.Bytes[PLXPtr++] = c;
+                        }
-                      print_large_string (buff, 32, 48, 6); // this prints spaces for \0 at end of string
-                      OldObservation = Observation;
-                      OldObservationIndex = ObservationIndex;
-                      //
-                    }
-                  double max_rdg;
-                  double min_rdg;
-                  double cur_rdg;
-                  max_rdg = ConveriMFDRaw2Data (Observation,
-                                                DisplayInfo[Observation].Units,
-                                                Max[ItemIndex]);
-                  min_rdg = ConveriMFDRaw2Data (Observation,
-                                                DisplayInfo[Observation].Units,
-                                                Min[ItemIndex]);
-                  cur_rdg = ConveriMFDRaw2Data (Observation,
-                                                DisplayInfo[Observation].Units,
-                                                DataVal);
+                }
-            }
-          if (c > PLX_Stop) // illegal char, restart reading
-            {
-              PLXPacket = 0;
-            }
-          if (PLXPtr < sizeof(Data.Bytes))
-            {
-              Data.Bytes[PLXPtr++] = c;
-            }
-        }
-      HAL_Delay (1);
+                HAL_Delay(1);
-      /* now scale and decode the dial position etc .
-       *
-       */
-      uint32_t CurrTicks = HAL_GetTick ();
-      if (CurrTicks > Ticks)
-        {
-          /* Lookup the dial etc . */
-          Ticks = CurrTicks + 100;
-          /* old needle un-draw */
-          if (dial1 >= 0)
-            {
-              dial_draw_needle (dial1);
-            }
-          dial0 = c % 100;
-          dial_draw_needle (dial0);
-          // print value overlaid by needle
-          // this is actual reading
-          print_digits (64 - 16, 30, 4, 3, c);
-          dial1 = dial0;
-          c++;
-          //font_gotoxy(0, 2);
-          //font_puts("baud\r\n");
-          //char buff[10];
-          //itoa(hirda3.Init.BaudRate, buff, 10);
-          //char l = 6 - strlen(buff);
-          /* pad with leading spaces */
-          //while (l > 0) {
-          //    font_putchar(' ');
-          //    l--;
-          //}
-          //font_puts(itoa(hirda3.Init.BaudRate, buff, 10));
-          display ();
+        }
-      /* USER CODE END WHILE */
+        /* USER CODE END WHILE */
-      /* USER CODE BEGIN 3 */
-    }
-  /* USER CODE END 3 */
+        /* USER CODE BEGIN 3 */
+}
+/* USER CODE END 3 */
 /** System Clock Configuration
  */
-void
-SystemClock_Config (void)
+void SystemClock_Config(void)
+{
-  RCC_OscInitTypeDef RCC_OscInitStruct;
+RCC_OscInitTypeDef RCC_OscInitStruct;
-  RCC_ClkInitTypeDef RCC_ClkInitStruct;
+RCC_ClkInitTypeDef RCC_ClkInitStruct;
-  RCC_PeriphCLKInitTypeDef PeriphClkInit;
-  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
-  RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS;
-  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
-  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
-  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
-  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
-  if (HAL_RCC_OscConfig (&RCC_OscInitStruct) != HAL_OK)
-    {
-      Error_Handler ();
-    }
-  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
-      | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
-  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
-  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
-  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
-  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
-  if (HAL_RCC_ClockConfig (&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
-    {
-      Error_Handler ();
-    }
-  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
-  PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV6;
-  if (HAL_RCCEx_PeriphCLKConfig (&PeriphClkInit) != HAL_OK)
-    {
-      Error_Handler ();
-    }
-  HAL_SYSTICK_Config (HAL_RCC_GetHCLKFreq () / 1000);
-  HAL_SYSTICK_CLKSourceConfig (SYSTICK_CLKSOURCE_HCLK);
+RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
+RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS;
+RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
-  /* SysTick_IRQn interrupt configuration */
+RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
+RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
+RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
-  HAL_NVIC_SetPriority (SysTick_IRQn, 0, 0);
+if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
+{
+        Error_Handler();
+}
+RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
+                | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
+RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
-/* ADC1 init function */
+RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
-static void
+RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
-MX_ADC1_Init (void)
+RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
+if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
+{
+        Error_Handler();
+}
-  ADC_ChannelConfTypeDef sConfig;
+HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq() / 1000);
-  /**Common config
-   */
-  hadc1.Instance = ADC1;
-  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
-  hadc1.Init.ContinuousConvMode = DISABLE;
-  hadc1.Init.DiscontinuousConvMode = DISABLE;
-  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
+HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
-  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
-  hadc1.Init.NbrOfConversion = 1;
-  if (HAL_ADC_Init (&hadc1) != HAL_OK)
-    {
-      Error_Handler ();
-    }
-  /**Configure Regular Channel
-   */
-  sConfig.Channel = ADC_CHANNEL_0;
-  sConfig.Rank = 1;
-  sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
-  if (HAL_ADC_ConfigChannel (&hadc1, &sConfig) != HAL_OK)
-    {
-      Error_Handler ();
-    }
+/* SysTick_IRQn interrupt configuration */
+HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
+}
 /* SPI1 init function */
-static void
-MX_SPI1_Init (void)
+static void MX_SPI1_Init(void)
+{
-  hspi1.Instance = SPI1;
+hspi1.Instance = SPI1;
-  hspi1.Init.Mode = SPI_MODE_MASTER;
+hspi1.Init.Mode = SPI_MODE_MASTER;
-  hspi1.Init.Direction = SPI_DIRECTION_1LINE;
+hspi1.Init.Direction = SPI_DIRECTION_1LINE;
-  hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
+hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
-  hspi1.Init.CLKPolarity = SPI_POLARITY_HIGH;
+hspi1.Init.CLKPolarity = SPI_POLARITY_HIGH;
-  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
+hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
-  hspi1.Init.NSS = SPI_NSS_SOFT;
+hspi1.Init.NSS = SPI_NSS_SOFT;
-  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
+hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
-  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
+hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
-  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
+hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
-  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
+hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
-  hspi1.Init.CRCPolynomial = 10;
+hspi1.Init.CRCPolynomial = 10;
-  if (HAL_SPI_Init (&hspi1) != HAL_OK)
+if (HAL_SPI_Init(&hspi1) != HAL_OK)
-    {
+{
-      Error_Handler ();
+        Error_Handler();
-    }
+}
+}
 /* USART1 init function */
-static void
-MX_USART1_UART_Init (void)
+static void MX_USART1_UART_Init(void)
+{
-  huart1.Instance = USART1;
+huart1.Instance = USART1;
-  huart1.Init.BaudRate = 115200;
+huart1.Init.BaudRate = 19200;
-  huart1.Init.WordLength = UART_WORDLENGTH_8B;
+huart1.Init.WordLength = UART_WORDLENGTH_8B;
-  huart1.Init.StopBits = UART_STOPBITS_1;
+huart1.Init.StopBits = UART_STOPBITS_1;
-  huart1.Init.Parity = UART_PARITY_NONE;
+huart1.Init.Parity = UART_PARITY_NONE;
-  huart1.Init.Mode = UART_MODE_TX_RX;
+huart1.Init.Mode = UART_MODE_TX_RX;
-  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
-  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
+huart1.Init.OverSampling = UART_OVERSAMPLING_16;
-  if (HAL_UART_Init (&huart1) != HAL_OK)
+if (HAL_UART_Init(&huart1) != HAL_OK)
-    {
+{
-      Error_Handler ();
+        Error_Handler();
-    }
+}
+}
 /* USART2 init function */
-static void
-MX_USART2_UART_Init (void)
+static void MX_USART2_UART_Init(void)
+{
-  huart2.Instance = USART2;
+huart2.Instance = USART2;
-  huart2.Init.BaudRate = 115200;
+huart2.Init.BaudRate = 115200;
-  huart2.Init.WordLength = UART_WORDLENGTH_8B;
+huart2.Init.WordLength = UART_WORDLENGTH_8B;
-  huart2.Init.StopBits = UART_STOPBITS_1;
+huart2.Init.StopBits = UART_STOPBITS_1;
-  huart2.Init.Parity = UART_PARITY_NONE;
+huart2.Init.Parity = UART_PARITY_NONE;
-  huart2.Init.Mode = UART_MODE_TX_RX;
+huart2.Init.Mode = UART_MODE_TX_RX;
-  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
-  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
+huart2.Init.OverSampling = UART_OVERSAMPLING_16;
-  if (HAL_UART_Init (&huart2) != HAL_OK)
+if (HAL_UART_Init(&huart2) != HAL_OK)
-    {
+{
-      Error_Handler ();
+        Error_Handler();
-    }
+}
+}
 /** Configure pins as
  * Analog
  * Input
  * Output
  * EVENT_OUT
  * EXTI
  */
-static void
-MX_GPIO_Init (void)
+static void MX_GPIO_Init(void)
+{
-  GPIO_InitTypeDef GPIO_InitStruct;
+GPIO_InitTypeDef GPIO_InitStruct;
-  /* GPIO Ports Clock Enable */
+/* GPIO Ports Clock Enable */
-  __HAL_RCC_GPIOD_CLK_ENABLE()
+__HAL_RCC_GPIOD_CLK_ENABLE()
-  ;
+;
-  __HAL_RCC_GPIOA_CLK_ENABLE()
+__HAL_RCC_GPIOA_CLK_ENABLE()
-  ;
+;
-  __HAL_RCC_GPIOC_CLK_ENABLE()
+__HAL_RCC_GPIOC_CLK_ENABLE()
-  ;
+;
-  __HAL_RCC_GPIOB_CLK_ENABLE()
+__HAL_RCC_GPIOB_CLK_ENABLE()
-  ;
+;
-  /*Configure GPIO pin Output Level */
+/*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin (SPI_NSS1_GPIO_Port, SPI_NSS1_Pin, GPIO_PIN_SET);
+HAL_GPIO_WritePin(SPI_NSS1_GPIO_Port, SPI_NSS1_Pin, GPIO_PIN_SET);
-  /*Configure GPIO pin Output Level */
+/*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin (SPI1CD_GPIO_Port, SPI1CD_Pin, GPIO_PIN_RESET);
+HAL_GPIO_WritePin(SPI1CD_GPIO_Port, SPI1CD_Pin, GPIO_PIN_RESET);
-  /*Configure GPIO pin Output Level */
+/*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin (GPIOC, SPI_RESET_Pin | USART3_INVERT_Pin | USB_PWR_Pin,
+HAL_GPIO_WritePin(GPIOC,
-                     GPIO_PIN_RESET);
+SPI_RESET_Pin | USART3_INVERT_Pin | USB_PWR_Pin, GPIO_PIN_RESET);
-  /*Configure GPIO pin Output Level */
+/*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin (SPI_NSS2_GPIO_Port, SPI_NSS2_Pin, GPIO_PIN_SET);
+HAL_GPIO_WritePin(SPI_NSS2_GPIO_Port, SPI_NSS2_Pin, GPIO_PIN_SET);
-  /*Configure GPIO pins : SPI_NSS1_Pin SPI1CD_Pin */
+/*Configure GPIO pins : SPI_NSS1_Pin SPI1CD_Pin */
-  GPIO_InitStruct.Pin = SPI_NSS1_Pin | SPI1CD_Pin;
+GPIO_InitStruct.Pin = SPI_NSS1_Pin | SPI1CD_Pin;
-  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
-  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
-  HAL_GPIO_Init (GPIOA, &GPIO_InitStruct);
+HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-  /*Configure GPIO pins : SPI_RESET_Pin SPI_NSS2_Pin USART3_INVERT_Pin USB_PWR_Pin */
+/*Configure GPIO pins : SPI_RESET_Pin SPI_NSS2_Pin USART3_INVERT_Pin USB_PWR_Pin */
-  GPIO_InitStruct.Pin = SPI_RESET_Pin | SPI_NSS2_Pin | USART3_INVERT_Pin
+GPIO_InitStruct.Pin = SPI_RESET_Pin | SPI_NSS2_Pin | USART3_INVERT_Pin
-      | USB_PWR_Pin;
+                | USB_PWR_Pin;
-  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
-  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
-  HAL_GPIO_Init (GPIOC, &GPIO_InitStruct);
+HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
-  /*Configure GPIO pins : SW1_PUSH_Pin SW1_I_Pin SW1_Q_Pin SW2_PUSH_Pin */
+/*Configure GPIO pins : SW1_PUSH_Pin SW1_I_Pin SW1_Q_Pin SW2_PUSH_Pin */
-  GPIO_InitStruct.Pin = SW1_PUSH_Pin | SW1_I_Pin | SW1_Q_Pin | SW2_PUSH_Pin;
+GPIO_InitStruct.Pin = SW1_PUSH_Pin | SW1_I_Pin | SW1_Q_Pin | SW2_PUSH_Pin;
-  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
+GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
-  GPIO_InitStruct.Pull = GPIO_PULLUP;
+GPIO_InitStruct.Pull = GPIO_PULLUP;
-  HAL_GPIO_Init (GPIOB, &GPIO_InitStruct);
+HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
-  /*Configure GPIO pins : SW2_I_Pin SW2_Q_Pin */
+/*Configure GPIO pins : SW2_I_Pin SW2_Q_Pin */
-  GPIO_InitStruct.Pin = SW2_I_Pin | SW2_Q_Pin;
+GPIO_InitStruct.Pin = SW2_I_Pin | SW2_Q_Pin;
-  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
+GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
-  GPIO_InitStruct.Pull = GPIO_PULLUP;
+GPIO_InitStruct.Pull = GPIO_PULLUP;
-  HAL_GPIO_Init (GPIOC, &GPIO_InitStruct);
+HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
+}
 /* USER CODE BEGIN 4 */
 /**
  * @brief  This function is executed in case of error occurrence.
  * @param  None
  * @retval None
  */
-void
-Error_Handler (void)
+void Error_Handler(void)
+{
-  /* USER CODE BEGIN Error_Handler */
+/* USER CODE BEGIN Error_Handler */
-  /* User can add his own implementation to report the HAL error return state */
+/* User can add his own implementation to report the HAL error return state */
-  while (1)
+while (1)
-    {
+{
-    }
+}
-  /* USER CODE END Error_Handler */
+/* USER CODE END Error_Handler */
+}
 #ifdef USE_FULL_ASSERT
 /**
  * @param file: pointer to the source file name
  * @param line: assert_param error line source number
  * @retval None
  */
 void assert_failed(uint8_t* file, uint32_t line)
-  {
+{
-    /* USER CODE BEGIN 6 */
+/* USER CODE BEGIN 6 */
-    /* User can add his own implementation to report the file name and line number,
+/* User can add his own implementation to report the file name and line number,
-     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
+ ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
-    /* USER CODE END 6 */
+/* USER CODE END 6 */
-  }
+}
 #endif
 /**
  * @}

Subversion Repositories DashDisplay

(root)/trunk/Src/main.c – Rev 6 → 7