Apat na Bit Oscilloscope: 6 Hakbang
Apat na Bit Oscilloscope: 6 Hakbang

Talaan ng mga Nilalaman:

Anonim
Apat na Bit Oscilloscope
Apat na Bit Oscilloscope

Ito ay isang for-fun-project upang makita lamang kung gaano kalayo ang bilis na maaari kong itulak ang isang MAX7219 dot matrix display. At sa halip na patakbuhin ang "laro ng buhay", nagpasya akong gumawa ng isang "saklaw" kasama nito. Tulad ng mauunawaan mo mula sa pamagat, hindi ito isang kapalit para sa isang tunay na oscilloscope:-).

Dahil hindi ko plano na gamitin ito sa anumang seryosong paraan, hindi ako gagawa ng isang naka-print na circuit board para dito. Siguro, marahil ay mailalagay ko ito sa isang perf-board ngunit sa ngayon ito ay, at mananatili, sa isang breadboard. Gayundin walang input amplifier / attenuator, kailangan mong magbigay ng isang senyas sa pagitan ng 0 at 3.3V, huwag maging negatibo o higit sa 3.3V dahil maaari mong mapinsala ang microcontroller.

Hakbang 1: Hardware

Hardware
Hardware
Hardware
Hardware
Hardware
Hardware

Ito ay mura, napaka murang kapag bumili ka ng mga bahagi sa Tsina sa pamamagitan ng ebay o mga katulad na site. Gumagamit ito ng isang board ng pag-unlad ng STM32F103C8, kung minsan ay tinatawag na "asul na tableta" na binili ko sa humigit-kumulang 2 euro (o USD, halos magkapareho ang halaga nila, pagtatapos ng 2018), dalawang 8x8x4 na dot-matrix na ipinapakita na may MAX7219 chips dito, binili para sa 5 euro isang piraso at isang rotary encoder na halos 1 euro.

Kailangan ng kurso ay isang power supply na naghahatid ng 3.3V sa ilang daang milliamp. Ang boltahe regulator sa STM32F103C8 development board ay hindi ginagamit, hindi ito maaaring magbigay ng sapat na kasalukuyang para sa mga ipinapakita. Ang datasheet para sa MAX7219 ay tumutukoy sa boltahe ng supply ng operating ay dapat nasa pagitan ng 4.0 at 5.5V ngunit tumatakbo ito ng maayos sa 3.3V, marahil hindi kapag ginamit mo ito sa isang napakainit o malamig na kapaligiran, ngunit sa 20 Celsius ayos lang. At ngayon hindi ko na kailangang gumamit ng mga level-converter sa pagitan ng microcontroller at ng mga displayboard.

Hakbang 2: Bumuo

Magtayo
Magtayo
Magtayo
Magtayo
Magtayo
Magtayo

Kapag tiningnan mo ang larawan maaari mong makita na gumagamit ako ng mga linya ng kuryente sa mga breadboard sa hindi pangkaraniwang paraan, ang parehong mga linya sa itaas ay ang positibong riles at pareho sa ibaba ay ang ground rail. Ito ang paraan na ginamit ko upang gawin ito at gumana ito ng maayos, ginagawang mas katulad ng pag-set up ang pag-set up sa mga eskematiko na iginuhit ko. Gayundin, gumawa ako ng maraming maliliit na board na may mga bahagi na maaari kong mai-plug sa breadboard upang mapabilis ang mga bagay at lahat sila ay naka-configure upang magamit ang dalawang tuktok na linya bilang positibo at ang mga mas mababang linya bilang lupa. Tulad ng sinabi ko, ang resolusyon ay 4 bit (16 mga antas), at tulad ng mayroong 4x8 leds sa tabi ng bawat isa mayroon lamang 32 mga sample na puntos (pts). Ihambing iyon sa isang Rigol Rigol DS1054Z (8 bit at 12Mpts) at makikita mo na ito ay halos hindi laruan. Ano ang aktwal na bandwidth, hindi ko alam, nasubukan ko ito hanggang sa 10kHz at gumagana nang maayos.

Hakbang 3: Mga Programa

