Osciloskopi me katër bit: 6 hapa

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-01-30 12:23

Projectshtë një projekt argëtues vetëm për të parë se sa shpejtësi mund të shtyjë një ekran MAX7219 të matricës së pikave. Dhe në vend që ta drejtoja "lojën e jetës", vendosa të bëja një "fushë" me të. Siç do ta kuptoni nga titulli, kjo nuk është një zëvendësim për një oshiloskop të vërtetë:-).

Meqenëse nuk kam ndërmend ta përdor këtë në ndonjë mënyrë serioze, nuk do të bëj një tabelë qarku të shtypur për të. Ndoshta, thjesht ndoshta do ta vendos në një tabelë, por tani për tani është, dhe do të qëndrojë, në një pjatë. Gjithashtu nuk ka përforcues/zbutës të hyrjes, duhet të jepni një sinjal midis 0 dhe 3.3V, mos shkoni negativ ose mbi 3.3V pasi mund të dëmtoni mikrokontrolluesin.

Hapi 1: Pajisje kompjuterike

Cheapshtë e lirë, shumë e lirë kur blini pjesë në Kinë përmes ebay ose faqeve të ngjashme. Ai përdor një tabelë zhvillimi STM32F103C8, nganjëherë e quajtur një "pilulë blu" që e bleva për rreth 2 euro (ose dollarë, ato kanë pothuajse të njëjtën vlerë, deri në fund të vitit 2018), dy ekrane me matricë 8x8x4 me patate të skuqura MAX7219, të blera për 5 euro copë dhe një kodues rrotullues prej rreth 1 euro.

Nevojitet natyrisht një furnizim me energji që jep 3.3V në disa qindra miliamps. Rregullatori i tensionit në tabelën e zhvillimit STM32F103C8 nuk përdoret, nuk mund të sigurojë rrymë të mjaftueshme për ekranet. Fleta e të dhënave për MAX7219 specifikon që tensioni i furnizimit të funksionimit duhet të jetë midis 4.0 dhe 5.5V, por funksionon mirë në 3.3V, ndoshta jo kur e përdorni në një mjedis shumë të nxehtë ose të ftohtë, por në 20 Celsius është mirë. Dhe tani nuk kam pse të përdor konvertues të nivelit midis mikrokontrolluesit dhe tabelave të ekranit.

Hapi 2: Ndërtoni

Kur shikoni figurën mund të shihni se unë përdor linjat e energjisë në dërrasat e bukës në një mënyrë jo konvencionale, të dy linjat në krye janë shina pozitive dhe të dyja në fund janë hekurudha tokësore. Theshtë mënyra se si jam mësuar ta bëj dhe funksionon mirë, e bën konfigurimin të duket pak më shumë si skemat që vizatoj. Gjithashtu, unë kam bërë shumë dërrasa të vogla me pjesë në të cilat mund t'i lidh në tryezë për të shpejtuar gjërat dhe të gjitha janë të konfiguruara që të përdorin dy linjat kryesore si pozitive dhe linjat e poshtme si tokë. Siç thashë, rezolucioni është 4 bit (16 nivele), dhe meqë ka 4x8 led pranë njëri -tjetrit ka vetëm 32 pika mostër (pts). Krahasoni atë me një Rigol Rigol DS1054Z (8 bit dhe 12Mpts) dhe do të shihni se kjo vështirë se është një lodër. Cila është gjerësia e brezit, nuk e di, e kam testuar atë deri në 10kHz dhe funksionon mirë.

Hapi 3: Programet

IDE që përdor është Atollic TrueStudio i cili që nga fillimi i këtij viti (2018) u miratua nga ST Micro Electronics dhe është i disponueshëm falas, pa afat, pa limit të madhësisë së kodit, pa ekrane. Së bashku me të, unë përdor STM32CubeMX, një program që më furnizon me kodin fillestar dhe gjeneron fillimin e të gjitha pajisjeve periferike. Dhe ka një ekran të të gjitha kunjave të mikrokontrolluesit dhe përdorimit të tyre. Edhe nëse nuk përdorni STM32CubeMX për gjenerimin e kodit, kjo është shumë e dobishme. Një gjë që nuk më pëlqen është e ashtuquajtura HAL e cila është parazgjedhja e STM32CubeMX. Unë preferoj metodën LowLayer të punës.

Për të programuar mikrokontrolluesin unë përdor programuesin/korrigjuesin ST-Link nga ST Micro Electronics ose J-Link të bërë nga Segger. Të dyja këto pajisje nuk janë falas, megjithëse mund të blini kopje kineze të tyre për disa euro.

Hapi 4: Rreth Kodit

