STM32-WS-RGB Clock 2021

2020-12-26T16:36:16+01:00

Witam,

Widzę, że chyba wszystkim udziela się ostatnio magia świąt, co widać po wzroście zainteresowań wszelkimi inteligentnymi diodami RGB. Ja zatem nie pozostaję gorszy i prezentuję projekt zegarka-prezentu dla dziewczyny opartego o miktokontroler STM32 z nowej rodziny G0, nad którym pracuję od listopada. Działa on w 99% Pozostało mi do ukończenia dosłownie kilka funkcji narzędziowych, które nie są jakoś specjalnie istotne. Mam nadzieję, że wielu osobom, które tak jak ja przesiadają się na 32-bitowce, uda mi się przy okazji pokazać jak ja podchodzę do wykorzystania ich możliwości, a jak wiadomo wbudowanych peryferiów mają one masę! Dodam tylko na wstępie, że program napisany został bezpośrednio "na rejestrach", także zwolennicy CMSIS powinni być zadowoleni Do dzieła!

Założenia sprzętowe:
- Zasilanie za pomocą 12VDC (zastosowałem dwie przetwornice: A8498 oraz LDO1117 3.3V),
- Wyświetlanie godziny, minuty, aktualnej daty za pomocą WS2812, wyświetlacza multiplexowanego LED,
- Powitalne wiadomości na dolnym wyświetlaczu,
- Możliwość konfiguracji za pomocą USART (w przyszłości umożliwiona rozbudowa o moduł WiFi - serwer NTP i takie bajery ), oraz trzech przycisków tact-switch,
- Dostosowanie kolorów do odpowiedniej pory dnia (rano żółty, po południu ciepła zieleń, wieczem pomarańcz i fiolet, a w nocy ciemny niebieski),
- Płynna regulacja jasności w zależności od oświetlenia w pokoju,
- Możliwość zapisywania danych do zewnętrznej pamięci EEPROM 2kB,
- Wsparcie Battery Backup Domain za pomocą superkondensatora sterowanego mosfetem,
- Buzzer (jako funkcja alarmu i nie tylko ),
- Status LED.

Założenia programowe:
- Stworzenie pełnej biblioteki wspierającej WS2812 i ładującej wszystkie dane do jednego bufora (w ten sposób łatwo wzbogacić program o użycie DMA),
- Stworzenie biblioteki do wyświetlania cyfr i znaków (wraz ze scrollowaniem) na alfanumerycznym wyświetlaczu 16-segmentowym,
- Wykorzystanie wewnętrznego zegara RTC oraz możliwość jego ŁATWEJ kalibracji,
- Uniwersalne funkcje do konfiguracji czasu i daty w rejestrach RTC,
- Proste menu konfiguracyjne (wymaga jeszcze dopracowania)

Schemat i model 3D płytki PCB:
Znajduje się w pliku załączonym pod postem.

Zdjęcia:

Pliki źródłowe (z komentarzami) i biblioteki:

main.c
[syntax=c]/*
* main.c
*
* Created on: Dec 15, 2020
* Author: Michal Makowka
*/

#include "stm32g071xx.h"
#include "config.h"
#include "ws_lib.h"
#include "segment_dsp.h"
#include "clock.h"
#include "clk_menu.h"

int main(void) {

uint8_t red, green, blue;// Digit colour channel values

TMENU menu_strct;

SystemCFG();// Configure uC registers

// Clear LCD Display (display SPACEs)
LEDClr();

// Clear WS2812B Display
FillLEDArray(LED_buf, 0, 0, 0);
SPI_SEND_WSBUF(LED_buf, sizeof(LED_buf));

// Scroll welcome message
ScrollLed("hi celine", medium, sizeof("hi celine"));

// Register menu executive functions
menu_strct.configuration = (void*)displayConfig;
menu_strct.alarm = (void*)displayAlarm;
menu_strct.study = (void*)displayStudy;

button_flag[B_UP]=0;
button_flag[B_DOWN]=0;
button_flag[B_SET]=0;

dot_enable[1]++; dot_enable[3]++;// Enable LED dots (for displaying the date)

while (1) {

// IF ADC idle, start conversion
if ((ADC1->CR & ADC_CR_ADSTART) == 0) {
ADC1->CR |= ADC_CR_ADSTART;// Start ADC conversion
}

// Display current date
DisplayNumberSet(day_t, day_u, month_t, month_u, year_t, year_u);

// Assign current color values
assignColour(hour_t, hour_u, &red, &green, &blue);
// Display the current date

// Display the current time
FillLEDArray(LED_buf, 0, 0, 0);
FillLEDNumber(LED_buf, 0, hour_t, red, green, blue);
FillLEDNumber(LED_buf, 1, hour_u, red, green, blue);
FillLEDNumber(LED_buf, 2, minute_t, red, green, blue);
FillLEDNumber(LED_buf, 3, minute_u, red, green, blue);
SPI_SEND_WSBUF(LED_buf, sizeof(LED_buf));
delay_ms(990);
FillLEDSegment(LED_buf, 26, 27, 0x0f, 0x03, 0);
SPI_SEND_WSBUF(LED_buf, sizeof(LED_buf));
delay_ms(990);

if (button_flag[B_SET]) {
button_flag[B_SET]=0;
dot_enable[1]=0; dot_enable[3]=0;
displayMenu(&menu_strct);
dot_enable[1]=1; dot_enable[3]=1;
}

}

}[/syntax]

Biblioteka WS2812
ws_lib.h
[syntax=c]/*
* ws_lib.h
*
* Created on: Dec 20, 2020
* Author: Michal Makowka
*/

#ifndef INC_WS_LIB_H_
#define INC_WS_LIB_H_

#include
#include
#include "stm32g071xx.h"
#include "segment_dsp.h"
#include "clock.h"

#define WS_NUMBER 54// Number of ALL WS2812B LEDs

uint8_t LED_buf[WS_NUMBER*24];// (WS_NUMBER * 3 colors * 8 bytes/color)

#define SPI_zero 0b11000000// HEX: 0xC0
#define SPI_one 0b11111000// HEX: 0xF8
#define SPI_reset 0b00000000// HEX: 0x00

void FillLEDArray(volatile uint8_t * array, uint8_t green, uint8_t red, uint8_t blue);
void FillLEDSegment(volatile uint8_t * array, uint8_t start_idx, uint8_t end_idx, uint8_t red, uint8_t green, uint8_t blue);
void FillLEDNumber(volatile uint8_t * array, uint8_t pos, uint8_t nbr, uint8_t red, uint8_t green, uint8_t blue);
void getBaseColour(uint8_t col_val);
void getBaseLed(uint8_t green, uint8_t red, uint8_t blue);

