Osiloskop Empat Bit: 6 Langkah

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:10

Ini adalah projek untuk bersenang-senang hanya untuk melihat sejauh mana kelajuan saya dapat mendorong paparan MAX7219 dot matrix. Dan bukannya menjalankannya "permainan hidup", saya memutuskan untuk membuat "skop" dengannya. Seperti yang akan anda fahami dari tajuk, ini bukan pengganti osiloskop sebenar:-).

Oleh kerana saya tidak merancang untuk menggunakannya dengan cara yang serius, saya tidak akan membuat papan litar bercetak untuknya. Mungkin, mungkin saya akan meletakkannya di papan wangi tetapi buat masa ini, dan akan kekal di papan roti. Juga tidak ada penguat input / atenuator, anda harus memberikan isyarat antara 0 dan 3.3V, jangan negatif atau melebihi 3.3V kerana anda boleh merosakkan mikrokontroler.

Langkah 1: Perkakasan

Ia murah, sangat murah apabila anda membeli alat ganti di China melalui ebay atau laman web serupa. Ia menggunakan papan pengembangan STM32F103C8, kadang-kadang disebut "pil biru" yang saya beli dengan harga sekitar 2 euro (atau USD, nilai mereka hampir sama, akhir 2018), dua paparan dot-matriks 8x8x4 dengan cip MAX7219 di atasnya, dibeli untuk 5 euro sehelai dan pengekod putar sekitar 1 euro.

Tentunya yang diperlukan adalah bekalan kuasa yang memberikan 3.3V pada beberapa ratus miliamp. Pengatur voltan pada papan pengembangan STM32F103C8 tidak digunakan, ia tidak dapat memberikan arus yang cukup untuk paparan. Lembar data untuk MAX7219 menentukan voltan bekalan operasi mestilah antara 4.0 dan 5.5V tetapi berjalan dengan baik pada 3.3V, mungkin bukan ketika anda menggunakannya dalam persekitaran yang sangat panas atau sejuk, tetapi pada suhu 20 Celsius tidak masalah. Dan sekarang saya tidak perlu menggunakan penukar tahap antara mikrokontroler dan papan paparan.

Langkah 2: Bina

Apabila anda melihat gambar, anda mungkin melihat bahawa saya menggunakan talian kuasa pada papan roti dengan cara yang tidak konvensional, kedua-dua garis di atas adalah rel positif dan kedua-duanya di bahagian bawah adalah landasan. Ini adalah cara saya terbiasa melakukannya dan ia berfungsi dengan baik, ia menjadikan penyediaannya sedikit lebih menyerupai skema yang saya lukis. Juga, saya telah membuat banyak papan kecil dengan bahagian yang boleh saya pasangkan ke papan roti untuk mempercepat perkara dan semuanya dikonfigurasi untuk menggunakan dua garis atas sebagai positif dan garis bawah sebagai tanah. Seperti yang saya katakan, resolusi adalah 4 bit (16 tahap), dan kerana terdapat 4x8 led bersebelahan, hanya ada 32 titik sampel (poin). Bandingkan dengan Rigol Rigol DS1054Z (8 bit dan 12Mpts) dan anda akan melihat bahawa ini bukan mainan. Berapa lebar jalur sebenarnya, saya tidak tahu, saya telah mengujinya hingga 10kHz dan berfungsi dengan baik.

Langkah 3: Program

IDE yang saya gunakan adalah Atollic TrueStudio yang pada awal tahun ini (2018) diadopsi oleh ST Micro Electronics dan tersedia secara percuma, tanpa had masa, tanpa had ukuran kod, tidak ada layar nag. Bersama dengannya, saya menggunakan STM32CubeMX, program yang membekalkan saya dengan kod permulaan dan menghasilkan inisialisasi semua periferal. Dan ia mempunyai paparan semua pin mikrokontroler dan penggunaannya. Walaupun anda tidak menggunakan STM32CubeMX untuk menghasilkan kod, ini sangat berguna. Satu perkara yang saya tidak suka ialah apa yang disebut HAL yang merupakan lalai STM32CubeMX. Saya lebih suka kaedah kerja LowLayer.

Untuk memprogram mikrokontroler, saya menggunakan pengaturcara ST-Link / debugger dari ST Micro Electronics atau J-Link yang dibuat oleh Segger. Kedua-dua peranti ini tidak percuma, walaupun anda boleh membeli salinan Cina dengan harga beberapa euro.

Langkah 4: Mengenai Kod