Mga Programa
Mga Programa
Mga Programa
Mga Programa
Mga Programa
Mga Programa
Mga Programa
Mga Programa

Ang ginamit kong IDE ay ang Atollic TrueStudio na simula ng taong ito (2018) ay pinagtibay ng ST Micro Electronics at magagamit nang libre, walang limitasyon sa oras, walang limitasyon sa laki ng code, walang nag-screen. Kasama nito, gumagamit ako ng STM32CubeMX, isang programa na nagbibigay sa akin ng panimulang code at bumubuo ng pagsisimula ng lahat ng mga peripheral. At mayroon itong pagpapakita ng lahat ng mga pin ng microcontroller at ang kanilang paggamit. Kahit na hindi ka gumagamit ng STM32CubeMX para sa pagbuo ng code, ito ay napaka madaling gamiting. Ang isang bagay na hindi ko gusto ay ang tinatawag na HAL na kung saan ay ang default ng STM32CubeMX. Mas gusto ko ang pamamaraan ng LowLayer ng pagtatrabaho.

Upang ma-program ang microcontroller gagamitin ko ang alinman sa programmer ng ST-Link / debugger mula sa ST Micro Electronics o ang J-Link na ginawa ng Segger. Ang parehong mga aparatong ito ay hindi libre, kahit na maaari kang bumili ng mga kopya ng Tsino sa kanila sa halagang ilang euro.

Hakbang 4: Tungkol sa Code

Ang address ng MAX7219 ay ang mga LED sa tinatawag kong pahalang na fashion, 8 leds sa tabi ng bawat isa. Para sa isang oscilloscope 8 LED's sa tuktok ng bawat isa ay magiging madali, kaya gumawa ako ng isang simpleng frame-buffer na nakasulat sa data sa isang patayong paraan, at basahin ang kinakailangang pahalang na paraan. Ang MAX7219 ay gumagamit ng isang 16bit code bawat 8 LEDs, kung saan ginamit ang unang byte upang matugunan ang napiling linya. At dahil may apat sa mga modyul na ito na nakasalansan sa tabi ng bawat isa, kasama ang kanilang mga input na konektado sa mga output ng module bago ito, kailangan mong ipadala ang mga 16bit na iyon ng apat na beses upang maabot ang huling module. (Inaasahan kong nililinaw ko ang mga bagay …) Ang data ay ipinapadala sa MAX7219 gamit ang SPI, isang simple ngunit napakabilis na protocol. Ito ang eksperimento ko, kung gaano ka kabilis magpadala ng data sa MAX7219. Sa huli, lumipat ako pabalik sa 9 MHz sa ibaba lamang ng maximum na bilis na tinukoy ng datasheet.

Gumagamit ako ng dalawa sa apat na magagamit na timer ng STM32F103C8, isa para sa henerasyon ng timebase at ang isa pa para sa pagbabasa ng rotary encoder, na nagtatakda ng timebase. Ang TIMER3 ay bumubuo ng timebase, ginagawa ito sa pamamagitan ng paghahati ng orasan ng 230, na ina-update ang counter sa bawat 3.2 uS. Witch ang rotary encoder maaari kang pumili upang mabilang ang counter mula sa 2 na pulso sa orasan hanggang sa 2000 na pulso ng orasan. Sabihin nating pumili ka ng 100. TIMER3 pagkatapos ay bumubuo ng isang PANGYAYARI tuwing 320 uS. Ang EVENT na ito ay nagpapalitaw sa ADC upang itala ang isang sample ng input signal, at dahil ang 32 mga sample na kukuha para sa isang naka-screen, makukumpleto ito pagkatapos ng aprox. 10 mS. Sa 10mS maaari kang magkasya sa isang haba ng daluyong ng 100 Hz, o dalawa sa 200 Hz, at iba pa. Ang pagpunta sa higit sa 3 mga alon bawat screen ay ginagawang mahirap upang makilala ang waveform kahit na.

