Төрт биттік осциллограф: 6 қадам

2024 Автор: John Day | [email protected]. Соңғы өзгертілген: 2024-01-30 10:26

Бұл MAX7219 нүктелік матрицалық дисплейді қаншалықты жылдамдықпен итере алатынымды көру үшін қызықты жоба. Мен оны «өмір ойынын» жүргізудің орнына, онымен «ауқымды» жасауды шештім. Тақырыптан түсінетін болсаңыз, бұл нағыз осциллографты алмастырмайды:-).

Мен мұны байыпты түрде қолдануды жоспарламағандықтан, мен оған баспа тақтасын жасамаймын. Мүмкін, мүмкін мен оны тақтаға қоямын, бірақ әзірге ол нан тақтасында қалады және қалады. Сондай -ақ, кіріс күшейткіші/әлсіреткіші жоқ, сіз 0 -ден 3,3В -қа дейінгі сигналды беруіңіз керек, теріс немесе 3,3В -тан аспаңыз, себебі микроконтроллерді зақымдауы мүмкін.

1 -қадам: Жабдық

Бұл бөлшектерді Қытайдан ebay немесе ұқсас сайттар арқылы сатып алғанда арзан, өте арзан. Ол STM32F103C8 әзірлеу тақтасын пайдаланады, оны мен кейде «көгілдір таблетка» деп атаймын, оны мен шамамен 2 еуроға сатып алдым (немесе АҚШ доллары, олар бірдей мәнге ие, 2018 ж. Соңы), 8x8x4 нүктелі матрицалық MAX7219 чиптері бар екі дисплей. Бөлік 5 евро және шамамен 1 еуро айналатын кодер.

Әрине, бірнеше жүз миллиамперде 3,3 В кернеуі бар қуат көзі қажет. STM32F103C8 даму тақтасындағы кернеу реттегіші қолданылмайды, ол дисплейлерге жеткілікті ток бере алмайды. MAX7219 деректер кестесінде жұмыс кернеуі 4,0 пен 5,5 В аралығында болуы керек, бірақ ол 3,3 В кернеуде жақсы жұмыс істейді, мүмкін оны өте ыстық немесе суық ортада қолданған кезде емес, бірақ 20 Цельсийде жақсы. Ал енді микроконтроллер мен дисплей тақталары арасында деңгейлік түрлендіргіштерді қолданудың қажеті жоқ.

2 -қадам: Құру

Сіз суретке қарасаңыз, мен тақталардағы электр желілерін дәстүрлі емес түрде қолданатынымды көре аласыз, үстіңгі жағындағы екі сызық - оң рельс, ал төменгі жағында - жердегі рельс. Мен мұны үйрендім және ол жақсы жұмыс істейді, бұл мен орнатқан схемаға ұқсайды. Сонымен қатар, мен кішкене тақтайшаларды жасадым, олардың барлығын тездету үшін нан тақтасына қосуға болады, және олардың барлығы екі жоғарғы жолды оң, ал төменгі жолдарды - жер ретінде пайдалануға арналған. Мен айтқанымдай, рұқсат 4 биттік (16 деңгей), және 4х8 жарық диодтары бір -бірінің жанында болғандықтан, тек 32 сынама нүктелері (нүктелер) бар. Мұны Rigol Rigol DS1054Z (8 биттік және 12 Мпт) салыстырыңыз, сонда сіз бұл ойыншық емес екенін көресіз. Нақты өткізу қабілеті дегеніміз не, білмеймін, мен оны 10 кГц -ге дейін сынап көрдім және бұл жақсы жұмыс істейді.

3 -қадам: Бағдарламалар

Мен қолданатын IDE-бұл Atollic TrueStudio, оны ағымдағы жылдың басында (2018 ж.) ST Micro Electronics қабылдады және ақысыз қол жетімді, уақыт шектеусіз, код өлшемінің шегі жоқ, экрандар жоқ. Мен онымен бірге STM32CubeMX бағдарламасын қолданамын, ол маған бастапқы кодты береді және барлық перифериялық құрылғылардың инициализациясын жасайды. Және онда микроконтроллердің барлық түйреуіштері мен оларды қолданудың дисплейі бар. Егер сіз кодты генерациялау үшін STM32CubeMX қолданбасаңыз да, бұл өте ыңғайлы, маған ұнамайтын нәрсе - бұл HAL деп аталатын, ол әдепкі бойынша STM32CubeMX болып табылады. Мен LowLayer жұмыс әдісін ұнатамын.