MAX7219 alamat LED dalam apa yang saya sebut secara mendatar, 8 led bersebelahan. Untuk osiloskop 8 LED di atas satu sama lain lebih mudah, jadi saya membuat penyangga bingkai sederhana yang ditulis dengan data secara menegak, dan dibaca dengan cara mendatar yang diperlukan. MAX7219 menggunakan kod 16bit per 8 LED, di mana bait pertama digunakan untuk mengatasi baris yang dipilih. Dan kerana terdapat empat modul ini yang tersusun di sebelah satu sama lain, dengan inputnya disambungkan ke output modul sebelum itu, anda harus menghantar 16 bit empat kali untuk mencapai modul terakhir. (Saya harap saya membuat semuanya jelas …) Data dihantar ke MAX7219 menggunakan SPI, protokol yang mudah tetapi cepat. Inilah yang saya percobaan, seberapa cepat anda boleh menghantar data ke MAX7219. Pada akhirnya, saya beralih kembali ke 9 MHz tepat di bawah kelajuan maksimum yang ditentukan oleh lembar data.

Saya menggunakan dua daripada empat pemasa yang tersedia dari STM32F103C8, satu untuk penghasilan pangkalan masa dan yang lain untuk membaca pengekod putar, yang menetapkan pangkalan masa. TIMER3 menghasilkan pangkalan masa, ia melakukannya dengan membahagi jam dengan 230, mengemas kini kaunter setiap 3.2 uS. Sihir pengekod putar yang boleh anda pilih untuk mempunyai kiraan pembilang dari 2 denyutan jam hingga 2000 denyutan jam. Katakan anda memilih 100. TIMER3 kemudian menghasilkan ACARA setiap 320 uS. ACARA ini memicu ADC untuk merakam sampel isyarat input, dan seperti 32 sampel yang akan diambil untuk satu skrining, ini akan selesai setelah aprox. 10 mS. Dalam 10mS anda boleh memuat satu gelombang 100 Hz, atau dua 200 Hz, dan seterusnya. Melewati 3 gelombang setiap skrin menjadikannya agak sukar untuk mengenali bentuk gelombang.

Selebihnya, saya hanya boleh merujuk kepada kod anda, tidak sukar untuk diikuti walaupun anda hanya mempunyai pengalaman dengan Arduino. Sebenarnya, anda boleh membuat perkara yang sama dengan Arduino, walaupun saya ragu bahawa ia akan berfungsi dengan cepat sebagai "pil biru". STM32F103C8 adalah mikrokontroler 32bit yang berjalan pada 72 MHz, ia mempunyai dua periferal SPI dan ADC yang sangat cepat.

Langkah 5: Main.h

#ifndef _MAIN_H _ # tentukan _MAIN_H_

#sertakan "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 "st_32" sertakan "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

# menentukan NVIC_PRIORITYGROUP_0 ((uint32_t) 0x00000007) # menentukan NVIC_PRIORITYGROUP_1 ((uint32_t) 0x00000006) # menentukan NVIC_PRIORITYGROUP_2 ((uint32_t) 0x00000005) # menentukan NVIC_PRIORITYGROUP_3 ((uint32_t) 0x00000004) # menentukan 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

Langkah 6: Main.c

#lampirkan "main.h" kekosongan statik LL_Init (tidak sah); batal SystemClock_Config (kekosongan); kekosongan statik MX_GPIO_Init (tidak sah); kekosongan statik MX_ADC1_Init (tidak sah); kekosongan statik MX_SPI1_Init (tidak sah); kekosongan statik MX_SPI2_Init (tidak sah); kekosongan statik MX_TIM3_Init (tidak sah); kekosongan statik MX_TIM4_Init (tidak sah);

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); batal MAX7219_1_init (); tidak sah MAX7219_2_init (); void erase_frame_buffer (tidak sah); pengosongan kosong_frame_buffer (kekosongan); void display_frame_buffer (tidak sah); void set_timebase (kekosongan);

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

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

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

int utama (tidak sah)

{LL_Init (); SystemClock_Config (); MX_GPIO_Init (); MX_ADC1_Init (); MX_SPI1_Init (); MX_SPI2_Init (); MX_TIM3_Init (); MX_TIM4_Init ();

LL_SPI_Daya (SPI1);

LL_SPI_Daya (SPI2);

LL_TIM_EnableCounter (TIM3);

LL_TIM_EnableCounter (TIM4);

LL_ADC_Daya (ADC1);

LL_ADC_REG_StartConversionSWStart (ADC1); LL_ADC_EnableIT_EOS (ADC1);

LL_mDelay (500); // MAX7219 memerlukan sedikit masa selepas hidup

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

semasa (1)

{set_timebase (); padam_frame_buffer (); isi_frame_buffer (); display_frame_buffer (); }}