Para sa natitira, maaari ka lamang mag-refer sa iyo sa code, hindi mahirap sundin kahit mayroon kang kaunting karanasan sa isang Arduino. Sa katunayan, maaari kang gumawa ng parehong bagay sa isang Arduino, kahit na nagdududa ako na gagana ito nang mas mabilis sa isang "asul na tableta". Ang STM32F103C8 ay isang 32bit microcontroller na tumatakbo sa 72 MHz, mayroon itong dalawang mga SPI peripheral at isang napakabilis na ADC.

Hakbang 5: Pangunahing.h

#ifndef _MAIN_H _ # tukuyin ang _MAIN_H_

# isama ang "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_corte.h" #f1 " isama ang "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

#tapusin kung

Hakbang 6: Pangunahing.c

# isama ang "main.h" static void LL_Init (void); walang bisa ang SystemClock_Config (walang bisa); static void MX_GPIO_Init (void); static void MX_ADC1_Init (void); static void MX_SPI1_Init (void); static void MX_SPI2_Init (void); static void MX_TIM3_Init (void); static void MX_TIM4_Init (void);

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

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

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

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

int main (walang bisa)

{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 nangangailangan ng ilang oras pagkatapos ng kapangyarihan sa

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

habang (1)

{set_timebase (); burahin ang_frame_buffer (); fill_frame_buffer (); display_frame_buffer (); }}

void erase_frame_buffer (void)

{int8_t x; int8_t y;

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

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

walang bisa ang fill_frame_buffer (walang bisa)

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

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

y = sample_buffer [tijd];

kung (y> 7) // sa itaas na display schrijven

{upper_display [display_byte] [15-y] | = (1 << display_bit); } iba // sa mas mababang display schrijven {lower_display [display_byte] [7-y] | = (1 << display_bit); }}}

walang bisa ang display_frame_buffer (walang bisa)

{

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

para sa (y = 0; y <8; y ++) {yl = (y + 1) << 8; // MAX7219 heeft lijnnummer in de upper 8 bits van 16 bits woord

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

}

walang bisa set_timebase (walang bisa)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

lumipat (timebase_knop)

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

default:

LL_TIM_SetAutoReload (TIM3, 99); pahinga; }}

walang bisa MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // shutdown sa SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testmode off SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // shutdown off, normal na operasyon SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // no 7seg decode, 64 pixel SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensity 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // lahat ng mga hilera sa}

walang bisa MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // shutdown sa SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testmode off SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // shutdown off, normal na operasyon SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // no 7seg decode, 64 pixel SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensity 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // lahat ng mga hilera sa}

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

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

LL_SPI_TransmitData16 (SPI1, data2);

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

LL_SPI_TransmitData16 (SPI1, data1);

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

LL_SPI_TransmitData16 (SPI1, data0);

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

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

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

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

LL_SPI_TransmitData16 (SPI2, data2);

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

LL_SPI_TransmitData16 (SPI2, data1);

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

LL_SPI_TransmitData16 (SPI2, data0);

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

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

ibalik ang LL_SPI_ReceiveData16 (SPI2); }

walang bisa ADC1_2_IRQHandler (walang bisa)

{static uint8_t sample_counter; uint8_t trigger; static uint8_t nakaraang_trigger;

kung (LL_ADC_IsActiveFlag_EOS (ADC1)! = RESET)

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

if ((trigger == 7) && (nakaraang_trigger <gatilyo)) // gaat niet helemaal goed bij blokgolven… {sample_counter = 0; } nakaraang_trigger = gatilyo; }

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

static void LL_Init (walang bisa)

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

}

walang bisa SystemClock_Config (walang bisa)

