Дөрвөн битийн осциллограф: 6 алхам

2024 Зохиолч: John Day | [email protected]. Хамгийн сүүлд өөрчлөгдсөн: 2024-01-30 11:04

Энэ бол MAX7219 цэг матрицын дэлгэцийг хэр хурдтайгаар түлхэж болохыг харахын тулд зугаа цэнгэлийн төсөл юм. Үүнийг "амьдралын тоглоом" болгохын оронд би үүнд "хамрах хүрээ" хийхээр шийдсэн. Гарчигнаас та ойлгох болно, энэ бол жинхэнэ осциллографыг орлох зүйл биш юм:-).

Би үүнийг нухацтай ашиглахаар төлөвлөөгүй байгаа тул хэвлэмэл хэлхээний самбар хийхгүй. Магадгүй, магадгүй би үүнийг самбар дээр тавина, гэхдээ одоогоор энэ нь талхны тавцан дээр байсаар байх болно. Мөн оролтын өсгөгч/сулруулагч байхгүй, та 0-3.3 В -ийн хооронд дохио өгөх ёстой, сөрөг эсвэл 3.3 В -оос хэтрүүлж болохгүй, учир нь микроконтроллерыг гэмтээж болзошгүй.

Алхам 1: Техник хангамж

Хятадад ebay эсвэл ижил төстэй сайтаар дамжуулан эд ангиудыг худалдаж авахад энэ нь хямд, маш хямд байдаг. Энэ нь STM32F103C8 хөгжлийн самбарыг ашигладаг бөгөөд үүнийг заримдаа "цэнхэр эм" гэж нэрлэдэг бөгөөд би үүнийг 2 еврогоор худалдаж авсан (эсвэл ам.доллар, тэдгээр нь бараг ижил утгатай, 2018 оны эцэс), дээр нь MAX7219 чип бүхий 8x8x4 хэмжээтэй хоёр матриц дэлгэцийг худалдаж авсан. Нэг ширхэг 5 евро ба ойролцоогоор 1 еврогийн эргэлддэг кодлогч.

Мэдээжийн хэрэг, хэдэн зуун миллипампт 3.3В хүчдэл өгдөг цахилгаан хангамж хэрэгтэй. STM32F103C8 хөгжлийн самбар дээрх хүчдэлийн зохицуулагчийг ашигладаггүй, энэ нь дэлгэцийг хангалттай гүйдэлээр хангаж чадахгүй байна. MAX7219 -ийн мэдээллийн хүснэгтэд тэжээлийн хангамжийн хүчдэл 4.0 -аас 5.5 В -ийн хооронд байх ёстой боловч 3.3 В -т сайн ажилладаг, магадгүй та үүнийг маш халуун эсвэл хүйтэн орчинд ашиглахгүй байж магадгүй, гэхдээ 20 Цельсийн температурт байвал зүгээр. Одоо би микроконтроллер ба дэлгэцийн хооронд түвшин хувиргагчийг ашиглах шаардлагагүй боллоо.

Алхам 2: Бүтээх

Зургийг харахад та талхны тавцан дээрх цахилгаан шугамыг уламжлалт бус байдлаар ашигладаг болохыг харж болно. Энэ бол миний хийдэг хэв маяг бөгөөд энэ нь сайн ажилладаг бөгөөд энэ нь тохиргоог миний зурсан схемтэй илүү төстэй болгодог. Нэмж дурдахад би талхны самбар дээр залгаж, хурдасгах боломжтой олон жижиг самбар хийсэн бөгөөд тэдгээр нь хоёр дээд шугамыг эерэг, доод шугамыг газар болгон ашиглахаар тохируулсан болно. Миний хэлсэнчлэн, нягтрал нь 4 бит (16 түвшин) бөгөөд 4х8 хэмжээтэй LED -ийн хажууд байгаа тул ердөө 32 дээжийн цэг (pts) байдаг. Үүнийг Rigol Rigol DS1054Z (8 бит ба 12Mpts) -тэй харьцуулж үзэхэд энэ нь бараг тоглоом биш гэдгийг та харах болно. Бодит зурвасын өргөн гэж юу болохыг би мэдэхгүй, би үүнийг 10 кГц хүртэл туршиж үзсэн бөгөөд энэ нь сайн ажилладаг.

Алхам 3: Хөтөлбөрүүд

