ოთხ ბიტიანი ოსცილოსკოპი: 6 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

ეს არის სახალისო პროექტი, მხოლოდ იმის დანახვა, თუ რამდენად შორს შემიძლია სიჩქარის გადატანა MAX7219 წერტილოვანი მატრიცის ჩვენებაზე. და იმის მაგივრად, რომ მას გაეტარებინა "ცხოვრების თამაში", მე გადავწყვიტე გამეკეთებინა იგი. როგორც სათაურიდან მიხვდებით, ეს არ არის ნამდვილი ოსცილოსკოპის შემცვლელი:-).

ვინაიდან მე არ ვგეგმავ ამის გამოყენებას რაიმე სერიოზული ფორმით, მე არ გავაკეთებ ამისთვის დაბეჭდილ მიკროსქემის დაფას. შეიძლება, უბრალოდ მე მას პერფ-დაფაზე დავდებ, მაგრამ ახლა ის არის და დარჩება, პურის დაფაზე. ასევე არ არის შემავალი გამაძლიერებელი/შესუსტება, თქვენ უნდა მიაწოდოთ სიგნალი 0 -დან 3.3 ვ -მდე, ნუ იმოქმედებთ უარყოფითად ან 3.3 ვ -ზე მეტს, რადგან თქვენ შეიძლება დააზიანოთ მიკროკონტროლერი.

ნაბიჯი 1: აპარატურა

ეს არის იაფი, ძალიან იაფი, როდესაც ყიდულობთ ნაწილებს ჩინეთში ebay– ის ან მსგავსი საიტების საშუალებით. იგი იყენებს STM32F103C8 განვითარების დაფას, რომელსაც ზოგჯერ უწოდებენ "ლურჯ აბი", რომელიც შევიძინე დაახლოებით 2 ევროდ (ან აშშ დოლარი, ისინი თითქმის ერთნაირია, 2018 წლის ბოლომდე), ორი 8x8x4 წერტილოვანი მატრიცის ჩვენება MAX7219 ჩიპებით, ნაყიდი 5 ევრო ცალი და მბრუნავი კოდირება დაახლოებით 1 ევრო.

რა თქმა უნდა, საჭიროა ელექტროენერგიის მიწოდება 3.3V რამდენიმე ასეულ მილიამპერზე. STM32F103C8 განვითარების დაფაზე ძაბვის რეგულატორი არ გამოიყენება, მას არ შეუძლია უზრუნველყოს საკმარისი დენი ჩვენებისთვის. MAX7219– ის მონაცემთა ცხრილში მითითებულია, რომ კვების ძაბვა უნდა იყოს 4.0 – დან 5.5 ვ – მდე, მაგრამ ის კარგად მუშაობს 3.3 ვ – ზე, ალბათ არა მაშინ, როდესაც მას იყენებთ ძალიან ცხელ ან ცივ გარემოში, მაგრამ 20 გრადუსი ცელსიუსზე ეს კარგია. ახლა მე არ უნდა გამოვიყენო დონის კონვერტორები მიკროკონტროლერსა და ეკრანის დაფებს შორის.

ნაბიჯი 2: აშენება

როდესაც სურათს შეხედავთ, შესაძლოა დაინახოთ, რომ მე გამოვიყენებ ელექტროგადამცემი ხაზებს პურის დაფებზე არატრადიციულად, ორივე ხაზი ზემოდან არის პოზიტიური სარკინიგზო და ორივე ქვემოდან არის მიწის სარკინიგზო. ეს არის ის, რაც მე ამას ვაკეთებ და ის კარგად მუშაობს, ის გარეგნობას უფრო ჰგავს ჩემს მიერ დახატულ სქემებს. ასევე, მე გავაკეთე ბევრი პატარა დაფა, რომელზეც არის ნაწილები, რომლითაც შემიძლია ჩავრთო პურის დაფაზე, რათა დავაჩქარო საქმეები და ყველა მათგანი კონფიგურირებულია, რომ გამოიყენოს ორი ზედა ხაზი დადებითად და ქვედა ხაზები მიწად. როგორც ვთქვი, რეზოლუცია არის 4 ბიტიანი (16 დონე), და რადგანაც 4x8 led არის ერთმანეთის გვერდით, არის მხოლოდ 32 ნიმუშის წერტილი (pts). შეადარეთ Rigol Rigol DS1054Z (8 ბიტიანი და 12Mpts) და ნახავთ, რომ ეს ძნელად სათამაშოა. რა არის რეალური გამტარობა, არ ვიცი, მე გამოვცადე 10 კჰც -მდე და მუშაობს კარგად.

