Oscilloskoop met vier bisse: 6 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:26

Dit is 'n pret-projek om net te sien hoe ver ek in 'n spoed 'n MAX7219-puntmatriks-skerm kan druk. En in plaas daarvan dat ek die 'spel van die lewe' laat loop, het ek besluit om 'n 'omvang' daarmee te maak. Soos u uit die titel sal verstaan, is dit nie 'n plaasvervanger vir 'n regte ossilloskoop nie:-).

Aangesien ek nie van plan is om dit op 'n ernstige manier te gebruik nie, sal ek nie 'n printplaat daarvoor maak nie. Miskien, miskien plaas ek dit op 'n perf-board, maar dit is en bly dit op 'n broodbord. Daar is ook geen ingangsversterker/verswakker nie; u moet 'n sein lewer tussen 0 en 3.3V, moenie negatief wees of meer as 3.3V nie, aangesien u die mikrobeheerder kan beskadig.

Stap 1: Hardeware

Dit is goedkoop, baie goedkoop as u die onderdele in China via ebay of soortgelyke webwerwe koop. Dit gebruik 'n STM32F103C8-ontwikkelbord, soms 'n 'blou pil' genoem wat ek vir ongeveer 2 euro gekoop het (of USD, dit is amper dieselfde waarde, einde 2018), twee 8x8x4 dot-matrix-skerms met MAX7219-skyfies daarop, gekoop vir 5 euro per stuk en 'n roterende encoder van ongeveer 1 euro.

Natuurlik is 'n kragtoevoer nodig wat 3,3V lewer op 'n paar honderd milliampere. Die spanningsreguleerder op die STM32F103C8 ontwikkelbord word nie gebruik nie; dit kan nie genoeg stroom vir die skerms verskaf nie. Die datablad vir die MAX7219 spesifiseer dat die voedingsspanning tussen 4.0 en 5.5V moet wees, maar dit werk goed op 3.3V, miskien nie as u dit in 'n baie warm of koue omgewing gebruik nie, maar by 20 Celsius is dit goed. En nou hoef ek nie omskakelaars tussen die mikrobeheerder en die vertoonborde te gebruik nie.

Stap 2: Bou

As u na die prentjie kyk, kan u sien dat ek die kraglyne op die broodplate op 'n nie -konvensionele manier gebruik, beide lyne bo -op die positiewe spoor en beide onderaan die grondrail. Dit is die manier waarop ek gewoond was om dit te doen, en dit werk goed; dit laat die opstelling 'n bietjie meer lyk soos die skemas wat ek teken. Ek het ook baie klein planke gemaak met dele waarop ek die broodbord kan aansluit om dinge te bespoedig, en hulle is almal ingestel om die twee boonste lyne so positief te gebruik en die onderste lyne as grond. Soos ek gesê het, is die resolusie 4 bit (16 vlakke), en daar is 4x8 leds langs mekaar, en daar is slegs 32 monsterpunte (punte). Vergelyk dit met 'n Rigol Rigol DS1054Z (8 bit en 12Mpts), en u sal sien dat dit skaars 'n speelding is. Ek weet nie wat die werklike bandwydte is nie; ek het dit tot 10 kHz getoets en dit werk goed.

Stap 3: Programme

Die IDE wat ek gebruik, is Atollic TrueStudio, wat aan die begin van hierdie jaar (2018) deur ST Micro Electronics aangeneem is en gratis beskikbaar is, geen tydsbeperking, geen kodegrootte, geen nagskerms nie. Daarmee saam gebruik ek STM32CubeMX, 'n program wat my die beginkode voorsien en die initialisering van alle randapparatuur genereer. En dit bevat 'n vertoning van al die penne van die mikrobeheerder en die gebruik daarvan. Selfs as u nie STM32CubeMX gebruik om kode te genereer nie, is dit baie handig. Een ding waarvan ek nie hou nie, is die sogenaamde HAL, wat die standaard van STM32CubeMX is. Ek verkies die lae werkmetode.

Om die mikrobeheerder te programmeer, gebruik ek óf die ST-Link programmeerder/ontfouter van ST Micro Electronics óf die J-Link gemaak deur Segger. Albei hierdie toestelle is nie gratis nie, alhoewel u Chinese kopieë daarvan vir 'n paar euro kan koop.

Stap 4: Oor die kode

