Štvorbitový osciloskop: 6 krokov
Štvorbitový osciloskop: 6 krokov

Obsah:

Anonim
Štvorbitový osciloskop
Štvorbitový osciloskop

Je to zábavný projekt, len vidieť, ako rýchlo som dokázal vytlačiť bodový maticový displej MAX7219. A namiesto toho, aby to hralo „hru života“, rozhodol som sa, že s ňou urobím „rozsah“. Ako z názvu pochopíte, toto nie je náhrada za skutočný osciloskop:-).

Keďže toto neplánujem nijako vážne využívať, neurobím pre to dosku s plošnými spojmi. Možno, možno to položím na dosku, ale zatiaľ je a zostane na doske. Tiež nie je žiadny vstupný zosilňovač/útlm, musíte dodávať signál medzi 0 a 3,3 V, neprechádzajte na záporné alebo nad 3,3 V, pretože by ste mohli poškodiť mikrokontrolér.

Krok 1: Hardvér

Hardvér
Hardvér
Hardvér
Hardvér
Hardvér
Hardvér

Je to lacné, veľmi lacné, keď diely nakupujete v Číne prostredníctvom ebay alebo podobných stránok. Používa vývojovú dosku STM32F103C8, niekedy nazývanú „modrá pilulka“, ktorú som kúpil za približne 2 eurá (alebo USD, majú takmer rovnakú hodnotu, koniec roku 2018), dva ihličkové displeje 8x8x4 s čipmi MAX7219 kúpené za 5 eur za kus a rotačný snímač asi 1 euro.

Potrebný je samozrejme zdroj dodávajúci 3,3 V pri niekoľko stovkách miliampérov. Regulátor napätia na vývojovej doske STM32F103C8 nie je použitý, nemôže poskytnúť dostatočný prúd pre displeje. Technický list k MAX7219 uvádza, že prevádzkové napájacie napätie by malo byť medzi 4,0 a 5,5 V, ale funguje dobre na 3,3 V, možno nie vtedy, keď ho používate vo veľmi horúcom alebo studenom prostredí, ale pri 20 stupňoch Celzia je to v poriadku. A teraz nemusím používať prevodníky úrovní medzi mikrokontrolérom a zobrazovacími doskami.

Krok 2: Zostavte

Stavať
Stavať
Stavať
Stavať
Stavať
Stavať

Keď sa pozriete na obrázok, môžete vidieť, že elektrické vedenia na doskách na pečenie používam nekonvenčným spôsobom, obidve vedenia na vrchu sú kladné a obidva v spodnej časti sú pozemné vodiče. Je to spôsob, akým som na to zvyknutý a funguje to dobre, takže nastavenie vyzerá trochu viac ako schémy, ktoré nakreslím. Tiež som vyrobil veľa malých dosiek s časťami, na ktoré sa môžem zapojiť do dosky, aby sa veci urýchlili, a všetky sú nakonfigurované tak, aby používali dve horné čiary ako pozitívne a spodné čiary ako zem. Ako som už povedal, rozlíšenie je 4 bit (16 úrovní) a keďže sú vedľa seba diódy 4x8, existuje iba 32 vzorových bodov (bodov). Porovnajte to s Rigol Rigol DS1054Z (8 bitov a 12 MP) a uvidíte, že to nie je hračka. Aká je skutočná šírka pásma, neviem, testoval som to až na 10 kHz a funguje to dobre.

Krok 3: Programy

Programy
Programy
Programy
Programy
Programy
Programy
Programy
Programy

IDE, ktoré používam, je Atollic TrueStudio, ktorý na začiatku tohto roku (2018) prijala spoločnosť ST Micro Electronics a je k dispozícii bezplatne, bez časového obmedzenia, bez obmedzenia veľkosti kódu, bez nag-obrazoviek. Spolu s ním používam program STM32CubeMX, ktorý mi dodáva štartovací kód a generuje inicializáciu všetkých periférnych zariadení. A má zobrazenie všetkých pinov mikrokontroléra a ich použitia. Aj keď na generovanie kódu nepoužívate STM32CubeMX, je to veľmi praktické. Jedna vec, ktorá sa mi nepáči, je takzvaný HAL, ktorý je predvoleným nastavením programu STM32CubeMX. Preferujem spôsob práce LowLayer.