Миний ашигладаг IDE бол энэ оны эхээр (2018 он) ST Micro Electronics-ийн баталсан Atollic TrueStudio бөгөөд үнэ төлбөргүй, цагийн хязгааргүй, кодын хэмжээ хязгааргүй, дэлгэцгүй байдаг. Үүнтэй хамт би STM32CubeMX програмыг ашигладаг бөгөөд энэ нь надад эхлэлийн кодыг өгч, бүх дагалдах хэрэгслийг эхлүүлэх боломжийг олгодог. Мөн энэ нь микроконтроллерийн бүх тээглүүр, тэдгээрийн хэрэглээний дэлгэцтэй. Хэрэв та код үүсгэхийн тулд STM32CubeMX -ийг ашигладаггүй байсан ч гэсэн энэ нь маш тохиромжтой юм. Надад таалагдахгүй байгаа зүйл бол STM32CubeMX -ийн анхдагч HAL юм. Би LowLayer -ийн ажиллах аргыг илүүд үздэг.

Микроконтроллерыг програмчлахын тулд би ST Micro Electronics-ийн ST-Link програмист/дибаг хийгч эсвэл Segger-ийн хийсэн J-Link-ийг ашигладаг. Эдгээр хоёр төхөөрөмж хоёулаа үнэ төлбөргүй байдаггүй, гэхдээ та хятад хуулбарыг хэдхэн еврогоор худалдаж авах боломжтой.

Алхам 4: Кодын тухай

MAX7219 -ийн хаяг нь LED -ийг хэвтээ байдлаар нэрлэдэг бөгөөд бие биенийхээ дэргэдэх 8 лед юм. Осциллографын хувьд 8 LED-ийг бие биенийхээ дээр байрлуулах нь илүү хялбар байх болно, тиймээс би өгөгдлийг босоо байдлаар бичиж, шаардлагатай хэвтээ байдлаар унших энгийн хүрээ-буфер хийсэн. MAX7219 нь 8 LED тутамд 16 бит код ашигладаг бөгөөд эхний байт нь сонгосон мөрийг шийдвэрлэхэд ашиглагддаг. Эдгээр модулиудын дөрөв нь бие биенийхээ хажууд овоолсон бөгөөд оролт нь модулийн гаралттай холбогдсон тул та сүүлийн модульд хүрэхийн тулд эдгээр 16 битийг дөрвөн удаа илгээх ёстой. (Би бүх зүйлийг тодорхой болгож байна гэж найдаж байна.) Өгөгдлийг SPI ашиглан энгийн боловч маш хурдан протокол ашиглан MAX7219 руу илгээдэг. Энэ бол миний туршиж үзсэн зүйл бөгөөд та MAX7219 руу өгөгдлийг хэр хурдан илгээж чадах вэ. Эцэст нь би өгөгдлийн хүснэгтэд заасан хамгийн дээд хурднаас доогуур 9 МГц руу шилжсэн.

Би STM32F103C8 -ийн боломжтой дөрвөн таймерын хоёрыг ашигладаг бөгөөд нэг нь цагийн суурийг бий болгоход, нөгөө нь цагийн суурийг тавьдаг эргэдэг кодлогчыг уншихад ашигладаг. TIMER3 нь цагийн суурийг бий болгодог бөгөөд үүнийг цагийг 230 -д хувааж, тоолуурыг 3.2 uS тутамд шинэчилж өгдөг. 2 цагийн импульсээс 2000 цаг хүртэлх импульсээс тоолуур тоолох боломжтой сонгож болох эргэдэг кодлогч. Та 100 -г сонгосон гэж бодъё. TIMER3 нь 320 uS тутамд EVENT үүсгэдэг. Энэхүү ҮЙЛ ЯВДАЛ нь ADC -ийг оролтын дохионы дээжийг бичихэд хүргэдэг бөгөөд нэг дэлгэцийн хувьд авах 32 дээжийн хувьд энэ нь ойролцоогоор дууссаны дараа дуусна. 10 mS. 10mS -д 100 Гц долгионы урт эсвэл 200 Гц -ийн хоёр гэх мэтийг багтааж болно. Дэлгэц тутамд 3 долгион давах нь долгионы хэлбэрийг танихад хэцүү болгодог.

Бусад тохиолдолд би зөвхөн кодыг зааж өгөх болно, хэрэв та зөвхөн Arduino -тэй туршлагатай байсан ч дагаж мөрдөх нь хэцүү биш юм. Үнэндээ та Arduino -тай ижил зүйлийг хийж чадна, гэхдээ энэ нь "цэнхэр эм" шиг хурдан ажиллах болно гэдэгт би эргэлзэж байна. STM32F103C8 нь 72 МГц давтамжтай ажилладаг 32 битийн микроконтроллер бөгөөд хоёр SPI дагалдах төхөөрөмжтэй бөгөөд маш хурдан ADC юм.