void SPI_SEND_WSBUF(uint8_t * buf, uint16_t size);
void SpiLed_Send(uint8_t data);

void assignColour(uint8_t ht, uint8_t hu, uint8_t * r, uint8_t * g, uint8_t * b);

#endif /* INC_WS_LIB_H_ */[/syntax]

ws_lib.c
[syntax=c]/*
* ws_lib.c
*
* Created on: Dec 20, 2020
* Author: Michal Makowka
*/
#include "ws_lib.h"

// Auxiliary arrays to fill the SPI LED buffer
uint8_t b_colour[8];
uint8_t b_led[24];

volatile uint8_t brg_div = 18;

volatile uint16_t ADC_result;// ADC result for the DEBUG purpose

// This function updates LED data array (first argument) with a number "nbr" on a given position 0 <= "pos" <= 3
void FillLEDNumber(volatile uint8_t * array, uint8_t pos, uint8_t nbr, uint8_t red, uint8_t green, uint8_t blue) {

uint8_t shift;

if (pos>1) shift = ((pos*13)+2);
else shift = (pos*13);

switch(nbr) {
case 0:
FillLEDSegment(array, (0+shift), (11+shift), red, green, blue);
break;
case 1:
FillLEDSegment(array, (2+shift), (6+shift), red, green, blue);
break;
case 2:
FillLEDSegment(array, (0+shift), (4+shift), red, green, blue);
FillLEDSegment(array, (6+shift), (10+shift), red, green, blue);
FillLEDSegment(array, (12+shift), (12+shift), red, green, blue);
break;
case 3:
FillLEDSegment(array, (0+shift), (8+shift), red, green, blue);
FillLEDSegment(array, (10+shift), (10+shift), red, green, blue);
FillLEDSegment(array, (12+shift), (12+shift), red, green, blue);
break;
case 4:
FillLEDSegment(array, (0+shift), (0+shift), red, green, blue);
FillLEDSegment(array, (2+shift), (6+shift), red, green, blue);
FillLEDSegment(array, (10+shift), (12+shift), red, green, blue);
break;
case 5:
FillLEDSegment(array, (0+shift), (2+shift), red, green, blue);
FillLEDSegment(array, (4+shift), (8+shift), red, green, blue);
FillLEDSegment(array, (10+shift), (12+shift), red, green, blue);
break;
case 6:
FillLEDSegment(array, (0+shift), (2+shift), red, green, blue);
FillLEDSegment(array, (4+shift), (12+shift), red, green, blue);
break;
case 7:
FillLEDSegment(array, (0+shift), (6+shift), red, green, blue);
break;
case 8:
FillLEDSegment(array, (0+shift), (12+shift), red, green, blue);
break;
case 9:
FillLEDSegment(array, (0+shift), (8+shift), red, green, blue);
FillLEDSegment(array, (10+shift), (12+shift), red, green, blue);
break;
default:
break;
}
}

// This function updates the entire LED data buffer (first argument)
void FillLEDArray(volatile uint8_t * array, uint8_t red, uint8_t green, uint8_t blue) {// * array is the array to be entirely filled with LED data
uint16_t a, b, c;
b=0;
for (a=0; a<(WS_NUMBER*24); a++) {
getBaseLed(green, red, blue);
c=0;
while(c<23) {
array[a] = b_led[b]; a++; b++;
c++;
}
array[a] = b_led[b]; b++;
b=0;
}
}
// This function updates LED data array (first argument) within specified indexes: start_idx and end_idx
void FillLEDSegment(volatile uint8_t * array, uint8_t start_idx, uint8_t end_idx, uint8_t red, uint8_t green, uint8_t blue) {
uint16_t a, b, c;
b=0;
for (a=(start_idx*24); a<=(end_idx*24); a++) {
getBaseLed(green, red, blue);
c=0;
while(c<23) {
array[a] = b_led[b]; a++; b++;
c++;
}
array[a] = b_led[b]; b++;
b=0;
}
}

// This function updates b_led[24] array
void getBaseLed(uint8_t green, uint8_t red, uint8_t blue) {// *bld is the array to be updated
uint8_t k, i;

getBaseColour(green);
i=7;
for (k=0; k<8; k++) {
b_led[k] = b_colour[i];
i--;
}
getBaseColour(red);
i=7;
for (k=8; k<16; k++) {
b_led[k] = b_colour[i];
i--;
}
getBaseColour(blue);
i=7;
for (k=16; k<24; k++) {
b_led[k] = b_colour[i];
i--;
}
}

// This function updates b_colour[8] array (one colour out of three/led)
void getBaseColour(uint8_t col_val) {// *bcl is the array to be updated

uint8_t temp;
for (uint8_t j=0; j<8; j++) {
temp = (col_val>>j);
if ((temp%2) == 0) b_colour[j] = SPI_zero;
else b_colour[j] = SPI_one;
}
}

void SPI_SEND_WSBUF(uint8_t * buf, uint16_t size) {
for(uint16_t i = 0; i<(WS_NUMBER*24); i++) {
SpiLed_Send(LED_buf[i]);
}
}

void SpiLed_Send(uint8_t data) {
while( !(SPI1->SR & SPI_SR_TXE) );
SPI1->DR = data;
}

// Update colour variable passed depending on a time (#define in clock.h file)
void assignColour(uint8_t ht, uint8_t hu, uint8_t * r, uint8_t * g, uint8_t * b) {
uint8_t hr = 10*(ht) + hu;// Hour in decimal format
*r=0; *g=0; *b=0;
if (hr >= 6 && hr < 12) *r = (R_T1/brg_div);
else if (hr >= 12 && hr < 18) *r = (R_T2/brg_div);
else if (hr >= 18 && hr < 21) *r = (R_T3/brg_div);
else if (hr >= 21 && hr < 23) *r = (R_T4/brg_div);
else if (hr >= 23 && hr < 5) *r = (R_T5/brg_div);
else if (hr >= 5 && hr < 6) *r = (R_T6/brg_div);

if (hr >= 6 && hr < 12) *g = (G_T1/brg_div);
else if (hr >= 12 && hr < 18) *g = (G_T2/brg_div);
else if (hr >= 18 && hr < 21) *g = (G_T3/brg_div);
else if (hr >= 21 && hr < 23) *g = (G_T4/brg_div);
else if (hr >= 23 && hr < 5) *g = (G_T5/brg_div);
else if (hr >= 5 && hr < 6) *g = (G_T6/brg_div);

if (hr >= 6 && hr < 12) *b = (B_T1/brg_div);
else if (hr >= 12 && hr < 18) *b = (B_T2/brg_div);
else if (hr >= 18 && hr < 21) *b = (B_T3/brg_div);
else if (hr >= 21 && hr < 23) *b = (B_T4/brg_div);
else if (hr >= 23 || hr < 5) *b = (B_T5/brg_div);
else if (hr >= 5 && hr < 6) *b = (B_T6/brg_div);
}