Микроконтроллерді бағдарламалау үшін мен ST Micro Electronics компаниясының ST-Link бағдарламашысын/отладчикін немесе Segger жасаған J-Link қолданамын. Бұл екі құрылғы да тегін емес, бірақ сіз олардың қытайлық көшірмелерін бірнеше еуроға сатып ала аласыз.

4 -қадам: Кодекс туралы

MAX7219 -дің светодиодтары көлденең деп аталады, олар бір -бірінің жанында 8 жарықдиодты. Осциллограф үшін 8 жарықдиодты бір-бірінің үстіне қою оңайырақ болар еді, сондықтан мен деректерге тік жолмен жазылған және қажетті горизонтальды түрде оқылатын қарапайым фрейм-буфер жасадым. MAX7219 8 светодиоды үшін 16 биттік кодты пайдаланады, мұнда бірінші байт таңдалған жолды адрестеу үшін қолданылады. Бұл модульдердің төртеуі қатар орналасқан, өйткені олардың кірістері модульдің шығысына қосылған, сіз соңғы модульге жету үшін 16 битті төрт рет жіберуіңіз керек. (Мен бәрін түсіндіремін деп үміттенемін …) Деректер MAX7219 -ға SPI, қарапайым, бірақ өте жылдам хаттама арқылы жіберіледі. Бұл мен тәжірибе жүргіздім, сіз MAX7219 -ге деректерді жіберуде қаншалықты жылдам жүре аласыз. Ақырында, мен деректер кестесінде көрсетілген максималды жылдамдықтан сәл төмен 9 МГц -ке ауыстым.

Мен STM32F103C8 қол жетімді төрт таймердің екеуін қолданамын, біреуі уақыт базасын құру үшін, екіншісі уақыт базасын орнататын айналмалы кодерді оқу үшін. TIMER3 уақыт базасын жасайды, ол оны сағатты 230 -ға бөлу арқылы жасайды, есептегішті әр 3,2 АҚШ -та жаңартады. Айналмалы кодерді 2 сағаттық импульстен 2000 сағаттық импульске дейін санауға болады. Айталық, сіз 100 -ді таңдайсыз. TIMER3 содан кейін әрбір 320 АҚШ -та ОҚИҒА жасайды. Бұл ОҚИҒА ADC -ті кіріс сигналының үлгісін жазуға итермелейді, және бір экранда 32 үлгіні алу керек, бұл шамамен кейін аяқталады. 10 мС. 10 мС жиілікте сіз 100 Гц бір толқын ұзындығына немесе 200 Гц жиіліктегі екеуіне және т.б. Бір экранға 3 толқыннан өту толқын пішінін тануды қиындатады.

Қалғандары үшін мен тек кодқа сілтеме жасай аламын, егер сізде Arduino -мен жұмыс тәжірибесі болса да, ұстану қиын емес. Шын мәнінде, сіз Arduino -мен бірдей нәрсені жасай аласыз, бірақ мен оның «көгілдір таблетка» сияқты тез жұмыс істейтініне күмәнданамын. STM32F103C8 - 72 МГц жиілігінде жұмыс істейтін 32 биттік микроконтроллер, оның екі SPI перифериялық құрылғысы және өте жылдам ADC бар.

5 -қадам: Негізгі сағ

#ifndef _ MAIN_H _#_MAIN_H_ анықтау

#«stm32f1xx_ll_adc.h» қосыңыз

#include «stm32f1xx_ll_rcc.h» #include «stm32f1xx_ll_bus.h» #include «stm32f1xx_ll_system.h» #include «stm32f1xx_ll_exti.h» #include «stm32f1xxlxxl_cort_cort» қосу «stm32f1xx_ll_dma.h» #include «stm32f1xx_ll_spi.h» #include «stm32f1xx_ll_tim.h» #include «stm32f1xx.h» #include «stm32f1xx_ll_gpio.h»

#ifndef NVIC_PRIORITYGROUP_0

