Dörd bitli osiloskop: 6 addım

2024 Müəllif: John Day | [email protected]. Son dəyişdirildi: 2024-01-30 07:46

MAX7219 nöqtəli matrisli ekranı nə qədər sürətlə itirə biləcəyimi görmək əyləncə üçün bir layihədir. Və "həyat oyununu" yerinə yetirmək əvəzinə, onunla "əhatə dairəsi" yaratmağa qərar verdim. Başlıqdan başa düşəcəyiniz kimi, bu əsl osiloskopun yerini tutmur:-).

Bunu ciddi şəkildə istifadə etməyi planlaşdırmadığım üçün bunun üçün çaplı bir elektron kart hazırlamayacağam. Bəlkə də, bəlkə də onu mükəmməl bir lövhəyə qoyacağam, amma indiyə qədər çörək taxtasının üstündədir və qalacaq. Həm də giriş gücləndiricisi/zəiflədicisi yoxdur, 0 və 3.3V arasında bir siqnal verməlisiniz, mənfi və ya 3.3V -dən yuxarı getməyin, çünki mikro nəzarətçiyə zərər verə bilərsiniz.

Addım 1: Avadanlıq

Ebay və ya oxşar saytlar vasitəsilə Çində hissələri aldıqda ucuz, çox ucuzdur. Təxminən 2 avroya satın aldığım "mavi həb" adlandırılan STM32F103C8 inkişaf etdirmə lövhəsi (və ya USD, demək olar ki, eyni dəyərdir, 2018-ci ilin sonu), üstündə MAX7219 çipləri olan iki ədəd 8x8x4 nöqtəli matrisli displey istifadə olunur. Bir parça 5 avro və təxminən 1 avro fırlanan bir kodlayıcı.

Əlbəttə ki, bir neçə yüz milliampda 3.3V gücündə bir enerji təchizatı lazımdır. STM32F103C8 inkişaf lövhəsindəki gərginlik tənzimləyicisi istifadə edilmir, ekranlar üçün kifayət qədər cərəyan verə bilməz. MAX7219 məlumat cədvəlində, işləmə gərginliyinin 4.0 ilə 5.5V arasında olması lazım olduğunu, ancaq 3.3V -də yaxşı işlədiyini, bəlkə də çox isti və ya soyuq bir mühitdə istifadə etdiyiniz zaman deyil, 20 Selsi dərəcəsində olması qaydasındadır. İndi mikrokontrolör və ekran lövhələri arasında səviyyə çeviricilərindən istifadə etmək məcburiyyətində deyiləm.

Addım 2: Qurmaq

Şəkilə baxdığınızda, çörək lövhələrindəki elektrik xətlərini qeyri -adi bir şəkildə istifadə etdiyimi görə bilərsiniz, yuxarıdakı hər iki xətt pozitiv, altdakı hər ikisi də yer rayıdır. Bunu etmək üçün istifadə etdiyim üsuldur və yaxşı işləyir, quruluşu çəkdiyim sxemlərə bənzəyir. Ayrıca, işlərini sürətləndirmək üçün çörək taxtasına qoşa biləcəyim hissələri olan bir çox kiçik lövhə düzəltdim və hamısı iki üst xətti pozitiv və alt sətirləri yer kimi istifadə etmək üçün qurulmuşdur. Dediyim kimi, qətnamə 4 bitdir (16 səviyyə) və bir -birinin yanında 4x8 led olduğu üçün yalnız 32 nümunə nöqtəsi (bal) var. Bunu bir Rigol Rigol DS1054Z (8 bit və 12Mpts) ilə müqayisə edin və bunun çətin bir oyuncaq olduğunu görəcəksiniz. Əsl bant genişliyi nədir, bilmirəm, 10 kHz -ə qədər sınadım və bu yaxşı işləyir.

Addım 3: Proqramlar

İstifadə etdiyim IDE, bu ilin əvvəlində (2018) ST Micro Electronics tərəfindən qəbul edilmiş və heç bir zaman məhdudiyyəti, kod ölçüsü məhdudiyyəti və nag-ekran olmayan pulsuz olaraq mövcud olan Atollic TrueStudio-dur. Bununla birlikdə, mənə başlanğıc kodu verən və bütün ətraf qurğuların işə salınmasını yaradan STM32CubeMX proqramından istifadə edirəm. Və mikrokontrolörün bütün sancaqlarını və istifadəsini göstərən bir ekrana malikdir. Kod yaratmaq üçün STM32CubeMX istifadə etməsəniz belə, bu çox rahatdır. İstəmədiyim bir şey STM32CubeMX -in standartı olan HAL adlanır. LowLayer iş üsuluna üstünlük verirəm.

Mikro nəzarətçini proqramlaşdırmaq üçün ya ST Micro Electronics-dən ST-Link proqramçı/debugger və ya Segger tərəfindən hazırlanan J-Link istifadə edirəm. Hər iki cihaz da pulsuz deyil, baxmayaraq ki, Çin nüsxələrini bir neçə avroya satın ala bilərsiniz.

