Nelja bitine ostsilloskoop: 6 sammu

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:49

See on lõbustusprojekt, et näha, kui kaugele suudan MAX7219 punktmaatriksekraani lükata. Ja selle asemel, et lasta sellel "elumängu" juhtida, otsustasin sellega "ulatuse" teha. Nagu pealkirjast aru saate, ei asenda see päris ostsilloskoopi:-).

Kuna ma ei kavatse seda tõsiselt kasutada, ei hakka ma selle jaoks trükkplaati tegema. Võib-olla, lihtsalt võib-olla panen ma selle tahvlile, kuid praegu on see ja jääb leivaplaadile. Samuti puudub sisendvõimendi/summuti, peate andma signaali vahemikus 0 kuni 3,3 V, ärge minge negatiivseks ega üle 3,3 V, kuna võite mikrokontrollerit kahjustada.

Samm: riistvara

See on odav, väga odav, kui ostate osi Hiinast ebay või sarnaste saitide kaudu. See kasutab STM32F103C8 arendusplaati, mida mõnikord nimetatakse ka "siniseks pilliks" ja mille ostsin umbes 2 euro eest (või USD, need on peaaegu sama väärtusega, 2018. aasta lõpus), kahte 8x8x4 punktmaatriksekraani, millel on MAX7219 kiibid, ostetud 5 eurot tükk ja pöörlev kodeerija umbes 1 euro.

Loomulikult on vaja toiteallikat, mis annab mõnesaja milliamperi juures 3,3 V toite. Arenguplaadi STM32F103C8 pingeregulaatorit ei kasutata, see ei suuda kuvaritele piisavalt voolu pakkuda. MAX7219 andmeleht täpsustab, et tööpinge peaks olema vahemikus 4,0–5,5 V, kuid see töötab hästi 3,3 V korral, võib -olla mitte siis, kui kasutate seda väga kuumas või külmas keskkonnas, kuid 20 kraadi juures on see hea. Ja nüüd ei pea ma kasutama nullmuundureid mikrokontrolleri ja näidikute vahel.

2. samm: ehitage

Kui vaatate pilti, võite näha, et kasutan leivaplaatidel olevaid elektriliine mittetraditsioonilisel viisil, mõlemad peal olevad jooned on positiivne rööbas ja mõlemad alumised on rööp. Olen harjunud seda tegema ja see toimib hästi, see muudab seadistuse natuke sarnasemaks minu joonistatud skeemidega. Samuti olen teinud palju väikeseid tahvleid, millel on osad, mille saab asjade kiirendamiseks leivaplaadiga ühendada ja need kõik on konfigureeritud kasutama kahte ülemist joont positiivse ja alumist joont maapinnana. Nagu ma ütlesin, on eraldusvõime 4 bitti (16 taset) ja kuna kõrvuti on 4x8 LED -i, on vaid 32 proovipunkti (punkti). Võrrelge seda Rigol Rigol DS1054Z -ga (8 bitti ja 12 Mpts) ja näete, et see on vaevalt mänguasi. Mis on tegelik ribalaius, seda ma ei tea, olen seda testinud kuni 10 kHz ja see töötab hästi.

3. samm: programmid

IDE, mida ma kasutan, on Atollic TrueStudio, mille selle aasta (2018) seisuga võttis kasutusele ST Micro Electronics ja mis on saadaval tasuta, ilma ajapiiranguta, ilma koodisuuruse piiranguta ja ilma ekraanideta. Koos sellega kasutan programmi STM32CubeMX, mis annab mulle lähtekoodi ja genereerib kõigi välisseadmete lähtestamise. Ja sellel on ekraan kõikidest mikrokontrolleri tihvtidest ja nende kasutamisest. Isegi kui te ei kasuta koodi genereerimiseks STM32CubeMX -i, on see väga mugav. Üks asi, mis mulle ei meeldi, on nn HAL, mis on STM32CubeMX vaikimisi. Eelistan LowLayer töömeetodit.