MAX7219 i drejtohet LED -ve në atë që unë e quaj një mënyrë horizontale, 8 led pranë njëri -tjetrit. Për një oshiloskop 8 LED-et njëra mbi tjetrën do të kishin qenë më të lehta, kështu që unë bëra një kornizë të thjeshtë mbrojtëse që është shkruar me të dhëna në mënyrë vertikale, dhe e lexova në mënyrën e kërkuar horizontale. MAX7219 përdor një kod 16bit për 8 LED, ku bajti i parë përdoret për të adresuar vijën e zgjedhur. Dhe meqenëse janë katër nga këto module të grumbulluara pranë njëri -tjetrit, me hyrjet e tyre të lidhura me daljet e modulit para tij, ju duhet t'i dërgoni ato 16bit katër herë për të arritur modulin e fundit. (Shpresoj se po i bëj të qarta gjërat …) Të dhënat dërgohen në MAX7219 duke përdorur SPI, një protokoll i thjeshtë por shumë i shpejtë. Kjo është ajo me të cilën po eksperimentoja, sa shpejt mund të shkoni në dërgimin e të dhënave në MAX7219. Në fund, u ktheva në 9 MHz vetëm nën shpejtësinë maksimale që përcakton fleta e të dhënave.

Unë përdor dy nga katër kohëmatësit në dispozicion të STM32F103C8, një për gjenerimin e bazës kohore dhe tjetri për leximin e kodifikuesit rrotullues, i cili përcakton bazën kohore. TIMER3 gjeneron bazën kohore, e bën atë duke e ndarë orën me 230, duke përditësuar numëruesin çdo 3.2 uS. Shtyjeni koduesin rrotullues që mund të zgjidhni për të pasur numëruesin e numëruesit nga 2 pulse të orës deri në 2000 pulse të orës. Le të themi që ju zgjidhni 100. TIMER3 pastaj gjeneron një NGJARJE çdo 320 uS. Kjo NGJARJE e nxit ADC -në të regjistrojë një mostër të sinjalit hyrës, dhe meqë janë 32 mostra që duhen marrë për një ekran, kjo do të përfundojë pas afërsisht. 10 mS Në 10mS ju mund të përshtatni një gjatësi vale prej 100 Hz, ose dy prej 200 Hz, e kështu me radhë. Kalimi mbi 3 valë për ekran e bën mjaft të vështirë njohjen e formës së valës.

Për pjesën tjetër, unë mund t'ju referoj vetëm në kod, nuk është e vështirë të ndiqni edhe nëse keni vetëm një përvojë me një Arduino. Në fakt, ju mund të bëni të njëjtën gjë me një Arduino, megjithëse dyshoj se do të funksiononte aq shpejt një "pilulë blu". STM32F103C8 është një mikrokontrollues 32bit që funksionon në 72 MHz, ka dy pajisje periferike SPI dhe një ADC shumë të shpejtë.

Hapi 5: Kryesor.h

#ifndef _MAIN_H _#përcakto _MAIN_H_

#përfshi "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 "stm32f1xx_ll_cortex.h" #include "stm32f1xx_ll_utils.h" #include "stm32f1xx_ll_pwr.h" # përfshijnë "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 _plusplus

ekstern "C" {#endif void _Error_Handler (char *, int);

#define Error_Handler () _Error_Handler (_ FILE_, _LINE_)

#ifdef _cplusplus} #endif

#endif

Hapi 6: Kryesor.c

#include "main.h" boshllëku statik LL_Init (i pavlefshëm); void SystemClock_Config (i pavlefshëm); zbrazëti statike MX_GPIO_Init (e pavlefshme); zbrazëti statike MX_ADC1_Init (e pavlefshme); zbrazëti statike MX_SPI1_Init (e pavlefshme); zbrazëti statike MX_SPI2_Init (e pavlefshme); zbrazëti statike MX_TIM3_Init (e pavlefshme); zbrazëti statike MX_TIM4_Init (e pavlefshme);

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); pavlefshme MAX7219_1_init (); pavlefshme MAX7219_2_init (); void erase_frame_buffer (void); void mbush_frame_buffer (i pavlefshëm); void display_frame_buffer (void); void set_timebase (void);

uint8_t shfaqja e sipërme [4] [8]; // vier bytes naast elkaar, acht onder elkaar

uint8_t ekrani më i ulët [4] [8]; // deze twee samen vormen de frame-buffer

uint8_t mostër_buffer [32]; // tampon për rezultatet e këtyre ADC

int kryesore (e pavlefshme)

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

LL_SPI_Anable (SPI1);

LL_SPI_Anable (SPI2);

LL_TIM_EnableCounter (TIM3);

LL_TIM_EnableCounter (TIM4);

LL_ADC_Enable (ADC1);

LL_ADC_REG_StartConversionSWStart (ADC1); LL_ADC_EnableIT_EOS (ADC1);

LL_mVonesa (500); // MAX7219 ka nevojë për ca kohë pas ndezjes

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

ndërsa (1)

{set_timebase (); erase_frame_buffer (); fill_frame_buffer (); korniza e ekranit_buffer (); }}

void erase_frame_buffer (e pavlefshme)