Die MAX7219 spreek die LED's aan wat ek horisontaal noem, 8 LED's langs mekaar. Vir 'n ossilloskoop sou 8 LED's bo-op mekaar makliker gewees het, daarom het ek 'n eenvoudige raambuffer gemaak wat vertikaal met data geskryf is en op die vereiste horisontale manier voorgelees is. Die MAX7219 gebruik 'n 16bit -kode per 8 LED's, waar die eerste byte gebruik word om die geselekteerde lyn aan te spreek. En aangesien daar vier van hierdie modules langs mekaar gestapel is, met hul insette gekoppel aan die uitsette van die module voor dit, moet u die 16 -bits vier keer stuur om die laaste module te bereik. (Ek hoop ek maak dinge duidelik …) Die data word met behulp van SPI, 'n eenvoudige maar baie vinnige protokol, na die MAX7219 gestuur. Dit is waarmee ek geëksperimenteer het, hoe vinnig kan u die data na die MAX7219 stuur. Uiteindelik het ek teruggeskakel na 9 MHz net onder die maksimum snelheid wat die datablad spesifiseer.

Ek gebruik twee van die vier beskikbare timers van die STM32F103C8, een vir die generering van die tydsbasis en die ander vir die voorlees van die roterende enkodeerder, wat die tydsbasis bepaal. TIMER3 genereer die tydsbasis, dit word gedoen deur die klok met 230 te deel en die toonbank elke 3,2 uS by te werk. Heks die roterende encoder wat u kan kies om die teller van 2 klokpulse tot 2000 klokpulse te laat tel. Gestel u kies 100. TIMER3 genereer dan 'n GELEENTHEID elke 320 uS. Hierdie GELEENTHEID veroorsaak dat die ADC 'n monster van die insetsein opneem, en aangesien dit 32 monsters is om vir 'n skerm te neem, sal dit voltooi word na ongeveer. 10 mS. In 10mS kan u een golflengte van 100 Hz, of twee van 200 Hz, ensovoorts pas. As u oor drie golwe per skerm gaan, is dit egter moeilik om die golfvorm te herken.

Vir die res kan ek u slegs verwys na die kode; dit is nie moeilik om te volg nie, selfs al het u slegs ervaring met 'n Arduino. In werklikheid kan u dieselfde ding met 'n Arduino maak, alhoewel ek twyfel of dit so vinnig as 'n 'blou pil' sou werk. Die STM32F103C8 is 'n 32bit -mikrobeheerder wat op 72 MHz werk, dit het twee SPI -randapparatuur en 'n baie vinnige ADC.

Stap 5: Main.h

#ifndef _MAIN_H _#definieer _MAIN_H_

#sluit "stm32f1xx_ll_adc.h" in

#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" #incl_st_m_x_h_ #_in_l_h32 sluit in "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

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

#define Error_Handler () _Error_Handler (_ LêER_, _LINE_)

#ifdef _cplusplus} #endif

#endif

Stap 6: Hoof. C

#sluit 'main.h' statiese leemte LL_Init (leegte) in; leegte SystemClock_Config (leegte); statiese leemte MX_GPIO_Init (nietig); statiese leemte MX_ADC1_Init (nietig); statiese leemte MX_SPI1_Init (nietig); statiese leemte MX_SPI2_Init (nietig); statiese leemte MX_TIM3_Init (nietig); statiese leemte MX_TIM4_Init (nietig);

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); nietig MAX7219_1_init (); nietig MAX7219_2_init (); leegte wis_frame_buffer (leeg); void fill_frame_buffer (void); leegte display_frame_buffer (ongeldig); void set_timebase (void);

uint8_t upper_display [4] [8]; // vier bytes naast mekaar, acht onder mekaar

uint8_t laer_vertoning [4] [8]; // hierdie twee saamgestelde vorms van die raambuffer

uint8_t sample_buffer [32]; // buffer voor die resultate van die ADC

int main (leeg)

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

LL_SPI_Aktiveer (SPI1);

LL_SPI_Aktiveer (SPI2);

LL_TIM_EnableCounter (TIM3);

LL_TIM_EnableCounter (TIM4);

LL_ADC_Aktiveer (ADC1);

LL_ADC_REG_StartConversionSWStart (ADC1); LL_ADC_EnableIT_EOS (ADC1);

LL_mDelay (500); // MAX7219 benodig 'n rukkie nadat dit aangeskakel is

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