Mikrokontrolleri programmeerimiseks kasutan kas ST-Linki programmeerijat/silurit ST Micro Electronicsist või Seggeri valmistatud J-Linki. Mõlemad seadmed ei ole tasuta, kuigi nende hiinakeelseid koopiaid saab osta mõne euro eest.

Samm 4: Teave koodi kohta

MAX7219 aadress suunab LED -e horisontaalselt, 8 LED -i kõrvuti. Ostsilloskoobi jaoks oleks 8 LED-i üksteise peal olnud lihtsam, nii et tegin lihtsa kaadripuhvri, mis on vertikaalselt andmetega kirjutatud ja vajalikul horisontaalsel viisil ette loetud. MAX7219 kasutab 16 LED -koodi 8 LED -i kohta, kus esimest baiti kasutatakse valitud rea aadressiks. Ja kuna neid mooduleid on üksteise kõrvale laotud neli ja nende sisendid on enne seda mooduli väljunditega ühendatud, siis tuleb need 16 bitti neli korda saata, et jõuda viimase moodulini. (Loodan, et teen asjad selgeks …) Andmed saadetakse MAX7219 -le, kasutades lihtsat, kuid väga kiiret protokolli. Seda ma katsetasin, kui kiiresti saate andmeid MAX7219 -le saata. Lõpuks lülitusin tagasi 9 MHz -le, mis on veidi alla andmelehe määratud maksimaalse kiiruse.

Kasutan kahte STM32F103C8 neljast saadaolevast taimerist, ühte ajabaasi genereerimiseks ja teist pöörleva kodeerija lugemiseks, mis määrab ajabaasi. TIMER3 loob ajabaasi, jagades kella 230 -ga, uuendades loendurit iga 3,2 uS järel. Lülitage pöördkodeerija sisse, et loendurid loeksid 2 kellaimpulssi kuni 2000 kellaimpulssi. Oletame, et valite 100. TIMER3 genereerib seejärel Sündmuse iga 320 USA kohta. See SÜNDMUS käivitab ADC sisendsignaali näidise salvestamise ja kuna ühe ekraanitäie jaoks tuleb võtta 32 proovi, lõpeb see pärast ligikaudu. 10 mS. 10mS mahub üks lainepikkus 100 Hz või kaks 200 Hz jne. Kuid üle 3 laine ekraani kohta muudab lainekuju äratundmise üsna raskeks.

Ülejäänud osas võin teile viidata ainult koodile, seda pole raske järgida, isegi kui teil on ainult Arduinoga kogemusi. Tegelikult võiks sama asja teha ka Arduinoga, kuigi ma kahtlen, et see "sinise pillina" sama kiiresti toimiks. STM32F103C8 on 32 -bitine mikrokontroller, mis töötab sagedusel 72 MHz, sellel on kaks SPI välisseadet ja väga kiire ADC.

Samm 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 "stm32 #stll32 kaasata "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

Samm 6: Main.c

#include "main.h" staatiline void LL_Init (tühine); tühine SystemClock_Config (tühine); staatiline tühine MX_GPIO_Init (tühine); staatiline tühine MX_ADC1_Init (tühine); staatiline tühine MX_SPI1_Init (tühine); staatiline tühine MX_SPI2_Init (tühine); staatiline tühine MX_TIM3_Init (tühine); staatiline tühine MX_TIM4_Init (tühine);

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

uint8_t ülemine_kuva [4] [8]; // vier bytes naast elkaar, acht onder elkaar

uint8_t madalam_kuva [4] [8]; // deze twee samen vormen de frame-buffer

uint8_t sample_buffer [32]; // puhver voor de resultaten van de ADC

int main (tühine)

