Firebit -oscilloskop: 6 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:28

Det er et sjovt projekt bare for at se, hvor langt i hastigheder jeg kunne skubbe et MAX7219 dot matrix display. Og i stedet for at få det til at køre "livets spil", besluttede jeg mig for at lave et "omfang" med det. Som du vil forstå fra titlen, er dette ikke en erstatning for et rigtigt oscilloskop:-).

Da jeg ikke har tænkt mig at bruge dette på nogen seriøs måde, vil jeg ikke lave et printkort til det. Måske, bare måske lægger jeg det på et perf-board, men for nu er det og bliver det på et brødbræt. Der er heller ingen indgangsforstærker/dæmper. Du skal levere et signal mellem 0 og 3.3V, gå ikke negativt eller over 3.3V, da du kan beskadige mikrokontrolleren.

Trin 1: Hardware

Det er billigt, meget billigt, når du køber delene i Kina via ebay eller lignende websteder. Den bruger et STM32F103C8 udviklingsbord, nogle gange kaldet en "blå pille", som jeg købte for omkring 2 euro (eller USD, de er næsten den samme værdi, slutningen af 2018), to 8x8x4 dot-matrix displays med MAX7219 chips på, købt for 5 euro stykket og en roterende encoder på cirka 1 euro.

Naturligvis er der brug for en strømforsyning, der leverer 3,3V ved et par hundrede milliampere. Spændingsregulatoren på udviklingsbordet STM32F103C8 bruges ikke, den kan ikke levere nok strøm til skærmene. Databladet til MAX7219 angiver, at driftsspændingen skal være mellem 4,0 og 5,5 V, men det kører fint på 3,3 V, måske ikke når du bruger det i et meget varmt eller koldt miljø, men ved 20 Celsius er det fint. Og nu behøver jeg ikke at bruge niveauomformere mellem mikrokontrolleren og displaybordene.

Trin 2: Byg

Når du ser på billedet, kan du se, at jeg bruger elledningerne på brødbrædderne på en ikke -konventionel måde, begge linjer på toppen er den positive skinne, og begge i bunden er jordskinnen. Det er den måde, jeg er vant til at gøre det på, og det fungerer godt, det får opsætningen til at ligne lidt mere det skema, jeg tegner. Jeg har også lavet en masse små brædder med dele på, som jeg kan tilslutte til brødbrættet for at fremskynde tingene, og de er alle konfigureret til at bruge de to øverste linjer som positive og de nederste linjer som jorden. Som sagt er opløsningen 4 bit (16 niveauer), og da der er 4x8 lysdioder ved siden af hinanden, er der kun 32 prøvepunkter (pts). Sammenlign det med en Rigol Rigol DS1054Z (8 bit og 12Mpts), og du vil se, at dette næppe er et legetøj. Hvad den egentlige båndbredde er, ved jeg ikke, jeg har testet det op til 10kHz, og det fungerer fint.

Trin 3: Programmer

Den IDE, jeg bruger, er Atollic TrueStudio, der fra begyndelsen af dette år (2018) blev vedtaget af ST Micro Electronics og er tilgængelig gratis, ingen tidsbegrænsning, ingen kodestørrelsesgrænse, ingen nag-skærme. Sammen med det bruger jeg STM32CubeMX, et program, der forsyner mig med startkoden og genererer initialiseringen af alle eksterne enheder. Og den har en visning af alle stifterne på mikrokontrolleren og deres anvendelse. Selvom du ikke bruger STM32CubeMX til at generere kode, er dette meget praktisk. En ting jeg ikke kan lide er den såkaldte HAL, som er standard for STM32CubeMX. Jeg foretrækker LowLayer -arbejdsmetoden.

For at programmere mikrokontrolleren bruger jeg enten ST-Link programmer/debugger fra ST Micro Electronics eller J-Link lavet af Segger. Begge disse enheder er ikke gratis, selvom du kan købe kinesiske kopier af dem for et par euro.

Trin 4: Om koden

MAX7219 adresserer lysdioderne på det, jeg kalder vandret, 8 lysdioder ved siden af hinanden. For et oscilloskop ville 8 lysdioder oven på hinanden have været lettere, så jeg lavede en simpel rammebuffer, der skrives til med data på en lodret måde, og læses op på den nødvendige vandrette måde. MAX7219 bruger en 16bit kode pr. 8 lysdioder, hvor den første byte bruges til at adressere den valgte linje. Og da der er fire af disse moduler stablet ved siden af hinanden, med deres input forbundet til modulets output før det, skal du sende disse 16 bit fire gange for at nå det sidste modul. (Jeg håber, at jeg gør tingene tydelige …) Dataene sendes til MAX7219 ved hjælp af SPI, en enkel, men meget hurtig protokol. Det var det, jeg eksperimenterede med, hvor hurtigt kan du gå med at sende dataene til MAX7219. Til sidst skiftede jeg tilbage til 9 MHz lige under den maksimale hastighed, databladet angiver.

Jeg bruger to af de fire tilgængelige timere i STM32F103C8, den ene til generering af tidsbasen og den anden til at aflæse den roterende encoder, som indstiller tidsbasen. TIMER3 genererer tidsbasen, den gør det ved at dividere uret med 230, opdatere tælleren hver 3,2 uS. Heks den roterende encoder, du kan vælge for at have tælleren fra 2 urpulser op til 2000 urimpulser. Lad os sige, at du vælger 100. TIMER3 genererer derefter et EVENT hvert 320 us. Denne Hændelse udløser ADC'en til at registrere en prøve af indgangssignalet, og da der er 32 sampler, der skal tages for en skærm, vil dette blive udført efter ca. 10 mS. I 10mS kan du passe en bølgelængde på 100 Hz eller to på 200 Hz og så videre. At gå over 3 bølger pr. Skærm gør det dog ret svært at genkende bølgeformen.