terwyl (1)

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

leegte wis_frame_buffer (leeg)

{int8_t x; int8_t y;

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

vir (y = 0; y <8; y ++) // lijnen {upper_display [x] [y] = 0; // alle bitjes op nul lower_display [x] [y] = 0; }}}

void fill_frame_buffer (nietig)

{uint8_t y = 0; // spanning uint8_t tyd = 0; // tyd uint8_t display_byte; // steeds 8 bits langs mekaar en dat 4 maal op 'n lyn uint8_t display_bit;

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

y = sample_buffer [tyd];

if (y> 7) // in die boonste skerm skryf

{upper_display [display_byte] [15-j] | = (1 << display_bit); } anders // in laer skerm skryf {lower_display [display_byte] [7-y] | = (1 << display_bit); }}}

leegte display_frame_buffer (nietig)

{

uint8_t y; // acht lijnen boven mekaar (per vertoning) uint16_t yl; // lijnnummer voor de MAX7219

vir (y = 0; y <8; y ++) {yl = (y+1) << 8; // MAX7219 heeft in die boonste 8 bits van 16 bits woord 'n lijnnummer

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 | lower_display [0] [y]), (yl | lower_display [1] [y]), (yl | lower_display [2] [y]), (yl | lower_display [3] [y])); }

}

leegte stel_tydsbasis (leeg)

{uint8_t tydsbasis_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

skakelaar (tydbasis_knop)

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

verstek:

LL_TIM_SetAutoReload (TIM3, 99); breek; }}

nietig MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nee SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // afsluiting op SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // toetsmodus af SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // afskakel, normale werking SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // geen 7seg -dekodeer, 64 pixels SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensiteit 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // alle rye op}

nietig MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nee SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // afsluiting op SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // toetsmodus af SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // afskakel, normale werking SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // geen 7seg -dekodeer, 64 pixels SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensiteit 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // alle rye op}

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

terwyl (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data2);

terwyl (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data1);

terwyl (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data0);

terwyl (LL_SPI_IsActiveFlag_BSY (SPI1) == 1) {}

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

stuur LL_SPI_ReceiveData16 (SPI1) terug; }

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

terwyl (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data2);

terwyl (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data1);

terwyl (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data0);

terwyl (LL_SPI_IsActiveFlag_BSY (SPI2) == 1) {}

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

stuur LL_SPI_ReceiveData16 (SPI2) terug; }

nietig ADC1_2_IRQHandler (nietig)

{statiese uint8_t sample_counter; uint8_t sneller; statiese uint8_t vorige_trigger;

as (LL_ADC_IsActiveFlag_EOS (ADC1)! = RESET)

{if (sample_counter <32) {sample_buffer [sample_counter] = LL_ADC_REG_ReadConversionData32 (ADC1) / 256; as (sample_counter <32) sample_counter ++; anders sample_counter = 0; } anders {trigger = LL_ADC_REG_ReadConversionData32 (ADC1) / 256;

if ((trigger == 7) && (previous_trigger <trigger)) // gaat helemaal goed by blokgolven… {sample_counter = 0; } vorige_trigger = sneller; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

statiese leemte LL_Init (leeg)

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

}

leegte SystemClock_Config (nietig)

{LL_FLASH_SetLatency (LL_FLASH_LATENCY_2); as (LL_FLASH_GetLatency ()! = LL_FLASH_LATENCY_2) Error_Handler (); LL_RCC_HSE_Enable (); terwyl (LL_RCC_HSE_IsReady ()! = 1); LL_RCC_PLL_ConfigDomain_SYS (LL_RCC_PLLSOURCE_HSE_DIV_1, LL_RCC_PLL_MUL_9); LL_RCC_PLL_Aktiveer (); terwyl (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); terwyl (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));

}

statiese leemte MX_ADC1_Init (nietig)

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

}

statiese leemte MX_SPI1_Init (nietig)

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

statiese leemte MX_SPI2_Init (nietig)

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

statiese leemte MX_TIM3_Init (nietig)

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

statiese leemte MX_TIM4_Init (nietig)

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

statiese leemte MX_GPIO_Init (nietig)

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

{terwyl (1) {}}

#ifdef GEBRUIK_FULL_ASSERT

ongeldig assert_failed (uint8_t* lêer, uint32_t reël)

{} #endif