ნაბიჯი 3: პროგრამები

IDE, რომელსაც მე ვიყენებ არის Atollic TrueStudio, რომელიც მიმდინარე წლის დასაწყისისთვის (2018) მიღებული იყო ST Micro Electronics– ის მიერ და ხელმისაწვდომია უფასოდ, დროის ლიმიტის გარეშე, კოდის ზომის შეზღუდვის გარეშე, ნაგ ეკრანების გარეშე. მასთან ერთად, მე ვიყენებ STM32CubeMX, პროგრამას, რომელიც მაწვდის საწყის კოდს და ქმნის ყველა პერიფერიული მოწყობილობის ინიციალიზაციას. მას აქვს მიკროკონტროლერის ყველა ქინძისთავის ჩვენება და მათი გამოყენება. მაშინაც კი, თუ თქვენ არ იყენებთ STM32CubeMX კოდის გენერირებისთვის, ეს ძალიან მოსახერხებელია. ერთი რამ, რაც მე არ მომწონს, არის ეგრეთ წოდებული HAL, რომელიც არის სტანდარტული STM32CubeMX. მე მირჩევნია მუშაობის LowLayer მეთოდი.

მიკროკონტროლერის დასაპროგრამებლად ვიყენებ ST-Link პროგრამისტს/დებაგერს ST Micro Electronics– დან ან სეგერის მიერ დამზადებულ J-Link– ს. ორივე ეს მოწყობილობა უფასო არ არის, თუმცა მათი ჩინური ასლების შეძენა რამდენიმე ევროდ შეგიძლიათ.

ნაბიჯი 4: კოდის შესახებ

MAX7219- ის მისამართია LED- ები, რასაც მე ვუწოდებ ჰორიზონტალურ სტილში, 8 LED ერთმანეთის გვერდით. ოსცილოსკოპისთვის 8 LED ერთმანეთის თავზე უფრო ადვილი იქნებოდა, ამიტომ მე გავაკეთე მარტივი ჩარჩო-ბუფერი, რომელიც მონაცემებით არის ჩაწერილი ვერტიკალურად და წავიკითხე საჭირო ჰორიზონტალური გზით. MAX7219 იყენებს 16 ბიტიან კოდს 8 LED- ზე, სადაც პირველი ბაიტი გამოიყენება შერჩეული ხაზის დასახატად. და რადგან ამ მოდულებიდან ოთხი ერთმანეთზეა განლაგებული და მათი შეყვანა დაკავშირებულია მოდულის გამოსვლამდე, თქვენ უნდა გაგზავნოთ ეს 16 ბიტი ოთხჯერ ბოლო მოდულის მისაღწევად. (ვიმედოვნებ, რომ მე ვაცხადებ ყველაფერს ნათლად …) მონაცემები იგზავნება MAX7219– ში SPI– ს გამოყენებით, მარტივი, მაგრამ ძალიან სწრაფი პროტოკოლი. ეს არის ის, რაც მე ექსპერიმენტებს ვატარებდი, რამდენად სწრაფად შეგიძლიათ მონაცემების გაგზავნა MAX7219– ში. საბოლოო ჯამში, მე დავბრუნდი 9 MHz– ზე, იმ მაქსიმალური სიჩქარის ქვემოთ, რომელიც მითითებულია მონაცემთა ცხრილში.

მე ვიყენებ STM32F103C8– ის ოთხი ხელმისაწვდომი ქრონომეტრიდან ორს, ერთს დროის ბაზის თაობისთვის, ხოლო მეორეს მბრუნავი კოდირების წასაკითხად, რომელიც ადგენს დროის ბაზას. TIMER3 წარმოქმნის დროის ბაზას, ამას აკეთებს საათი 230 -ზე გაყოფით, მრიცხველის განახლება ყოველ 3.2 სთ -ში. Witch მბრუნავი კოდირების თქვენ შეგიძლიათ აირჩიოთ აქვს counter რიცხვი 2 საათის პულსი 2000 საათის პულსი. ვთქვათ თქვენ ირჩევთ 100 -ს. TIMER3 შემდეგ ქმნის მოვლენას ყოველ 320 აშშ დოლარში. ეს მოვლენა იწვევს ADC– ს ჩაწეროს შეყვანის სიგნალის ნიმუში და რადგანაც 32 ნიმუშის აღება ერთი სკრინინგისთვის, ეს დასრულდება დაახლოებით. 10 mS 10mS– ში შეგიძლიათ მოათავსოთ ერთი ტალღის სიგრძე 100 Hz, ან ორი 200 Hz და ა. ერთ ეკრანზე 3 ტალღაზე მეტი გადასვლა ართულებს ტალღის ფორმის ამოცნობას.