uint8_t ADCCompress (uint16_t adc) {

if (adc > 0 && adc < 1801) return 2;// Much light
if (adc > 1800 && adc < 2101) return 3;
if (adc > 2100 && adc < 2401) return 5;
if (adc > 2400 && adc < 2701) return 7;
if (adc > 2700 && adc < 3001) return 8;
if (adc > 3000 && adc < 3301) return 10;
if (adc > 3300 && adc < 3601) return 12;
if (adc > 3600 && adc < 3901) return 14;
if (adc > 3900 && adc < 4201) return 20;// No light
if (adc > 4200) return 22;

return 16;// If LDR malfunction, return default (16)
}

__attribute__((interrupt)) void ADC1_COMP_IRQHandler(void){
ADC1->ISR |= ADC_ISR_EOC;// Clear end of conversion flag
ADC_result = ADC1->DR;
brg_div = ADCCompress(ADC_result);

}[/syntax]

Pliki konfiguracyjne (ustawienia rejestrów STM32)
config.h
[syntax=c]/*
* config.h
*
* Created on: Dec 15, 2020
* Author: Michal Makowka
*/

#ifndef INC_CONFIG_H_
#define INC_CONFIG_H_

#include
#include
#include "stm32g071xx.h"

// RTC Calibration values
// By default, the value of PREDIV_A = 127, PREDIV_S = 255, CALP = 0, CALM = 0
#define PREDIV_A 127// [val: 0-127]
#define PREDIV_S 251// [val: 0-32767]
#define CALP 0// [val: 0-1]
#define CALM 511// [val: 0-511]
/*
* Set RTC_OSC_CALIB_OUTPUT_EN to 1 if RTC_OUT clk signal
* needs to be available on the PA4 (RTC_OUT2 - 1Hz); otherwise, set to 0.
* This feature is useful to sample the RTC clk source by a logic analyser.
* Set PREDIV_S, CALP, and CALM bits, so that the F_RTC_OUT2 = 1.000Hz
*/
#define RTC_OSC_CALIB_OUTPUT_EN 0

uint8_t d_flag;// Delay flag

volatile uint8_t button_flag[3];

enum{B_SET, B_DOWN, B_UP};// Intexes for the button_flag[3] array

void SystemCFG (void);
void delay_ms (uint16_t ms);[/syntax]

config.c
[syntax=c]/*
* config.c
*
* Created on: Dec 15, 2020
* Author: Michal Makowka
*/

#include "config.h"
#include "ws_lib.h"

void SystemCFG (void){

// *** Configure System Clock (48MHz for each system BUS) ***
RCC->PLLCFGR &= ~RCC_PLLCFGR_PLLN_4;// Clear (as it's 1 by default)
RCC->PLLCFGR |= RCC_PLLCFGR_PLLN_2 | RCC_PLLCFGR_PLLN_3;// Set PLLN Mult. for 12 (0000 1100)
RCC->PLLCFGR |= RCC_PLLCFGR_PLLR_0;// Set PLLR Div. for 2 (001)
RCC->PLLCFGR |= RCC_PLLCFGR_PLLSRC_0 | RCC_PLLCFGR_PLLSRC_1;// Fpllin = HSE
RCC->PLLCFGR |= RCC_PLLCFGR_PLLREN;// Enable output of the PLL
RCC->CFGR |= RCC_CFGR_SW_1;// PLLRCLK for SYSCLK
RCC->PLLCFGR |= RCC_PLLCFGR_PLLPEN;
FLASH->ACR |= FLASH_ACR_LATENCY_1;
RCC->CR |= RCC_CR_HSEON;// HSE ON
while (!(RCC->CR & RCC_CR_HSERDY)); // Wait for HSE ON
RCC->CR |= RCC_CR_PLLON;// PLL ON
while ((RCC->CR & RCC_CR_PLLRDY)); // Check if PLL not locked
while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL);// Check for a correct source set
RCC->CR &= ~RCC_CR_HSION;// 16MHz HSI OFF
// *********************************

// *** Configure GPIO: Techled, LED Display, BUZZ ***
RCC->IOPENR |= RCC_IOPENR_GPIOAEN | RCC_IOPENR_GPIOBEN | RCC_IOPENR_GPIOCEN | RCC_IOPENR_GPIODEN | RCC_IOPENR_GPIOFEN;// GPIO: ABCDF

GPIOB->MODER = GPIO_MODER_MODE0_0 | GPIO_MODER_MODE1_0 | GPIO_MODER_MODE2_0 | GPIO_MODER_MODE3_0 |
GPIO_MODER_MODE4_0 | GPIO_MODER_MODE5_0 | GPIO_MODER_MODE6_0 | GPIO_MODER_MODE7_0 |
GPIO_MODER_MODE8_0 | GPIO_MODER_MODE9_0 | GPIO_MODER_MODE10_0 | GPIO_MODER_MODE11_0 |
GPIO_MODER_MODE12_0 | GPIO_MODER_MODE13_0 | GPIO_MODER_MODE14_0;// PB0-PB14: Output

// LED Cathodes
GPIOC->ODR |= (GPIO_ODR_OD6 | GPIO_ODR_OD7);
GPIOC->MODER &= ~(GPIO_MODER_MODE6_1 | GPIO_MODER_MODE7_1);// PC6-PC7: Output
GPIOD->ODR |= (GPIO_ODR_OD0 | GPIO_ODR_OD1 | GPIO_ODR_OD2 | GPIO_ODR_OD3);
GPIOD->MODER &= ~(GPIO_MODER_MODE0_1 | GPIO_MODER_MODE1_1 | GPIO_MODER_MODE2_1 | GPIO_MODER_MODE3_1);// PD0-PD3: Output
// Techled, BUZZ
GPIOA->MODER &= ~(GPIO_MODER_MODE6_1 | GPIO_MODER_MODE7_1);// PA6-PA7: Output
// *********************************

// *** Configure TIM14 for delay subroutine ***
NVIC_EnableIRQ(TIM14_IRQn);
RCC->APBENR2 |= RCC_APBENR2_TIM14EN;// Enable TIM14 clock
TIM14->CCMR1 |= TIM_CCMR1_OC2M_0;// Set channel 1 to active level on match
TIM14->DIER |= TIM_DIER_CC1IE;
TIM14->PSC = 47999;/// 1000 Hz(psc = 47999), F_CPU = 48MHz
// *********************************