Алхам 5: Үндсэн.h

#ifndef _MAIN_H _#_MAIN_H_ тодорхойлох

#"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 "stm32f1xxlxxl_cort1" оруулах "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);

#de Erine_Handler () _Error_Handler (_ FILE_, _LINE_)

#ifdef _cplusplus} #endif

#endif

Алхам 6: Үндсэн c

#inclite "main.h" статик хоосон LL_Init (хүчингүй); хоосон SystemClock_Config (хүчингүй); статик хоосон MX_GPIO_Init (хүчингүй); статик хоосон MX_ADC1_Init (хүчингүй); статик хоосон MX_SPI1_Init (хүчингүй); статик хоосон MX_SPI2_Init (хүчингүй); статик хоосон MX_TIM3_Init (хүчингүй); статик хоосон MX_TIM4_Init (хүчингүй);

uint16_t SPI1_send64 (uint16_t өгөгдөл3, uint16_t өгөгдөл2, uint16_t өгөгдөл1, uint16_t өгөгдөл0);

uint16_t SPI2_send64 (uint16_t өгөгдөл3, uint16_t өгөгдөл2, uint16_t өгөгдөл1, uint16_t өгөгдөл0); хүчингүй MAX7219_1_init (); хүчингүй MAX7219_2_init (); хүчингүй erase_frame_buffer (хүчингүй); хүчингүй fill_frame_buffer (хүчингүй); void display_frame_buffer (хүчингүй); хүчингүй set_timebase (хүчингүй);

uint8_t дээд дэлгэц [4] [8]; // vier bytes naast elkaar, acht onder elkaar

uint8_t доод талын дэлгэц [4] [8]; // фрэйм-буферыг ашиглах боломжтой

uint8_t sample_buffer [32]; // ADC -ийн үр дүнгийн буфер

int main (хүчингүй)

{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 -ийг асаасны дараа хэсэг хугацаа шаардагдана

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

байхад (1)

{set_timebase (); арилгах_хүрээ_буфер (); дүүргэх_хүрээ_буфер (); Display_frame_buffer (); }}

хүчингүй erase_frame_buffer (хүчингүй)

