चार बिट आस्टसीलस्कप: 6 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

यह देखने के लिए एक मजेदार परियोजना है कि मैं MAX7219 डॉट मैट्रिक्स डिस्प्ले को कितनी गति से आगे बढ़ा सकता हूं। और इसे "जीवन का खेल" चलाने के बजाय, मैंने इसके साथ "दायरा" बनाने का फैसला किया। जैसा कि आप शीर्षक से समझेंगे, यह वास्तविक आस्टसीलस्कप:-) का प्रतिस्थापन नहीं है।

जैसा कि मैं इसे किसी भी गंभीर तरीके से उपयोग करने की योजना नहीं बना रहा हूं, मैं इसके लिए एक मुद्रित सर्किट बोर्ड नहीं बनाऊंगा। हो सकता है, शायद मैं इसे एक पूर्ण-बोर्ड पर रख दूं लेकिन अभी के लिए यह एक ब्रेडबोर्ड पर है, और रहेगा। इसके अलावा कोई इनपुट एम्पलीफायर/एटेन्यूएटर नहीं है, आपको 0 और 3.3V के बीच एक सिग्नल की आपूर्ति करनी है, नकारात्मक या 3.3V से अधिक न जाएं क्योंकि आप माइक्रोकंट्रोलर को नुकसान पहुंचा सकते हैं।

चरण 1: हार्डवेयर

यह सस्ता है, बहुत सस्ता है जब आप ईबे या इसी तरह की साइटों के माध्यम से चीन में पुर्जे खरीदते हैं। यह एक STM32F103C8 विकास बोर्ड का उपयोग करता है, जिसे कभी-कभी "नीली गोली" कहा जाता है जिसे मैंने लगभग 2 यूरो (या USD, वे लगभग समान मूल्य, 2018 के अंत में) के लिए खरीदा था, दो 8x8x4 डॉट-मैट्रिक्स डिस्प्ले पर MAX7219 चिप्स के साथ खरीदा गया था, जिसके लिए खरीदा गया था 5 यूरो एक टुकड़ा और लगभग 1 यूरो का एक रोटरी एन्कोडर।

निश्चित रूप से कुछ सौ मिलीमीटर पर 3.3V देने वाली बिजली आपूर्ति की आवश्यकता है। STM32F103C8 विकास बोर्ड पर वोल्टेज नियामक का उपयोग नहीं किया जाता है, यह डिस्प्ले के लिए पर्याप्त करंट प्रदान नहीं कर सकता है। MAX7219 के लिए डेटाशीट निर्दिष्ट करती है कि ऑपरेटिंग आपूर्ति वोल्टेज 4.0 और 5.5V के बीच होना चाहिए, लेकिन यह 3.3V पर ठीक चलता है, शायद तब नहीं जब आप इसे बहुत गर्म या ठंडे वातावरण में उपयोग करते हैं, लेकिन 20 सेल्सियस पर यह ठीक है। और अब मुझे माइक्रोकंट्रोलर और डिस्प्लेबोर्ड के बीच लेवल-कन्वर्टर्स का उपयोग करने की आवश्यकता नहीं है।

चरण 2: बिल्ड

जब आप तस्वीर को देखते हैं तो आप देख सकते हैं कि मैं ब्रेडबोर्ड पर बिजली की लाइनों का उपयोग गैर-पारंपरिक तरीके से करता हूं, ऊपर की दोनों लाइनें सकारात्मक रेल हैं और नीचे दोनों तरफ ग्राउंड रेल हैं। जिस तरह से मैं इसे करने के लिए अभ्यस्त हूं और यह अच्छी तरह से काम करता है, यह सेटअप को मेरे द्वारा खींचे गए स्कीमैटिक्स की तरह थोड़ा और दिखता है। इसके अलावा, मैंने बहुत सारे छोटे बोर्ड बनाए हैं जिन पर मैं चीजों को गति देने के लिए ब्रेडबोर्ड में प्लग कर सकता हूं और वे सभी दो शीर्ष लाइनों को सकारात्मक और निचली लाइनों को जमीन के रूप में उपयोग करने के लिए कॉन्फ़िगर किए गए हैं। जैसा कि मैंने कहा, रिज़ॉल्यूशन 4 बिट (16 स्तर) है, और जैसा कि एक दूसरे के बगल में 4x8 एलईडी हैं, केवल 32 नमूना बिंदु (अंक) हैं। इसकी तुलना रिगोल रिगोल DS1054Z (8 बिट और 12Mpts) से करें और आप देखेंगे कि यह शायद ही कोई खिलौना हो। वास्तविक बैंडविड्थ क्या है, मुझे नहीं पता, मैंने इसे 10kHz तक परीक्षण किया है और यह ठीक काम करता है।

