მატრიცული დისპლეი - მოწყობილობა, რომელიც შედგება 8x8 LED მატრიცისგან და MAX7219 ჩიპზე დაფუძნებული მართვის დაფისგან, მინიმალური საჭირო მილებით. ფოტოზე უკვე ხედავთ დასრულებულ მოწყობილობას, მაგრამ ის ფოსტით მომივიდა ამ ფორმით, ამიტომ მომიწია აეღო გამაგრილებელი უთო და ყველაფერი სწორად გამეყარა.
Arduino Nano-ს დაფასთან ძირითადი კავშირი ნაჩვენებია მიკროსქემის დიაგრამაში.
როგორც სქემიდან ხედავთ, ყველაფერი მარტივია, თქვენ უბრალოდ უნდა დააკავშიროთ ორივე დაფის კონტაქტები შემდეგი თანმიმდევრობით:
| არდუინო ნანო | მატრიცა 8x8 |
| PIN 12 | PIN DIN |
| PIN 11 | PIN CLK |
| PIN 10 | PIN CS |
| PIN 5V | PIN 5V |
| PIN GND | PIN GND |
ასე რომ, საბოლოოდ დროა ვიმუშაოთ კოდთან და LED მატრიცის გასაშვებად, თქვენ უნდა ჩამოტვირთოთ და დააინსტალიროთ LedControl ბიბლიოთეკა. ბიბლიოთეკა მხარს უჭერს MAXIM 7221 და 7219 მიკროსქემებს. LED მატრიცა იყენებს MAX7219 როგორც დრაივერი, ეს არის ის, რაც ჩვენ გვჭირდება. ვფიქრობ, ჩვენ უნდა დავიწყოთ პატარა ჩანახატით, რომელიც აჩვენებს ამ ბიბლიოთეკის ძირითად ფუნქციებს. ესკიზში setRow() ფუნქცია გამოიყენება LED-ების ჩართვის/გამორთვისთვის. setRow() ფუნქციის გამოძახების სინტაქსია:
matrix.setRow(0, row, col, set);
სად მატრიცა- კლასის ობიექტი LedControl
0 - მოწყობილობის მისამართი SPI ავტობუსზე, ამ შემთხვევაში არის მხოლოდ ერთი მოწყობილობა და ნუმერაცია იწყება მისამართიდან ნულიდან.
რიგი- მწკრივი (შესაძლებელია მნიშვნელობები 0-დან 7-მდე)
პოლკოვნიკი- სვეტი (შესაძლებელია მნიშვნელობები 0-დან 7-მდე)
კომპლექტი- დაყენების მნიშვნელობა ( მართალია- ჩართვა, ყალბი- გამორთვა)
matrix.setRow(0, 1, 4, true)
ჩართეთ LED მატრიცაზე, რომელიც მდებარეობს პირველ რიგში და მე -4 სვეტში.
Სხვა მაგალითი:
int x = 1;
int y = 4;
matrix.setRow(0, x, y, true);
matrix.setRow(0, x, y, false);
იგივე ხდება მხოლოდ ცვლადების გამოყენებით და შემდგომში ანთებული LED-ის გამორთვა მოცემულ კოორდინატებზე. ასე რომ, ესკიზში რამდენიმე ანიმაცია ითამაშა setRow () ფუნქციის გამოყენებით.
#include "LedControl.h" //სინტაქსი LedControl კლასის შესაქმნელად (dataPin,clockPin,csPin,numDevices) //სადაც LedControl არის კლასის ობიექტი //dataPin არის პინი Arduino დაფაზე, რომელსაც DIN pin იყოს დაკავშირებული //clockPin არის პინი Arduino დაფაზე, რომელსაც დაუკავშირდება CLK პინი //csPin - პინი Arduino-ს დაფაზე, რომელსაც დაუკავშირდება CS პინი //numDevices - მოწყობილობების რაოდენობა ავტობუსში / /შექმენით მატრიცის კლასის ობიექტი ჩვენს შემთხვევაში ერთი დაკავშირებული მოწყობილობით LedControl matrix = LedControl(12, 11 , 10, 1); //მატრიცაზე LED-ის ჩართვის/გამორთვის დაყოვნების დრო const int delayValue = 100; //ფუნქციის პროტოტიპები //sequential on/off void PointSerialSet(); //გველი მარჯვნიდან მარცხნივ void PointRigthToLeft(); //გველი ქვემოდან ზევით void PointDownToUp(); //გველი მარცხნიდან მარჯვნივ void PointLeftToRigth(); //გველი ზემოდან ქვემოდან void PointUpToDown(); //Effect - პულსის გაქრობა void PointFading(); //ეფექტი - პულსი void PointPulse(); //Effect - მზარდი იმპულსი void PointClimbing(); //სპირალის გადახვევის ეფექტი void PointToSpiralIn(); //სპირალის გარეთა სიცარიელის დატრიალების ეფექტი PointToSpiralOut(); void setup() (// მოწყობილობა 0 მისამართით wake up by default matrix.shutdown(0, false); //Led მატრიცის სიკაშკაშე დააყენეთ 8-ზე //შესაძლებელი მნიშვნელობებია 0-დან 15-მდე matrix.setIntensity( 0, 8). (); PointPulse() ; PointClimbing(); PointToSpiralIn(); PointToSpiralOut(); ) //ფუნქციის ორგანოები void PointSerialSet() ( //setLed(მისამართი, მწკრივი, col, ნაკრები) ფუნქციის გამოყენება //მიმდევრობითი ჩართვა რიგების მიხედვით for(int i = 0; i< 8; i ++) { for(int j = 0; j < 8; j ++) { //Включить светодиод matrix.setLed(0, i, j, true); delay(delayValue); //Выключить светодиод matrix.setLed(0, i, j, false); } } } void PointRigthToLeft() { //Используем функцию setLed(address, row, col, set) //Змейка справа - налево for(int i = 7; i >= 0; i --) ( for(int j = 7, n = 0; j >= 0, n< 8; j --, n ++) { if((i % 2) >0) ( matrix.setLed(0, j, i, true); delay(delayValue); matrix.setLed(0, j, i, false); ) else (matrix.setLed(0, n, i, true); delay(delayValue); matrix.setLed(0, n, i, false); ) ) ) ) void PointDownToUp() ( //გამოიყენე setLed(მისამართი, მწკრივი, col, ნაკრები) ფუნქცია //Snake ქვემოდან ზევით ამისთვის (int i = 7; i >= 0; i --) ( for(int j = 7, n = 0; j >= 0, n< 8; j --, n ++) { if((i % 2) >0) ( matrix.setLed(0, i, n, true); delay(delayValue); matrix.setLed(0, i, n, false); ) else (matrix.setLed(0, i, j, true); delay(delayValue); matrix.setLed(0, i, j, false); ) ) ) ) void PointLeftToRigth() ( //გამოიყენე ფუნქცია setLed(მისამართი, მწკრივი, col, ნაკრები) //გველი მარცხნიდან მარჯვნივ (int i = 0 i< 8; i ++) { for(int j = 7, n = 0; j >= 0, n< 8; j --, n ++) { if((i % 2) >0) ( matrix.setLed(0, j, i, true); delay(delayValue); matrix.setLed(0, j, i, false); ) else (matrix.setLed(0, n, i, true); delay(delayValue); matrix.setLed(0, n, i, false); ) ) ) ) void PointUpToDown() ( //გამოიყენე setLed(მისამართი, მწკრივი, col, ნაკრები) ფუნქცია //Snake ზემოდან ქვემოდან (int i = 0 i< 8; i ++) { for(int j = 7, n = 0; j >= 0, n< 8; j --, n ++) { if((i % 2) >0) ( matrix.setLed(0, i, n, true); delay(delayValue); matrix.setLed(0, i, n, false); ) else (matrix.setLed(0, i, j, true); delay(delayValue); matrix.setLed(0, i, j, false); ) ) ) ) void PointFading() ( //გამოიყენე setLed(მისამართი, მწკრივი, col, ნაკრები) ფუნქცია //Fading effect int upValue = 0 ; int downValue = 7; for(int i = 0; i< 8; i ++) { if(i % 2) { for(int n = downValue; n >= upValue; n --) ( matrix.setLed(0, n, i, true); delay(delayValue); matrix.setLed(0, n, i, false); ) downValue --; ) else (for(int j = upValue; j< downValue + 1; j ++) { matrix.setLed(0, j, i, true); delay(delayValue); matrix.setLed(0, j, i, false); } upValue ++; } } } void PointClimbing() { //Используем функцию setLed(address, row, col, set) //Эффект затухания int upValue = 4; int downValue = 4; for(int i = 0; i < 8; i ++) { if(i % 2) { for(int n = downValue; n >= upValue; n --) ( matrix.setLed(0, n, i, true); delay(delayValue); matrix.setLed(0, n, i, false); ) downValue ++; ) else (for(int j = upValue; j< downValue + 1; j ++) { matrix.setLed(0, j, i, true); delay(delayValue); matrix.setLed(0, j, i, false); } upValue --; } } } void PointPulse() { //Используем функцию setLed(address, row, col, set) //Эффект пульса for(int i = 0; i < 8; i ++) { if(i == 4) { for(int climb = i; climb >= 0; climb --) ( matrix.setLed(0, climb, i, true); delay(delayValue / 4); matrix.setLed(0, climb, i, false); ) for(int fade = 1; fade< 8; fade ++) { matrix.setLed(0, fade, i, true); delay(delayValue / 4); matrix.setLed(0, fade, i, false); } } else { matrix.setLed(0, 4, i, true); delay(delayValue); matrix.setLed(0, 4, i, false); } } } void PointToSpiralIn() { //Используем функцию setLed(address, row, col, set) //Эффект спирали внутрь int lengthX = 8; // Ширина матрицы int lengthY = 8; // Высота матрицы int pointX = 0; int pointY = 0; int dir = 0; // Направление (0 - вправо, 1 - вниз, 2 - влево, 3 - вверх) int offset = 0; // Смещение // Перебираем всю матрицу for (int i = 0; i < lengthX * lengthY; i++) { matrix.setLed(0, pointY, pointX, true); delay(delayValue); matrix.setLed(0, pointY, pointX, false); if(dir == 0) { pointX ++; if(pointX >= სიგრძეX - 1 - ოფსეტური) ( dir = 1; ) გაგრძელება; ) if(dir == 1) (pointY ++; if(pointY ><= offset) { dir = 3; } continue; } if(dir == 3) { pointY --; if(pointY <= offset + 1) { dir = 0; offset ++; pointY = offset; } continue; } } } void PointToSpiralOut() { //Используем функцию setLed(address, row, col, set) //Эффект спирали внаружу int lengthX = 8; // Ширина матрицы int lengthY = 8; // Высота матрицы int pointX = 3; //начать с этих координат int pointY = 3; //начать с этих координат int dir = 0; // Направление (0 - вправо, 1 - вниз, 2 - влево, 3 - вверх) int offset = 3; // Смещение // Перебираем всю матрицу for (int i = 0; i < lengthX * lengthY; i++) { matrix.setLed(0, pointY, pointX, true); delay(delayValue); matrix.setLed(0, pointY, pointX, false); if(dir == 0) { pointX ++; if(pointX >= სიგრძეX - 1 - ოფსეტური) ( dir = 1; ) გაგრძელება; ) if(dir == 1) ( pointY ++; if(pointY >= lengthY - 1 - offset) (dir = 2; ) გაგრძელება; ) if(dir == 2) (pointX --; if(pointX<= offset - 1) { dir = 3; } continue; } if(dir == 3) { pointY --; if(pointY <= offset - 1) { dir = 0; offset --; pointY = offset; } continue; } } }
ესკიზის ვიდეო:
წინა გაკვეთილებზე ვისწავლეთ ცვლის რეესტრის დახმარებით. ეს ცოტა უფრო რთული აღმოჩნდა, ვიდრე უშუალოდ ზოგადი დანიშნულების ქინძისთავები. პრობლემა, რომლის გადაჭრაც მოგვიწია, იყო Arduino კონტროლერზე კონტროლირებადი გამომავლების შეზღუდული რაოდენობა. ჩვენი კვლევის აპოგეა იყო დინამიური აღნიშვნის გამოყენება. ახლა დროა ცოტათი გავართულოთ დავალება: ვსწავლობთ LED მატრიცასთან მუშაობას.
1. მატრიცული მაჩვენებელი
როგორც უკვე ვიცით, სეგმენტის ინდიკატორები, იქნება ეს სასწორები თუ რიცხვები, შედგება ცალკეული LED-ებისგან, რომლებიც ერთმანეთთან არის დაკავშირებული. მაგალითად, LED-ების ჯგუფს შეიძლება ჰქონდეს ყველა კათოდი დაკავშირებული. ასეთ ინდიკატორს აქვს პოსტსკრიპტი „საერთო კათოდით“, წინააღმდეგ შემთხვევაში – „საერთო ანოდით“. და რა მოხდება, თუ LED-ებს მოვათავსებთ არა რიცხვის ან სასწორის, არამედ ბადის სახით? ეს საკმაოდ გრაფიკული მაჩვენებელი აღმოჩნდება. ანუ ის, რომელზედაც შეგიძლიათ არა მხოლოდ რიცხვის ჩვენება, არამედ რაიმე სახის გამოსახულებაც. ასეთ ბადეს ეწოდება მატრიცული ინდიკატორი, ხოლო LED-ების შემთხვევაში, LED მატრიცა. მატრიცის ინდიკატორის გარჩევადობა არის ჰორიზონტალური და ვერტიკალური წერტილების რაოდენობა. მაგალითად, ყველაზე გავრცელებულ ინდიკატორებს აქვთ 8×8 პიქსელის გარჩევადობა. თუ საჭიროა უფრო მაღალი გარჩევადობის LED მატრიცა, მაშინ ის უბრალოდ შედგება რამდენიმე 8x8 ინდიკატორისგან. როგორ გავაკეთოთ ეს, მოგვიანებით ვნახავთ. იმავდროულად, მოდით გაერკვნენ, თუ როგორ არის დაკავშირებული მატრიცის შიგნით არსებული 64 LED-ები. რა თქმა უნდა, შესაძლებელი იქნებოდა, როგორც შვიდსეგმენტიანი ინდიკატორის შემთხვევაში, ყველა LED-ის დაკავშირება საერთო კათოდით ან ანოდით. ამ შემთხვევაში, დაგვჭირდება ან 64 კონტროლერის პინი ან 8 ცვლის რეგისტრი. ორივე ვარიანტი ძალიან ფუჭია. უფრო სწორი ვარიანტია LED-ების გაერთიანება 8 ცალი ჯგუფებად საერთო კათოდით. მოდით ეს იყოს მატრიცის სვეტები. შემდეგ, ამ სვეტებში პარალელური LED-ები კვლავ გაერთიანებულია 8 ცალი ჯგუფებად უკვე საერთო ანოდით. თქვენ მიიღებთ შემდეგ სქემას:
დავუშვათ, ამოცანაა R6C3 LED-ის განათება. ამისათვის ჩვენ უნდა გამოვიყენოთ მაღალი სიგნალის დონე პინ R6-ზე და დავაკავშიროთ პინი C3 მიწასთან. 
ამ წერტილის გამორთვის გარეშე, შევეცადოთ გავანათოთ მეორე - R3C7. შეაერთეთ დადებითი დენის პინი R3-ზე და დამიწება C7-ზე. მაგრამ ამ შემთხვევაში, R6 და R3 რიგები გადაიკვეთება C3 და C7 სვეტებთან არა ორ, არამედ ოთხ ადგილას! შესაბამისად, ანათებს არა ორი, არამედ ოთხი ქულა. პრობლემა! 
ცხადია, იგივე შეიძლება დაგვეხმაროს. თუ რიგრიგობით ძალიან სწრაფად ჩავრთავთ R6C3 და R3C7 წერტილებს, შეგვიძლია გამოვიყენოთ მხედველობის გამძლეობა - სწრაფად ცვალებადი სურათების მთლიანობაში ინტერპრეტაციის უნარი. 2. LED მატრიცის და ცვლის რეგისტრები
ჩვენს გაკვეთილზე ჩვენ დავაკავშირებთ უმარტივეს 8 × 8 წითელ LED მატრიცას Arduino Uno-ს. პინის ნუმერაცია იწყება ქვედა მარცხენა კუთხიდან. ამავდროულად, 1-16 ფეხის ნუმერაცია არავითარი ლოგიკით არ არის დაკავშირებული C და R სტრიქონების ნუმერაციასთან.
დინამიური მითითების შესახებ გაკვეთილზე ფოკუსირებით, შევეცადოთ გამოვიყენოთ 8-ბიტიანი ცვლის რეგისტრები მატრიცის ინდიკატორის კონტროლის სქემაში. ჩვენ ვაკავშირებთ ერთ რეგისტრს სვეტებზე პასუხისმგებელი ინდიკატორის გამოსავალზე, ხოლო მეორეს მწკრივებზე. წრიული დიაგრამა
მნიშვნელოვანი შენიშვნა #1.აუცილებელია, რომ რეზისტორები ამ წრეში იყოს პირველი ცვლის რეესტრიდან გამოსულ ხაზებზე. ეს ცვლის რეგისტრი პასუხისმგებელია სვეტებზე. ამ კავშირით, თითოეული რეზისტორი დააყენებს დენს მხოლოდ ერთი LED-ისთვის დინამიური ალგორითმის თითოეულ საფეხურზე. ამიტომ, ყველა LED-ები თანაბრად ანათებენ. მნიშვნელოვანი შენიშვნა #2.ზემოთ მოცემული დიაგრამა მხოლოდ საინფორმაციო მიზნებისთვისაა. უფრო სწორი იქნება დამატებითი სიმძლავრის მიკროსქემის ჩართვა მეორე რეესტრსა და მატრიცას შორის არსებულ უფსკრულის სახით, მაგალითად, ULN2003 ტრანზისტორი კრებული. 3. პროგრამა
უფრო სახალისო რომ გავხადოთ, შევეცადოთ გამოვყოთ სმაილი ინდიკატორზე. როგორც უკვე აღვნიშნეთ, გამოსახულების მატრიცაზე გამოსატანად გამოვიყენებთ დინამიურ აღნიშვნას. კერძოდ, ჩვენ გამოვყოფთ ჩვენს სურათს ხაზ-სტრიქონით. ჯერ ვანათებთ აუცილებელ სვეტებს ზედა მწკრივში, შემდეგ მეორეში, მესამეში და ასე შემდეგ 8-ვე მწკრივში.
პირველი ცვლის რეგისტრი პასუხისმგებელია სვეტებზე, ხოლო მეორე რიგებზე. მაშასადამე, სტრიქონის გამომავალი შედგება ორი თანმიმდევრული ჩაწერისგან რეესტრში: ჯერ გადავცემთ სტრიქონის კოდს, შემდეგ ამ სტრიქონის წერტილების კოდს. ამ პროგრამაში ჩვენ ასევე გამოვიყენებთ digitalWrite ფუნქციის დაჩქარებულ ვერსიას. ეს აუცილებელია იმისათვის, რომ დინამიური ჩვენების პროცესი ძალიან სწრაფად წარიმართოს. წინააღმდეგ შემთხვევაში, ჩვენ დავინახავთ მატრიცის შესამჩნევ ციმციმს. წყარო const byte data_pin = PD2; const byte st_pin = PD3; const byte sh_pin = PD4; ხელმოუწერელი long tm, next_flick; const unsigned int to_flick = 500; ბაიტის ხაზი = 0; const byte მონაცემები = ( 0b00111100, 0b01000010, 0b10100101, 0b10000001, 0b10100101, 0b10011001, 0b01000010, 01001); void latchOn()( digitalWriteFast(st_pin, HIGH); digitalWriteFast(st_pin, LOW); ) void fill(byte d)(for(char i=0; i<8; i++){
digitalWriteFast(sh_pin, LOW);
digitalWriteFast(data_pin, d & (1<4. ანიმაცია LED მატრიცაზე
ახლა კი ჩვენ დავასრულებთ პროგრამას ისე, რომ ინდიკატორზე გამოსახულება ყოველ ნახევარ წამში შეიცვალოს. ამისათვის კიდევ ერთხელ გავიხსენოთ. const byte data_pin = PD2; const byte st_pin = PD3; const byte sh_pin = PD4; ხელმოუწერელი long tm, next_flick, next_switch; const unsigned int to_flick = 500; const unsigned long to_switch = 500000; ბაიტის ხაზი = 0; ბაიტის ჩარჩო = 0; Const Byte Data = ((0b00111100, 0B101000010, 0B10100101, 0B10100101, 0B10100101, 0B0100001, 0B0100001, 0B00111100, 0B101000010, 0B10100001, 0B10000001, 0B10000001, 0B101110101, 0B101110101, 0B101000010, 0B00111100); void latchOn()( digitalWriteFast(st_pin, HIGH); digitalWriteFast(st_pin, LOW); ) void fill(byte d)(for(char i=0; i<8; i++){ digitalWriteFast(sh_pin, LOW); digitalWriteFast(data_pin, d & (1<
5. LED მატრიცის სკალირება
8×8 LED მატრიცა შესაფერისია ორი ნომრის ან მარტივი სიმბოლოს ჩვენებისთვის. თუ გსურთ ინდიკატორზე მეტ-ნაკლებად სასარგებლო გამოსახულების ჩვენება, თქვენ უნდა დააკავშიროთ მატრიცები. ეს კეთდება ახალი ცვლის რეგისტრების დამატებით, როგორც ვერტიკალურად, ასევე ჰორიზონტალურად. უნდა აღინიშნოს, რომ Arduino Uno კონტროლერის სიჩქარე ცვლის რეგისტრებთან ერთად საკმარისია მხოლოდ 16 × 16 დისპლეისთვის. LED დისპლეის ზომის შემდგომი გაზრდა გამოიწვევს შესამჩნევ ციმციმს.Დავალებები
- ჰიპნოზი. დაპროგრამეთ კონტროლერი ისე, რომ LED მატრიცაზე მუდმივად მზარდი რადიუსის კონცენტრული წრეები გამოჩნდეს 1 წამის პერიოდით.
- გველის თამაში. განახორციელეთ ისეთი ცნობილი თამაში, როგორიცაა გველი 8×8 LED მატრიცაზე. აუცილებელია წრეში ოთხი ღილაკის დამატება მოძრაობის მიმართულების გასაკონტროლებლად, ასევე ზუმერი ვაშლის ჭამის მოვლენის სიგნალიზაციისთვის (ან რასაც გველი ჭამს იქ ...).
- ელექტრონული დონე. წრეს დაამატეთ აქსელერომეტრი. დაწერეთ პროგრამა, რომელიც აჩვენებს წერტილს LED მატრიცაზე, რომლის კოორდინატები დამოკიდებულია მთელი მოწყობილობის დახრილობაზე. მაგალითად, როდესაც მოწყობილობა ფიქსირდება მიწის პარალელურად (სიმძიმის ვექტორის პერპენდიკულარულად), მაშინ წერტილი ცენტრშია. როდესაც ელექტრონული დონე მარცხნივ არის დახრილი, წერტილი პროპორციულად გადაინაცვლებს მარჯვნივ.
დასკვნა
მატრიცის მართვის სქემის აწყობის შემდეგ, ბევრს შეიძლება გაუჩნდეს შეკითხვა: "აბა, ვინმემ არ მოიფიქრა მატრიცთან მუშაობის მარტივი გზა 30 წლის განმავლობაში?" სინამდვილეში, მათ ეს გაარკვიეს. არსებობს სპეციალიზებული მიკროსქემები სხვადასხვა ტიპის დისპლეებთან მუშაობისთვის, მათ შორის LED მატრიცით მუშაობისთვის. ერთ-ერთ შემდეგ გაკვეთილზე ჩვენ ვისწავლით თუ როგორ უნდა აკონტროლოთ ინდიკატორი MAX7219 ჩიპის გამოყენებით. ეს მეთოდი საშუალებას მოგვცემს მარტივად გავაერთიანოთ რამდენიმე მატრიცა ერთ დიდ ეკრანთან, ელექტრული წრედის დიდი გართულების საჭიროების გარეშე.ორი წლის წინ, როცა პირველად დავიწყე მულტიკოპტერები, მომიწია პატარა . ვინაიდან კვადროკოპტერი ჩაფიქრებული იყო, როგორც წმინდა ავტონომიური, ამ დისტანციური მართვისგან საჭირო იყო მხოლოდ დრონის კონტროლი ტესტირებისა და დარეგულირების დროს.
პრინციპში, დისტანციურმა მართვამ საკმაოდ წარმატებით გაართვა თავი მასზე დაკისრებულ ყველა დავალებას. . მაგრამ იყო სერიოზული ხარვეზებიც.
- ბატარეები არ ჯდებოდა კოლოფში, ამიტომ მომიწია ელექტრული ლენტით კეისზე მიმაგრება :)
- პარამეტრის დაყენება განხორციელდა ოთხ პოტენციომეტრზე, რომელიც აღმოჩნდა ძალიან მგრძნობიარე ტემპერატურის მიმართ. ოთახში შენ ადგენ რაღაც ფასეულობებს, გამოდიხარ ქუჩაში - და ისინი უკვე განსხვავებულები არიან, გაცურდნენ.
- Arduino Nano-ს, რომელიც მე ვიყენებდი დისტანციურ პულტში, აქვს 8 ანალოგური შეყვანა. ოთხი დაკავებული იყო ტიუნინგის პოტენციომეტრებით. ერთი პოტენციომეტრი ემსახურებოდა გაზს. ორი შემავალი ჯოისტიკთან იყო დაკავშირებული. მხოლოდ ერთი გასასვლელი დარჩა თავისუფალი და კიდევ ბევრი პარამეტრია კონფიგურაციისთვის.
- ერთადერთი ჯოისტიკი საერთოდ არ იყო პილოტი. გაზის კონტროლი პოტენციომეტრითაც საკმაოდ დამთრგუნველი იყო.
- და პულტი არ გამოსდიოდა ხმებს, რაც ზოგჯერ ძალიან სასარგებლოა.
ყველა ამ ხარვეზის აღმოსაფხვრელად, გადავწყვიტე რადიკალურად გადამეკეთებინა დისტანციური მართვა. როგორც აპარატურა, ასევე პროგრამული უზრუნველყოფა. აი რისი გაკეთება მინდოდა:
- გააკეთეთ დიდი ქეისი, რათა ახლავე ჩაყაროთ ყველაფერი, რაც გსურთ (ბატარეების ჩათვლით) და რაც გსურთ მოგვიანებით.
- როგორმე მოაგვარეთ პრობლემა პარამეტრებში და არა პოტენციომეტრების რაოდენობის გაზრდით. გარდა ამისა, დაამატეთ კონსოლში პარამეტრების შენახვის შესაძლებლობა.
- გააკეთეთ ორი ჯოისტიკი, როგორც ჩვეულებრივ პილოტ კონსოლებზე. ისე, თავად ჯოისტიკები მართლმადიდებლურად დააყენეთ.
Ახალი შენობა
იდეა ძალიან მარტივი და ეფექტურია. პლექსიგლასისგან ან სხვა თხელი მასალისგან ამოვჭრით ორ ფირფიტას და ვაკავშირებთ თაროებით. კორპუსის მთელი შიგთავსი მიმაგრებულია ზედა ან ქვედა ფირფიტაზე.
კონტროლი და მენიუები
რამდენიმე პარამეტრის გასაკონტროლებლად, თქვენ ან უნდა მოათავსოთ დისტანციური მართვის პულტზე რამდენიმე პოტენციომეტრი და დაამატოთ ADC, ან გააკეთოთ ყველა პარამეტრი მენიუში. როგორც ვთქვი, პოტენციომეტრებით დაკონკრეტება ყოველთვის არ არის კარგი იდეა, მაგრამ არც უარი უნდა თქვათ. ასე რომ, გადაწყდა დისტანციურ სამართავში ოთხი პოტენციომეტრის დატოვება და სრულფასოვანი მენიუს დამატება.
ღილაკები ჩვეულებრივ გამოიყენება მენიუში ნავიგაციისთვის და პარამეტრების შესაცვლელად. მარცხნივ, მარჯვნივ, ზევით, ქვევით. მაგრამ ღილაკების ნაცვლად ენკოდერის გამოყენება მინდოდა. მე მივიღე ეს იდეა 3D პრინტერის კონტროლერისგან.
რა თქმა უნდა, მენიუს დამატების გამო, დისტანციური მართვის კოდი რამდენჯერმე ადიდებულა. დასაწყებად, მე დავამატე მენიუს მხოლოდ სამი ელემენტი: "ტელემეტრია", "პარამეტრები" და "მაღაზიის პარამეტრები". პირველი ფანჯარა აჩვენებს რვამდე სხვადასხვა ინდიკატორს. ჯერჯერობით მხოლოდ სამს ვიყენებ: ბატარეის ენერგია, კომპასი და სიმაღლე.
მეორე ფანჯარაში ხელმისაწვდომია ექვსი პარამეტრი: PID კონტროლერის კოეფიციენტები X/Y,Z ღერძებისთვის და აქსელერომეტრის კორექტირების კუთხეები.
მესამე პუნქტი საშუალებას გაძლევთ შეინახოთ პარამეტრები EEPROM-ში.
ჯოისტიკები
საპილოტე ჯოისტიკების არჩევაზე დიდი ხანი არ მიფიქრია. მოხდა ისე, რომ პირველი Turnigy 9XR ჯოისტიკი მივიღე კოლეგისგან კვადკოპტერების ბიზნესში - ალექსანდრე ვასილიევი, ცნობილი საიტის alex-exe.ru მფლობელი. მეორე კი პირდაპირ Hobbyking-ს შევუკვეთე.
პირველი ჯოისტიკი ზამბარით იყო დატვირთული ორივე კოორდინატში - იავისა და სიმაღლის გასაკონტროლებლად. მეორეც იგივე ავიღე, შემდეგ გადავიყვანე ჯოისტიკად ბიძგისა და ბრუნვის გასაკონტროლებლად.
კვება
ძველ პულტში გამოვიყენე მარტივი LM7805 ძაბვის რეგულატორი, რომელიც იკვებება 8 AA ბატარეით. საშინლად არაეფექტური ვარიანტი, რომელშიც 7 ვოლტი წავიდა რეგულატორის გასათბობად. 8 ბატარეა - იმიტომ, რომ ხელთ მხოლოდ ასეთი კუპე იყო, და LM7805 - იმიტომ, რომ იმ დროს ეს ვარიანტი მეჩვენებოდა ყველაზე მარტივი და რაც მთავარია, ყველაზე სწრაფი.
ახლა გადავწყვიტე ვიყო უფრო ბრძენი და დავაყენო საკმაოდ ეფექტური რეგულატორი LM2596S-ზე. და 8 AA ბატარეის ნაცვლად, დავაყენე კუპე ორი LiIon 18650 ბატარეისთვის.
შედეგი
ამ ყველაფრის ერთად, ჩვენ მივიღეთ ასეთი მოწყობილობა. შიდა ხედი.
აქ არის დახურული სახურავით.
არ არის საკმარისი ქუდი ერთ პოტენციომეტრზე და ქუდები ჯოისტიკებზე.
და ბოლოს, ვიდეო, თუ როგორ ხდება პარამეტრების კონფიგურაცია მენიუში.
შედეგი
ფიზიკურად, პულტი აწყობილია. ახლა იმით ვარ დაკავებული, რომ ვასრულებ დისტანციური მართვის და კვადროკოპტერის კოდს, რათა აღვადგინო მათი ყოფილი ძლიერი მეგობრობა.
დისტანციური მართვის დაყენებისას გამოვლინდა ხარვეზები. ჯერ ერთი, დისტანციური მართვის ქვედა კუთხეები ეყრდნობა ხელებს: (ალბათ თეფშებს ოდნავ გადავამუშავებ, კუთხეებს დავასწორებ. მეორეც, ლამაზი ტელემეტრიის გამოსავალისთვის 16x4 დისპლეიც კი არ არის საკმარისი - პარამეტრების სახელები უნდა შევამცირო. ორ ასომდე.მოწყობილობის შემდეგ ვერსიაში დავაყენებ წერტილოვანი დისპლეის ან დაუყოვნებლივ TFT მატრიცას.
ეს სტატია შეიქმნა მათთვის, ვინც იყიდა შიშველი 8x8 მატრიცა და 74hc595 ცვლის რეგისტრები და არ იცის როგორ დააკავშიროს ეს ყველაფერი.
დიდი ხნის განმავლობაში ვეძებდი ინტერნეტს ინსტრუქციებისთვის, თუ როგორ უნდა დამეკავშირებინა ზემოთ ჩამოთვლილი კომპონენტები, მაგრამ აღმოვაჩინე ან არა ჩემი რეგისტრებისთვის, ან არამუშაო ესკიზებით, ამიტომ გადავწყვიტე, რომ ჯერ კიდევ ხელებითა და თავით უნდა ვიმუშაო, რომ თავი მსიამოვნებდეს. 8*8 სურათით.
ინტერნეტში მატრიცისა და ცვლის რეგისტრების მონაცემთა ცხრილების აღმოჩენის შემდეგ, მე დავხატე შემდეგი დიაგრამა:
ორივე მიკროსქემის მე-12 ფეხი (ჩამკეტი პინი), პორტების შესანახად ხშირია, რადგან აზრი არ აქვს რეგისტრების ჩაკეტვას სხვადასხვა დროს. ზოგიერთი მატრიცის ქინძისთავები (ანოდები) დაკავშირებულია დენის შემზღუდველი რეზისტორებით, რომელთა ნომინალური მნიშვნელობაა 220 ohms. ყველაფერი დანარჩენი სქემის მიხედვით ძალიან მარტივია. ყოველი შემთხვევისთვის, სურათები მატრიცის პინოტით.
სურათების ჩვენება სტრიქონ-სტრიქონში მოგიწევთ (თორემ მსგავსი მატრიცებით გზა არ არის), მცირე დაგვიანებით (ადამიანის თვალი პრაქტიკულად არ განასხვავებს 1 ms დაგვიანებას).
შევეცადე ყველაფერი აეხსნა ესკიზში. დაფაზე ატვირთვისას ეკრანზე გამოჩნდება ნომრები, რომლებსაც ჩვენ გამოგიგზავნით arduino პორტის მონიტორზე (იხილეთ ვიდეო)
დასრულებული მოწყობილობის ფოტო (ზიგზაგი ეკრანზე, ესკიზში მისი სურათი ინახება pic მასივში)
მომავალში ვეცდები ამ ჩვენებაზე რაიმე საინტერესო გავაკეთო.