#define NVIC_PRIORITYGROUP_0 ((uint32_t) 0x00000007) #define NVIC_PRIORITYGROUP_1 ((uint32_t) 0x00000006) #define NVIC_PRIORITYGROUP_2 ((uint32_t) 0x00000005) #define NVIC_PRIORITYGROUP_3 ((uint32_t) 0x00000004) #define NVIC_PRIORITYGROUP_4 ((uint32_t) 0x00000003) #ENDIF

#ifdef _cplusplus

extern «C» {#endif void _Error_Handler (char *, int);

#Анықтау Error_Handler () _Error_Handler (_ FILE_, _LINE_)

#ifdef _cplusplus} #endif

#endif

6 -қадам: Main.c

#include «main.h» статикалық жарамсыздығы LL_Init (жарамсыз); жарамсыз SystemClock_Config (жарамсыз); статикалық жарамсыздық MX_GPIO_Init (жарамсыз); статикалық жарамсыздық MX_ADC1_Init (жарамсыз); статикалық жарамсыздық MX_SPI1_Init (жарамсыз); статикалық жарамсыздық MX_SPI2_Init (жарамсыз); статикалық жарамсыздық MX_TIM3_Init (жарамсыз); статикалық жарамсыздық MX_TIM4_Init (жарамсыз);

uint16_t SPI1_send64 (uint16_t деректер3, uint16_t деректер2, uint16_t деректер1, uint16_t деректер0);

uint16_t SPI2_send64 (uint16_t деректер3, uint16_t деректер2, uint16_t деректер1, uint16_t деректер0); жарамсыз MAX7219_1_init (); жарамсыз MAX7219_2_init (); жарамсыз erase_frame_buffer (жарамсыз); жарамсыз fill_frame_buffer (жарамсыз); жарамсыз display_frame_buffer (жарамсыз); void set_timebase (жарамсыз);

uint8_t жоғарғы_дисплей [4] [8]; // витер байт нааст елкаар, ахт ондер елкаар

uint8_t төменгі_көрініс [4] [8]; // фрейм-буфердің негізгі ережелері

uint8_t sample_buffer [32]; // ADC нәтижелері бойынша буфер

int main (жарамсыз)

{LL_Init (); SystemClock_Config (); MX_GPIO_Init (); MX_ADC1_Init (); MX_SPI1_Init (); MX_SPI2_Init (); MX_TIM3_Init (); MX_TIM4_Init ();

LL_SPI_Enable (SPI1);

LL_SPI_Enable (SPI2);

LL_TIM_EnableCounter (TIM3);

LL_TIM_EnableCounter (TIM4);

LL_ADC_Enable (ADC1);

LL_ADC_REG_StartConversionSWStart (ADC1); LL_ADC_EnableIT_EOS (ADC1);

LL_mDelay (500); // MAX7219 қуат көзіне қосылғаннан кейін біраз уақыт қажет

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

кезінде (1)

{set_timebase (); erase_frame_buffer (); fill_frame_buffer (); display_frame_buffer (); }}

жарамсыз erase_frame_buffer (жарамсыз)

{int8_t x; int8_t y;

үшін (x = 0; x <4; x ++) // kolom_bytes {

үшін (y = 0; y <8; y ++) // lijnen {жоғарғы_дисплей [x] [y] = 0; // барлық нұсқалар төменгі_көрініс [x] [y] = 0; }}}

жарамсыз fill_frame_buffer (жарамсыз)

{uint8_t y = 0; // кернеу uint8_t tijd = 0; // tijd uint8_t display_byte; // аттар 8 разряд 4 жыл бұрын

үшін (tijd = 0; tijd <32; tijd ++) {display_byte = tijd / 8; display_bit = 7 - (% 8);

y = sample_buffer [tijd];

if (y> 7) // жоғарғы дисплейде schrijven

{жоғарғы_дисплей [display_byte] [15-ж] | = (1 << display_bit); } else // төменгі дисплейде schrijven {low_display [display_byte] [7-y] | = (1 << display_bit); }}}

жарамсыз display_frame_buffer (жарамсыз)

{

uint8_t y; // acht lijnen boven elkaar (әр дисплейге) uint16_t yl; // MAX7219 нұсқасы

үшін (y = 0; y <8; y ++) {yl = (y+1) << 8; // MAX7219 16 биттік вагонның жоғарғы 8 биттік санында

SPI2_send64 ((yl | жоғарғы_дисплей [0] [y]), (yl | жоғарғы_көрсетілім [1] [y]), (yl | жоғарғы_спозиция [2] [y]), (yl | жоғарғы_спозиция [3] [y]));

SPI1_send64 ((yl | төменгі_көрсетілім [0] [y]), (yl | төменгі_көрсетілім [1] [y]), (yl | төменгі_көрсетілім [2] [y]), (yl | төменгі_көрсетілім [3] [y])); }

}

void set_timebase (жарамсыз)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

қосқыш (уақыт аралығы_қысқасы)

{0 жағдай: LL_TIM_SetAutoReload (TIM3, 1999); үзіліс; 1 -жағдай: LL_TIM_SetAutoReload (TIM3, 999); үзіліс; 2 -жағдай: LL_TIM_SetAutoReload (TIM3, 499); үзіліс; 3 -жағдай: LL_TIM_SetAutoReload (TIM3, 199); үзіліс; 4 -жағдай: LL_TIM_SetAutoReload (TIM3, 99); үзіліс; 5 -жағдай: LL_TIM_SetAutoReload (TIM3, 49); үзіліс; 6 -жағдай: LL_TIM_SetAutoReload (TIM3, 19); үзіліс; 7 -жағдай: LL_TIM_SetAutoReload (TIM3, 9); үзіліс; 8 -жағдай: LL_TIM_SetAutoReload (TIM3, 4); үзіліс; 9 -жағдай: LL_TIM_SetAutoReload (TIM3, 1); үзіліс;

әдепкі:

LL_TIM_SetAutoReload (TIM3, 99); үзіліс; }}

жарамсыз MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // жоқ SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000) бойынша өшіру; // жоқ SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01) сынақ режимі өшірілген; // өшіру, қалыпты жұмыс SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // 7сегодты декодтау жоқ, 64 пиксель SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // қарқындылығы 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // барлық жолдар}

жарамсыз MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // жоқ SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000) бойынша өшіру; // жоқ SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01) сынақ режимі өшірілген; // өшіру, қалыпты жұмыс SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // 7сегодты декодтау жоқ, 64 пиксель SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // қарқындылығы 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // барлық жолдар}

uint16_t SPI1_send64 (uint16_t деректер3, uint16_t деректер2, uint16_t деректер1, uint16_t деректер0)

{LL_GPIO_ResetOutputPin (GPIOA, LL_GPIO_PIN_4);

LL_SPI_TransmitData16 (SPI1, деректер3);

while (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, деректер2);

while (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, деректер1);

while (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, деректер0);

while (LL_SPI_IsActiveFlag_BSY (SPI1) == 1) {}

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

қайтару LL_SPI_ReceiveData16 (SPI1); }

uint16_t SPI2_send64 (uint16_t деректер3, uint16_t деректер2, uint16_t деректер1, uint16_t деректер0)

{LL_GPIO_ResetOutputPin (GPIOB, LL_GPIO_PIN_12);

LL_SPI_TransmitData16 (SPI2, деректер3);

while (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, деректер2);

while (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, деректер1);

while (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, деректер0);

while (LL_SPI_IsActiveFlag_BSY (SPI2) == 1) {}

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

қайтару LL_SPI_ReceiveData16 (SPI2); }

ADC1_2_IRQHandler жарамсыз (жарамсыз)

{static uint8_t sample_counter; uint8_t триггері; статикалық uint8_t previous_trigger;

егер (LL_ADC_IsActiveFlag_EOS (ADC1)! = ҚАЛПЫНА КЕЛТІРУ)

{if (sample_counter <32) {sample_buffer [sample_counter] = LL_ADC_REG_ReadConversionData32 (ADC1) / 256; if (sample_counter <32) sample_counter ++; else sample_counter = 0; } else {trigger = LL_ADC_REG_ReadConversionData32 (ADC1) / 256;

if ((триггер == 7) && (алдыңғы_триггер <триггер)) // блоки группировать… {sample_counter = 0; } previous_trigger = триггер; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

LL_Init статикалық жарамсыздығы (жарамсыз)

{LL_APB2_GRP1_EnableClock (LL_APB2_GRP1_PERIPH_AFIO); LL_APB1_GRP1_EnableClock (LL_APB1_GRP1_PERIPH_PWR);

NVIC_SetPriorityGrouping (NVIC_PRIORITYGROUP_4);

NVIC_SetPriority (MemoryManagement_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0))); NVIC_SetPriority (BusFault_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0))); NVIC_SetPriority (UsageFault_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0))); NVIC_SetPriority (SVCall_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0))); NVIC_SetPriority (DebugMonitor_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0))); NVIC_SetPriority (PendSV_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0))); NVIC_SetPriority (SysTick_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0)));