चरण 3: कार्यक्रम

मैं जिस आईडीई का उपयोग करता हूं वह एटोलिक ट्रू स्टूडियो है जिसे इस वर्ष (2018) की शुरुआत में एसटी माइक्रो इलेक्ट्रॉनिक्स द्वारा अपनाया गया था और यह मुफ्त में उपलब्ध है, कोई समय सीमा नहीं, कोई कोड आकार सीमा नहीं, कोई नाग-स्क्रीन नहीं। इसके साथ में, मैं STM32CubeMX का उपयोग करता हूं, एक प्रोग्राम जो मुझे शुरुआती कोड प्रदान करता है और सभी बाह्य उपकरणों के आरंभीकरण को उत्पन्न करता है। और इसमें माइक्रोकंट्रोलर के सभी पिन और उनके उपयोग का डिस्प्ले है। यदि आप कोड जनरेट करने के लिए STM32CubeMX का उपयोग नहीं करते हैं, तो भी यह बहुत आसान है। एक चीज जो मुझे पसंद नहीं है वह तथाकथित HAL है जो STM32CubeMX का डिफ़ॉल्ट है। मुझे काम करने का लोलेयर तरीका पसंद है।

माइक्रोकंट्रोलर को प्रोग्राम करने के लिए मैं एसटी माइक्रो इलेक्ट्रॉनिक्स से एसटी-लिंक प्रोग्रामर/डीबगर या सेगर द्वारा बनाए गए जे-लिंक का उपयोग करता हूं। ये दोनों डिवाइस फ्री नहीं हैं, हालांकि आप इनकी चीनी कॉपी कुछ यूरो में खरीद सकते हैं।

चरण 4: कोड के बारे में

MAX7219 का पता एल ई डी है जिसे मैं एक क्षैतिज फैशन कहता हूं, एक दूसरे के बगल में 8 एलईडी। एक आस्टसीलस्कप के लिए 8 एलईडी एक दूसरे के ऊपर आसान होता, इसलिए मैंने एक साधारण फ्रेम-बफर बनाया जो डेटा के साथ लंबवत तरीके से लिखा जाता है, और आवश्यक क्षैतिज तरीके से पढ़ा जाता है। MAX7219 प्रति 8 एल ई डी में 16 बिट कोड का उपयोग करता है, जहां पहले बाइट का उपयोग चयनित लाइन को संबोधित करने के लिए किया जाता है। और चूंकि इनमें से चार मॉड्यूल एक दूसरे के बगल में स्टैक्ड हैं, उनके इनपुट इसके पहले मॉड्यूल के आउटपुट से जुड़े हैं, आपको अंतिम मॉड्यूल तक पहुंचने के लिए उन 16 बिट्स को चार बार भेजना होगा। (मुझे आशा है कि मैं चीजों को स्पष्ट कर रहा हूँ…)डेटा SPI, एक सरल लेकिन बहुत तेज़ प्रोटोकॉल का उपयोग करके MAX7219 पर भेजा जाता है। यही मैं प्रयोग कर रहा था, आप MAX7219 पर डेटा भेजने में कितनी तेजी से जा सकते हैं। अंत में, मैंने डेटाशीट द्वारा निर्दिष्ट अधिकतम गति के ठीक नीचे 9 मेगाहर्ट्ज पर वापस स्विच किया।