დანარჩენისთვის შემიძლია მხოლოდ კოდზე მოგახსენოთ, ძნელი არ არის დაიცვას მაშინაც კი, თუ მხოლოდ არდუინოსთან გაქვთ გარკვეული გამოცდილება. სინამდვილეში, თქვენ შეგიძლიათ იგივე გააკეთოთ არდუინოს საშუალებით, თუმცა მეეჭვება, რომ ის სწრაფად იმუშაოს "ცისფერმა აბამ". STM32F103C8 არის 32 ბიტიანი მიკროკონტროლერი, რომელიც მუშაობს 72 MHz– ზე, მას აქვს ორი SPI პერიფერიული მოწყობილობა და ძალიან სწრაფი ADC.

ნაბიჯი 5: მთავარი. თ

#ifndef _MAIN_H _#განსაზღვრა _MAIN_H_

#მოიცავს "stm32f1xx_ll_adc.h"

#მოიცავს "stm32f1xx_ll_rcc.h" #მოიცავს "stm32f1xx_ll_bus.h" #მოიცავს "stm32f1xx_ll_system.h" #Include "stm32f1xx_ll_exti.h" #include "stm32f1_xxxxx_xxx_xxx_xxx_xxx_xxx_xxx_x_xxx_x_xxx_x_xll_xhll_xhll_xxx_xll_mxxx_xll_mxxxx_ll_hll_xhll_hll_xhll_hll_xhll_hll_hll_hll_hll_hll_xhll_x35x_hll_xml_xml_hll_xml] მოიცავს "stm32f1xx_ll_dma.h" #მოიცავს "stm32f1xx_ll_spi.h" #მოიცავს "stm32f1xx_ll_tim.h" #მოიცავს "stm32f1xx.h" #მოიცავს "stm32f1xx_ll_gpio.h"

#ifndef NVIC_PRIORITYGROUP_0

განსაზღვრავს NVIC_PRIORITYGROUP_0 ((uint32_t) 0x00000007) განსაზღვრავს NVIC_PRIORITYGROUP_1 ((uint32_t) 0x00000006) განსაზღვრავს NVIC_PRIORITYGROUP_2 ((uint32_t) 0x00000005) განსაზღვრავს NVIC_PRIORITYGROUP_3 ((uint32_t) 0x00000004) განსაზღვრავს NVIC_PRIORITYGROUP_4 ((uint32_t) 0x00000003) #endif

#ifdef _plusplus

