Čtyřbitový osciloskop: 6 kroků

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:22

Je to zábavný projekt, jen abych viděl, jak daleko v rychlostech jsem mohl tlačit na maticový displej MAX7219. A místo toho, aby to vedlo „hru života“, rozhodl jsem se s tím udělat „rozsah“. Jak z názvu pochopíte, toto není náhrada skutečného osciloskopu:-).

Jelikož to neplánuji nijak vážně využívat, nebudu pro to dělat plošný spoj. Možná, jen to možná dám na prkno, ale zatím je a zůstane na prkénku. Také zde není žádný vstupní zesilovač/útlum, musíte dodávat signál mezi 0 a 3,3 V, nepřekračujte záporný nebo přes 3,3 V, protože byste mohli poškodit mikrokontrolér.

Krok 1: Hardware

Je to levné, velmi levné, když díly kupujete v Číně přes ebay nebo podobné stránky. Používá vývojovou desku STM32F103C8, někdy nazývanou „modrou pilulku“, kterou jsem koupil za zhruba 2 eura (nebo USD, jsou téměř stejné hodnoty, konec roku 2018), dva jehličkové displeje 8x8x4 s čipy MAX7219, koupené za 5 euro za kus a rotační kodér asi 1 euro.

Potřebný je samozřejmě napájecí zdroj dodávající 3,3 V při několika stovkách miliampérů. Regulátor napětí na vývojové desce STM32F103C8 není použit, nemůže poskytnout dostatečný proud pro displeje. Datový list pro MAX7219 uvádí, že provozní napájecí napětí by mělo být mezi 4,0 a 5,5 V, ale běží dobře na 3,3 V, možná ne, když jej používáte ve velmi horkém nebo chladném prostředí, ale při 20 Celsia je to v pořádku. A teď nemusím používat převodníky úrovní mezi mikrokontrolérem a zobrazovacími panely.

Krok 2: Stavět

Když se podíváte na obrázek, můžete vidět, že elektrická vedení na prkénkách používám nekonvenčním způsobem, obě vedení nahoře jsou kladné kolejnice a obě ve spodní části jsou kolejnice na zem. Je to způsob, jakým jsem na to zvyklý, a funguje to dobře, takže nastavení vypadá trochu víc jako schémata, která kreslím. Také jsem vytvořil spoustu malých desek s díly, na které se mohu zapojit do prkénka, aby se věci urychlily, a všechny jsou nakonfigurovány tak, aby používaly dvě horní linie jako kladné a spodní čáry jako zem. Jak jsem řekl, rozlišení je 4 bitové (16 úrovní), a protože jsou vedle sebe 4x8 LED, je zde pouze 32 vzorových bodů (bodů). Porovnejte to s Rigol Rigol DS1054Z (8 bitů a 12 MP) a uvidíte, že to není žádná hračka. Jaká je skutečná šířka pásma, nevím, testoval jsem to až na 10 kHz a funguje to dobře.

Krok 3: Programy

IDE, které používám, je Atollic TrueStudio, které na začátku tohoto roku (2018) přijala společnost ST Micro Electronics a je k dispozici zdarma, bez časového omezení, bez omezení velikosti kódu, bez nag-obrazovek. Spolu s tím používám STM32CubeMX, program, který mi dodává startovací kód a generuje inicializaci všech periferií. A má zobrazení všech pinů mikrokontroléru a jejich využití. I když pro generování kódu nepoužíváte STM32CubeMX, je to velmi užitečné. Jedna věc, která se mi nelíbí, je takzvaný HAL, což je výchozí nastavení STM32CubeMX. Dávám přednost způsobu práce LowLayer.

K programování mikrokontroléru používám buď programátor/debugger ST-Link od ST Micro Electronics, nebo J-Link od společnosti Segger. Obě tato zařízení nejsou zdarma, přestože si můžete pořídit jejich čínské kopie za pár eur.

Krok 4: O kódu

