Četru bitu osciloskops: 6 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:56

Tas ir izklaides projekts, lai tikai redzētu, cik lielā ātrumā es varētu nospiest MAX7219 punktu matricas displeju. Un tā vietā, lai tas vadītu “dzīves spēli”, es nolēmu ar to izveidot “vērienu”. Kā jūs sapratīsiet no nosaukuma, tas neaizstāj īstu osciloskopu:-).

Tā kā es neplānoju to izmantot nekādā nopietnā veidā, es tam neveidošu iespiedshēmas plates. Varbūt, tikai varbūt es to uzlikšu uz plātnes, bet pagaidām tā ir un paliek uz maizes dēļa. Tāpat nav ieejas pastiprinātāja/vājinātāja, jums ir jāpiegādā signāls no 0 līdz 3.3V, nekļūstiet negatīvs vai virs 3.3V, jo jūs varat sabojāt mikrokontrolleru.

1. darbība. Aparatūra

Tas ir lēts, ļoti lēts, pērkot detaļas Ķīnā, izmantojot ebay vai līdzīgas vietnes. Tas izmanto STM32F103C8 izstrādes paneli, ko dažkārt sauc par "zilo tableti", kuru iegādājos par aptuveni 2 eiro (vai USD, tās ir gandrīz vienādas vērtības, 2018. gada beigās), divus 8x8x4 punktu matricas displejus ar MAX7219 mikroshēmām, kas nopirkti par 5 eiro gabalā un rotējošais kodētājs aptuveni 1 eiro.

Protams, ir nepieciešams barošanas avots, kas piegādā 3,3 V ar dažiem simtiem miliamperu. Sprieguma regulators uz STM32F103C8 izstrādes plates netiek izmantots, tas nevar nodrošināt pietiekamu strāvu displejiem. MAX7219 datu lapā norādīts, ka strāvas padeves spriegumam jābūt no 4,0 līdz 5,5 V, bet tas darbojas labi ar 3,3 V spriegumu, iespējams, ne tad, ja to lietojat ļoti karstā vai aukstā vidē, bet 20 C temperatūrā tas ir labi. Un tagad man nav jāizmanto līmeņa pārveidotāji starp mikrokontrolleru un displeja paneļiem.

2. darbība. Veidojiet

Aplūkojot attēlu, jūs varētu redzēt, ka es izmantoju maizes dēļu elektrolīnijas netradicionālā veidā, abas līnijas augšpusē ir pozitīvā sliede, un abas apakšā ir sliedes. Tas ir veids, kā es esmu pieradis to darīt, un tas darbojas labi, tāpēc iestatījums izskatās nedaudz vairāk kā manis zīmētās shēmas. Turklāt esmu izveidojis daudz mazu dēļu ar detaļām, kuras es varu pieslēgt pie maizes dēļa, lai paātrinātu lietas, un tās visas ir konfigurētas tā, lai abas augšējās līnijas izmantotu kā pozitīvas, bet apakšējās - kā zemi. Kā jau teicu, izšķirtspēja ir 4 biti (16 līmeņi), un, tā kā blakus ir 4x8 gaismas diodes, ir tikai 32 izlases punkti (punkti). Salīdziniet to ar Rigol Rigol DS1054Z (8 biti un 12 Mpts), un jūs redzēsit, ka tā diez vai ir rotaļlieta. Kāds ir faktiskais joslas platums, es nezinu, esmu to pārbaudījis līdz 10 kHz, un tas darbojas labi.

3. darbība: programmas

IDE, ko izmantoju, ir Atollic TrueStudio, kuru šī gada (2018. gada) sākumā pieņēma ST Micro Electronics, un tas ir pieejams bez maksas, bez laika ierobežojuma, bez koda lieluma ierobežojuma, bez nag-screen. Kopā ar to es izmantoju STM32CubeMX - programmu, kas man piegādā sākuma kodu un ģenerē visu perifērijas ierīču inicializāciju. Un tam ir displejs ar visām mikrokontrollera tapām un to izmantošanu. Pat ja jūs neizmantojat STM32CubeMX koda ģenerēšanai, tas ir ļoti ērti. Viena lieta, kas man nepatīk, ir tā sauktā HAL, kas ir STM32CubeMX noklusējums. Es dodu priekšroku LowLayer darba metodei.

Lai ieprogrammētu mikrokontrolleru, es izmantoju ST-Link programmētāju/atkļūdotāju no ST Micro Electronics vai Segger izgatavoto J-Link. Abas šīs ierīces nav bezmaksas, lai gan to ķīniešu kopijas var iegādāties par dažiem eiro.