void erase_frame_buffer (tidak sah)

{int8_t x; int8_t y;

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

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

kekosongan mengisi_frame_buffer (tidak sah)

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

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

y = sample_buffer [tijd];

jika (y> 7) // di schrijven paparan atas

{upper_display [display_byte] [15-y] | = (1 << display_bit); } lain // dalam paparan rendah schrijven {lower_display [display_byte] [7-y] | = (1 << display_bit); }}}

void display_frame_buffer (tidak sah)

{

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

untuk (y = 0; y <8; y ++) {yl = (y + 1) << 8; // MAX7219 heeft lijnnummer di de upper 8 bit van 16 bit woord

SPI2_send64 ((yl | paparan_ atas];

SPI1_send64 ((yl | low_display [0] [y]), (yl | lower_display [1] [y]), (yl | lower_display [2] [y]), (yl | lower_display [3] [y])); }

}

void set_timebase (tidak sah)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

tukar (timebase_knop)

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

lalai:

LL_TIM_SetAutoReload (TIM3, 99); rehat; }}

tidak sah MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // tutup pada SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testmode mati SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // mematikan, operasi biasa SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // no decode 7seg, 64 piksel SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensiti 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // semua baris aktif}

tidak sah MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // tutup pada SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // testmode mati SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // mematikan, operasi biasa SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // tiada dekod 7seg, 64 piksel SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // intensiti 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // semua baris aktif}

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

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

LL_SPI_TransmitData16 (SPI1, data2);

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

LL_SPI_TransmitData16 (SPI1, data1);

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

LL_SPI_TransmitData16 (SPI1, data0);

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

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

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

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

LL_SPI_TransmitData16 (SPI2, data2);

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

LL_SPI_TransmitData16 (SPI2, data1);

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

LL_SPI_TransmitData16 (SPI2, data0);

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

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

pulangkan LL_SPI_ReceiveData16 (SPI2); }

batal ADC1_2_IRQHandler (tidak sah)

{static uint8_t sample_counter; pencetus uint8_t; statik uint8_t sebelumnya_trigger;

jika (LL_ADC_IsActiveFlag_EOS (ADC1)! = RESET)

{if (sample_counter <32) {sample_buffer [sample_counter] = LL_ADC_REG_ReadConversionData32 (ADC1) / 256; jika (sample_counter <32) sample_counter ++; contoh_counter lain = 0; } lain {trigger = LL_ADC_REG_ReadConversionData32 (ADC1) / 256;

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

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

kekosongan statik LL_Init (tidak sah)

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

}

batal SystemClock_Config (batal)

{LL_FLASH_SetLatency (LL_FLASH_LATENCY_2); jika (LL_FLASH_GetLatency ()! = LL_FLASH_LATENCY_2) Ralat_Pengguna (); LL_RCC_HSE_Aktifkan (); sementara (LL_RCC_HSE_IsReady ()! = 1); LL_RCC_PLL_ConfigDomain_SYS (LL_RCC_PLLSOURCE_HSE_DIV_1, LL_RCC_PLL_MUL_9); LL_RCC_PLL_Aktifkan (); sementara (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); sementara (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));

}

kekosongan statik MX_ADC1_Init (tidak sah)

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

}

kekosongan statik MX_SPI1_Init (tidak sah)

{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, & 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; Pengiraan SPI_InitStruct. CRCC = LL_SPI_CRCCALCULATION_DISABLE; SPI_InitStruct. CRCPoly = 10; LL_SPI_Init (SPI1, & SPI_InitStruct); }

kekosongan statik MX_SPI2_Init (tidak sah)

{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; Pengiraan SPI_InitStruct. CRCC = LL_SPI_CRCCALCULATION_DISABLE; SPI_InitStruct. CRCPoly = 10; LL_SPI_Init (SPI2, & SPI_InitStruct); }

kekosongan statik MX_TIM3_Init (tidak sah)

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

kekosongan statik MX_TIM4_Init (tidak sah)

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

LL_TIM_DisableARRPreload (TIM4);

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

kekosongan statik MX_GPIO_Init (tidak sah)

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

batal _Error_Handler (char * file, int line)

{sementara (1) {}}

#ifdef USE_FULL_ASSERT

batal assert_failed (fail uint8_t *, garis uint32_t)

{} #endif