Keturių bitų osciloskopas: 6 žingsniai

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:47

Tai įdomus projektas tik tam, kad pamatyčiau, kokiu greičiu galėčiau pastumti MAX7219 taškų matricos ekraną. Ir vietoj to, kad jis paleistų „gyvenimo žaidimą“, nusprendžiau su juo padaryti „taikymo sritį“. Kaip suprasite iš pavadinimo, tai nepakeičia tikro osciloskopo:-).

Kadangi neplanuoju to naudoti jokiu rimtu būdu, nesudarysiu jai spausdintinės plokštės. Galbūt, gal tik padėsiu jį ant lentos, bet dabar ji yra ir liks ant duonos lentos. Taip pat nėra įvesties stiprintuvo/slopintuvo, turite tiekti signalą nuo 0 iki 3,3 V, neviršykite neigiamo ar didesnio nei 3,3 V, nes galite sugadinti mikrovaldiklį.

1 žingsnis: Aparatūra

Tai pigu, labai pigu, kai perkate dalis Kinijoje per „ebay“ar panašias svetaines. Jame naudojama STM32F103C8 kūrimo plokštė, kartais vadinama „mėlyna piliulė“, kurią įsigijau už maždaug 2 eurus (arba USD, jos beveik tokios pačios vertės, 2018 m. Pabaigoje), du 8x8x4 taškinių matricų ekranai su MAX7219 lustais, nupirkti 5 eurai už gabalą ir sukamasis koduotojas - apie 1 eurą.

Žinoma, reikalingas maitinimo šaltinis, tiekiantis 3,3 V esant keliems šimtams miliamperių. Nenaudojamas STM32F103C8 kūrimo plokštės įtampos reguliatorius, jis negali tiekti pakankamai srovės ekranams. MAX7219 duomenų lape nurodyta, kad darbinė maitinimo įtampa turi būti nuo 4,0 iki 5,5 V, tačiau ji veikia gerai esant 3,3 V įtampai, galbūt ne tada, kai naudojate labai karštoje ar šaltoje aplinkoje, tačiau esant 20 laipsnių Celsijaus temperatūrai tai gerai. Ir dabar man nereikia naudoti lygio keitiklių tarp mikrovaldiklio ir ekranų.

2 žingsnis: statykite

Kai pažvelgsite į paveikslėlį, galite pastebėti, kad maitinimo linijas ant duonos lentų naudoju netradiciniu būdu, abi viršuje esančios linijos yra teigiamas bėgis, o abi apačioje - antžeminis bėgis. Taip aš esu įpratęs tai daryti ir jis veikia gerai, todėl sąranka atrodo šiek tiek labiau panaši į piešiamas schemas. Be to, aš padariau daug mažų lentų su dalimis, kurias galiu prijungti prie duonos lentos, kad pagreitintumėte reikalus, ir visos jos sukonfigūruotos taip, kad dvi viršutines linijas naudotų kaip teigiamas, o apatines - kaip žemę. Kaip sakiau, skiriamoji geba yra 4 bitai (16 lygių), o kadangi šalia yra 4x8 šviesos diodai, yra tik 32 mėginio taškai (tšk.). Palyginkite tai su „Rigol Rigol DS1054Z“(8 bitų ir 12 Mpts) ir pamatysite, kad tai vargu ar yra žaislas. Koks yra tikrasis pralaidumas, aš nežinau, aš jį išbandžiau iki 10 kHz ir tai veikia gerai.

3 žingsnis: programos

Mano naudojamas IDE yra „Atollic TrueStudio“, kurį nuo šių metų pradžios (2018 m.) Priėmė „ST Micro Electronics“ir kuris yra nemokamas, neribojamas laikas, nėra kodo dydžio apribojimų, nėra jokių ekranų. Kartu su juo naudoju STM32CubeMX - programą, kuri man suteikia pradinį kodą ir sugeneruoja visų periferinių įrenginių inicijavimą. Jame yra visų mikrovaldiklio kaiščių ir jų naudojimo ekranas. Net jei kodo generavimui nenaudojate STM32CubeMX, tai labai patogu. Vienas dalykas, kuris man nepatinka, yra vadinamasis HAL, kuris yra numatytasis STM32CubeMX. Man labiau patinka „LowLayer“darbo metodas.

