Négybites oszcilloszkóp: 6 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:42

Ez egy szórakoztató projekt, csak hogy lássam, milyen sebességgel tudnám eltolni a MAX7219 pontmátrix kijelzőt. És ahelyett, hogy az "élet játékát" futtatná, úgy döntöttem, hogy "hatókört" csinálok vele. Ahogy a címből is érthető, ez nem helyettesíti az igazi oszcilloszkópot:-).

Mivel nem tervezem ennek komoly használatát, nem fogok nyomtatott áramkört készíteni hozzá. Lehet, csak talán felrakom egy parfümtáblára, de egyelőre ez van, és marad is, egy kenyértáblán. Továbbá nincs bemeneti erősítő/csillapító, 0 és 3,3 V közötti jelet kell biztosítania, ne menjen negatívra vagy 3,3 V fölé, mert károsíthatja a mikrokontrollert.

1. lépés: Hardver

Olcsó, nagyon olcsó, ha az alkatrészeket Kínában vásárolja meg az ebay -en vagy hasonló oldalakon keresztül. STM32F103C8 fejlesztőlapot használ, amelyet néha "kék pirulának" is neveznek, és amelyet körülbelül 2 euróért (vagy USD-ért, majdnem azonos értékű, 2018 végén) vásároltam, két 8x8x4-es pontmátrixos kijelzőt, rajta MAX7219 chipekkel, vásárolt 5 euró darabonként és egy forgó kódoló körülbelül 1 euro.

Természetesen szükség van egy tápegységre, amely néhány száz milliamperen 3,3 V -ot szolgáltat. Az STM32F103C8 fejlesztőkártya feszültségszabályozóját nem használják, nem tud elegendő áramot biztosítani a kijelzők számára. A MAX7219 adatlapja előírja, hogy az üzemi tápfeszültségnek 4,0 és 5,5 V között kell lennie, de 3,3 V -on jól működik, talán nem akkor, ha nagyon meleg vagy hideg környezetben használja, de 20 Celsius -fokon rendben van. És most nem kell szintváltót használnom a mikrokontroller és a kijelzőegységek között.

2. lépés: Építsen

Ha megnézi a képet, láthatja, hogy a kenyérsütő tápvezetékeket nem hagyományos módon használom, mindkét felső vonal a pozitív sín, az alsó pedig a földi sín. Én így szoktam csinálni, és jól működik, így a beállítás kicsit jobban hasonlít az általam rajzolt rajzokra. Ezenkívül sok kis táblát készítettem olyan alkatrészekkel, amelyeket a kenyértáblához csatlakoztathatok, hogy felgyorsítsam a dolgokat, és mindegyik úgy van konfigurálva, hogy a két felső sort pozitívként, az alsó vonalakat pedig földelésként használja. Mint mondtam, a felbontás 4 bites (16 szint), és mivel 4x8 led van egymás mellett, csak 32 mintapont (pont) van. Hasonlítsa össze ezt egy Rigol Rigol DS1054Z -vel (8 bit és 12 Mpts), és látni fogja, hogy ez aligha játék. Mi a tényleges sávszélesség, nem tudom, teszteltem 10 kHz -ig, és ez jól működik.

3. lépés: Programok

Az általam használt IDE az Atollic TrueStudio, amelyet az év elején (2018) az ST Micro Electronics fogadott el, és ingyenesen, időkorlát nélkül, kódméret-korlát nélkül, nag-képernyőkön érhető el. Ezzel együtt használom az STM32CubeMX programot, amely a kezdő kóddal látja el az összes perifériát. És van egy kijelzője a mikrovezérlő összes érintkezőjéről és azok használatáról. Még ha nem is az STM32CubeMX -et használja kód generálásához, ez nagyon praktikus. Egy dolog, ami nem tetszik, az úgynevezett HAL, amely az STM32CubeMX alapértelmezettje. Inkább a LowLayer módszert használom.

A mikrokontroller programozásához vagy az ST Micro Link programozóját/hibakeresőjét használom, vagy a Segger által készített J-Linket. Mindkét eszköz nem ingyenes, bár néhány euróért kínai példányokat vásárolhat.

4. lépés: A kódról