4. darbība. Par kodu

MAX7219 adresē gaismas diodes, ko es saucu par horizontālu, 8 gaismas diodes blakus. Osciloskopam 8 gaismas diodes viena virs otras būtu bijušas vienkāršākas, tāpēc es izveidoju vienkāršu rāmja buferi, uz kura tiek rakstīts ar datiem vertikālā veidā un nolasīts vajadzīgajā horizontālajā veidā. MAX7219 izmanto 16 bitu kodu uz 8 gaismas diodēm, kur pirmais baits tiek izmantots atlasītās līnijas adresēšanai. Un tā kā četri no šiem moduļiem ir sakrauti viens otram, un to ieejas ir pievienotas moduļa izejām pirms tā, jums ir jānosūta šie 16 biti četras reizes, lai sasniegtu pēdējo moduli. (Es ceru, ka paskaidroju lietas …) Dati tiek nosūtīti uz MAX7219, izmantojot SPI - vienkāršu, bet ļoti ātru protokolu. Ar to es eksperimentēju, cik ātri jūs varat nosūtīt datus uz MAX7219. Galu galā es atkal pārslēdzos uz 9 MHz, kas ir tieši zem maksimālā datu lapā norādītā ātruma.

Es izmantoju divus no četriem pieejamajiem STM32F103C8 taimeriem, vienu laika bāzes ģenerēšanai un otru rotācijas kodētāja nolasīšanai, kas nosaka laika bāzi. TIMER3 ģenerē laika bāzi, to darot, dalot pulksteni ar 230, atjauninot skaitītāju ik pēc 3,2 US. Izmantojot rotējošo kodētāju, jūs varat izvēlēties skaitītāju no 2 pulksteņa impulsiem līdz 2000 pulksteņa impulsiem. Pieņemsim, ka izvēlaties 100. TIMER3 pēc tam ģenerē PASĀKUMU ik pēc 320 ASV dolāriem. Šis notikums aktivizē ADC, lai ierakstītu ieejas signāla paraugu, un, tā kā vienā ekrānuzņēmumā jāņem 32 paraugi, tas tiks pabeigts pēc apm. 10 mS. 10mS var ievietot vienu viļņu garumu 100 Hz vai divus 200 Hz utt. Tomēr, pārsniedzot 3 viļņus vienā ekrānā, ir diezgan grūti atpazīt viļņu formu.

Pārējā gadījumā es varu jums atsaukties tikai uz kodu, to nav grūti ievērot, pat ja jums ir tikai zināma pieredze ar Arduino. Patiesībā jūs varētu pagatavot to pašu ar Arduino, lai gan es šaubos, ka tas tik ātri darbotos kā "zilā tablete". STM32F103C8 ir 32 bitu mikrokontrolleris, kas darbojas 72 MHz frekvencē, tam ir divas SPI perifērijas ierīces un ļoti ātrs ADC.

5. darbība. Galvenais 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 iekļaut "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. darbība. Galvenais. C

#include "main.h" static void LL_Init (void); void SystemClock_Config (tukšs); static void MX_GPIO_Init (anulēts); static void MX_ADC1_Init (anulēts); static void MX_SPI1_Init (anulēts); static void MX_SPI2_Init (anulēts); static void MX_TIM3_Init (anulēts); static void MX_TIM4_Init (anulēts);

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 (anulēts); void fill_frame_buffer (tukšs); void display_frame_buffer (tukšs); void set_timebase (void);

uint8_t augšējais_displejs [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]; // buferis vai rezultāts ADC

int main (anulēts)