LL_GPIO_AF_Remap_SWJ_NOJTAG ();

}

жарамсыз SystemClock_Config (жарамсыз)

{LL_FLASH_SetLatency (LL_FLASH_LATENCY_2); егер (LL_FLASH_GetLatency ()! = LL_FLASH_LATENCY_2) Error_Handler (); LL_RCC_HSE_Enable (); while (LL_RCC_HSE_IsReady ()! = 1); LL_RCC_PLL_ConfigDomain_SYS (LL_RCC_PLLSOURCE_HSE_DIV_1, LL_RCC_PLL_MUL_9); LL_RCC_PLL_Enable (); while (LL_RCC_PLL_IsReady ()! = 1); LL_RCC_SetAHBPrescaler (LL_RCC_SYSCLK_DIV_1); LL_RCC_SetAPB1Prescaler (LL_RCC_APB1_DIV_2); LL_RCC_SetAPB2Prescaler (LL_RCC_APB2_DIV_1); LL_RCC_SetSysClkSource (LL_RCC_SYS_CLKSOURCE_PLL); while (LL_RCC_GetSysClkSource ()! = LL_RCC_SYS_CLKSOURCE_STATUS_PLL); LL_Init1msTick (72000000); LL_SYSTICK_SetClkSource (LL_SYSTICK_CLKSOURCE_HCLK); LL_SetSystemCoreClock (72000000); LL_RCC_SetADCClockSource (LL_RCC_ADC_CLKSRC_PCLK2_DIV_6);

NVIC_SetPriority (SysTick_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0)));

}

