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

2024 Автор: John Day | [email protected]. Акыркы өзгөртүү: 2024-01-30 10:41

Бул MAX7219 чекиттүү матрицанын дисплейин канчалык ылдамдыкта түртүп жибере алаарымды көрүү үчүн кызыктуу долбоор. Жана аны "жашоо оюнун" иштетүүнүн ордуна, мен аны менен "масштаб" түзүүнү чечтим. Аталышынан түшүнгөндөй, бул чыныгы осциллографты алмаштырбайт:-).

Мен муну олуттуу түрдө колдонууну пландабагандыктан, мен ал үчүн басылган плата жасабайм. Балким, балким, мен муну тактага коём, бирок азырынча ал нан столунда турат жана кала берет. Ошондой эле эч кандай күчөткүч/атенюатор жок, сиз 0 менен 3.3В ортосунда сигнал беришиңиз керек, терс же 3.3Втан жогору болбоңуз, анткени микроконтроллерди бузуп коюшуңуз мүмкүн.

1 -кадам: Аппараттык

Кыймылдарды ebay же окшош сайттар аркылуу Кытайдан сатып алсаңыз, бул абдан арзан. Бул STM32F103C8 өнүктүрүү тактасын колдонот, кээде аны "көк таблетка" деп аташат, аны мен 2 еврого жакын сатып алгам (же АКШ доллары, алар дээрлик бирдей, 2018-жылдын аягында), 8X8x4 чекиттүү матрицалуу дисплейде MAX7219 микросхемалары бар. 5 евро бир даана жана болжол менен 1 евронун айлануучу коддогучу.

Албетте, бир нече жүз миллиамперге 3.3В жеткирүүчү энергия булагы керек. STM32F103C8 өнүктүрүү тактасындагы чыңалуу жөндөгүчү колдонулбайт, ал дисплейлерге жетиштүү ток бере албайт. MAX7219 маалымат барагында иштөөчү чыңалуу 4.0 жана 5.5V ортосунда болушу керек, бирок 3.3Vде жакшы иштейт, балким сиз аны өтө ысык же муздак чөйрөдө колдонгондо эмес, бирок 20 Цельсийде жакшы. Эми мен микроконтроллер менен дисплей такталарынын ортосундагы деңгээлди өзгөрткүчтөрдү колдонуунун кажети жок.

2 -кадам: куруу

Сүрөттү карасаңыз, мен таблицанын электр чубалгыларын кадимки эмес түрдө колдонуп жатканымды көрөсүң, үстүндөгү эки линия тең оң темир, асты экөө тең жер темир жолу. Бул мен көнүп калган жол жана ал жакшы иштейт, ал орнотууну мен тарткан схемаларга окшоштурат. Ошондой эле, мен тездетүү үчүн нан тактасына туташтыра турган бөлүктөрү бар көптөгөн кичинекей тактайчаларды жасадым жана алардын бардыгы эки жогорку сапты оң, төмөнкү сызыктарды жер катары колдонууга конфигурацияланган. Мен айткандай, токтом 4 бит (16 деңгээл), жана 4х8 леддердин жанында тургандыктан, болгону 32 үлгү пункттары (упайлар) бар. Муну Rigol Rigol DS1054Z (8 бит жана 12Mpts) менен салыштырып көрүңүз, бул оюнчук эмес экенин көрөсүз. Чыныгы өткөрүү жөндөмү эмне экенин билбейм, мен аны 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 LED биринин үстүнө бири жеңилирээк болмок, ошондуктан мен маалыматтар менен вертикалдуу түрдө жазылган жана керектүү горизонталдык жол менен окулган жөнөкөй кадр-буфер жасадым. MAX7219 8 LEDга 16 бит кодду колдонот, мында биринчи байт тандалган линияны чечүү үчүн колдонулат. Жана бул модулдардын төртөө бири -бирине тизилгендиктен, алардын кириштери модулдун чыгышына туташкандыктан, акыркы модулга жетүү үчүн ошол 16 битти төрт жолу жөнөтүү керек. (Мен түшүнүктүү кылып жатам деп үмүттөнөм …) Маалыматтар MAX7219га SPI, жөнөкөй, бирок өтө тез протокол аркылуу жөнөтүлөт. Бул мен эксперимент кылган нерсе, сиз MAX7219га маалыматтарды жөнөтүүдө канчалык тез бара аласыз. Акыр -аягы, мен маалымат барагында көрсөтүлгөн максималдуу ылдамдыктан бир аз төмөн 9 МГцке которулдум.