// *** Configure TIM15 for Segment Multiplexing ***
NVIC_EnableIRQ(TIM15_IRQn);
RCC->APBENR2 |= RCC_APBENR2_TIM15EN;// Enable TIM15 clock
TIM15->CCMR1 |= TIM_CCMR1_OC2M_0;// Set channel 1 to active level on match
TIM15->DIER |= TIM_DIER_CC1IE;
TIM15->PSC = 1;/// 1000 Hz(psc = 47999), F_CPU = 48MHz
TIM15->CR1 |= TIM_CR1_CEN;// Counter enable
// *********************************

// *** Configure RTC Clock ***
RCC->APBENR1 |= RCC_APBENR1_RTCAPBEN | RCC_APBENR1_PWREN;
PWR->CR1 |= PWR_CR1_DBP;// Disable RTC write protection
RCC->BDCR |= RCC_BDCR_LSEON;// LSE eabled
while(!(RCC->BDCR & RCC_BDCR_LSERDY));// Wait for LSE ready
RCC->BDCR |= RCC_BDCR_RTCSEL_0 | RCC_BDCR_RTCEN;// LSE for the RTC, RTC enable

// RTC CALIBRATION PROCESS
// Update RTC_PRER register
uint32_t tmp_prer = RTC->PRER;
tmp_prer &= ~(0x7f7fff);// Set zeros to the tmp_pres Prediv_A and Prediv_S register
tmp_prer |= (PREDIV_A<<16);// SET PREDIV_A [val: 0-127]
tmp_prer |= PREDIV_S;// SET PREDIV_S [val: 0-32767]
RTC->WPR = 0xca;
RTC->WPR = 0x53;// Write protection disabled
// Enter clock init mode
RTC->ICSR |= RTC_ICSR_INIT;
while ((RTC->ICSR & RTC_ICSR_INITF) == 0);// Wait until ready to update
RTC->PRER = tmp_prer;// Update PRER register
RTC->ICSR &= ~RTC_ICSR_INIT;// Disable RTC init mode

// Update RTC_CALR register
uint32_t tmp_calr = RTC->CALR;
tmp_calr &= ~(0x81ff);// CALP and CALM mask (setting to zero)
tmp_calr |= (CALP<<15);// SET CALP [val: 0-1]
tmp_calr |= (CALM);// SET CALM [val: 0-511]
RTC->WPR = 0xca;
RTC->WPR = 0x53;// Write protection disabled
RTC->CALR = tmp_calr;// Update CALR resgister

#if (RTC_OSC_CALIB_OUTPUT_EN)
// Map the RTC clock on the PA4 pin (RTC_OUT2)
RTC->CR |= RTC_CR_COE;// Calibration output enabled
RTC->CR |= RTC_CR_COSEL;// F_calibration = 1Hz
GPIOA->MODER &= ~GPIO_MODER_MODE4_1;
RTC->CR |= RTC_CR_OUT2EN;// RTC clock available on PA4 - RTC_OUT2
#endif
#if (!RTC_OSC_CALIB_OUTPUT_EN)
RTC->CR &= ~RTC_CR_COE;// Calibration output disbled
RTC->CR &= ~RTC_CR_COSEL;// F_calibration 1Hz disabled
GPIOA->MODER |= GPIO_MODER_MODE4_1;
RTC->CR &= ~RTC_CR_OUT2EN;// RTC clock disabled on PA4 - RTC_OUT2
#endif
// END OF RTC CALIBRATION PROCESS
// *********************************

// *** Configure TIM16 for RTC clock data update ***
NVIC_EnableIRQ(TIM16_IRQn);
RCC->APBENR2 |= RCC_APBENR2_TIM16EN;// Enable TIM16 clock
TIM16->PSC = 47999;
TIM16->CCR1 = 250;
TIM16->DIER |= TIM_DIER_CC1IE;// CaptureCompare1 Interrupt Enable(2Hz)
TIM16->CR1 |= TIM_CR1_CEN;// Counter enable
// *********************************

// *** Configure SPI ***
NVIC_EnableIRQ(SPI1_IRQn);
GPIOA->MODER &= ~GPIO_MODER_MODE2_0;// MODER: 10 - Alternative function
// GPIOA->AFR[0] // AFDEL set to 0000 automatically (SPI1_MOSI)
SPI1->CR1 |= SPI_CR1_BR_1;// SPI psc (010) : (8), 48/8 = 6Mhz set
SPI1->CR1 |= (SPI_CR1_MSTR | SPI_CR1_SSM | SPI_CR1_SSI);// Set as Master (also, enable software slave management)
SPI1->CR1 |= SPI_CR1_CPHA;// The second clock transition is the first data capture edge (as a result, first LED will always be active)
// 8-bit data length set initially by the hardware
SPI1->CR1 |= SPI_CR1_SPE;// SPI enable
// *********************************

// *** Configure ADC ***
NVIC_EnableIRQ(ADC1_COMP_IRQn);
RCC->APBENR2 |= RCC_APBENR2_ADCEN;
ADC1->IER |= ADC_IER_EOCIE;// End of conversion interrupt enable
ADC1->CR |= ADC_CR_ADVREGEN;// ADC voltage regulator enable
ADC1->CFGR1 |= ADC_CFGR1_DISCEN;// ADC discontinuous mode enabled
ADC1->CFGR1 |= ADC_CFGR1_OVRMOD;// Overwire with the last conversion result
ADC1->CHSELR |= ADC_CHSELR_CHSEL5;// Channel 5 selected for conversion

ADC1->CR |= ADC_CR_ADEN;// Start ADC
while((ADC1->ISR & ADC_ISR_ADRDY) == 0);
ADC1->ISR |= ADC_ISR_ADRDY;// Clear flag
// *********************************

// *** Configure USART1 ***
GPIOA->MODER &= ~(GPIO_MODER_MODE9_1 | GPIO_MODER_MODE10_1);// GPIO Output mode
// *********************************

// *** Configure EXTI (switches) ***
// SW2 (SET) - PA11 | SW3 (DOWN) - PA12 | SW4 (UP) - PB15
GPIOA->MODER &= ~(GPIO_MODER_MODE11_0 | GPIO_MODER_MODE11_1);
GPIOA->MODER &= ~(GPIO_MODER_MODE12_0 | GPIO_MODER_MODE12_1);
GPIOB->MODER &= ~(GPIO_MODER_MODE15_0 | GPIO_MODER_MODE15_1);
GPIOA->PUPDR |= GPIO_PUPDR_PUPD11_0;
GPIOA->PUPDR |= GPIO_PUPDR_PUPD12_0;
GPIOB->PUPDR |= GPIO_PUPDR_PUPD15_0;

