Štiri bitni osciloskop: 6 korakov

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:05

To je projekt za zabavo, samo zato, da vidim, kako daleč bi lahko pri hitrostih potisnil matrični zaslon MAX7219. Namesto da bi vodil "igro življenja", sem se odločil, da z njo naredim "obseg". Kot boste razumeli iz naslova, to ni zamenjava za pravi osciloskop:-).

Ker tega ne nameravam uporabljati na resen način, zanj ne bom izdelal tiskanega vezja. Mogoče, samo morda ga bom dal na desko, ampak zaenkrat je in bo ostal na krovu. Prav tako ni vhodnega ojačevalnika/dušilca, oddajati morate signal med 0 in 3,3 V, ne puščajte negativnega ali preko 3,3 V, saj lahko poškodujete mikrokrmilnik.

1. korak: Strojna oprema

Je poceni, zelo poceni, ko dele kupujete na Kitajskem prek ebaya ali podobnih spletnih mest. Uporablja razvojno ploščo STM32F103C8, včasih imenovano tudi "modra tabletka", ki sem jo kupil za približno 2 evra (ali USD, skoraj enaka vrednost, konec leta 2018), dva matrična zaslona 8x8x4 z čipi MAX7219, kupljena za 5 evrov za kos in rotacijski dajalnik približno 1 evro.

Seveda je potreben napajalnik, ki oddaja 3.3V pri nekaj sto miliamperih. Regulator napetosti na razvojni plošči STM32F103C8 se ne uporablja, ne more zagotoviti dovolj toka za zaslone. Podatkovni list za MAX7219 določa, da mora biti delovna napajalna napetost med 4,0 in 5,5 V, vendar deluje dobro pri 3,3 V, morda ne, če ga uporabljate v zelo vročem ali hladnem okolju, vendar je pri 20 Celzija v redu. In zdaj mi ni treba uporabljati pretvornikov nivoja med mikrokrmilnikom in prikaznimi ploščami.

2. korak: Zgradite

Ko pogledate sliko, boste morda videli, da daljnovode na ploščah uporabljam na nekonvencionalen način, obe zgornji vodi sta pozitivni tirnici, obe na dnu pa talni tirnici. To je način, na katerega sem navajen, in deluje dobro, zaradi česar je nastavitev nekoliko bolj podobna shemam, ki jih narišem. Naredil sem tudi veliko majhnih plošč z deli, ki jih lahko priključim na mizo, da pospešim stvari, in vse so nastavljene tako, da dve zgornji črti uporabljata kot pozitivni, spodnje pa kot tla. Kot sem rekel, je ločljivost 4 -bitna (16 stopenj), in ker so LED diode 4x8 ena poleg druge, je le 32 vzorčnih točk (točk). Primerjajte to z Rigol Rigol DS1054Z (8 bit in 12Mpts) in videli boste, da to skoraj ni igrača. Kakšna je dejanska pasovna širina, ne vem, preizkusil sem jo do 10 kHz in to dobro deluje.

3. korak: Programi

IDE, ki ga uporabljam, je Atollic TrueStudio, ki ga je od začetka letošnjega leta (2018) prevzela družba ST Micro Electronics in je na voljo brezplačno, brez časovne omejitve, brez omejitve velikosti kode, brez zaskrbljujočih zaslonov. Skupaj z njim uporabljam program STM32CubeMX, ki mi dobavi začetno kodo in ustvari inicializacijo vseh zunanjih naprav. Ima tudi prikaz vseh zatičev mikrokrmilnika in njihove uporabe. Tudi če za ustvarjanje kode ne uporabljate STM32CubeMX, je to zelo priročno. Ne maram pa tako imenovanega HAL, ki je privzeta vrednost za STM32CubeMX. Raje imam metodo dela LowLayer.

Za programiranje mikrokrmilnika uporabljam programer/razhroščevalnik ST-Link podjetja ST Micro Electronics ali J-Link proizvajalca Segger. Obe napravi nista brezplačni, čeprav ju lahko za nekaj evrov kupite v kitajski obliki.

4. korak: O kodi