A MAX7219 címe a LED -eket úgynevezett vízszintes módon, 8 led egymás mellett. Egy oszcilloszkóp esetében könnyebb lett volna 8 egymásra helyezett LED, ezért készítettem egy egyszerű keretpuffert, amely függőleges módon adatokkal van írva, és a szükséges vízszintes módon olvasható ki. A MAX7219 16 bites kódot használ 8 LED -enként, ahol az első bájt a kiválasztott vonal címzésére szolgál. És mivel négy ilyen modul van egymás mellett, és bemeneteik a modul kimeneteihez vannak csatlakoztatva, négyszer kell elküldeni ezeket a 16 biteket, hogy elérjék az utolsó modult. (Remélem, tisztázom a dolgokat …) Az adatok SPI -vel, egy egyszerű, de nagyon gyors protokollal kerülnek elküldésre a MAX7219 -re. Ezzel kísérleteztem, milyen gyorsan tudja elküldeni az adatokat a MAX7219 -re. Végül visszatértem 9 MHz -re, éppen az adatlap által meghatározott maximális sebesség alatt.

Az STM32F103C8 négy elérhető időzítőjéből kettőt használok, az egyik az időalap előállításához, a másik pedig az időalapot beállító forgó kódoló leolvasásához. A TIMER3 generálja az időalapot, és ezt úgy teszi meg, hogy elosztja az órát 230 -cal, és 3,2 uS -onként frissíti a számlálót. Kapcsolja be a választható forgó jeladót, hogy a számláló 2 óraimpulzus és 2000 óra közötti impulzus között legyen. Tegyük fel, hogy a 100 -at választja. A TIMER3 ezután 320 US -enként eseményt generál. Ez az ESEMÉNY arra készteti az ADC -t, hogy rögzítsen egy mintát a bemeneti jelből, és mivel 32 mintát kell venni egy képernyőképen, ez kb. 10 mS. A 10 mS -ban egy 100 Hz -es vagy két 200 Hz -es hullámhossz illeszthető be, és így tovább. Ha azonban képernyőnként 3 hullámot meghalad, meglehetősen nehéz felismerni a hullámformát.

A többiben csak a kódra hivatkozhatok, nem nehéz követni, még akkor sem, ha csak van némi tapasztalata egy Arduino -val. Valójában ugyanazt készíthetné egy Arduino -val is, bár kétlem, hogy olyan gyorsan működne, mint egy "kék pirula". Az STM32F103C8 egy 32 bites mikrokontroller, amely 72 MHz -en működik, két SPI -perifériával és egy nagyon gyors ADC -vel rendelkezik.

5. lépés: Fő.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 "stm32" #clude "stm32" 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

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

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

#ifdef _cplusplus} #endif

#endif

6. lépés: Main.c

#include "main.h" static void LL_Init (void); void SystemClock_Config (érvénytelen); static void MX_GPIO_Init (érvénytelen); static void MX_ADC1_Init (érvénytelen); static void MX_SPI1_Init (érvénytelen); static void MX_SPI2_Init (érvénytelen); static void MX_TIM3_Init (érvénytelen); static void MX_TIM4_Init (érvénytelen);

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

uint8_t felső_kijelző [4] [8]; // vier bytes naast elkaar, acht onder elkaar

uint8_t alsó_kijelző [4] [8]; // deze twee samen vormen de frame-buffer

uint8_t sample_buffer [32]; // buffer voor de resultaten van de 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); // A MAX7219 -nek szüksége van egy kis időre a bekapcsolás után

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

míg (1)

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

void erase_frame_buffer (érvénytelen)