{LL_FLASH_SetLatency (LL_FLASH_LATENCY_2); kung (LL_FLASH_GetLatency ()! = LL_FLASH_LATENCY_2) Error_Handler (); LL_RCC_HSE_Enable (); habang (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 (); habang (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); habang (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 (walang bisa)

{LL_ADC_InitTypeDef ADC_InitSonstr; LL_ADC_CommonInitTypeDef ADC_CommonInitSonstr; LL_ADC_REG_InitTypeDef ADC_REG_InitSonstr; LL_GPIO_InitTypeDef GPIO_InitSonstr;

LL_APB2_GRP1_EnableClock (LL_APB2_GRP1_PERIPH_ADC1);

GPIO_InitSonstr. Pin = LL_GPIO_PIN_0;

GPIO_InitSonstr. Mode = LL_GPIO_MODE_ANALOG; LL_GPIO_Init (GPIOA, & GPIO_InitSonstr);

NVIC_SetPriority (ADC1_2_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0));

NVIC_EnableIRQ (ADC1_2_IRQn);

ADC_InitSonstr. DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;

ADC_InitSonstr. SequencersScanMode = LL_ADC_SEQ_SCAN_DISABLE; LL_ADC_Init (ADC1, & ADC_InitSonstr);

ADC_CommonInitSonstr. Multimode = LL_ADC_MULTI_INDEPENDENT;

LL_ADC_CommonInit (_ LL_ADC_COMMON_INSTANCE (ADC1), & ADC_CommonInitSonstr);

ADC_REG_InitSonstr. TriggerSource = LL_ADC_REG_TRIG_EXT_TIM3_TRGO;

ADC_REG_InitStruktur. SequencerLength = 1; ADC_REG_InitSonstr. SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE; ADC_REG_InitSonstr. ContinuousMode = LL_ADC_REG_CONV_SINGLE; ADC_REG_InitSonstr. DMATransfer = LL_ADC_REG_DMA_TRANSFER_NONE; LL_ADC_REG_Init (ADC1, & ADC_REG_InitSonstr);

LL_ADC_SetChannelSamplingTime (ADC1, LL_ADC_CHANNEL_0, LL_ADC_SAMPLINGTIME_41CYCLES_5);

}

static void MX_SPI1_Init (void)

{LL_SPI_InitTypeDef SPI_InitSonstr; LL_GPIO_InitTypeDef GPIO_InitSonstr;

LL_APB2_GRP1_EnableClock (LL_APB2_GRP1_PERIPH_SPI1);

GPIO_InitSonstr. Pin = LL_GPIO_PIN_5 | LL_GPIO_PIN_7;

GPIO_InitSonstr. Mode = LL_GPIO_MODE_ALTERNATE; GPIO_InitSonstr. Speed = LL_GPIO_SPEED_FREQ_HIGH; GPIO_InitSonstr. OutputType = LL_GPIO_OUTPUT_PUSHPULL; LL_GPIO_Init (GPIOA, & GPIO_InitSonstr);

// NVIC_SetPriority (SPI1_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0));

// NVIC_EnableIRQ (SPI1_IRQn);

SPI_InitSonstr. TransferDirection = LL_SPI_FULL_DUPLEX;

SPI_InitSonstr. Mode = LL_SPI_MODE_MASTER; SPI_InitSonstr. DataWidth = LL_SPI_DATAWIDTH_16BIT; SPI_InitSonstr. ClockPolarity = LL_SPI_POLARITY_LOW; SPI_InitSonstr. ClockPhase = LL_SPI_PHASE_1EDGE; SPI_InitSonstr. NSS = LL_SPI_NSS_SOFT; SPI_InitSonstr. BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV8; SPI_InitSonstr. BitOrder = LL_SPI_MSB_FIRST; SPI_InitSonstr. CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE; SPI_InitSonstr. CRCPoly = 10; LL_SPI_Init (SPI1, & SPI_InitSonstr); }

static void MX_SPI2_Init (walang bisa)

{LL_SPI_InitTypeDef SPI_InitSonstr; LL_GPIO_InitTypeDef GPIO_InitSonstr;

LL_APB1_GRP1_EnableClock (LL_APB1_GRP1_PERIPH_SPI2);

GPIO_InitSonstr. Pin = LL_GPIO_PIN_13 | LL_GPIO_PIN_15;

GPIO_InitSonstr. Mode = LL_GPIO_MODE_ALTERNATE; GPIO_InitSonstr. Speed = LL_GPIO_SPEED_FREQ_HIGH; GPIO_InitSonstr. OutputType = LL_GPIO_OUTPUT_PUSHPULL; LL_GPIO_Init (GPIOB, & GPIO_InitSonstr);

// NVIC_SetPriority (SPI2_IRQn, NVIC_EncodePriority (NVIC_GetPriorityGrouping (), 0, 0));

// NVIC_EnableIRQ (SPI2_IRQn);

SPI_InitSonstr. TransferDirection = LL_SPI_FULL_DUPLEX;

SPI_InitSonstr. Mode = LL_SPI_MODE_MASTER; SPI_InitSonstr. DataWidth = LL_SPI_DATAWIDTH_16BIT; SPI_InitSonstr. ClockPolarity = LL_SPI_POLARITY_LOW; SPI_InitSonstr. ClockPhase = LL_SPI_PHASE_1EDGE; SPI_InitSonstr. NSS = LL_SPI_NSS_SOFT; SPI_InitSonstr. BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV4; SPI_InitSonstr. BitOrder = LL_SPI_MSB_FIRST; SPI_InitSonstr. CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE; SPI_InitSonstr. CRCPoly = 10; LL_SPI_Init (SPI2, & SPI_InitSonstr); }

static void MX_TIM3_Init (walang bisa)

{LL_TIM_InitTypeDef TIM_InitSonstr;

LL_APB1_GRP1_EnableClock (LL_APB1_GRP1_PERIPH_TIM3);

TIM_InitSonstr. Prescaler = 229;

TIM_InitSonstr. CounterMode = LL_TIM_COUNTERMODE_UP; TIM_InitSonstr. Autoreload = 9; TIM_InitSonstr. ClockDivision = LL_TIM_CLOCKDIVISION_DIV1; LL_TIM_Init (TIM3, & TIM_InitSonstr);

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 (walang bisa)

{LL_TIM_InitTypeDef TIM_InitSonstr; LL_GPIO_InitTypeDef GPIO_InitSonstr;

LL_APB1_GRP1_EnableClock (LL_APB1_GRP1_PERIPH_TIM4);

GPIO_InitSonstr. Pin = LL_GPIO_PIN_6 | LL_GPIO_PIN_7;

GPIO_InitSonstr. Mode = LL_GPIO_MODE_FLOATING; LL_GPIO_Init (GPIOB, & GPIO_InitSonstr);

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_InitSonstr. Prescaler = 0;

TIM_InitSonstr. CounterMode = LL_TIM_COUNTERMODE_UP; TIM_InitSonstr. Autoreload = 19; TIM_InitSonstr. ClockDivision = LL_TIM_CLOCKDIVISION_DIV1; LL_TIM_Init (TIM4, & TIM_InitSonstr);

LL_TIM_DisableARRPreload (TIM4);

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

static void MX_GPIO_Init (walang bisa)

{LL_GPIO_InitTypeDef GPIO_InitSonstr;

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_InitSonstr. Pin = LL_GPIO_PIN_13;

GPIO_InitSonstr. Mode = LL_GPIO_MODE_OUTPUT; GPIO_InitSonstr. Speed = LL_GPIO_SPEED_FREQ_LOW; GPIO_InitSonstr. OutputType = LL_GPIO_OUTPUT_PUSHPULL; LL_GPIO_Init (GPIOC, & GPIO_InitSonstr);

GPIO_InitSonstr. Pin = LL_GPIO_PIN_4;

GPIO_InitSonstr. Mode = LL_GPIO_MODE_OUTPUT; GPIO_InitSonstr. Speed = LL_GPIO_SPEED_FREQ_HIGH; GPIO_InitSonstr. OutputType = LL_GPIO_OUTPUT_PUSHPULL; LL_GPIO_Init (GPIOA, & GPIO_InitSonstr);

GPIO_InitSonstr. Pin = LL_GPIO_PIN_12;

GPIO_InitSonstr. Mode = LL_GPIO_MODE_OUTPUT; GPIO_InitSonstr. Speed = LL_GPIO_SPEED_FREQ_HIGH; GPIO_InitSonstr. OutputType = LL_GPIO_OUTPUT_PUSHPULL; LL_GPIO_Init (GPIOB, & GPIO_InitSonstr); }

walang bisa _Error_Handler (char * file, int line)

{habang (1) {}}

#ifdef USE_Full_ASSERT

walang bisa assert_failed (uint8_t * file, uint32_t line)

{ } #tapusin kung