статикалық жарамсыздық MX_ADC1_Init (жарамсыз)

{LL_ADC_InitTypeDef ADC_InitStruct; LL_ADC_CommonInitTypeDef ADC_CommonInitStruct; LL_ADC_REG_InitTypeDef ADC_REG_InitStruct; LL_GPIO_InitTypeDef GPIO_InitStruct;

LL_APB2_GRP1_EnableClock (LL_APB2_GRP1_PERIPH_ADC1);

GPIO_InitStruct. Pin = LL_GPIO_PIN_0;

GPIO_InitStruct. Mode = LL_GPIO_MODE_ANALOG; LL_GPIO_Init (GPIOA, & GPIO_InitStruct);

NVIC_SetPriority (ADC1_2_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0)));

NVIC_EnableIRQ (ADC1_2_IRQn);

ADC_InitStruct. DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;

ADC_InitStruct. SequencersScanMode = LL_ADC_SEQ_SCAN_DISABLE; LL_ADC_Init (ADC1, & ADC_InitStruct);

ADC_CommonInitStruct. Multimode = LL_ADC_MULTI_INDEPENDENT;

LL_ADC_CommonInit (_ LL_ADC_COMMON_INSTANCE (ADC1), & ADC_CommonInitStruct);

ADC_REG_InitStruct. TriggerSource = LL_ADC_REG_TRIG_EXT_TIM3_TRGO;

ADC_REG_InitStruct. SequencerLength = 1; ADC_REG_InitStruct. SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE; ADC_REG_InitStruct. ContinuousMode = LL_ADC_REG_CONV_SINGLE; ADC_REG_InitStruct. DMATransfer = LL_ADC_REG_DMA_TRANSFER_NONE; LL_ADC_REG_Init (ADC1, & ADC_REG_InitStruct);

LL_ADC_SetChannelSamplingTime (ADC1, LL_ADC_CHANNEL_0, LL_ADC_SAMPLINGTIME_41CYCLES_5);

}

статикалық жарамсыздық MX_SPI1_Init (жарамсыз)