Mikrovaldikliui programuoti naudoju ST-Link programuotoją/derintuvą iš ST Micro Electronics arba Segger sukurtą J-Link. Abu šie įrenginiai nėra nemokami, nors kiniškų jų kopijų galite nusipirkti už kelis eurus.

4 žingsnis: Apie kodą

MAX7219 adresas šviesos diodams, kuriuos aš vadinu horizontaliai, 8 šviesos diodai vienas šalia kito. Osciloskopui būtų buvę lengviau, kai vienas ant kito dedami 8 šviesos diodai, todėl sukūriau paprastą kadrų buferį, kuris vertikaliai surašomas su duomenimis ir nuskaitomas reikiamu horizontaliu būdu. MAX7219 naudoja 16 bitų kodą 8 šviesos diodams, kur pirmasis baitas naudojamas pasirinktai eilutei adresuoti. Ir kadangi keturi iš šių modulių yra sukrauti vienas šalia kito, o jų įvestys yra prijungtos prie modulio išėjimų prieš jį, jūs turite keturis kartus siųsti tuos 16 bitų, kad pasiektumėte paskutinį modulį. (Tikiuosi, kad viską paaiškinsiu …) Duomenys siunčiami į MAX7219 naudojant SPI - paprastą, bet labai greitą protokolą. Tai aš eksperimentavau, kaip greitai galite siųsti duomenis į MAX7219. Galų gale aš vėl perėjau prie 9 MHz, šiek tiek mažesnio už maksimalų duomenų lape nurodytą greitį.

Aš naudoju du iš keturių galimų STM32F103C8 laikmačių, vieną laiko bazės generavimui, o kitą - sukamojo kodavimo įrenginio, kuris nustato laiko bazę, skaitymui. „TIMER3“sukuria laiko bazę, padalijant laikrodį iš 230, atnaujindamas skaitiklį kas 3,2 uS. Pasukite sukamąjį kodavimo įrenginį, kurį galite pasirinkti, kad skaitiklis skaičiuotų nuo 2 laikrodžio impulsų iki 2000 laikrodžio impulsų. Tarkime, kad pasirenkate 100. Tada TIMER3 generuoja ĮVYKĮ kas 320 JAV. Šis ĮVYKIS paskatina ADC įrašyti įvesties signalo pavyzdį, o kadangi yra 32 pavyzdžiai, kurių reikia paimti vienam ekranui, tai bus baigta maždaug po. 10 mS. 10 mS galite pritaikyti vieną 100 Hz bangos ilgį arba du 200 Hz bangos ilgius ir pan. Tačiau peržengiant daugiau nei 3 bangas per ekraną, gana sunku atpažinti bangos formą.

Likusioje vietoje galiu nurodyti tik kodą, nesunku sekti, net jei turite tik tam tikrą „Arduino“patirtį. Tiesą sakant, jūs galite padaryti tą patį su „Arduino“, nors abejoju, ar jis veiktų taip greitai, kaip „mėlyna tabletė“. STM32F103C8 yra 32 bitų mikrovaldiklis, veikiantis 72 MHz dažniu, jis turi du SPI periferinius įrenginius ir labai greitą ADC.

5 žingsnis: pagrindinis.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" #include "stm32 įtraukti "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 žingsnis: pagrindinis. C

#include "main.h" static void LL_Init (void); void SystemClock_Config (negalioja); statinis negaliojimas MX_GPIO_Init (negalioja); statinis negaliojimas MX_ADC1_Init (negalioja); statinis negaliojimas MX_SPI1_Init (negalioja); statinis negaliojimas MX_SPI2_Init (negalioja); statinis negaliojimas MX_TIM3_Init (negalioja); statinis negaliojimas MX_TIM4_Init (negalioja);

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 (negalioja); void fill_frame_buffer (negalioja); void display_frame_buffer (negalioja); void set_timebase (negalioja);