Na programovanie mikrokontroléra používam buď programátor/debugger ST-Link od ST Micro Electronics, alebo J-Link vyrobený spoločnosťou Segger. Obe tieto zariadenia nie sú zadarmo, aj keď ich čínske kópie kúpite za pár eur.

Krok 4: O kódexe

MAX7219 -ka oslovuje LED diódy takzvaným horizontálnym spôsobom, 8 LED diód vedľa seba. V prípade osciloskopu by bolo 8 LED diód na sebe jednoduchších, a tak som urobil jednoduchú rámcovú vyrovnávaciu pamäť, do ktorej sa zapisujú údaje vertikálnym spôsobom a odčítava sa požadovaným horizontálnym spôsobom. MAX7219 používa 16 -bitový kód na 8 LED diód, kde prvý bajt slúži na adresovanie vybraného riadku. A keďže sú štyri tieto moduly uložené vedľa seba a ich vstupy sú pripojené k výstupom modulu pred ním, musíte týchto 16 bitov poslať štyrikrát, aby ste dosiahli posledný modul. (Dúfam, že objasňujem veci …) Údaje sa odosielajú do MAX7219 pomocou SPI, jednoduchého, ale veľmi rýchleho protokolu. Práve s tým som experimentoval, ako rýchlo môžete odoslať údaje do MAX7219. Nakoniec som sa vrátil späť na 9 MHz tesne pod maximálnu rýchlosť, ktorú uvádza údajový list.

Používam dva zo štyroch dostupných časovačov STM32F103C8, jeden na generovanie časovej základne a druhý na čítanie rotačného enkodéra, ktorý nastavuje časovú základňu. TIMER3 generuje časovú základňu, robí to vydelením hodín číslom 230 a aktualizáciou počítadla každých 3,2 uS. Zapnite rotačný snímač, ktorý si môžete zvoliť, aby mal počítadlo od 2 hodinových impulzov do 2 000 hodinových impulzov. Povedzme, že vyberiete 100. TIMER3 potom generuje UDÁLOSŤ každých 320 uS. Táto UDALOSŤ spustí ADC, aby zaznamenal vzorku vstupného signálu, a keďže je potrebných 32 vzoriek na jednu obrazovku, dokončí sa to približne. 10 mS. Do 10 mS sa zmestí jedna vlnová dĺžka 100 Hz alebo dve 200 Hz atď. Pri prechode cez 3 vlny na obrazovku je však pomerne ťažké rozpoznať priebeh.

Vo zvyšku vás môžem len odkázať na kód, nie je ťažké ho dodržať, aj keď máte s Arduinom iba určité skúsenosti. V skutočnosti môžete to isté urobiť s Arduinom, aj keď pochybujem, že by to fungovalo tak rýchlo ako „modrá pilulka“. STM32F103C8 je 32bitový mikrokontrolér bežiaci na frekvencii 72 MHz, má dve periférie SPI a veľmi rýchly ADC.

Krok 5: Main.h

#ifndef _MAIN_H _#define _MAIN_H_

#include "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_ st_321 zahrnúť "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

#koniec Ak

Krok 6: Main.c

#include "main.h" static prázdno LL_Init (neplatné); neplatný SystemClock_Config (neplatný); statická prázdnota MX_GPIO_Init (prázdna); statická prázdnota MX_ADC1_Init (prázdna); statická prázdnota MX_SPI1_Init (prázdna); statická prázdnota MX_SPI2_Init (prázdna); statická prázdnota MX_TIM3_Init (prázdna); statická prázdnota MX_TIM4_Init (prázdna);

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); neplatné MAX7219_1_init (); neplatné MAX7219_2_init (); neplatné erase_frame_buffer (neplatné); neplatné fill_frame_buffer (neplatné); void display_frame_buffer (neplatné); neplatné set_timebase (neplatné);

uint8_t horný_displej [4] [8]; // vier bytes naast elkaar, acht onder elkaar

uint8_t nižší_displej [4] [8]; // deze twee samen vormen de frame-buffer

uint8_t sample_buffer [32]; // vyrovnávacia pamäť pre ADC