{int8_t x; int8_t y;

për (x = 0; x <4; x ++) // kolom_bytes {

për (y = 0; y <8; y ++) // lijnen {shfaqja e sipërme [x] [y] = 0; // alle bitjes op nul low_display [x] [y] = 0; }}}

void fill_frame_buffer (i pavlefshëm)

{uint8_t y = 0; // tension uint8_t mbush = 0; // tijd uint8_t display_byte; // kalon 8 copë më parë në datën 4 muaj më parë dhe në të ardhmen_bit display_bit;

për (tijd = 0; tijd <32; tijd ++) {display_byte = mbush / 8; bit_i ekranit = 7 - (mbush % 8);

y = mostër_buffer [mbush];

if (y> 7) // në ekranin e sipërm schrijven

{shfaqja e sipërme [shfaqja_bajt] [15-y] | = (1 << biti i shfaqjes]; } else // në ekranin e poshtëm schrijven {low_display [display_byte] [7-y] | = (1 << shfaqje_bit); }}}

void display_frame_buffer (i pavlefshëm)

{

uint8_t y; // acht lijnen boven elkaar (për ekran) uint16_t yl; // lijnnummer voor de MAX7219

për (y = 0; y <8; y ++) {yl = (y+1) << 8; // Numri MAX7219 me këmbë në pjesën e sipërme të 8 bitëve në fjala 16 bit

SPI2_send64 ((yl | shfaqja e sipërme [0] [y]), (yl | shfaqja e sipërme [1] [y]), (yl | shfaqja e sipërme [2] [y]), (yl | shfaqja e sipërme [3] [y]));

SPI1_send64 ((yl | ekrani më i ulët [0] [y]), (yl | ekrani më i ulët [1] [y]), (yl | ekrani më i ulët [2] [y]), (yl | ekrani më i ulët [3] [y])); }

}

void set_timebase (i pavlefshëm)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

kaloni (timebase_knop)

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

parazgjedhje:

LL_TIM_SetAutoReload (TIM3, 99); pushim; }}

pavlefshme MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // jo SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // mbyllje në SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // jo SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // modaliteti i testimit jashtë SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // fikje, funksionim normal SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // pa deshifrim 7seg, 64 piksele SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensiteti 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // të gjitha rreshtat ndezur}

pavlefshme MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // jo SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // mbyllje në SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // jo SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // modaliteti i testimit jashtë SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // fikje, funksionim normal SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // pa deshifrim 7seg, 64 piksele SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensiteti 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // të gjitha rreshtat ndezur}

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

ndërsa (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, të dhëna2);

ndërsa (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data1);

ndërsa (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data0);

ndërsa (LL_SPI_IsActiveFlag_BSY (SPI1) == 1) {}

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

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

ndërsa (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, të dhëna2);

ndërsa (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, të dhënat1);

ndërsa (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data0);

ndërsa (LL_SPI_IsActiveFlag_BSY (SPI2) == 1) {}

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

kthehu LL_SPI_ReceiveData16 (SPI2); }

i pavlefshëm ADC1_2_IRQHandler (i pavlefshëm)

{statike uint8_t sample_counter; uint8_t shkakton; uint8_t statike_trigger i mëparshëm;

nëse (LL_ADC_IsActiveFlag_EOS (ADC1)! = RESETO)

{if (sample_counter <32) {sample_buffer [sample_counter] = LL_ADC_REG_ReadConversionData32 (ADC1) / 256; nëse (numër_numërues <32) numërues_kampion ++; tjetër sample_counter = 0; } else {trigger = LL_ADC_REG_ReadConversionData32 (ADC1) / 256;

nëse ((shkakton == 7) && (provokuesi i mëparshëm <shkakton)) // gaat niet helemaal goed bij blokgolven… {sample_counter = 0; } previous_trigger = shkas; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

zbrazëti statike LL_Init (e pavlefshme)

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

}

i pavlefshëm SystemClock_Config (i pavlefshëm)

{LL_FLASH_SetLatency (LL_FLASH_LATENCY_2); nëse (LL_FLASH_GetLatency ()! = LL_FLASH_LATENCY_2) Error_Handler (); LL_RCC_HSE_Enable (); ndërsa (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 (); ndërsa (LL_RCC_PLL_IsReady ()! = 1); LL_RCC_SetAHBPrescaler (LL_RCC_SYSCLK_DIV_1); LL_RCC_SetAPB1Preskaler (LL_RCC_APB1_DIV_2); LL_RCC_SetAPB2Prescaler (LL_RCC_APB2_DIV_1); LL_RCC_SetSysClkSource (LL_RCC_SYS_CLKSOURCE_PLL); ndërsa (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));

}

zbrazëti statike MX_ADC1_Init (e pavlefshme)

{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. DMAT Transfer = 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);

}

zbrazëti statike MX_SPI1_Init (e pavlefshme)

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

zbrazëti statike MX_SPI2_Init (e pavlefshme)

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

zbrazëti statike MX_TIM3_Init (e pavlefshme)

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

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

zbrazëti statike MX_TIM4_Init (e pavlefshme)

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

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

zbrazëti statike MX_GPIO_Init (e pavlefshme)

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

i pavlefshëm _Error_Handler (skedari char *, linja int)

{ndërsa (1) {}}

#ifdef USE_FULL_ASSERT

void assert_failed (skedari uint8_t*, rreshti uint32_t)

{} #endif