For resten kan jeg kun henvise dig til koden, det er ikke svært at følge, selvom du kun har en vis erfaring med en Arduino. Faktisk kunne du lave det samme med en Arduino, selvom jeg tvivler på, at det ville fungere lige så hurtigt som en "blå pille". STM32F103C8 er en 32bit mikrokontroller, der kører ved 72 MHz, den har to SPI -perifere enheder og en meget hurtig ADC.

Trin 5: Main.h

#ifndef _MAIN_H _#definere _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" #inc._1_32.h_ #_m_xx_h_ #_mc_xx_h_ #_mc_xx_h ##inc_xx_h_ #_mc_xx_h_ #_mc_xx_h_ #mc_xx_h_ #_mc_xx_h_ #_inc_xx_h_ #_mc_xx_h_ #_inc_xx_h_ #_mc_xx_h_ #_inc_xx_h_ #_mc_xx_h_ #mc_xx_h_ #_inc_xx_h_ #_mc_xx_h_ #_mc_x_h1 #h32_xx_h inkludere "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 (_ FILE_, _LINE_)

#ifdef _cplusplus} #endif

#Afslut Hvis

Trin 6: Main. C

#include "main.h" statisk tomrum LL_Init (void); void SystemClock_Config (void); statisk tomrum MX_GPIO_Init (ugyldigt); statisk tomrum MX_ADC1_Init (ugyldigt); statisk void MX_SPI1_Init (void); statisk tomrum MX_SPI2_Init (ugyldigt); statisk tomrum MX_TIM3_Init (ugyldigt); statisk tomrum MX_TIM4_Init (ugyldigt);

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

uint8_t øvre_display [4] [8]; // vier bytes ved siden af hinanden, acht under hinanden

uint8_t lavere_display [4] [8]; // disse to samme former for frame-buffer

uint8_t sample_buffer [32]; // buffer voor de resultater af de ADC

int main (tomrum)

{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 har brug for lidt tid efter tænding

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

mens (1)

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

void erase_frame_buffer (void)

{int8_t x; int8_t y;

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

for (y = 0; y <8; y ++) // lijnen {øvre_display [x] [y] = 0; // alle bitjes på nul lavere_display [x] [y] = 0; }}}

void fill_frame_buffer (void)

{uint8_t y = 0; // spænding uint8_t tijd = 0; // tijd uint8_t display_byte; // stadig 8 bits ved siden af hinanden og det 4 maal på en linje uint8_t display_bit;

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

y = sample_buffer [tijd];

hvis (y> 7) // i øvre displayskrivning

{upper_display [display_byte] [15-y] | = (1 << display_bit); } ellers // i lavere displayskrivning {lower_display [display_byte] [7-y] | = (1 << display_bit); }}}

void display_frame_buffer (void)

{

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

for (y = 0; y <8; y ++) {yl = (y+1) << 8; // MAX7219 har en sommer i de øvre 8 bits af 16 bits ord

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

}

void set_timebase (void)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

switch (tidsbase_knop)

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

Standard:

LL_TIM_SetAutoReload (TIM3, 99); pause; }}

ugyldig MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nej SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // nedlukning på SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nej SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testtilstand fra SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // nedlukning, normal drift SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // ingen 7seg -afkodning, 64 pixels SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensitet 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // alle rækker på}

ugyldig MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nej SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // nedlukning på SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nej SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testtilstand fra SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // nedlukning, normal drift SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // ingen 7seg -afkodning, 64 pixels SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensitet 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // alle rækker på}

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

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

LL_SPI_TransmitData16 (SPI1, data2);

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

LL_SPI_TransmitData16 (SPI1, data1);

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

LL_SPI_TransmitData16 (SPI1, data0);

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

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

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

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

LL_SPI_TransmitData16 (SPI2, data2);

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

LL_SPI_TransmitData16 (SPI2, data1);

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

LL_SPI_TransmitData16 (SPI2, data0);

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

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

return LL_SPI_ReceiveData16 (SPI2); }

ugyldig ADC1_2_IRQHandler (ugyldig)

{statisk uint8_t sample_counter; uint8_t trigger; statisk uint8_t foregående_trigger;

hvis (LL_ADC_IsActiveFlag_EOS (ADC1)! = NULSTIL)

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

if ((trigger == 7) && (previous_trigger <trigger)) // gaat niet helemaal goed bij blokgolven… {sample_counter = 0; } foregående_trigger = udløser; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

statisk tomrum LL_Init (ugyldigt)

{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); hvis (LL_FLASH_GetLatency ()! = LL_FLASH_LATENCY_2) Error_Handler (); LL_RCC_HSE_Enable (); mens (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 (); mens (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); mens (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));

}

statisk tomrum MX_ADC1_Init (ugyldigt)

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

}

statisk tomrum MX_SPI1_Init (ugyldigt)

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

statisk tomrum MX_SPI2_Init (ugyldigt)

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

statisk tomrum MX_TIM3_Init (ugyldigt)

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

statisk tomrum MX_TIM4_Init (ugyldigt)

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

LL_TIM_DisableARRPreload (TIM4);

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

statisk tomrum MX_GPIO_Init (ugyldigt)

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

{mens (1) {}}

#ifdef BRUG_FULL_ASSERT

void assert_failed (uint8_t* fil, uint32_t linje)

{ } #Afslut Hvis