MAX7219 řeší LED diody v tom, čemu říkám horizontální, 8 LED vedle sebe. Pro osciloskop by bylo snazší umístit 8 LED na sebe, a tak jsem vytvořil jednoduchý rámcový buffer, do kterého se zapisují data svisle a čte se požadovaným vodorovným způsobem. MAX7219 používá 16bitový kód na 8 LED diod, kde první bajt slouží k adresování vybrané linky. A protože jsou čtyři tyto moduly naskládány vedle sebe a jejich vstupy jsou připojeny k výstupům modulu před ním, musíte poslat těchto 16 bitů čtyřikrát, abyste dosáhli posledního modulu. (Doufám, že dávám věci jasně najevo …) Data jsou odesílána do MAX7219 pomocí SPI, jednoduchého, ale velmi rychlého protokolu. Právě s tím jsem experimentoval, jak rychle můžete odeslat data do MAX7219. Nakonec jsem přešel zpět na 9 MHz těsně pod maximální rychlost, kterou udává datový list.

Používám dva ze čtyř dostupných časovačů STM32F103C8, jeden pro generování časové základny a druhý pro čtení rotačního kodéru, který nastavuje časovou základnu. TIMER3 generuje časovou základnu, dělá to tak, že hodiny rozdělí na 230 a počítadlo aktualizuje každých 3,2 uS. Přepněte rotační kodér, který můžete vybrat, aby měl čítač počitadlo od 2 hodinových impulzů do 2 000 hodinových impulzů. Řekněme, že zvolíte 100. TIMER3 pak generuje UDÁLOST každých 320 uS. Tato UDÁLOST spustí ADC, aby zaznamenal vzorek vstupního signálu, a protože je potřeba odebrat 32 vzorků na jednu obrazovku, bude to dokončeno po přibližně. 10 mS. Do 10 mS se vejde jedna vlnová délka 100 Hz nebo dvě 200 Hz atd. Přechod přes 3 vlny na obrazovku ztěžuje rozpoznání průběhu.

Ve zbytku vás mohu odkázat pouze na kód, není těžké ho sledovat, i když máte pouze nějaké zkušenosti s Arduinem. Ve skutečnosti byste mohli udělat totéž s Arduinem, i když pochybuji, že by to fungovalo stejně rychle jako „modrá pilulka“. STM32F103C8 je 32bitový mikrokontrolér běžící na frekvenci 72 MHz, má dvě periferní zařízení SPI a velmi rychlý 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 zahrnout "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

Krok 6: Main.c

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

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 (); void erase_frame_buffer (neplatné); void 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žší_zobrazení [4] [8]; // deze twee samen vormen de frame-buffer

uint8_t sample_buffer [32]; // vyrovnávací paměť pro výsledky ADC

int main (neplatné)

{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 potřebuje nějaký čas po zapnutí

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

zatímco (1)

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

void erase_frame_buffer (neplatné)

{int8_t x; int8_t y;

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

for (y = 0; y <8; y ++) // lijnen {upper_display [x] [y] = 0; // všechny bitjes op nul lower_display [x] [y] = 0; }}}

void fill_frame_buffer (neplatné)

{uint8_t y = 0; // napětí uint8_t tijd = 0; // tijd uint8_t display_byte; // oci 8 bitů naast elkaar en dat 4 maal op een lijn uint8_t display_bit;

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

y = sample_buffer [tijd];

if (y> 7) // v horním zobrazení schrijven

{upper_display [display_byte] [15-y] | = (1 << display_bit); } else // v dolním 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; // lijnnummer voor de MAX7219

pro (y = 0; y <8; y ++) {yl = (y+1) << 8; // MAX7219 výškových lijnnummer v horních 8 bitů dodávka 16 bitů woord

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 | dolní_displej [3] [y])); }

}

neplatné set_timebase (neplatné)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

přepínač (timebase_knop)

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

výchozí:

LL_TIM_SetAutoReload (TIM3, 99); přestávka; }}

zrušit MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // vypnutí na SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testovací režim vypnutý SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // vypnutí vypnuto, normální provoz SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // žádné 7seg dekódování, 64 pixelů SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intenzita 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // všechny řádky zapnuty}

zrušit MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // vypnutí na SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testovací režim vypnutý SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // vypnutí vypnuto, normální provoz SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // žádné 7seg dekódování, 64 pixelů SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intenzita 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // všechny řádky zapnuty}

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átit 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átit LL_SPI_ReceiveData16 (SPI2); }

void ADC1_2_IRQHandler (neplatné)

{static uint8_t sample_counter; uint8_t spoušť; 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 blokgolven… {sample_counter = 0; } previous_trigger = trigger; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

statická prázdnota LL_Init (prázdná)

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

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

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

{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ázdná)

{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ázdná)

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

{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 (soubor uint8_t*, řádek uint32_t)

{} #endif