NVIC_EnableIRQ(EXTI4_15_IRQn);
EXTI->EXTICR[2] |= ((0x00)<<24);// Set PA11
EXTI->EXTICR[3] |= ((0x00)<<0);// Set PA12
EXTI->EXTICR[3] |= ((0x01)<<24);// Set PB15
EXTI->FTSR1 |= EXTI_FTSR1_FT11 | EXTI_FTSR1_FT12 | EXTI_FTSR1_FT15;// Falling edge event
EXTI->IMR1 |= EXTI_IMR1_IM11 | EXTI_IMR1_IM12 | EXTI_IMR1_IM15;
// *********************************

}

void delay_ms (uint16_t ms){
d_flag = 0;
TIM14->CCR1 = ms;
TIM14->CR1 |= TIM_CR1_CEN;// Counter enable
while(!d_flag);
}

__attribute__((interrupt)) void TIM14_IRQHandler(void){
if (TIM14->SR & TIM_SR_CC1IF){
TIM14->SR &= ~TIM_SR_CC1IF;// Clear flag
TIM14->CR1 &= ~TIM_CR1_CEN;// Counter disabled
TIM14->EGR |= TIM_EGR_UG;// Reinitialise the counter
d_flag = 1;
}
}

__attribute__((interrupt)) void EXTI4_15_IRQHandler(void){
if ((EXTI->FPR1 & EXTI_FPR1_FPIF11)){// SET button
EXTI->FPR1 |= EXTI_FPR1_FPIF11;
button_flag[B_SET] = 1;
}

if ((EXTI->FPR1 & EXTI_FPR1_FPIF12)){// DOWN button
EXTI->FPR1 |= EXTI_FPR1_FPIF12;
button_flag[B_DOWN] = 1;
}

if ((EXTI->FPR1 & EXTI_FPR1_FPIF15)){// UP button
EXTI->FPR1 |= EXTI_FPR1_FPIF15;
button_flag[B_UP] = 1;
}
}[/syntax]

Biblioteka do obsługi wyświetlacza 16-seg
segment_dsp.h
[syntax=c]/*
* segment_dsp.h
*
* Created on: Dec 21, 2020
* Author: Michal Makowka
*/

#ifndef INC_SEGMENT_DSP_H_
#define INC_SEGMENT_DSP_H_

#include
#include
#include "stm32g071xx.h"

#include "config.h"

volatile uint8_t dot_enable[6];
volatile uint16_t led_dsp[6];// Array holding the LED display value

enum {slow = 350, medium = 200, fast = 100};// LED display scroll speed
enum {OFF, ON};// LCD dot enabled, disabled

void ScrollLed(char * data, uint16_t speed, uint8_t len);
void DisplayNumberSet(uint8_t n0, uint8_t n1, uint8_t n2, uint8_t n3, uint8_t n4, uint8_t n5);
void DisplayLEDStr(char * str);
void displayChar(char c, uint8_t pos);
void setDigit (uint8_t digit);

void LEDClr(void);

#endif /* INC_SEGMENT_DSP_H_ */[/syntax]

segment_dsp.c
[syntax=c]/*
* segment_dsp.c
*
* Created on: Dec 21, 2020
* Author: Michal Makowka
*/
#include "segment_dsp.h"

#define D0_SET GPIOC->BSRR = GPIO_BSRR_BR6
#define D1_SET GPIOC->BSRR = GPIO_BSRR_BR7
#define D2_SET GPIOD->BSRR = GPIO_BSRR_BR0
#define D3_SET GPIOD->BSRR = GPIO_BSRR_BR1
#define D4_SET GPIOD->BSRR = GPIO_BSRR_BR2
#define D5_SET GPIOD->BSRR = GPIO_BSRR_BR3

#define D0_CLR GPIOC->BSRR = GPIO_BSRR_BS6
#define D1_CLR GPIOC->BSRR = GPIO_BSRR_BS7
#define D2_CLR GPIOD->BSRR = GPIO_BSRR_BS0
#define D3_CLR GPIOD->BSRR = GPIO_BSRR_BS1
#define D4_CLR GPIOD->BSRR = GPIO_BSRR_BS2
#define D5_CLR GPIOD->BSRR = GPIO_BSRR_BS3

// *** Symbol values representation to be written to the GPIOB ODR register ***
const uint16_t ZERO = 32704;
const uint16_t ONE = 32761;
const uint16_t TWO = 28388;
const uint16_t THREE = 28400;
const uint16_t FOUR = 28377;
const uint16_t FIVE = 28370;
const uint16_t SIX = 28354;
const uint16_t SEVEN = 32760;
const uint16_t EIGHT = 28352;
const uint16_t NINE = 28368;

const uint16_t SPACE = 32767;

const uint16_t A = 28360;
const uint16_t B = 31408;
const uint16_t C = 32710;
const uint16_t D = 31664;
const uint16_t E = 28358;
const uint16_t F = 28366;
const uint16_t G = 32450;
const uint16_t H = 28361;
const uint16_t I = 31679;
const uint16_t J = 32737;
const uint16_t K = 27983;
const uint16_t L = 32711;
const uint16_t M = 16201;
const uint16_t N = 15817;
const uint16_t O = 32704;
const uint16_t P = 28364;
const uint16_t Q = 32192;
const uint16_t R = 27852;
const uint16_t S = 28370;
const uint16_t T = 31678;
const uint16_t U = 32705;
const uint16_t W = 30153;
const uint16_t V = 30543;
const uint16_t X = 13695;
const uint16_t Y = 15231;
const uint16_t Z = 63350;

// ******** ******** ******** ********

// Select for which DOT should be enabled
volatile uint8_t dot_enable[6] = {OFF, OFF, OFF, OFF, OFF, OFF};

void DisplayNumberSet(uint8_t n0, uint8_t n1, uint8_t n2, uint8_t n3, uint8_t n4, uint8_t n5) {
displayChar((n0+48), 0);
displayChar((n1+48), 1);
displayChar((n2+48), 2);
displayChar((n3+48), 3);
displayChar((n4+48), 4);
displayChar((n5+48), 5);
// 48 must be added to reach the number char value from the ASCII table
}

void DisplayLEDStr(char * str) {
uint8_t i;
LEDClr();
for (i=0; i<6; i++) {
displayChar(str[i], i);
}
}

void ScrollLed(char * data, uint16_t speed, uint8_t len) {
uint8_t j=0;
uint8_t k=0;
char temp_buf[len+12];
memset(temp_buf, 32, (len+12));
for (j=6; j<(5+len); j++) {
temp_buf[j] = data[k];
k++;
}
k=0;
for (j=0; j<=(6+len); j++) {
displayChar(temp_buf[k+j], 0); k++;
displayChar(temp_buf[k+j], 1); k++;
displayChar(temp_buf[k+j], 2); k++;
displayChar(temp_buf[k+j], 3); k++;
displayChar(temp_buf[k+j], 4); k++;
displayChar(temp_buf[k+j], 5); k=0;
delay_ms(speed);
}
}