Addım 4: Kod haqqında

MAX7219 -un üfüqi olaraq adlandırdığım LED -lər, bir -birinin yanında 8 led. Bir osiloskop üçün 8 LED-in üst-üstə qoyulması daha asan olardı, buna görə məlumatları şaquli şəkildə yazılmış və lazımi üfüqi şəkildə oxunan sadə bir çərçivə buferi hazırladım. MAX7219, 8 LED başına 16 bit kod istifadə edir, burada ilk bayt seçilmiş xəttə müraciət etmək üçün istifadə olunur. Və bu modulların dördü bir -birinin yanında yığılmış olduğundan, girişləri modulun çıxışlarına bağlanır, son modula çatmaq üçün bu 16 biti dörd dəfə göndərməlisiniz. (Ümid edirəm hər şeyi aydınlaşdırıram …) Məlumatlar sadə, lakin çox sürətli bir protokol olan SPI istifadə edərək MAX7219 -a göndərilir. Təcrübə etdiyim budur ki, məlumatları MAX7219 -a nə qədər sürətli göndərə bilərsiniz. Sonda, məlumat cədvəlinin göstərdiyi maksimum sürətdən bir qədər aşağı olan 9 MHz -ə qayıtdım.

STM32F103C8 -in mövcud olan dörd taymerindən ikisini istifadə edirəm, biri zaman bazasının yaradılması üçün, digəri isə vaxt bazasını təyin edən fırlanan kodlayıcının oxunması üçün. TIMER3 vaxt bazası yaradır, saatı 230 -a bölməklə, sayğacı hər 3.2 uS -də yeniləməklə edir. Sayğacın sayını 2 saatdan 2000 -ə qədər vurmaq üçün seçə bilərsiniz. Deyək ki, 100 -ü seçirsiniz. TIMER3 sonra hər 320 uS -da bir hadisə yaradır. Bu TƏDBİB ADC -ni giriş siqnalının bir nümunəsini yazmağa təhrik edir və bir nümunə üçün götürülməsi lazım olan 32 nümunə olduğu üçün bu təxminən təxminən sonra tamamlanacaq. 10 mS. 10mS -də 100 Hz -lik bir dalğa uzunluğuna və ya 200 Hz -dən ikisinə uyğunlaşa bilərsiniz. Ekran başına 3 dalğadan çox keçmək dalğa formasını tanımağı çətinləşdirir.

Qalanları üçün yalnız koda istinad edə bilərəm, yalnız bir Arduino ilə təcrübəniz olsa belə bunu izləmək çətin deyil. Əslində, eyni şeyi bir Arduino ilə də edə bilərsiniz, baxmayaraq ki, "mavi bir həb" kimi sürətli işləyəcəyinə şübhə edirəm. STM32F103C8, 72 MHz -də işləyən 32 bitlik bir mikro nəzarətçidir, iki SPI ətraf qurğusuna və çox sürətli bir ADC -yə malikdir.

Addım 5: Əsas.h

#ifndef _MAIN_H _#_MAIN_H_ təyin edin

#"stm32f1xx_ll_adc.h" daxil edin

#include "stm32f1xx_ll_rcc.h" #include "stm32f1xx_ll_bus.h" #include "stm32f1xx_ll_system.h" #include "stm32f1xx_ll_exti.h" #include "stm32f1xxxl_xort_sayfası" #incm " "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

# müəyyən NVIC_PRIORITYGROUP_0 ((uint32_t) 0x00000007) # müəyyən NVIC_PRIORITYGROUP_1 ((uint32_t) 0x00000006) # müəyyən NVIC_PRIORITYGROUP_2 ((uint32_t) 0x00000005) # müəyyən NVIC_PRIORITYGROUP_3 ((uint32_t) 0x00000004) # müəyyən 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

Addım 6: Əsas c

#incl "main.h" statik boşluğu LL_Init (boşluq); boş SystemClock_Config (boş); statik boşluq MX_GPIO_Init (boş); statik boşluq MX_ADC1_Init (boş); statik boşluq MX_SPI1_Init (boş); statik boşluq MX_SPI2_Init (boş); statik boşluq MX_TIM3_Init (boş); statik boşluq MX_TIM4_Init (boş);

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); etibarsız MAX7219_1_init (); etibarsız MAX7219_2_init (); boş erase_frame_buffer (boş); void fill_frame_buffer (boş); void display_frame_buffer (boş); void set_timebase (boş);

uint8_t üst_görüntü [4] [8]; // daha çox bayt yox, heç bir şey yoxdur

uint8_t alt_görüntü [4] [8]; // çərçivə tamponunu dəyişdirin

uint8_t sample_buffer [32]; // ADC nəticəsi üçün bufer