{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 pēc ieslēgšanas nepieciešams zināms laiks

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

kamēr (1)

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

void erase_frame_buffer (anulēts)

{int8_t x; int8_t y;

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

par (y = 0; y <8; y ++) // lijnen {augšējais_displejs [x] [y] = 0; // alle bitjes op nul low_display [x] [y] = 0; }}}

void fill_frame_buffer (anulēts)

{uint8_t y = 0; // spriegums 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;

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

y = parauga_buferis [tijd];

if (y> 7) // augšējā displejā schrijven

{augšējais_displejs [displeja_baits] [15 gadi] | = (1 << displeja_bit); } else // apakšējā displejā schrijven {low_display [display_byte] [7-y] | = (1 << display_bit); }}}

void display_frame_buffer (anulēts)

{

uint8_t y; // acht lijnen boven elkaar (vienā displejā) uint16_t yl; // lijnnummer voor de MAX7219

par (y = 0; y <8; y ++) {yl = (y+1) << 8; // MAX7219 heeft lijnnummer in top 8 bits van 16 bits woord

SPI2_send64 ((yl | augšējais displejs [0] [y]), (il | augšējais displejs [1] [y]), (il | augšējais displejs [2] [y]), (il | augšējais displejs [3] [y]));

SPI1_send64 ((yl | apakšējais displejs [0] [y]), (il | apakšējais displejs [1] [y]), (il | apakšējais displejs [2] [y]), (il | apakšējais displejs [3] [y])); }

}

void set_timebase (anulēts)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

slēdzis (timebase_knop)

{0 gadījums: LL_TIM_SetAutoReload (TIM3, 1999); pārtraukums; 1. gadījums: LL_TIM_SetAutoReload (TIM3, 999); pārtraukums; 2. gadījums: LL_TIM_SetAutoReload (TIM3, 499); pārtraukums; 3. gadījums: LL_TIM_SetAutoReload (TIM3, 199); pārtraukums; 4. gadījums: LL_TIM_SetAutoReload (TIM3, 99); pārtraukums; 5. gadījums: LL_TIM_SetAutoReload (TIM3, 49); pārtraukums; 6. gadījums: LL_TIM_SetAutoReload (TIM3, 19); pārtraukums; 7. gadījums: LL_TIM_SetAutoReload (TIM3, 9); pārtraukums; 8. gadījums: LL_TIM_SetAutoReload (TIM3, 4); pārtraukums; 9. gadījums: LL_TIM_SetAutoReload (TIM3, 1); pārtraukums;

noklusējums:

LL_TIM_SetAutoReload (TIM3, 99); pārtraukums; }}

void MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // izslēgšana SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testa režīms izslēgts no SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // izslēgšana, normāla darbība SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // nav 7seg dekodēšanas, 64 pikseļi SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensitāte 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // visas rindas ieslēgtas}

void MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI2_send64 izslēgšana (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testa režīms izslēgts no SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // izslēgšana, normāla darbība SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // nav 7seg dekodēšanas, 64 pikseļi SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensitāte 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // visas rindas ieslēgtas}

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

kamēr (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, dati2);

kamēr (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, dati1);

kamēr (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, dati0);

kamēr (LL_SPI_IsActiveFlag_BSY (SPI1) == 1) {}

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

atgriezt 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, dati3);

kamēr (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, dati2);

kamēr (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, dati1);

kamēr (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, dati0);

kamēr (LL_SPI_IsActiveFlag_BSY (SPI2) == 1) {}

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

atgriezt LL_SPI_ReceivedData16 (SPI2); }

void ADC1_2_IRQHandler (anulēts)

{static uint8_t sample_counter; uint8_t sprūda; statisks uint8_t previous_trigger;

ja (LL_ADC_IsActiveFlag_EOS (ADC1)! = RESET)

{ja (parauga_skaitītājs <32) {parauga_buferis [izlases_skaitītājs] = LL_ADC_REG_ReadConversionData32 (ADC1) / 256; ja (izlases_skaitītājs <32) izlases_skaitītājs ++; cits parauga_skaitītājs = 0; } cits {trigger = LL_ADC_REG_ReadConversionData32 (ADC1) / 256;

if ((trigger == 7) && (previous_trigger <trigger)) // gaat niet helemaal goed bij blokgolven… {sample_counter = 0; } previous_trigger = sprūda; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

static void LL_Init (anulēts)

{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 (tukšs)

{LL_FLASH_SetLatency (LL_FLASH_LATENCY_2); ja (LL_FLASH_GetLatency ()! = LL_FLASH_LATENCY_2) Error_Handler (); LL_RCC_HSE_Enable (); kamēr (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 (); kamēr (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); kamēr (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 (anulēts)

{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 un 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 un & ADC_REG_InitStruct);

LL_ADC_SetChannelSamplingTime (ADC1, LL_ADC_CHANNEL_0, LL_ADC_SAMPLINGTIME_41CYCLES_5);

}

static void MX_SPI1_Init (anulēts)

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

static void MX_SPI2_Init (anulēts)

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

static void MX_TIM3_Init (anulēts)

{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 (anulēts)

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

LL_TIM_DisableARRPreload (TIM4);

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

static void MX_GPIO_Init (anulēts)

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

void _Error_Handler (char *fails, int line)

{kamēr (1) {}}

#ifdef USE_FULL_ASSERT

void assert_failed (fails uint8_t*, rinda uint32_t)

{} #endif