MAX7219 naslavlja LED diode na način, ki ga imenujem vodoravno, 8 LED drug poleg drugega. Za osciloskop bi bilo 8 LED-jev eno na drugi lažje, zato sem naredil enostaven okvirni vmesnik, v katerega se podatki zapisujejo navpično in odčitajo na zahtevan vodoravni način. MAX7219 uporablja 16 -bitno kodo na 8 LED, pri čemer se prvi bajt uporablja za naslavljanje izbrane vrstice. In ker so štirje od teh modulov zloženi drug poleg drugega, njihovi vhodi pa so povezani z izhodi modula pred njim, morate teh 16 bitov poslati štirikrat, da pridete do zadnjega modula. (Upam, da razčistim stvari …) Podatki se pošljejo v MAX7219 s pomočjo preprostega, a zelo hitrega protokola SPI. S tem sem eksperimentiral, kako hitro lahko pošljete podatke na MAX7219. Na koncu sem se vrnil na 9 MHz tik pod največjo hitrostjo, ki jo določa podatkovni list.

Uporabljam dva od štirih razpoložljivih časovnikov STM32F103C8, enega za generiranje časovne baze in drugega za branje rotacijskega dajalnika, ki nastavi časovno os. TIMER3 ustvari časovno bazo, to stori tako, da uro deli z 230, posodobi števec vsakih 3,2 uS. S pomočjo vrtljivega dajalnika lahko izberete, da števec šteje od 2 taktnih impulzov do 2000 taktnih impulzov. Recimo, da izberete 100. TIMER3 nato ustvari DOGODEK vsakih 320 uS. Ta DOGODEK sproži ADC, da zabeleži vzorec vhodnega signala, in ker je za en zaslon potrebnih 32 vzorcev, se bo to končalo po pribl. 10 mS. V 10 mS lahko namestite eno valovno dolžino 100 Hz ali dve po 200 Hz itd. Če presežete 3 valove na zaslon, je precej težko prepoznati valovno obliko.

Za ostalo se lahko sklicujem samo na kodo, slediti ji ni težko, tudi če imate le nekaj izkušenj z Arduinom. Pravzaprav bi lahko isto naredili z Arduinom, čeprav dvomim, da bi tako hitro deloval kot "modra tabletka". STM32F103C8 je 32 -bitni mikrokrmilnik, ki deluje na 72 MHz, ima dve zunanji enoti SPI in zelo hiter ADC.

5. korak: Main.h

#ifndef _MAIN_H _#definiraj _MAIN_H_

#include "stm32f1xx_ll_adc.h"

#include "stm32f1xx_ll_rcc.h" #include "stm32f1xx_ll_system.h" #include "stm32f1xx_ll_xxxxxxxxxxxxxx" xx include "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

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

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

#ifdef _cplusplus} #endif

#endif

6. korak: Main.c

#include "main.h" static void LL_Init (void); void SystemClock_Config (void); statična praznina MX_GPIO_Init (void); statična praznina MX_ADC1_Init (void); statična praznina MX_SPI1_Init (void); statična praznina MX_SPI2_Init (void); statična praznina MX_TIM3_Init (void); statična praznina MX_TIM4_Init (void);

uint16_t SPI1_send64 (uint16_t podatki3, uint16_t podatki2, uint16_t podatki1, uint16_t podatki0);

uint16_t SPI2_send64 (uint16_t podatki3, uint16_t podatki2, uint16_t podatki1, uint16_t podatki0); void MAX7219_1_init (); void MAX7219_2_init (); void erase_frame_buffer (void); void fill_frame_buffer (void); void display_frame_buffer (void); void set_timebase (void);

uint8_t zgornji_zaslon [4] [8]; // vier bytes naast elkaar, acht onder elkaar

uint8_t spodnji_zaslon [4] [8]; // deze twee samen vormen de frame-buffer

uint8_t vzorec_pomnilnika [32]; // vmesni pomnilnik za rezultate ADC

int main (void)