Мен STM32F103C8 жеткиликтүү төрт таймеринин экөөнү колдоном, бири убакыт базасын түзүү үчүн, экинчиси убакыт базасын орнотуучу айлануучу коддогучту окуу үчүн. TIMER3 убакыт базасын түзөт, муну саатты 230га бөлүү менен жасайт, эсептегичти ар бир 3.2 АКШда жаңыртып турат. Сыйкырдуу коддогучту эсептегичти 2 сааттык импульстен 2000 сааттык импульска чейин тандап алсаңыз болот. Айталы, сиз 100 тандадыңыз. TIMER3 андан кийин ар бир 320 АКШда ОКУЯ жаратат. Бул ОКУЯ ADCди кирүүчү сигналдын үлгүсүн жаздырууга түрткү берет жана 32 үлгү бир скриншот үчүн кабыл алынат, бул болжол менен кийин бүтөт. 10 mS. 10 мСте бир толкун узундугу 100 Гцке же 200 Гцтин экөөнө ж. Экранга 3 толкундан өтүү толкун формасын таанууну бир топ кыйын кылат.

Калгандары үчүн, мен сизге кодду гана айта алам, эгер сизде Arduino менен бир аз тажрыйба болсо дагы, аны ээрчүү кыйын эмес. Чынында, сиз Arduino менен эле жасай аласыз, бирок мен анын "көк таблетка" тез иштээрине күмөн санайм. STM32F103C8 - бул 72 МГцте иштеген 32 бит микроконтроллер, анын эки SPI перифериялык түзүлүшү жана абдан тез ADC бар.

5 -кадам: Main.h

#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);

#define 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 data3, uint16_t data2, uint16_t data1, uint16_t data0);

uint16_t SPI2_send64 (uint16_t data3, uint16_t data2, uint16_t data1, uint16_t data0); жараксыз MAX7219_1_init (); жараксыз MAX7219_2_init (); жараксыз erase_frame_buffer (жараксыз); жараксыз fill_frame_buffer (жараксыз); жараксыз display_frame_buffer (жараксыз); void set_timebase (жараксыз);

uint8_t жогорку_көрсөтүү [4] [8]; // vier байт нааст элкаар, ахт ондер элкаар

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 {top_display [x] [y] = 0; // alj bitjes nol_display [x] [y] = 0; }}}

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

{uint8_t y = 0; // чыңалуу uint8_t tijd = 0; // tijd uint8_t display_byte; // аттар 8 бит нааст элкаар даты 4 маал опыт любовь uint8_t display_bit;

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

y = sample_buffer [tijd];

if (y> 7) // жогорку дисплейде schrijven

{üst_display [display_byte] [15-y] | = (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 ыл; // MAX7219

үчүн (y = 0; y <8; y ++) {yl = (y+1) << 8; // MAX7219 жогорку деңгээлдеги 8 бит ван 16 бит woord

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;

которуштуруу (timebase_knop)

{0 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); // testmode SPI1_send64 өчүрүлгөн (0x0C01, 0x0C01, 0x0C01, 0x0C01); // өчүрүү, нормалдуу иштөө SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // 7seg декоддоосу жок, 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); // 7seg декоддоосу жок, 64 пиксел SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // интенсивдүүлүк 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // бардык катарлар}

uint16_t SPI1_send64 (uint16_t data3, uint16_t data2, uint16_t data1, uint16_t data0)

{LL_GPIO_ResetOutputPin (GPIOA, LL_GPIO_PIN_4);

LL_SPI_TransmitData16 (SPI1, data3);

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

LL_SPI_TransmitData16 (SPI1, data2);

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

LL_SPI_TransmitData16 (SPI1, data1);

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

LL_SPI_TransmitData16 (SPI1, data0);

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 data3, uint16_t data2, uint16_t data1, uint16_t data0)

{LL_GPIO_ResetOutputPin (GPIOB, LL_GPIO_PIN_12);

LL_SPI_TransmitData16 (SPI2, data3);

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

LL_SPI_TransmitData16 (SPI2, data2);

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

LL_SPI_TransmitData16 (SPI2, data1);

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

LL_SPI_TransmitData16 (SPI2, data0);

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 trigger; static 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 ((trigger == 7) && (previous_trigger <trigger)) // gait niet helemaal goed bij blokgolven… {sample_counter = 0; } previous_trigger = 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); if (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); }

жараксыз _Error_Handler (char *файлы, int сабы)

{while (1) {}}

#ifdef USE_FULL_ASSERT

void assert_failed (uint8_t* файлы, uint32_t сабы)

{} #endif