मैं STM32F103C8 के चार उपलब्ध टाइमर में से दो का उपयोग करता हूं, एक टाइमबेस की पीढ़ी के लिए और दूसरा रोटरी एन्कोडर को पढ़ने के लिए, जो टाइमबेस सेट करता है। TIMER3 टाइमबेस उत्पन्न करता है, यह घड़ी को 230 से विभाजित करके करता है, काउंटर को हर 3.2 यूएस में अपडेट करता है। रोटरी एनकोडर को विच करें जिसे आप 2 क्लॉक पल्स से लेकर 2000 क्लॉक पल्स तक काउंटर काउंट के लिए चुन सकते हैं। मान लें कि आप 100 चुनते हैं। TIMER3 फिर हर 320 यूएस में एक EVENT जेनरेट करता है। यह घटना एडीसी को इनपुट सिग्नल का एक नमूना रिकॉर्ड करने के लिए ट्रिगर करती है, और एक स्क्रीनफुल के लिए 32 नमूने लेने के लिए, यह लगभग के बाद पूरा हो जाएगा। 10 एमएस। 10mS में आप 100 Hz की एक तरंग दैर्ध्य, या 200 Hz की दो तरंगदैर्ध्य फिट कर सकते हैं, और इसी तरह। प्रति स्क्रीन ३ तरंगों से अधिक जाने से हालांकि तरंग को पहचानना कठिन हो जाता है।

बाकी के लिए, मैं आपको केवल कोड के लिए संदर्भित कर सकता हूं, इसका पालन करना कठिन नहीं है, भले ही आपके पास केवल Arduino के साथ कुछ अनुभव हो। वास्तव में, आप एक Arduino के साथ एक ही चीज़ बना सकते हैं, हालांकि मुझे संदेह है कि यह एक "नीली गोली" के रूप में तेजी से काम करेगा। STM32F103C8 एक 32 बिट माइक्रोकंट्रोलर है जो 72 मेगाहर्ट्ज पर चल रहा है, इसमें दो एसपीआई परिधीय और एक बहुत तेज एडीसी है।

चरण 5: Main.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 "stm32f1xx_ll_cortex.h" #mf शामिल "stm32f1xx_ll_dma.h" #शामिल "stm32f1xx_ll_spi.h" #शामिल "stm32f1xx_ll_tim.h" #शामिल "stm32f1xx.h" #शामिल "stm32f1xx_ll_gpio.h"

#ifndef NVIC_PRIORITYGROUP_0

#uint32_t)0x00000005 परिभाषित करें

#ifdef _cplusplus