{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 vajab pärast sisselülitamist mõnda aega

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

samas (1)

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

void erase_frame_buffer (tühine)

{int8_t x; int8_t y;

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

jaoks (y = 0; y <8; y ++) // lijnen {ülemine_kuva [x] [y] = 0; // alle bitjes op nul low_display [x] [y] = 0; }}}

void fill_frame_buffer (tühine)

{uint8_t y = 0; // pinge uint8_t tijd = 0; // tijd uint8_t display_byte; // steeds 8 bitti naast elkaar en dat 4 maal op een lijn uint8_t display_bit;

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

y = proovi_puhver [tijd];

if (y> 7) // ülemisel kuval schrijven

{ülemine_kuva [kuva_bait] [15-aastane] | = (1 << kuva_bitt); } else // alumisel kuval schrijven {low_display [display_byte] [7-y] | = (1 << display_bit); }}}

tühine display_frame_buffer (tühine)

{

uint8_t y; // acht lijnen boven elkaar (kuvari kohta) uint16_t yl; // lijnnummer voor de MAX7219

(y = 0; y <8; y ++) {üül = (y+1) << 8; // MAX7219 heeft lijnnummer in 8 bit bit, 16 bitti

SPI2_send64 ((üül | ülemine_kuva [0] [y]), (üül | ülemine_kuva [1] [y]), (üül | ülemine_kuva [2] [y]), (üül | ülemine_kuva [3] [y]));

SPI1_send64 ((üül | alumine_kuva [0] [y]), (üül | alumine_kuva [1] [y]), (üül | alumine_kuva [2] [y]), (üül | alumine_kuva [3] [y])); }

}

void set_timebase (tühine)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

lüliti (timebase_knop)

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

vaikimisi:

LL_TIM_SetAutoReload (TIM3, 99); murda; }}

tühine MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI1_send64 väljalülitamine (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testmode off SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // väljalülitamine, normaalne töö SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // puudub 7seg dekodeerimine, 64 pikslit SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensiivsus 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // kõik read sees}

tühine MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI2_send64 väljalülitamine (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testmode off SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // väljalülitamine, normaalne töö SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // puudub 7seg dekodeerimine, 64 pikslit SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensiivsus 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // kõik read sees}

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

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

LL_SPI_TransmitData16 (SPI1, andmed2);

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

LL_SPI_TransmitData16 (SPI1, andmed1);

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

LL_SPI_TransmitData16 (SPI1, andmed0);

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

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

tagasta LL_SPI_ReceptData16 (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, andmed3);

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

LL_SPI_TransmitData16 (SPI2, andmed2);

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

LL_SPI_TransmitData16 (SPI2, andmed1);

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

LL_SPI_TransmitData16 (SPI2, andmed0);

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

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

tagasta LL_SPI_ReceptData16 (SPI2); }

tühine ADC1_2_IRQHandler (tühine)

{staatiline uint8_t proovi_loendur; uint8_t päästik; staatiline 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 (proovi_loendur <32) proovi_loendur ++; muu proovi_loendur = 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 = päästik; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

staatiline tühine LL_Init (tühine)

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

}

tühine SystemClock_Config (tühine)

{LL_FLASH_SetLatency (LL_FLASH_LATENCY_2); kui (LL_FLASH_GetLatency ()! = LL_FLASH_LATENCY_2) Error_Handler (); LL_RCC_HSE_Luba (); samas (LL_RCC_HSE_IsReady ()! = 1); LL_RCC_PLL_ConfigDomain_SYS (LL_RCC_PLLSOURCE_HSE_DIV_1, LL_RCC_PLL_MUL_9); LL_RCC_PLL_Luba (); samas (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); samas (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));

}

staatiline tühine MX_ADC1_Init (tühine)

{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 ja 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 ja & ADC_InitStruct);

ADC_CommonInitStruct. Multimode = LL_ADC_MULTI_INDEPENDENT;

LL_ADC_CommonInit (_ LL_ADC_COMMON_INSTANCE (ADC1) ja & 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);

}

staatiline tühine MX_SPI1_Init (tühine)

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

staatiline tühine MX_SPI2_Init (tühine)

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

staatiline tühine MX_TIM3_Init (tühine)

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

staatiline tühine MX_TIM4_Init (tühine)

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

LL_TIM_DisableARRPreload (TIM4);

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

staatiline tühine MX_GPIO_Init (tühine)

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

tühine _Error_Handler (char *fail, int rida)

{samas (1) {}}

#ifdef USE_FULL_ASSERT

void assert_failed (fail uint8_t*, rida uint32_t)

{} #endif