void displayChar(char c, uint8_t pos) {
if (pos<0 && pos>5) return;
if ((c>47 && c<58) || (c>96 && c<123) || (c==32)) {
if (c=='0') {led_dsp[pos] = ZERO; return;}
if (c=='1') {led_dsp[pos] = ONE; return;}
if (c=='2') {led_dsp[pos] = TWO; return;}
if (c=='3') {led_dsp[pos] = THREE; return;}
if (c=='4') {led_dsp[pos] = FOUR; return;}
if (c=='5') {led_dsp[pos] = FIVE; return;}
if (c=='6') {led_dsp[pos] = SIX; return;}
if (c=='7') {led_dsp[pos] = SEVEN; return;}
if (c=='8') {led_dsp[pos] = EIGHT; return;}
if (c=='9') {led_dsp[pos] = NINE; return;}

if (c==' ') {led_dsp[pos] = SPACE; return;}

if (c=='a') {led_dsp[pos] = A; return;}
if (c=='b') {led_dsp[pos] = B; return;}
if (c=='c') {led_dsp[pos] = C; return;}
if (c=='d') {led_dsp[pos] = D; return;}
if (c=='e') {led_dsp[pos] = E; return;}
if (c=='f') {led_dsp[pos] = F; return;}
if (c=='g') {led_dsp[pos] = G; return;}
if (c=='h') {led_dsp[pos] = H; return;}
if (c=='i') {led_dsp[pos] = I; return;}
if (c=='j') {led_dsp[pos] = J; return;}
if (c=='k') {led_dsp[pos] = K; return;}
if (c=='l') {led_dsp[pos] = L; return;}
if (c=='m') {led_dsp[pos] = M; return;}
if (c=='n') {led_dsp[pos] = N; return;}
if (c=='o') {led_dsp[pos] = O; return;}
if (c=='p') {led_dsp[pos] = P; return;}
if (c=='q') {led_dsp[pos] = Q; return;}
if (c=='r') {led_dsp[pos] = R; return;}
if (c=='s') {led_dsp[pos] = S; return;}
if (c=='t') {led_dsp[pos] = T; return;}
if (c=='u') {led_dsp[pos] = U; return;}
if (c=='w') {led_dsp[pos] = W; return;}
if (c=='v') {led_dsp[pos] = V; return;}
if (c=='x') {led_dsp[pos] = X; return;}
if (c=='y') {led_dsp[pos] = Y; return;}
if (c=='z') {led_dsp[pos] = Z; return;}
}
}

void setDigit(uint8_t digit) {
switch(digit) {
case 0:
D0_SET;
D1_CLR;
D2_CLR;
D3_CLR;
D4_CLR;
D5_CLR;
break;
case 1:
D0_CLR;
D1_SET;
D2_CLR;
D3_CLR;
D4_CLR;
D5_CLR;
break;
case 2:
D0_CLR;
D1_CLR;
D2_SET;
D3_CLR;
D4_CLR;
D5_CLR;
break;
case 3:
D0_CLR;
D1_CLR;
D2_CLR;
D3_SET;
D4_CLR;
D5_CLR;
break;
case 4:
D0_CLR;
D1_CLR;
D2_CLR;
D3_CLR;
D4_SET;
D5_CLR;
break;
case 5:
D0_CLR;
D1_CLR;
D2_CLR;
D3_CLR;
D4_CLR;
D5_SET;
break;
}
}

void LEDClr(void) {
displayChar(' ', 0);
displayChar(' ', 1);
displayChar(' ', 2);
displayChar(' ', 3);
displayChar(' ', 4);
displayChar(' ', 5);
}

// LED display multiplexing
__attribute__((interrupt)) void TIM15_IRQHandler(void){
if (TIM15->SR & TIM_SR_CC1IF){
TIM15->SR &= ~TIM_SR_CC1IF;// Clear flag
static uint8_t pos = 0;
if (pos>5) pos = 0;
if (dot_enable[pos] == 1) led_dsp[pos] -= 8192;// Subtract (ENABLE) the bit value responsible for DOT display (note: active low)
GPIOB->ODR = ((0x7FFF) & led_dsp[pos]);// 0x7FFF masks the button value on PB15
if (dot_enable[pos] == 1) led_dsp[pos] += 8192;// Add (DISABLE) the bit value responsible for DOT display (note: active low)
setDigit(pos);
pos++;

}
}[/syntax]

Biblioteka do obsługi RTC/konfiguracji/aktualizacji danych czasu:
clock.h
[syntax=c]/*
* clock.h
*
* Created on: Dec 22, 2020
* Author: Michal Makowka
*/

#ifndef INC_CLOCK_H_
#define INC_CLOCK_H_

#include
#include
#include "stm32g071xx.h"

volatile uint8_t hour_t;
volatile uint8_t hour_u;
volatile uint8_t minute_t;
volatile uint8_t minute_u;

volatile uint8_t year_t;
volatile uint8_t year_u;
volatile uint8_t month_t;
volatile uint8_t month_u;
volatile uint8_t day_t;
volatile uint8_t day_u;

// *** COLOUR DEFINITIONS ***
// Each time of the day has a corresponding colour of the clock.
// The sum of all three channels per T(X) should add up to 255! Otherwise, auto-brightness will be slightly disturbed!
// T1: 6:00 - 12:00
#define R_T1 160
#define G_T1 95
#define B_T1 0
// T2: 12:00 - 18:00
#define R_T2 100
#define G_T2 155
#define B_T2 0
// T3: 18:00 - 21:00
#define R_T3 170
#define G_T3 50
#define B_T3 35
// T4: 21:00 - 23:00
#define R_T4 155
#define G_T4 0
#define B_T4 100
// T5: 23:00 - 5:00
#define R_T5 0
#define G_T5 0
#define B_T5 220
// T6: 5:00 - 6:00
#define R_T6 0
#define G_T6 0
#define B_T6 220
// **************************

void setTime(uint8_t t_hour, uint8_t u_hour, uint8_t t_minute, uint8_t u_minute);
void setDate(uint8_t t_day, uint8_t u_day, uint8_t t_month, uint8_t u_month, uint8_t t_year, uint8_t u_year);

#endif /* INC_CLOCK_H_ */[/syntax]

clock.c
[syntax=c]/*
* clock.c
*
* Created on: Dec 22, 2020
* Author: Michal Makowka
*/

#include "clock.h"
#include "ws_lib.h"

#define TEMP_TR_MASK 0x7f7f7f
#define TEMP_DR_MASK 0xffff3f