बाहरी "सी" {#endif void _Error_Handler(char *, int);

#define Error_Handler() _Error_Handler(_FILE_, _LINE_)

#ifdef _cplusplus } #endif

#अगर अंत

चरण 6: Main.c

#include "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 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); शून्य MAX7219_1_init (); शून्य MAX7219_2_init (); शून्य इरेज़_फ्रेम_बफ़र (शून्य); शून्य fill_frame_buffer (शून्य); शून्य डिस्प्ले_फ्रेम_बफर (शून्य); शून्य सेट_टाइमबेस (शून्य);

uint8_t अपर_डिस्प्ले[4][8]; // विएर बाइट्स नास्ट एलकार, अचट ओन्डर एलकार

uint8_t निचला_डिस्प्ले[4][8]; // डीज़ ट्वी सैमन वोर्मेन डे फ्रेम-बफर

uint8_t नमूना_बफर [32]; // बफर वूर डे रिजल्टटेन वैन डे एडीसी

मुख्य अंतर (शून्य)

{ एलएल_इनिट (); सिस्टमक्लॉक_कॉन्फिग (); एमएक्स_जीपीआईओ_इनिट (); MX_ADC1_Init (); MX_SPI1_Init (); MX_SPI2_Init (); MX_TIM3_Init (); MX_TIM4_Init ();

LL_SPI_ सक्षम करें (SPI1);

LL_SPI_सक्षम करें (SPI2);

LL_TIM_EnableCounter (TIM3);

LL_TIM_EnableCounter(TIM4);

LL_ADC_सक्षम करें (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)

{सेट_टाइमबेस (); इरेज़_फ्रेम_बफ़र (); fill_frame_buffer (); डिस्प्ले_फ्रेम_बफर (); } }

शून्य मिटा_फ्रेम_बफ़र (शून्य)

{ int8_t एक्स; int8_t वाई;

के लिए (x = 0; x <4; x++) //kolom_bytes {

के लिए (y = 0; y <8; y++) //lijnen {अपर_डिस्प्ले[x][y] = 0; // सभी बिटजेस op nul lower_display[x][y] = 0; } } }

शून्य fill_frame_buffer (शून्य)

{ uint8_t y = 0; // वोल्टेज uint8_t tijd = 0; // tijd uint8_t डिस्प्ले_बाइट; // स्टीड्स 8 बिट्स नास्ट एलकार एन डेट 4 माल ऑप ईन लिजन uint8_t डिस्प्ले_बिट;

के लिए (tijd = 0; tijd <32; tijd++) {display_byte = tijd/8; डिस्प्ले_बिट = 7 - (टीजेड% 8);

y = नमूना_बफ़र [tijd];

अगर (y > 7) // ऊपरी डिस्प्ले में schrijven

{ अपर_डिस्प्ले [डिस्प्ले_बाइट] [१५-वाई] | = (१ << डिस्प्ले_बिट); } और // निचले डिस्प्ले में schrijven {lower_display[display_byte][7-y] |= (1 << display_bit); } } }

शून्य डिस्प्ले_फ्रेम_बफर (शून्य)

{

uint8_t y; // अचट लिजेन बोवेन एल्कार (प्रति डिस्प्ले) uint16_t yl; //lijnnummer voor de MAX7219

के लिए (y = 0; y <8; y++) { yl = (y+1) << 8; // MAX7219 हीफ्ट लिजनममर इन डी अपर 8 बिट वैन 16 बिट वूर्ड

SPI2_send64 ((yl | अपर_डिस्प्ले [0] [y]), (yl | अपर_डिस्प्ले [1] [y]), (yl | अपर_डिस्प्ले [2] [y]), (yl | अपर_डिस्प्ले [3] [y]));

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

}

शून्य सेट_टाइमबेस (शून्य)

{ uint8_t timebase_knop;

timebase_knop = LL_TIM_GetCounter(TIM4) / 2;

स्विच (timebase_knop)

{केस 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 data3, uint16_t data2, uint16_t data1, uint16_t data0)

{ 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 नमूना_काउंटर; uint8_t ट्रिगर; स्थिर uint8_t पिछला_ट्रिगर;

अगर (LL_ADC_IsActiveFlag_EOS (ADC1)! = रीसेट)

{ अगर (नमूना_काउंटर <32) {नमूना_बफ़र [नमूना_काउंटर] = LL_ADC_REG_ReadConversionData32 (ADC1) / 256; अगर (नमूना_काउंटर <32) नमूना_काउंटर ++; अन्य नमूना_काउंटर = 0; } और { ट्रिगर = LL_ADC_REG_ReadConversionData32 (ADC1) / 256;

अगर ((ट्रिगर == 7) && (पिछला_ट्रिगर <ट्रिगर)) // गैट नीत हेलमाल गोड बिज ब्लॉकगोल्वेन… {नमूना_काउंटर = 0; } पिछला_ट्रिगर = ट्रिगर; }

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_सेट लेटेंसी (LL_FLASH_LATENCY_2); अगर (LL_FLASH_GetLatency ()! = LL_FLASH_LATENCY_2) Error_Handler (); LL_RCC_HSE_सक्षम करें (); जबकि (LL_RCC_HSE_IsReady ()! = 1); LL_RCC_PLL_ConfigDomain_SYS(LL_RCC_PLLSOURCE_HSE_DIV_1, LL_RCC_PLL_MUL_9); LL_RCC_PLL_सक्षम करें (); जबकि (LL_RCC_PLL_IsReady ()! = 1); LL_RCC_SetAHBPरेस्केलर (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_Init1ms टिक (72000000); LL_SYSTICK_SetClkSource (LL_SYSTICK_CLKSOURCE_HCLK); एलएल_सेटसिस्टमकोरक्लॉक (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. CRCगणना = LL_SPI_CRCALCULATION_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. CRCगणना = LL_SPI_CRCALCULATION_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 = २२९;

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

शून्य _Error_Handler (चार * फ़ाइल, इंट लाइन)

{ जबकि(1) { } }

#ifdef USE_FULL_ASSERT

शून्य मुखर_विफल (uint8_t* फ़ाइल, uint32_t पंक्ति)

{ } #अगर अंत