{LL_SPI_InitTypeDef SPI_InitStruct; LL_GPIO_InitTypeDef GPIO_InitStruct;

LL_APB2_GRP1_EnableClock (LL_APB2_GRP1_PERIPH_SPI1);

GPIO_InitStruct. Pin = LL_GPIO_PIN_5 | LL_GPIO_PIN_7;

GPIO_InitStruct. Mode = LL_GPIO_MODE_ALTERNATE; GPIO_InitStruct. Speed = LL_GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct. OutputType = LL_GPIO_OUTPUT_PUSHPULL; LL_GPIO_Init (GPIOA, & GPIO_InitStruct);

// NVIC_SetPriority (SPI1_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0)));

// NVIC_EnableIRQ (SPI1_IRQn);

SPI_InitStruct. TransferDirection = LL_SPI_FULL_DUPLEX;

SPI_InitStruct. Mode = LL_SPI_MODE_MASTER; SPI_InitStruct. DataWidth = LL_SPI_DATAWIDTH_16BIT; SPI_InitStruct. ClockPolarity = LL_SPI_POLARITY_LOW; SPI_InitStruct. ClockPhase = LL_SPI_PHASE_1EDGE; SPI_InitStruct. NSS = LL_SPI_NSS_SOFT; SPI_InitStruct. BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV8; SPI_InitStruct. BitOrder = LL_SPI_MSB_FIRST; SPI_InitStruct. CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE; SPI_InitStruct. CRCPoly = 10; LL_SPI_Init (SPI1, & SPI_InitStruct); }

статикалық жарамсыздық MX_SPI2_Init (жарамсыз)

{LL_SPI_InitTypeDef SPI_InitStruct; LL_GPIO_InitTypeDef GPIO_InitStruct;

LL_APB1_GRP1_EnableClock (LL_APB1_GRP1_PERIPH_SPI2);

GPIO_InitStruct. Pin = LL_GPIO_PIN_13 | LL_GPIO_PIN_15;

GPIO_InitStruct. Mode = LL_GPIO_MODE_ALTERNATE; GPIO_InitStruct. Speed = LL_GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct. OutputType = LL_GPIO_OUTPUT_PUSHPULL; LL_GPIO_Init (GPIOB, & GPIO_InitStruct);

// NVIC_SetPriority (SPI2_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0)));

// NVIC_EnableIRQ (SPI2_IRQn);

SPI_InitStruct. TransferDirection = LL_SPI_FULL_DUPLEX;

SPI_InitStruct. Mode = LL_SPI_MODE_MASTER; SPI_InitStruct. DataWidth = LL_SPI_DATAWIDTH_16BIT; SPI_InitStruct. ClockPolarity = LL_SPI_POLARITY_LOW; SPI_InitStruct. ClockPhase = LL_SPI_PHASE_1EDGE; SPI_InitStruct. NSS = LL_SPI_NSS_SOFT; SPI_InitStruct. BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV4; SPI_InitStruct. BitOrder = LL_SPI_MSB_FIRST; SPI_InitStruct. CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE; SPI_InitStruct. CRCPoly = 10; LL_SPI_Init (SPI2, & SPI_InitStruct); }

статикалық жарамсыздық MX_TIM3_Init (жарамсыз)

{LL_TIM_InitTypeDef TIM_InitStruct;

LL_APB1_GRP1_EnableClock (LL_APB1_GRP1_PERIPH_TIM3);

TIM_InitStruct. Prescaler = 229;

TIM_InitStruct. CounterMode = LL_TIM_COUNTERMODE_UP; TIM_InitStruct. Autoreload = 9; TIM_InitStruct. ClockDivision = LL_TIM_CLOCKDIVISION_DIV1; LL_TIM_Init (TIM3, & TIM_InitStruct);

LL_TIM_DisableARRPқайта жүктеу (TIM3);

LL_TIM_SetClockSource (TIM3, LL_TIM_CLOCKSOURCE_INTERNAL); LL_TIM_SetTriggerOutput (TIM3, LL_TIM_TRGO_UPDATE); LL_TIM_EnableMasterSlaveMode (TIM3); }

статикалық жарамсыздық MX_TIM4_Init (жарамсыз)