void setTime(uint8_t t_hour, uint8_t u_hour, uint8_t t_minute, uint8_t u_minute) {
if(t_hour > 2 || u_hour > 9 || t_minute > 5 || u_minute > 9) return;// Verify the input

uint32_t TR_TEMP = 0;// Temporary RTC TR register

// Load appropriate values to the temporary time register (TR)
TR_TEMP |= (t_hour<<20);
TR_TEMP |= (u_hour<<16);
TR_TEMP |= (t_minute<<12);
TR_TEMP |= (u_minute<<8);

// RTC write protection keyes
RTC->WPR = 0xca;
RTC->WPR = 0x53;

// Enter clock init mode
RTC->ICSR |= RTC_ICSR_INIT;
while ((RTC->ICSR & RTC_ICSR_INITF) == 0);// Wait until ready to update

RTC->TR = (TR_TEMP & TEMP_TR_MASK);// Update clock registers

RTC->ICSR &= ~RTC_ICSR_INIT;// Disable RTC init mode

}

void setDate(uint8_t t_day, uint8_t u_day, uint8_t t_month, uint8_t u_month, uint8_t t_year, uint8_t u_year) {
if(t_day > 3 || u_day > 9 || t_month > 1 || u_month > 9 || t_year>9 || u_year>9) return;// Verify input

uint32_t DR_TEMP = 0;// Temporary RTC DR register

// Load appropriate values to the temporary data register (DR)
DR_TEMP |= (t_day<<4);
DR_TEMP |= (u_day<<0);
DR_TEMP |= (t_month<<12);
DR_TEMP |= (u_month<<8);
DR_TEMP |= (t_year<<20);
DR_TEMP |= (u_year<<16);

// RTC write protection keyes
RTC->WPR = 0xca;
RTC->WPR = 0x53;

// Enter clock init mode
RTC->ICSR |= RTC_ICSR_INIT;
while ((RTC->ICSR & RTC_ICSR_INITF) == 0);// Wait until ready to update

RTC->DR = (DR_TEMP & TEMP_DR_MASK);// Update clock registers

RTC->ICSR &= ~RTC_ICSR_INIT;// Disable RTC init mode

}

__attribute__((interrupt)) void TIM16_IRQHandler(void){
if (TIM16->SR & TIM_SR_CC1IF){
TIM16->SR &= ~TIM_SR_CC1IF;// Clear flag
TIM16->EGR |= TIM_EGR_UG;// Reinitialise the counter

while((RTC->ICSR & RTC_ICSR_RSF)==0);// See if the data was updated by the RTC
hour_t = ((RTC->TR & RTC_TR_HT)>>20);
hour_u = ((RTC->TR & RTC_TR_HU)>>16);
minute_t = ((RTC->TR & RTC_TR_MNT)>>12);
minute_u = ((RTC->TR & RTC_TR_MNU)>>8);

year_t = ((RTC->DR & RTC_DR_YT)>>20);
year_u = ((RTC->DR & RTC_DR_YU)>>16);
month_t = ((RTC->DR & RTC_DR_MT)>>12);
month_u = ((RTC->DR & RTC_DR_MU)>>8);
day_t = ((RTC->DR & RTC_DR_DT)>>4);
day_u = ((RTC->DR & RTC_DR_DU)>>0);

RTC->ICSR &= ~RTC_ICSR_RSF;// Clear the SR update bit

}
}[/syntax]

Biblioteka menu (zrobiona na szybko i wymaga jeszcze pracy, także proszę się nie przerażać )
clk_menu.h
[syntax=c]/*
* clk_menu.h
*
* Created on: Dec 25, 2020
* Author: Michal Makowka
*/

#ifndef INC_CLK_MENU_H_
#define INC_CLK_MENU_H_

#include
#include
#include "stm32g071xx.h"
#include "ws_lib.h"
#include "segment_dsp.h"
#include "config.h"

typedef struct menu {
// Menu variables
uint8_t menu_pos;
uint8_t nxt_level;
uint8_t back;

// Executive functions
void (*configuration)(void * wsk);
void (*study)(void);
void (*alarm)(void);

} TMENU;

// Menu options: position order
enum{p_main_config, p_main_alarm, p_main_study, p_main_back};// Main menu
enum{p_conf_time, p_conf_back};// Config menu
enum{p_al_time, p_al_enable, p_al_back};// Alarm menu
enum{p_std_studytime, p_std_breaktime, p_std_enable, p_std_back};// Study menu

// Menu options: position char (max. 6 characters)
char * main_options[4];
char * config_options[2];
char * alarm_options[3];
char * study_options[4];

void displayMenu (TMENU * str_wsk);
void displayConfig (TMENU * str_wsk);
void displayAlarm (TMENU * str_wsk);
void displayStudy (TMENU * str_wsk);

uint8_t decToBcd(uint8_t val);

#endif /* INC_CLK_MENU_H_ */[/syntax]

clk_menu.c
[syntax=c]/*
* clk_menu.c
*
* Created on: Dec 25, 2020
* Author: Michal Makowka
*/

#include "clk_menu.h"

char * main_options[4] = {"config", "alarm", "study", "back"};
char * config_options[2] = {"time", "back"};
char * alarm_options[3] = {"config", "enable", "back"};
char * study_options[4] = {"study", "break", "enable", "back"};

typedef struct menuInput {
uint8_t temp_val_ten;
uint8_t temp_val_units;
uint8_t idx;
uint8_t idx_default_ten;
uint8_t idx_default_units;
uint8_t idx_max;
uint8_t idx_min;
char display[4];
} TINPUT;

void menuInputService (TINPUT * in_wsk) {

// Display which variable is being configured
DisplayLEDStr(in_wsk->display);
displayChar(((in_wsk->idx_default_ten + 48)), 4);// Display initial values in line with the current idx
displayChar(((in_wsk->idx_default_units + 48)), 5);

in_wsk->temp_val_ten = in_wsk->idx_default_ten;
in_wsk->temp_val_units = in_wsk->idx_default_units;
in_wsk->idx = (in_wsk->idx_default_ten * 10) + in_wsk->idx_default_units;

while(!button_flag[B_SET]) {
if (button_flag[B_UP]) {
button_flag[B_UP]=0;
(in_wsk->idx)++;
if (in_wsk->idx > (in_wsk->idx_max)) in_wsk->idx = in_wsk->idx_min;
in_wsk->temp_val_ten = (decToBcd(in_wsk->idx)>>4);
in_wsk->temp_val_units = (decToBcd(in_wsk->idx) & 0x0F);
displayChar(((in_wsk->temp_val_ten)+48), 4);
displayChar(((in_wsk->temp_val_units)+48), 5);
}
if (button_flag[B_DOWN]) {
button_flag[B_DOWN]=0;
(in_wsk->idx)--;
if (in_wsk->idx > 250 || in_wsk->idx < in_wsk->idx_min) in_wsk->idx = in_wsk->idx_max;
in_wsk->temp_val_ten=(decToBcd(in_wsk->idx)>>4);
in_wsk->temp_val_units = (decToBcd(in_wsk->idx) & 0x0F);
displayChar(((in_wsk->temp_val_ten)+48), 4);
displayChar(((in_wsk->temp_val_units)+48), 5);
}

delay_ms(250);
}
button_flag[B_SET]=0;
}