{int8_t x; int8_t y;

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

for (y = 0; y <8; y ++) // lijnen {felső_kijelző [x] [y] = 0; // alle bitjes op nul alsó_megjelenítés [x] [y] = 0; }}}

void fill_frame_buffer (érvénytelen)

{uint8_t y = 0; // feszültség uint8_t tijd = 0; // tijd uint8_t display_byte; // steeds 8 bit 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 = minta_buffer [tijd];

if (y> 7) // a felső kijelzőn schrijven

{felső_kijelző [kijelző_bájt] [15 éves] | = (1 << kijelző_bit); } else // alsó kijelzőn schrijven {alsó_kijelző [kijelző_bájt] [7-év] | = (1 << kijelző_bit); }}}

void display_frame_buffer (érvénytelen)

{

uint8_t y; // acht lijnen boven elkaar (kijelzőnként) uint16_t yl; // lijnnummer voor de MAX7219

mert (y = 0; y <8; y ++) {il = (y+1) << 8; // MAX7219 heeft lijnnummer in felső 8 bit van 16 bit woord

SPI2_send64 ((yl | felső_kijelző [0] [y]), (il | felső_kijelző [1] [y]), (il | felső_kijelző [2] [y]), (yl | felső_kijelző [3] [y]));

SPI1_send64 ((yl | alsó_kijelző [0] [y]), (il | alsó_kijelző [1] [y]), (il | alsó_kijelző [2] [y]), (il | alsó_kijelző [3] [y])); }

}

void set_timebase (érvénytelen)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

kapcsoló (timebase_knop)

{0. eset: LL_TIM_SetAutoReload (TIM3, 1999); szünet; 1. eset: LL_TIM_SetAutoReload (TIM3, 999); szünet; 2. eset: LL_TIM_SetAutoReload (TIM3, 499); szünet; 3. eset: LL_TIM_SetAutoReload (TIM3, 199); szünet; 4. eset: LL_TIM_SetAutoReload (TIM3, 99); szünet; 5. eset: LL_TIM_SetAutoReload (TIM3, 49); szünet; 6. eset: LL_TIM_SetAutoReload (TIM3, 19); szünet; 7. eset: LL_TIM_SetAutoReload (TIM3, 9); szünet; 8. eset: LL_TIM_SetAutoReload (TIM3, 4); szünet; 9. eset: LL_TIM_SetAutoReload (TIM3, 1); szünet;

alapértelmezett:

LL_TIM_SetAutoReload (TIM3, 99); szünet; }}

void MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI1_send64 leállítása (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // tesztmód kikapcsolva az SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // kikapcsolás, normál működés SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // nincs 7seg dekódolás, 64 pixel SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intenzitás 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // minden sor bekapcsolva}

void MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI2_send64 leállítása (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // tesztmód kikapcsolva az SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // kikapcsolás, normál működés SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // nincs 7seg dekódolás, 64 pixel SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intenzitás 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // minden sor bekapcsolva}

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

míg (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, adat2);

míg (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, adat1);

míg (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, adat0);

míg (LL_SPI_IsActiveFlag_BSY (SPI1) == 1) {}

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

return LL_SPI_ReceivedData16 (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);

míg (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, adat2);

míg (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, adat1);

míg (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, adat0);

míg (LL_SPI_IsActiveFlag_BSY (SPI2) == 1) {}

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

return LL_SPI_ReceivedData16 (SPI2); }

void ADC1_2_IRQHandler (érvénytelen)

{static uint8_t minta_számláló; uint8_t trigger; statikus uint8_t előző_indító;

ha (LL_ADC_IsActiveFlag_EOS (ADC1)! = RESET)

{if (sample_counter <32) {sample_buffer [sample_counter] = LL_ADC_REG_ReadConversionData32 (ADC1) / 256; if (minta_számláló <32) mintaszámláló ++; else minta_számláló = 0; } else {trigger = LL_ADC_REG_ReadConversionData32 (ADC1) / 256;

if ((trigger == 7) && (previous_trigger <trigger)) // gaat niet helemaal goed bij blokgolven… {sample_counter = 0; } előző_indító = trigger; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

static void LL_Init (érvénytelen)

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

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

}

static void MX_ADC1_Init (érvénytelen)

{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 és & 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);

}

static void MX_SPI1_Init (érvénytelen)

{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 és & 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 és & SPI_InitStruct); }

static void MX_SPI2_Init (érvénytelen)

{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 és & 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 és & SPI_InitStruct); }

static void MX_TIM3_Init (érvénytelen)

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

static void MX_TIM4_Init (érvénytelen)

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

static void MX_GPIO_Init (érvénytelen)

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

void _Error_Handler (char *fájl, int sor)

{while (1) {}}

#ifdef USE_FULL_ASSERT

void assert_failed (uint8_t* fájl, uint32_t sor)

{} #endif