int main (boş)

{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 -un işə salınmasından bir müddət sonra lazımdır

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

vaxt (1)

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

boş erase_frame_buffer (boş)

{int8_t x; int8_t y;

üçün (x = 0; x <4; x ++) // kolom_bytes {

üçün (y = 0; y <8; y ++) // lijnen {üst_görüntü [x] [y] = 0; // bütün bitjes aşağı_display [x] [y] = 0; }}}

void fill_frame_buffer (boş)

{uint8_t y = 0; // gərginlik uint8_t tijd = 0; // onu göstər8_t ekran_byte; // atlar 8 bitdən çox deyil, həm də 4 gündən çox göstərilir;

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

y = sample_buffer [tijd];

if (y> 7) // yuxarı ekranda schrijven

{üst_display [display_byte] [15-y] | = (1 << display_bit); } başqa // aşağı ekranda schrijven {alt_display [display_byte] [7-y] | = (1 << display_bit); }}}

void display_frame_buffer (boş)

{

uint8_t y; // hər şeyi yoxlayın (hər ekran üçün) uint16_t yl; // MAX7219 nömrəsi

(y = 0; y <8; y ++) {yl = (y+1) << 8; // MAX7219, 8 bitlik üst 16 bitlik woordda

SPI2_send64 ((yl | üst_görüntü [0] [y]), (yl | üst_görüntü [1] [y]), (yl | üst_görüntü [2] [y]), (yl | yuxarı_görüntü [3] [y]));

SPI1_send64 ((yl | alt_display [0] [y]), (yl | alt_display [1] [y]), (yl | alt_görüntü [2] [y]), (yl | aşağı_östər [3] [y])); }

}

void set_timebase (boş)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

keçid (timebase_knop)

{halda 0: LL_TIM_SetAutoReload (TIM3, 1999); fasilə; hal 1: LL_TIM_SetAutoReload (TIM3, 999); fasilə; hal 2: LL_TIM_SetAutoReload (TIM3, 499); fasilə; hal 3: LL_TIM_SetAutoReload (TIM3, 199); fasilə; hal 4: LL_TIM_SetAutoReload (TIM3, 99); fasilə; hal 5: LL_TIM_SetAutoReload (TIM3, 49); fasilə; hal 6: LL_TIM_SetAutoReload (TIM3, 19); fasilə; hal 7: LL_TIM_SetAutoReload (TIM3, 9); fasilə; hal 8: LL_TIM_SetAutoReload (TIM3, 4); fasilə; hal 9: LL_TIM_SetAutoReload (TIM3, 1); fasilə;

defolt:

LL_TIM_SetAutoReload (TIM3, 99); fasilə; }}

boş MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // yox SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI1_send64 -də bağlanma (0x0000, 0x0000, 0x0000, 0x0000); // yox SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // test modu SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // bağlanma, normal iş SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // 7seg deşifr yoxdur, 64 piksel SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensivlik 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // bütün sətirlər}

boş MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // yox SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI2_send64 -də bağlanma (0x0000, 0x0000, 0x0000, 0x0000); // yox SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // test rejimi SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // bağlanma, normal əməliyyat SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // 7seg deşifr yoxdur, 64 piksel SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensivlik 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // bütün sətirlər}

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

isə (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data2);

isə (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data1);

isə (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);

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

isə (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data2);

isə (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data1);

isə (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data0);

isə (LL_SPI_IsActiveFlag_BSY (SPI2) == 1) {}

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

qaytar LL_SPI_ReceiveData16 (SPI2); }

boş ADC1_2_IRQHandler (boş)

{statik uint8_t sample_counter; uint8_t tetikleyici; statik uint8_t previous_trigger;

əgər (LL_ADC_IsActiveFlag_EOS (ADC1)! = SIFIRLA)

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

əgər ((tetikleyici == 7) && (əvvəlki_tetik <tetikleyici)) // bir çox problemi həll etsəniz… {sample_counter = 0; } previous_trigger = tetikleyici; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

statik boşluq LL_Init (boş)

{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 ();

}

boş SystemClock_Config (boş)

{LL_FLASH_SetLatency (LL_FLASH_LATENCY_2); əgər (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));

}

statik boşluq MX_ADC1_Init (boş)

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

}

statik boşluq MX_SPI1_Init (boş)

{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 və SPI_InitStruct); }

statik boşluq MX_SPI2_Init (boş)

{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); }

statik boşluq MX_TIM3_Init (boş)

{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 yenidən yüklə (TIM3);

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

statik boşluq MX_TIM4_Init (boş)

{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 yenidən yüklə (TIM4);

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

statik boşluq MX_GPIO_Init (boş)

{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 *fayl, int xətti)

{müddət (1) {}}

#ifdef USE_FULL_ASSERT

void assert_failed (uint8_t* fayl, uint32_t xətti)

{} #endif