void selectTime(void) {

uint8_t temp_t_hour, temp_u_hour, temp_t_minute, temp_u_minute,
temp_t_day, temp_u_day, temp_t_month, temp_u_month, temp_t_year, temp_u_year;

TINPUT input;

// Input hour
input.display[0]='h'; input.display[1]='r';
input.idx_max=23;
input.idx_min=0;
input.idx_default_ten = 0;
input.idx_default_units = 0;
menuInputService(&input);
temp_t_hour = input.temp_val_ten;
temp_u_hour = input.temp_val_units;

// Input minute
input.display[0]='m'; input.display[1]='i'; input.display[2]='n';
input.idx_max=59;
input.idx_min=0;
input.idx_default_ten = 0;
input.idx_default_units = 0;
menuInputService(&input);
temp_t_minute = input.temp_val_ten;
temp_u_minute = input.temp_val_units;

setTime(temp_t_hour, temp_u_hour, temp_t_minute, temp_u_minute);

// Input day
input.display[0]='d'; input.display[1]='a'; input.display[2]='y';
input.idx_max=31;
input.idx_min=1;
input.idx_default_ten = 0;
input.idx_default_units = 1;
menuInputService(&input);
temp_t_day = input.temp_val_ten;
temp_u_day = input.temp_val_units;

// Input month
input.display[0]='m'; input.display[1]='o'; input.display[2]='n';
input.idx_max=12;
input.idx_min=1;
input.idx_default_ten = 0;
input.idx_default_units = 1;
menuInputService(&input);
temp_t_month = input.temp_val_ten;
temp_u_month = input.temp_val_units;

// Input year
input.display[0]='y'; input.display[1]='e'; input.display[2]='a'; input.display[3]='r';
input.idx_max=99;
input.idx_min=0;
input.idx_default_ten = 1;
input.idx_default_units = 8;
menuInputService(&input);
temp_t_year = input.temp_val_ten;
temp_u_year = input.temp_val_units;

setDate(temp_t_day, temp_u_day, temp_t_month, temp_u_month, temp_t_year, temp_u_year);

}

void displayMenu (TMENU * str_wsk) {
LEDClr();

FillLEDArray(LED_buf, 0, 0, 0);
SPI_SEND_WSBUF(LED_buf, sizeof(LED_buf));

button_flag[B_UP]=0;
button_flag[B_DOWN]=0;
button_flag[B_SET]=0;

str_wsk->nxt_level = 0;
str_wsk->menu_pos = 0;
str_wsk->nxt_level = 0;
str_wsk->back = 0;

uint8_t temp_pos;

while(!str_wsk->back) {

if (button_flag[B_UP]) {
button_flag[B_UP]=0;
str_wsk->menu_pos++;
if(str_wsk->menu_pos>3) str_wsk->menu_pos=0;
}

if (button_flag[B_DOWN]) {
button_flag[B_DOWN]=0;
str_wsk->menu_pos--;
if(str_wsk->menu_pos>250) str_wsk->menu_pos=3;
}

if (button_flag[B_SET]) {
button_flag[B_SET]=0;
str_wsk->nxt_level=1;
}

if (temp_pos != str_wsk->menu_pos) {
DisplayLEDStr(main_options[str_wsk->menu_pos]);
temp_pos = str_wsk->menu_pos;
}

if(str_wsk->nxt_level) {
if (str_wsk->menu_pos == p_main_back) return;
if ((str_wsk->configuration) && (str_wsk->menu_pos == p_main_config)) str_wsk->configuration(str_wsk);
if ((str_wsk->alarm) && (str_wsk->menu_pos == p_main_alarm)) str_wsk->alarm();
if ((str_wsk->study) && (str_wsk->menu_pos == p_main_study)) str_wsk->study();
}
delay_ms(250);
}
}

void displayConfig (TMENU * str_wsk) {
LEDClr();

FillLEDArray(LED_buf, 0, 0, 0);
SPI_SEND_WSBUF(LED_buf, sizeof(LED_buf));

DisplayLEDStr(config_options[str_wsk->menu_pos]);

button_flag[B_UP]=0;
button_flag[B_DOWN]=0;
button_flag[B_SET]=0;

str_wsk->nxt_level = 0;
str_wsk->menu_pos = 0;
str_wsk->nxt_level = 0;
str_wsk->back = 0;

uint8_t temp_pos;

while(!str_wsk->back) {

if (button_flag[B_UP]) {
delay_ms(80);
button_flag[B_UP]=0;
str_wsk->menu_pos++;
if(str_wsk->menu_pos>1) str_wsk->menu_pos=0;
}

if (button_flag[B_DOWN]) {
delay_ms(80);
button_flag[B_DOWN]=0;
str_wsk->menu_pos--;
if(str_wsk->menu_pos>250) str_wsk->menu_pos=1;
}

if (button_flag[B_SET]) {
delay_ms(80);
button_flag[B_SET]=0;
str_wsk->nxt_level=1;
}

if (temp_pos != str_wsk->menu_pos) {
DisplayLEDStr(config_options[str_wsk->menu_pos]);
temp_pos = str_wsk->menu_pos;
}

if(str_wsk->nxt_level) {
if (str_wsk->menu_pos == p_conf_back) return;
if (str_wsk->menu_pos == p_conf_time) {selectTime(); str_wsk->back=1;}

}
delay_ms(250);
}
}

void displayAlarm (TMENU * str_wsk) {

// To be done

}

void displayStudy (TMENU * str_wsk) {

// To be done

}

uint8_t decToBcd(uint8_t val) {
return ((val/10*16) + (val%10));
}[/syntax]

Pozdrawiam

Statystyki: Napisane przez Makowka — 26 gru 2020, o 16:36

ATNEL tech-forum

Re: STM32-WS-RGB Clock 2021

Re: STM32-WS-RGB Clock 2021

Re: STM32-WS-RGB Clock 2021

Re: STM32-WS-RGB Clock 2021

Re: STM32-WS-RGB Clock 2021

Re: STM32-WS-RGB Clock 2021

Re: STM32-WS-RGB Clock 2021

Re: STM32-WS-RGB Clock 2021

Re: STM32-WS-RGB Clock 2021

Re: STM32-WS-RGB Clock 2021

STM32-WS-RGB Clock 2021