გარე "C" {#endif void _Error_Handler (char *, int);

#განსაზღვრა Error_Handler () _Error_Handler (_ FILE_, _LINE_)

#ifdef _plusplus} #endif

#დაასრულე თუ

ნაბიჯი 6: მთავარი. გ

#მოიცავს "main.h" სტატიკური სიცარიელე LL_Init (ბათილია); void 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 (); void erase_frame_buffer (void); void fill_frame_buffer (ბათილია); ბათილი ჩვენება_ჩარჩო_ბუფერი (ბათილია); void set_timebase (void);

uint8_t ზედა_ ჩვენება [4] [8]; // vier bytes naast elkaar, acht onder elkaar

uint8_t ქვედა_ ჩვენება [4] [8]; // deze twee samen vormen de frame-buffer

uint8_t ნიმუში_ ბუფერი [32]; // ბუფერული შედეგი ან სხვა შედეგი ADC

მთავარი (ბათილია)

{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_ ჩართვა (SPI2);

LL_TIM_EnableCounter (TIM3);

LL_TIM_EnableCounter (TIM4);

LL_ADC_Enable (ADC1);

LL_ADC_REG_StartConversionSWStart (ADC1); LL_ADC_EnableIT_EOS (ADC1);

LL_mDale (500); // MAX7219 სჭირდება გარკვეული დრო ჩართვის შემდეგ

MAX7219_1_init (); MAX7219_2_init ();

// LL_TIM_SetAutoReload (TIM3, 9);

ხოლო (1)

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

void erase_frame_buffer (ბათილია)

{int8_t x; int8_t y;

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

for (y = 0; y <8; y ++) // lijnenen {above_display [x] [y] = 0; // alle bitjes op nul lower_display [x] [y] = 0; }}}

void fill_frame_buffer (ბათილია)

{uint8_t y = 0; // ძაბვა uint8_t tijd = 0; // tijd uint8_t ჩვენება_ბაიტი; // steeds 8 bit in aast 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

{above_display [display_byte] [15-y] | = (1 << ჩვენების ბიტი); } სხვა // ქვედა ეკრანზე schrijven {lower_display [display_byte] [7-y] | = (1 << ჩვენების_ბიტი]; }}}

void display_frame_buffer (ბათილია)

{

uint8_t y; // acht lijnen boven elkaar (თითო ჩვენებაზე) uint16_t yl; // lijnnummer voor de MAX7219

for (y = 0; y <8; y ++) {yl = (y+1) << 8; // MAX7219 heeft lijnnummer in above 8 bit of 16 16 bit woord

SPI2_send64 ((yl | above_display [0] [y]), (yl | above_display [1] [y]), (yl | above_display [2] [y]), (yl | above_display [3] [y]));

SPI1_send64 ((yl | ქვედა_ჩვენების [0] [y]), (yl | ქვედა_ჩვენების [1] [y]), (yl | ქვედა_ჩვენების [2] [y]), (yl | ქვედა_ჩვენების [3] [y])); }

}

void set_timebase (void)

{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); // nop SPI1_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // გამორთვა SPI1_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI1_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // ტესტის რეჟიმი გამორთულია SPI1_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // გამორთვა, ნორმალური მოქმედება SPI1_send64 (0x0900, 0x0900, 0x0900, 0x0900); // არა 7 სეგიანი დეკოდირება, 64 პიქსელი SPI1_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // ინტენსივობა 50% SPI1_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // ყველა რიგი ჩართულია}

ბათილია MAX7219_2_init ()

{SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0C00, 0x0C00, 0x0C00, 0x0C00); // გამორთვა SPI2_send64 (0x0000, 0x0000, 0x0000, 0x0000); // nop SPI2_send64 (0x0F00, 0x0F00, 0x0F00, 0x0F00); // ტესტის რეჟიმი გამორთულია SPI2_send64 (0x0C01, 0x0C01, 0x0C01, 0x0C01); // გამორთვა, ნორმალური მოქმედება SPI2_send64 (0x0900, 0x0900, 0x0900, 0x0900); // არა 7 სეგიანი დეკოდირება, 64 პიქსელი SPI2_send64 (0x0A07, 0x0A07, 0x0A07, 0x0A07); // ინტენსივობა 50% SPI2_send64 (0x0B07, 0x0B07, 0x0B07, 0x0B07); // ყველა რიგი ჩართულია}

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

ხოლო (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data2);

ხოლო (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data1);

ხოლო (LL_SPI_IsActiveFlag_TXE (SPI1) == 0) {}

LL_SPI_TransmitData16 (SPI1, data0);

ხოლო (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, data3);

ხოლო (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data2);

ხოლო (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data1);

ხოლო (LL_SPI_IsActiveFlag_TXE (SPI2) == 0) {}

LL_SPI_TransmitData16 (SPI2, data0);

ხოლო (LL_SPI_IsActiveFlag_BSY (SPI2) == 1) {}

LL_GPIO_SetOutputPin (GPIOB, LL_GPIO_PIN_12);

დაბრუნება LL_SPI_ReceiveData16 (SPI2); }

სიცარიელე ADC1_2_IRQ მენეჯერი (ბათილია)

{static uint8_t sample_counter; uint8_t გამომწვევი; სტატიკური uint8_t წინა_ტრიგერი;

თუ (LL_ADC_IsActiveFlag_EOS (ADC1)! = გადატვირთვა)

{if (sample_counter <32) {sample_buffer [sample_counter] = LL_ADC_REG_ReadConversionData32 (ADC1) / 256; თუ (sample_counter <32) sample_counter ++; სხვაგან sample_counter = 0; } else {trigger = LL_ADC_REG_ReadConversionData32 (ADC1) / 256;

თუ ((გამომწვევი == 7) && (წინა_ტრიგერი <გამომწვევი)) // გათიშეთ ჰელემია წავიდა ბიჯ ბლოკგოლვენი… {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 ();

}

void SystemClock_Config (ბათილია)

{LL_FLASH_SetLatency (LL_FLASH_LATENCY_2); if (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 (); ხოლო (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. DMAT გადაცემა = 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. CRCC გამოთვლა = 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. CRCC გამოთვლა = 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_DesableARR გადატვირთვა (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_DesableARR გადატვირთვა (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 ხაზი)

{ } #დაასრულე თუ