{LL_TIM_InitTypeDef TIM_InitStruct; LL_GPIO_InitTypeDef GPIO_InitStruct;

LL_APB1_GRP1_EnableClock (LL_APB1_GRP1_PERIPH_TIM4);

GPIO_InitStruct. Pin = LL_GPIO_PIN_6 | LL_GPIO_PIN_7;

GPIO_InitStruct. Mode = LL_GPIO_MODE_FLOATING; LL_GPIO_Init (GPIOB, & GPIO_InitStruct);

LL_TIM_SetEncoderMode (TIM4, LL_TIM_ENCODERMODE_X2_TI1);

LL_TIM_IC_SetActiveInput (TIM4, LL_TIM_CHANNEL_CH1, LL_TIM_ACTIVEINPUT_DIRECTTI); LL_TIM_IC_SetPrescaler (TIM4, LL_TIM_CHANNEL_CH1, LL_TIM_ICPSC_DIV1); LL_TIM_IC_SetFilter (TIM4, LL_TIM_CHANNEL_CH1, LL_TIM_IC_FILTER_FDIV1); LL_TIM_IC_SetPolarity (TIM4, LL_TIM_CHANNEL_CH1, LL_TIM_IC_POLARITY_RISING); LL_TIM_IC_SetActiveInput (TIM4, LL_TIM_CHANNEL_CH2, LL_TIM_ACTIVEINPUT_DIRECTTI); LL_TIM_IC_SetPrescaler (TIM4, LL_TIM_CHANNEL_CH2, LL_TIM_ICPSC_DIV1); LL_TIM_IC_SetFilter (TIM4, LL_TIM_CHANNEL_CH2, LL_TIM_IC_FILTER_FDIV1); LL_TIM_IC_SetPolarity (TIM4, LL_TIM_CHANNEL_CH2, LL_TIM_IC_POLARITY_RISING);

TIM_InitStruct. Prescaler = 0;

TIM_InitStruct. CounterMode = LL_TIM_COUNTERMODE_UP; TIM_InitStruct. Autoreload = 19; TIM_InitStruct. ClockDivision = LL_TIM_CLOCKDIVISION_DIV1; LL_TIM_Init (TIM4, & TIM_InitStruct);

LL_TIM_DisableARRPқайта жүктеу (TIM4);

LL_TIM_SetTriggerOutput (TIM4, LL_TIM_TRGO_RESET); LL_TIM_DisableMasterSlaveMode (TIM4); }

статикалық жарамсыздық MX_GPIO_Init (жарамсыз)

{LL_GPIO_InitTypeDef GPIO_InitStruct;

LL_APB2_GRP1_EnableClock (LL_APB2_GRP1_PERIPH_GPIOC);

LL_APB2_GRP1_EnableClock (LL_APB2_GRP1_PERIPH_GPIOD); LL_APB2_GRP1_EnableClock (LL_APB2_GRP1_PERIPH_GPIOA); LL_APB2_GRP1_EnableClock (LL_APB2_GRP1_PERIPH_GPIOB);

LL_GPIO_SetOutputPin (GPIOC, LL_GPIO_PIN_13);

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4); LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

GPIO_InitStruct. Pin = LL_GPIO_PIN_13;

GPIO_InitStruct. Mode = LL_GPIO_MODE_OUTPUT; GPIO_InitStruct. Speed = LL_GPIO_SPEED_FREQ_LOW; GPIO_InitStruct. OutputType = LL_GPIO_OUTPUT_PUSHPULL; LL_GPIO_Init (GPIOC, & GPIO_InitStruct);

GPIO_InitStruct. Pin = LL_GPIO_PIN_4;

GPIO_InitStruct. Mode = LL_GPIO_MODE_OUTPUT; GPIO_InitStruct. Speed = LL_GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct. OutputType = LL_GPIO_OUTPUT_PUSHPULL; LL_GPIO_Init (GPIOA, & GPIO_InitStruct);

GPIO_InitStruct. Pin = LL_GPIO_PIN_12;

GPIO_InitStruct. Mode = LL_GPIO_MODE_OUTPUT; GPIO_InitStruct. Speed = LL_GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct. OutputType = LL_GPIO_OUTPUT_PUSHPULL; LL_GPIO_Init (GPIOB, & GPIO_InitStruct); }

void _Error_Handler (char *файлы, int жолы)

{while (1) {}}

#ifdef USE_FULL_ASSERT

void assert_failed (uint8_t* файлы, uint32_t жолы)

{} #endif