int main (prázdny)

{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 určitý čas po zapnutí

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

zatiaľ čo (1)

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

void erase_frame_buffer (neplatné)

{int8_t x; int8_t y;

pre (x = 0; x <4; x ++) // kolom_bytes {

for (y = 0; y <8; y ++) // lijnen {upper_display [x] [y] = 0; // všetky veľkosti bitov sa nezobrazia nižšie_zobrazenie [x] [y] = 0; }}}

void fill_frame_buffer (neplatné)

{uint8_t y = 0; // napätie uint8_t tijd = 0; // tijd uint8_t display_byte; // oci 8 bitov naast elkaar en dat 4 maal op een lijn uint8_t display_bit;

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

y = sample_buffer [tijd];

if (y> 7) // v hornom zobrazení schrijven

{upper_display [display_byte] [15-r] | = (1 << display_bit); } else // v spodnom zobrazení schrijven {lower_display [display_byte] [7-y] | = (1 << display_bit); }}}

void display_frame_buffer (neplatné)

{

uint8_t y; // acht lijnen boven elkaar (per display) uint16_t yl; // maximálna životnosť MAX7219

pre (y = 0; y <8; y ++) {yl = (y+1) << 8; // MAX7219 výškových formátov v horných 8 bitoch na 16 bitových slov

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

SPI1_send64 ((yl | nižší_ displej [0] [y]), (yl | nižší_ displej [1] [y]), (yl | nižší_ displej [2] [y]), (yl | nižší_ displej [3] [y])); }

}

neplatné set_timebase (neplatné)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

prepnúť (timebase_knop)

{prípad 0: LL_TIM_SetAutoReload (TIM3, 1999); prestávka; prípad 1: LL_TIM_SetAutoReload (TIM3, 999); prestávka; prípad 2: LL_TIM_SetAutoReload (TIM3, 499); prestávka; prípad 3: LL_TIM_SetAutoReload (TIM3, 199); prestávka; prípad 4: LL_TIM_SetAutoReload (TIM3, 99); prestávka; prípad 5: LL_TIM_SetAutoReload (TIM3, 49); prestávka; prípad 6: LL_TIM_SetAutoReload (TIM3, 19); prestávka; prípad 7: LL_TIM_SetAutoReload (TIM3, 9); prestávka; prípad 8: LL_TIM_SetAutoReload (TIM3, 4); prestávka; prípad 9: LL_TIM_SetAutoReload (TIM3, 1); prestávka;

predvolené:

LL_TIM_SetAutoReload (TIM3, 99); prestávka; }}

zrušiť MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // vypnutie na SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testovací režim vypnutý SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // vypnutie, normálna prevádzka SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // žiadne 7seg dekódovanie, 64 pixelov SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intenzita 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // všetky riadky sú zapnuté}

zrušiť MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // vypnutie na SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testovací režim vypnutý SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // vypnutie, normálna prevádzka SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // žiadne 7seg dekódovanie, 64 pixelov SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intenzita 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // všetky riadky sú zapnuté}

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

vrátiť 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);

vrátiť LL_SPI_ReceiveData16 (SPI2); }

neplatný ADC1_2_IRQHandler (prázdny)

{static uint8_t sample_counter; uint8_t spúšťač; static uint8_t previous_trigger;

if (LL_ADC_IsActiveFlag_EOS (ADC1)! = RESET)

{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)) // gaat niet helemaal goed bij blockgolven… {sample_counter = 0; } previous_trigger = spúšťač; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

statická prázdnota LL_Init (prázdna)

{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 (neplatné)

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

}

statická prázdnota MX_ADC1_Init (prázdna)

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

}

statická prázdnota MX_SPI1_Init (prázdna)

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

statická prázdnota MX_SPI2_Init (prázdna)

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

statická prázdnota MX_TIM3_Init (prázdna)

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

statická prázdnota MX_TIM4_Init (prázdna)

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

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

statická prázdnota MX_GPIO_Init (prázdna)

{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 *file, int line)

{while (1) {}}

#ifdef USE_FULL_ASSERT

neplatné assert_failed (súbor uint8_t*, riadok uint32_t)

{ } #koniec Ak