{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 potrebuje nekaj časa po vklopu

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

medtem ko (1)

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

void erase_frame_buffer (void)

{int8_t x; int8_t y;

za (x = 0; x <4; x ++) // kolom_bajtov {

za (y = 0; y <8; y ++) // lijnen {zgornji_zaslon [x] [y] = 0; // vse bitne vrednosti nižje_displej [x] [y] = 0; }}}

void fill_frame_buffer (void)

{uint8_t y = 0; // napetost uint8_t tijd = 0; // tijd uint8_t display_byte; // steeds 8 bits naast elkaar en dat 4 maal op een lijn uint8_t display_bit;

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

y = medpomnilnik vzorca [tijd];

if (y> 7) // v zgornjem zaslonu schrijven

{zgornji_zaslon [prikaz_bajta] [15-y] | = (1 << prikaz_bit); } else // v spodnjem zaslonu schrijven {lower_display [display_byte] [7-y] | = (1 << display_bit); }}}

void display_frame_buffer (void)

{

uint8_t y; // acht lijnen boven elkaar (na zaslon) uint16_t yl; // lijnnummer voor de MAX7219

za (y = 0; y <8; y ++) {yl = (y+1) << 8; // MAX7219 višje število v zgornjih 8 bitih od 16 bitov

SPI2_send64 ((yl | zgornji_zaslon [0] [y]), (yl | zgornji_zaslon [1] [y]), (yl | zgornji_zaslon [2] [y]), (yl | zgornji_zaslon [3] [y]));

SPI1_send64 ((yl | lower_display [0] [y]), (yl | lower_display [1] [y]), (yl | lower_display [2] [y]), (yl | lower_display [3] [y])); }

}

void set_timebase (void)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

stikalo (timebase_knop)

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

privzeto:

LL_TIM_SetAutoReload (TIM3, 99); prekiniti; }}

void MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // zaustavitev na SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // preskusni način izklopljen SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // izklop, normalno delovanje SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // brez dekodiranja 7 seg, 64 slikovnih pik SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intenzivnost 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // vse vrstice na}

void MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // zaustavitev na SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // preskusni način izklopljen SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // izklop, normalno delovanje SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // brez dekodiranja 7 seg, 64 slikovnih pik SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intenzivnost 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // vse vrstice na}

uint16_t SPI1_send64 (uint16_t podatki3, uint16_t podatki2, uint16_t podatki1, uint16_t podatki0)

{LL_GPIO_ResetOutputPin (GPIOA, LL_GPIO_PIN_4);

LL_SPI_TransmitData16 (SPI1, data3);

medtem ko (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data2);

medtem ko (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data1);

medtem ko (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data0);

medtem ko (LL_SPI_IsActiveFlag_BSY (SPI1) == 1) {}

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

vrni LL_SPI_ReceiveData16 (SPI1); }

uint16_t SPI2_send64 (uint16_t podatki3, uint16_t podatki2, uint16_t podatki1, uint16_t podatki0)

{LL_GPIO_ResetOutputPin (GPIOB, LL_GPIO_PIN_12);

LL_SPI_TransmitData16 (SPI2, data3);

medtem ko (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data2);

medtem ko (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data1);

medtem ko (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data0);

medtem ko (LL_SPI_IsActiveFlag_BSY (SPI2) == 1) {}

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

vrni LL_SPI_ReceiveData16 (SPI2); }

void ADC1_2_IRQHandler (void)

{static uint8_t sample_counter; sprožilec uint8_t; static uint8_t previous_trigger;

če (LL_ADC_IsActiveFlag_EOS (ADC1)! = RESET)

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

if ((sprožilec == 7) && (prejšnji_triger <sprožilec)) // gaat niet helemaal goed bij blokgolven… {sample_counter = 0; } prejšnji_sprožilec = sprožilec; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

statična praznina LL_Init (void)

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

}

void SystemClock_Config (void)

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

}

statična praznina MX_ADC1_Init (void)

{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 in & 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 in & 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 in & ADC_REG_InitStruct);

LL_ADC_SetChannelSamplingTime (ADC1, LL_ADC_CHANNEL_0, LL_ADC_SAMPLINGTIME_41CYCLES_5);

}

statična praznina MX_SPI1_Init (void)

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

statična praznina MX_SPI2_Init (void)

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

statična praznina MX_TIM3_Init (void)

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

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

statična praznina MX_TIM4_Init (void)

{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 in & 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_DisableARRPreload (TIM4);

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

statična praznina MX_GPIO_Init (void)

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

void _Error_Handler (char *datoteka, int vrstica)

{while (1) {}}

#ifdef USE_FULL_ASSERT

void assert_failed (datoteka uint8_t*, vrstica uint32_t)

{} #endif