{int8_t x; int8_t y;

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

for (y = 0; y <8; y ++) // lijnen {дээд_хэрэглэл [x] [y] = 0; // бүх bitjes нь n_display [x] [y] = 0; }}}

хоосон дүүргэх_хүрээ_буфер (хүчингүй)

{uint8_t y = 0; // хүчдэл uint8_t tijd = 0; // tijd uint8_t display_byte; // азарганууд 8 бит 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 = sample_buffer [tijd];

if (y> 7) // дээд дэлгэц дээр schrijven

{дээд_хэрэглэл [display_byte] [15-y] | = (1 << display_bit); } өөр // дэлгэцийн доод хэсэгт schrijven {доод_дисплей [display_byte] [7-y] | = (1 << display_bit); }}}

хоосон Display_frame_buffer (хүчингүй)

{

uint8_t y; // acht lijnen boven elkaar (дэлгэц бүрт) uint16_t yl; // MAX7219 -ийн хамгийн том хувилбар

for (y = 0; y <8; y ++) {yl = (y+1) << 8; // MAX7219 дээд 8 битийн ван 16 бит woord

SPI2_send64 ((yl | дээд_хэрэглэл [0] [y]), (yl | дээд_хэрэглэл [1] [y]), (yl | дээд_хэрэглэл [2] [y]), (yl | дээд_хэрэглэл [3] [y]));

SPI1_send64 ((yl | доод_хэрэглэл [0] [y]), (yl | доод_хэрэглэл [1] [y]), (yl | доод_хэрэглэл [2] [y]), (yl | доод_хэрэглэл [3] [y])); }

}

хүчингүй set_timebase (хүчингүй)

{uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter (TIM4) / 2;

унтраалга (цаг хугацааны_нүүр)

{тохиолдол 0: LL_TIM_SetAutoReload (TIM3, 1999); завсарлага; тохиолдол 1: LL_TIM_SetAutoReload (TIM3, 999); завсарлага; тохиолдол 2: LL_TIM_SetAutoReload (TIM3, 499); завсарлага; тохиолдол 3: LL_TIM_SetAutoReload (TIM3, 199); завсарлага; тохиолдол 4: LL_TIM_SetAutoReload (TIM3, 99); завсарлага; тохиолдол 5: LL_TIM_SetAutoReload (TIM3, 49); завсарлага; тохиолдол 6: LL_TIM_SetAutoReload (TIM3, 19); завсарлага; тохиолдол 7: LL_TIM_SetAutoReload (TIM3, 9); завсарлага; тохиолдол 8: LL_TIM_SetAutoReload (TIM3, 4); завсарлага; тохиолдол 9: LL_TIM_SetAutoReload (TIM3, 1); завсарлага;

анхдагч:

LL_TIM_SetAutoReload (TIM3, 99); завсарлага; }}

хүчингүй MAX7219_1_init ()

{SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // үгүй SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000) дээр унтрах; // үгүй SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // туршилтын горимыг унтраах SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // унтрах, хэвийн ажиллах SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // 7seg декод байхгүй, 64 пиксел SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // эрчим 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // бүх мөрүүд}

хүчингүй MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // үгүй SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000) дээр унтрах; // үгүй SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // туршилтын горимыг унтраах SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // унтрах, хэвийн ажиллах SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // 7seg декодчилолгүй, 64 пиксел SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // эрчим 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // бүх мөрүүд}

uint16_t SPI1_send64 (uint16_t өгөгдөл3, uint16_t өгөгдөл2, uint16_t өгөгдөл1, uint16_t өгөгдөл0)

{LL_GPIO_ResetOutputPin (GPIOA, LL_GPIO_PIN_4);

LL_SPI_TransmitData16 (SPI1, өгөгдөл3);

байхад (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, өгөгдөл2);

байхад (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, өгөгдөл1);

байхад (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, өгөгдөл0);

байхад (LL_SPI_IsActiveFlag_BSY (SPI1) == 1) {}

LL_GPIO_SetOutputPin (GPIOA, LL_GPIO_PIN_4);

буцаах LL_SPI_ReceiveData16 (SPI1); }

uint16_t SPI2_send64 (uint16_t өгөгдөл3, uint16_t өгөгдөл2, uint16_t өгөгдөл1, uint16_t өгөгдөл0)

{LL_GPIO_ResetOutputPin (GPIOB, LL_GPIO_PIN_12);

LL_SPI_TransmitData16 (SPI2, өгөгдөл3);

байхад (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, өгөгдөл2);

байхад (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, өгөгдөл1);

байхад (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, өгөгдөл0);

байхад (LL_SPI_IsActiveFlag_BSY (SPI2) == 1) {}

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

буцаах LL_SPI_ReceiveData16 (SPI2); }

хүчингүй ADC1_2_IRQHandler (хүчингүй)

{статик uint8_t sample_counter; uint8_t гох; статик uint8_t previous_trigger;

хэрэв (LL_ADC_IsActiveFlag_EOS (ADC1)! = ДАХИН тохируулах)

{if (sample_counter <32) {sample_buffer [sample_counter] = LL_ADC_REG_ReadConversionData32 (ADC1) / 256; if (sample_counter <32) sample_counter ++; else sample_counter = 0; } өөр {trigger = LL_ADC_REG_ReadConversionData32 (ADC1) / 256;

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

LL_GPIO_TogglePin (GPIOC, LL_GPIO_PIN_13);

LL_ADC_ClearFlag_EOS (ADC1);

} }

статик хоосон LL_Init (хүчингүй)

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

}

хоосон SystemClock_Config (хүчингүй)

{LL_FLASH_SetLatency (LL_FLASH_LATENCY_2); хэрэв (LL_FLASH_GetLatency ()! = LL_FLASH_LATENCY_2) Error_Handler (); LL_RCC_HSE_Enable (); байхад (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 (); 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); байхад (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));

}

статик хоосон MX_ADC1_Init (хүчингүй)

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

}

статик хоосон MX_SPI1_Init (хүчингүй)

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

статик хоосон MX_SPI2_Init (хүчингүй)

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

статик хоосон MX_TIM3_Init (хүчингүй)

{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_DisableARRP дахин ачаалах (TIM3);

LL_TIM_SetClockSource (TIM3, LL_TIM_CLOCKSOURCE_INTERNAL); LL_TIM_SetTriggerOutput (TIM3, LL_TIM_TRGO_UPDATE); LL_TIM_EnableMasterSlaveMode (TIM3); }

статик хоосон MX_TIM4_Init (хүчингүй)

{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_DisableARRP дахин ачаалах (TIM4);

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

статик хоосон MX_GPIO_Init (хүчингүй)

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

void _Error_Handler (char *файл, int мөр)

{байхад (1) {}}

#ifdef USE_FULL_ASSERT

void assert_failed (uint8_t* файл, uint32_t мөр)

{} #endif