uint8_t viršutinis_display [4] [8]; // vier bytes naast elkaar, acht onder elkaar

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

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

int main (niekinis)

{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 reikia šiek tiek laiko po įjungimo

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

kol (1)

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

void erase_frame_buffer (negalioja)

{int8_t x; int8_t y;

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

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

void fill_frame_buffer (negalioja)

{uint8_t y = 0; // įtampa uint8_t tijd = 0; // tijd uint8_t display_byte; // steeds 8 bits 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 = mėginio_buferis [tijd];

if (y> 7) // viršutiniame ekrane schrijven

{viršutinis_display [display_byte] [15-y] | = (1 << display_bit); } else // apatiniame ekrane schrijven {low_display [display_byte] [7-y] | = (1 << display_bit); }}}

void display_frame_buffer (negalioja)

{

uint8_t y; // acht lijnen boven elkaar (per ekraną) uint16_t yl; // lijnnummer voor de MAX7219

(y = 0; y <8; y ++) {il = (y+1) << 8; // MAX7219 heeft lijnnummer in the 8 8 bits with 16 bits woord

SPI2_send64 ((yl | viršutinis_disple [0] [y]), (yl | viršutinis_rodymas [1] [y]), (yl | viršutinis_display [2] [y]), (yl | viršutinis_display [3] [y]));

SPI1_send64 ((yl | apatinis_rodymas [0] [y]), (yl | apatinis_rodymas [1] [y]), (il | apatinis_rodymas [2] [y]), (yl | apatinis_rodymas [3] [y])); }

}

void set_timebase (negalioja)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

jungiklis (timebase_knop)

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

numatytas:

LL_TIM_SetAutoReload (TIM3, 99); pertrauka; }}

void MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI1_send64 išjungimas (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testmode off SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // išjungimas, normalus veikimas SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // nėra 7seg dekodavimo, 64 pikselių SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensyvumas 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // visos eilutės

void MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI2_send64 išjungimas (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testmode off SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // išjungimas, normalus veikimas SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // nėra 7seg dekodavimo, 64 pikselių SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensyvumas 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // visos eilutės yra}

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

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

LL_SPI_TransmitData16 (SPI1, duomenys2);

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

LL_SPI_TransmitData16 (SPI1, duomenys1);

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

LL_SPI_TransmitData16 (SPI1, duomenys0);

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

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

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

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

LL_SPI_TransmitData16 (SPI2, duomenys2);

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

LL_SPI_TransmitData16 (SPI2, duomenys1);

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

LL_SPI_TransmitData16 (SPI2, duomenys0);

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

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

return LL_SPI_ReceptData16 (SPI2); }

void ADC1_2_IRQHandler (negalioja)

{static uint8_t sample_counter; uint8_t trigeris; statinis uint8_t previous_trigger;

jei (LL_ADC_IsActiveFlag_EOS (ADC1)! = RESET)

{if (sample_counter <32) {sample_buffer [sample_counter] = LL_ADC_REG_ReadConversionData32 (ADC1) / 256; if (mėginio_skaitiklis <32) imties_skaitiklis ++; 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 = trigeris; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

static void LL_Init (negalioja)

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

{LL_FLASH_SetLatency (LL_FLASH_LATENCY_2); jei (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_Įgalinti (); 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));

}

statinis negaliojimas MX_ADC1_Init (negalioja)

{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 ir 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 ir 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 (negalioja)

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

static void MX_SPI2_Init (negalioja)

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

statinis negaliojimas MX_TIM3_Init (negalioja)

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

statinis negaliojimas MX_TIM4_Init (negalioja)

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

statinis negaliojimas MX_GPIO_Init (negalioja)

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

void _Error_Handler (char *failas, int eilutė)

{while (1) {}}

#ifdef USE_FULL_ASSERT

void assert_failed (uint8_t* failas, uint32_t eilutė)

{} #endif