Category / Arduino
Prisiminiau, kad senokai buvau įsijungęs Arduino IDE. Įsijungiau, pasiūlė atsinaujinti. Ką padarysi, atnaujinau… Bet atnaujinant išsitrynė rankiniu būdu įmontuota tamsi tema, man kažkaip ir gražesnė, ir programint patogiau. Atrodo va taip:
O parsisiųsti galima iš čia:
Radau Internete paveiksliuką, gal kada pravers.
Ir pačios Atmega 328:
Ir dar Atmega328P-AU versijos:
Kol kas neturiu ką įdomaus parašyti, tai rašau tai kas naudinga :). Kažkada labai reikėjo, tai pasidariau lentelę su Arduino UNO fusais. Arduino UNO naudoja ATmega 328P, nors man labiau patinka ATmega 328P-AU, nes mažiukas TQFP-32 korpusas ir turi papildomai du ADC. Programuoju per ICSP, visai naujus čipus, tai prisireikia supūsti ir fuse bitus. Pas ATmegas toks niuansas, truputį prieš žmonišką logiką – jeigu 1 tai išjungta, jeigu 0 tai įjungta. O štai ir lentelė:
Arba jeigu rašoma su eXreme Burner’iu – tuomet galima va taip:
Noriu išmokti saugoti duomenis Atmegos pastovioje atmintyje, kad išjungus ir vėl įjungus nuskaitytų ir veiktų toliau. Tuo pačiu ir pasitreniruosiu „gaminti” meniu. Pigiausiais sprendimas 0 2×16 LCD skydas iš eBay, kainavo apie 2,5 € su siuntimu. Atvažiavo toks pabraižytas, tai dar uždisputinau su pardavėju.
Kontaktai nesurašyti, bet turėtų būti taip:
Aprašymas toks, vadinamąja, Chinglish kalba:
Features:
This is a basic 16 character by 2 line display.
Utilizes the extremely common HD44780 parallel interface chipset.
Interface code is freely available.
Blue Backlight with white words.
uses 4 Bit Arduino LCD Library.
Size:8cm x 5.9cm - 3.15inch x 2.32inch.
Quantity:1pc
LCD Keypad Shield input and output expansion board with 2-line, 16-character LCD with contrast
adjustment and backlight
Use an analog port will complete five key input, a reset button, the unused spare IO ports
are extended out, take advantage of IO ports
Occupation digital ports: PIN4 (DB4), 5 (DB5), 6 (DB6), 7 (DB7), 8 (RS), 9 (E), 10 (backlight
control), analog buttons port A0. Used in conjunction with the Arduino
Module debugging:
1.The LCD Keypad Shield Arduino controller plugged,Then you need to download LCD4Bit_mod.h
library file to arduino-0015 \ hardware \ libraries in
2.Then compile the following test program will be downloaded to an Arduino in
3.Initial use LCD Keypad Shield, the first observation LCD has no display characters,
characters may be displayed if there is no contrast is not correct, you can use the
screwdriver adjust RP1 (clockwise rotation), characters can be transferred to emerge clearly.
Ranging code GP2D12:
#include <LCD4Bit_mod.h>
LCD4Bit_mod lcd = LCD4Bit_mod(2);
char GP2D12;
char a,b;
char str1[]="Renge:";
char str2[]=" Renge Over ";
char str3[]="cm";
void setup()
{
lcd.init();
lcd.clear();
lcd.printIn("GP2D12 testing...");
}
void loop()
{
GP2D12=read_gp2d12_range(1);
if(GP2D12>80||GP2D12<10)
{
lcd.cursorTo(2,0);
lcd.printIn(str2);
}
else
{
a=0x30+GP2D12/10;
b=0x30+GP2D12%10;
lcd.cursorTo(2, 3);
lcd.printIn(str1);
lcd.print(a);
lcd.print(b);
lcd.printIn(str3);
}
delay(50);
}
float read_gp2d12_range(byte pin)
{
int tmp;
tmp = analogRead(pin);
if (tmp < 3)return -1;
return (6787.0 /((float)tmp - 3.0)) - 4.0;
Reiks bandyt susigaudyt apie ką čia kalba eina :D. Iššifruoju pats sau, kad nepamirščiau ir nereiktų vėl iš naujo galvot:
LCD pajungimas: PIN4 (DB4), 5 (DB5), 6 (DB6), 7 (DB7), 8 (RS), 9 (E), 10 (backlight control)
Mygtukai: A0.
LCD, panašu, pajungtas pagal 4 bitų schemą, gerai, bus galima greitai sumesti programą su LiquidCrystal biblioteka. O mygtukas prijungti prie vieno kontakto… Iš pradžių nusistebėjau, nes nesimatė rezistorių. Paskui radau ir juos ;).
LCD valdomas standartiniu HD44780 valdikliu, taigi, pravers jo aprašymas. Ypač – visokių ne standartinių simbolių „žemėlapis”:
Taigi, norint parašyti kokį nors ypatingesnį simbolį, tarkim juodą stačiakampį █ galima nupaišyti viena eilute – lcd.print(char(255));. Kodėl 255 ? Nes juodojo kvadrato adresas yra 1111 1111 (bin) = 255 (dec). Tas pats galiotų, pavyzdžiui, laipsnio simboliui lcd.print((char)223); – adresas 1101 1111 (bin) = 223 (dec). Galima sukrti ir savo simbolį, jeigu jo nėra lentelėje. Bet apie tai kada nors kitą kartą.
Toliau vat ir bandymas, nuskaitant ADC vertes.
Select – 722
Left – 480
Up – 131 (tuo pačiu dar ir šviesina LCD pašvietimą)
Down – 308 (tuo pačiu dar ir tamsina LCD pašvietimą)
Right – 0
Reset – reikšmės nėra, tiesiog perkrauna uCPU.
Toliau fantazijos reikalas, o šita programėlė štai:
#include <LiquidCrystal.h> //Naudojama biblioteka // Įėjimai LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //Inicializuojami prijungti LCD ekraniuko kontaktai //LiquidCrystal(rs, enable, d4, d5, d6, d7) //PIN4 (DB4), 5 (DB5), 6 (DB6), 7 (DB7), 8 (RS), 9 (E), 10 (backlight control) const int mygtukai = A0; // Išėjimai // Kintamieji int paspaustas = 0; int i = 0; void setup() { lcd.begin(16, 2); //Inicializuojamas LCD (irgi is bibliotekos default komandu) lcd.noCursor(); // Nustatome, kad kursorius ekrane nebus rodomas pinMode(A0, INPUT); //Mygtukų įėjimas pinMode(10, OUTPUT); //Pinas ekrano pašvietimo ryškumui nustatyti (PWM) analogWrite(10, 0); //********************************* for (i = 0; i <= 255; i++) { //* Užgesinam pašvietimą * analogWrite(10, i); //* Nedidelis cikliukas * delay (3); //* kad pašvietimas iš lėto * } //* užsidegtų iki pilno galingumo * } //********************************* void loop() { lcd.setCursor(0, 0); //Perjungiam kursorių į pirmą eilutę (0 - stulpelis, 0 - eilutė) lcd.print("Mygt. indikacija"); //Pirmos eilutės tekstas paspaustas = (analogRead(mygtukai)); //Nuskaitom mygtuko reikšmę iš ADC ir priskiriam kintamajam if (paspaustas > 1010) { //Nieko nepaspaudus ADC reikšmė 1023 lcd.setCursor(0, 1); //Antros eilutės adresas lcd.print(" "); //Rašom tuščius simbolius info ištrynimui } if (paspaustas >= 710 && paspaustas <= 730) { lcd.setCursor(0, 1); //Perjungiam kursorių į antrą eilutę (0 - stulpelis, 1 - eilutė) lcd.print (paspaustas); //Nuskaitom ir rašom į ekraną A0 ADC reikšmę lcd.print(" - Select"); //Antros eilutės tekstas } if (paspaustas >= 470 && paspaustas <= 490) { lcd.setCursor(0, 1); //Perjungiam kursorių į antrą eilutę (0 - stulpelis, 1 - eilutė) lcd.print (paspaustas); //Nuskaitom ir rašom į ekraną A0 ADC reikšmę lcd.print(" - Left"); //Antros eilutės tekstas } if (paspaustas >= 120 && paspaustas <= 140) { lcd.setCursor(0, 1); //Perjungiam kursorių į antrą eilutę (0 - stulpelis, 1 - eilutė) lcd.print (paspaustas); //Nuskaitom ir rašom į ekraną A0 ADC reikšmę lcd.print(" - Up"); //Antros eilutės tekstas if (i <= 250) { i = i + 1; analogWrite(10, i); } } if (paspaustas >= 300 && paspaustas <= 320) { lcd.setCursor(0, 1); //Perjungiam kursorių į antrą eilutę (0 - stulpelis, 1 - eilutė) lcd.print (paspaustas); //Nuskaitom ir rašom į ekraną A0 ADC reikšmę lcd.print(" - Down"); //Antros eilutės tekstas if (i >= 5) { i = i - 1; analogWrite(10, i); } } if (paspaustas <= 10) { lcd.setCursor(0, 1); //Perjungiam kursorių į antrą eilutę (0 - stulpelis, 1 - eilutė) lcd.print (paspaustas); //Nuskaitom ir rašom į ekraną A0 ADC reikšmę lcd.print(" - Right"); //Antros eilutės tekstas } }
Pradžia kaip visada paprasta – tai nuo šio tai nuo to vis lieka kokių detalių, tai koks projektukas nepasiteisina ar tampa nebeaktualus ir lieka dar kas nors, tai patestuot veikimą reikia. Taip ir čia – liko vienas ampermetras, keletas RTC schemų, o pratestuoti reikia LMZ23605 iš Texas Instruments (DC-DC maitinimo šaltinis) ir µCPU mažame MLF korpuse. Idėja sugeneruota – sumontuoti viską kaip analoginį laikrodį. Toliau, kaip visada, užduoties sudėtinginimas. Chm, tikrai yra toks žodis ? Gal pasunkinimas :D? Taigi užduotis:
Tai ir einam papunkčiui. Kad laikrodis rodytų valandas, minutes ir sekundes kaip ir natūralu, nors galima apseiti ir be sekundžių. Rodykliniai indikatoriai – paprasti, kinietiško „Hopesun” PM-2. Lietuvoje juos stumdo „Lemona”. Atrodo va taip vat:
Nieko labai prašmatnaus, bet ir ne visai blogai. Tinka iš esmės bet koks, bet, kad mažiau būtų skaičiavimo ir vartotų mažiausiai srovės – čiupau DC ampermetrą su 50 µA pilno atlenkimo srove.
Laiko tikslumas yra geras dalykas, idealiu atveju reiktų sinchronizuoti su radio laiko sistema, arba GPS, bet paskui pagalvojau, kad čia būtų šaudymas į žvirblius iš patrankos, nes yra kitas puikus, ganėtinai tikslus ir labai seniai naudojamas būdas laiko skaičiavimui – RTC mikroschemos. Tuo dar išsispręstų ir laiko skaičiavimas atjungus maitinimą. Ankščiau, kitam projektukui (ok, ok, pasakysiu – Nixie laikrodžiui) buvau pasirinkęs DS3231SN mikroschemą, puikios galimybės už mažą kainą ir duomenų siuntimu per I²C, o dar ir moduliukai iš eBay, 5 vnt už kelis €. Atėjo jie jau seniai, tik nebuvo kaip išbandyt.
Maitinimas iš išorinio maitinimo blokelio arba baterijų/akumuliatorių, perjungimas turi būti automatiškas, bet tai realizuojama nesunkiai ir matysis schemoje. Taigi, schema:
Įtariu paveiksliuką norėsis pasididinti :). Pradedam. Maitinimo lizdukas baterijos pajungimui – dviejų kontaktų smeigiamas lizdas, anksčiau buvęs trumpikliu ant kompiuterio motininės plokštės. Šalia, kilmingas Wurth Electronics maitinimo lizdukas. Nu tikrai geras daikčiukas. Jis ir daro automatinį maitinimo nuo baterijos atjungimą. Kol kištukas neįkištas – 2 ir 3 kontaktai susijungę ir perduoda maitinimą iš baterijos lizdo, o kai kištukas įkištas, vietoj baterijos minuso lieka prijungtas kištuko minusas. Toliau, 5V maitinimo šaltinis. Kadangi mūsų prietaisas „srovinis”, t.y. parodymai priklauso nuo srovės, o ji, savo ruožtu, priklauso nuo maitinimo įtampos – čia reiktų stabilaus šaltinio. Arba galima būtų eliminuoti pokyčius programiškai (gal kada nors). Kol kas užtenka LMZ23605TZ arba jo giminaičių. Veikia stabiliai ir dar visokio gėrio pilnas. Toliau – pagrindinis darbinis arkliukas, ATMEGA328P, MLF korpuse, kurį ir norėjau išbandyti. Į kairę nuo Atmegos – perkrovimo (Reset) schema, mygtukas S1, rezistorius R16 ir diodas D6. Paspaudus mygtuką žemas lygis atitinkamame kontakte perkrauna procesorių. Toliau – kontaktai mygtukus, kurį paspaudus rodys temperatūrą (RTC čipas turi sensoriuką). Rezistorius R10 – pulldown’as. Tas pats ir su kalibravimo mygtuku S2. Jį paspaudus procesorius sukomanduoja rodyklėms maksimaliai atsilenkti, taip galima sureguliuoti maksimalaus atsilenkimo padėtį rezistoriais R6, R7 ir R8. Pastovūs rezistoriai R3, R4 ir R5 jau sukuria apie 54,94 µA srovę, o patenciometrais galima ją pakeisti iki 49,50 µA, taigi, turime maksimalaus atlenkimo reguliavimo ribas – 49,50..54,94 µA.
Lyrinis nukrypimas apie skaičiavimus, kadangi galima naudoti praktiškai bet kokius indikatorius, kurių žinoma maksimali atlenkimo srovė. Čia mums padės Omo dėsnis. Taigi, pirmiausia apsisprendžiame, kokia įtampa viskas bus maitinama. Mano atveju ta pačia įtampą valgo ir procesoriukas, taigi, 5V. Tuomet, žinant indikatoriaus maksimalaus atlenkimo srovę galima paskaičiuoti varžą, R[Ω] = U[V] /I[A].
R = 5V / 50 µA = 5V / 0,00005 A = 100000 Ω = 100 kΩ.
Taigi, dar paliekam „vietos” pareguliavimui ir pasirenkam artimiausias vertes pagal gaminamus standartus.
JP1 – programavimo/diagnostinė jungtis (C6 jai padeda padaryti procesoriaus perkrovimą). Dar toje pusėje yra kontaktas pažymėtas „touch”. Čia turėtų būti jau seniau nagrinėtas talpuminis lietimo sensorius, su jam priklausančiais C1 ir R11. Pagal idėją, palietus turėtų uždegti rodyklinių indikatorių pašvietimą, tam panaudojant tris (arba vieną, o kiti darytų ką nors kitą) atskirus tranzistorius Q1, Q2 ir Q6 (be srovės ribojimo !). Ir paskutinė detalė – RTC schema, iš kurios nuskaitom laiką.
PCB, kaip visada, pagaminta pas kinus, iš seeedstudio.com ir atrodo va taip:
Jei kam reikia plikų PCB, kreipkitės, turiu dar 5 vnt. Sukompiliuotą failiuką įdėsiu straipsnelio pabaigoje, kartu su schema.
Originali ampermetrų skalė netinkama, bet po svaičiojimų apie naujos skalės gamybą lazeriuojant, šilkografuojant ir bandant pagaminti dar keletu mazochistinių būdų, nuėjau lengviausiu keliu – užsakiau pagaminti lipdukus su man tinkama skale. Ją pasibraižiau su AutoCADu, nors skalėms iš tikrųjų yra specializuotas softas.
Toliau sudėtingiausia dalis – korpusas. Iš pradžių galvojau padaryti tokį „old school” vaizdelį, montuojant visą elektroniką į seną, rusišką, ebonitinį korpusą, gal net su kokiom rankenėlėm ar užrašais, pavyzdžiui:
Bet tokios dėžutės neturiu, o laikas eina… Šiaip, aišku aš neskubu, tai nusitempė tie korpuso parinkimai tikrai ilgam laikui, tuo labiau, kad darbiniai projektai visokie visą laiką suvalgo. Bet darbiniai projektai man pasufleriavo ir sprendimą – korpusą iš aliuminio kompozito. Sumontavimas toks truputį sunkokas, bet neskubant viskas sutilpo ir rezultatas gavosi toks:
Toliau – skalės apšvietimas. Čia jau teko paprasčiausiai priklijuoti SMD LEDus (OSM5DLS1C1A). Vaizdas štai toks:
Bandymai parodė, kad pašvietimas gražus ir tolygus. Spalva – šiltai balta. O štai kaip tai atrodo (dieną, maksimalus šviesumas):
Darbinė srovė be apšvietimo prie 9,302V – 26,16 mA (0,2433 W), su apšvietimu 94,00 mA prie 8,95V (0,8413 W). Ir trumpas video kaip viskas veikia:
Čia yra viskas, ko reikia Eagle ir AutoCAD brėžiniai. Programa gali būti developinama, tai naujausią sukompiliuotą HEXą čia rasite atskirai.
Programos versija – V1:
Tolimesnių tobulinimų idėjos:
Vienam iš projektų reikia padaryti pašvietimą. Bet paprastai uždegti LEDą ar lemputę neįdomu. Taigi, užduotis tokia – palietus prietaiso metalinį korpusą (nesujungtas su GND), apšvietimas turi lėtai užsidegti, degti kol liečiamas korpusas ir lėtai užgesti kai jau neliečiamas. Su Capacitive Sensor V5 pagalba tas padaroma labai paprastai, tik pakoreguojant kodą pagal savo poreikius:
#include <CapacitiveSensor.h> // Išėjimai const int led = 3; // LED išęjimas, 3 kontaktas, mokantis PWMinti. int i = 0; // Įsivedam vieną kntamąjį CapacitiveSensor sensorius = CapacitiveSensor(4, 2); // Rezistorius tarp 4 ir 2 kontaktų, 2 sensorinis void setup() { pinMode (led, OUTPUT); // Nustatom 3 kontaktą kaip išėjimą digitalWrite (led, LOW); // Inicializuojam LEDą sensorius.set_CS_AutocaL_Millis(0xFFFFFFFF); // Autokalibracijos išjungimas } void loop() { long laikas = sensorius.capacitiveSensor(60); // Matavimų skaičius vidurkio skaičiavimui if (laikas > 600) // Jeigu paskaičiuotas vidurkis daugiau 600 ms { while (i < 255) // ************************ { // * Kai vidurkis daugiau * analogWrite (led, i); // * 600 ms lėtai uždega * i++; // * LEDą ir laiko, kol * delay (8); // * liečiamas sensorius * } // ************************ } else { while (i >= 0) // ************************ { // * Atvirščias procesas, * analogWrite (led, i); // * kai laikas < 200, * i--; // * lėtai užgesina LEDą * delay (8); // ************************ } i = 0; // Įnulinam kintamąjį, nes kitaip atsiranda } // neteisingas LED mirktelėjimas } O štai ir video:
Pats LED indikatorius ELF-512GWA išluptas seniai, iš kažkokio šroto, net pats nepamenu. Toks, nei panaudot, nei išmest, tai sugalvojau prijungt prie Arduino. Schema labai paprasta, bendri anodai/katodai prie A1, A2, A3 ir A4 (čia keturių skaičių indikatorius). O 7 segmentai prie 2, 3, 4, 5, 6, 7, 8, 9. Visa esmė čia programoje. Internete labai daug pavyzdžių, gerų ir nelabai. Pabandžiau keletą bibliotekų ir labiausiai patiko PrintTo7Seg. Programėlė:
#include "PrintTo7Seg.h" // Įėjimai //Išėjimai byte numOfDigits = 4; // Kelių skaičių indikatorius byte digPins[] = {A1, A2, A3, A4 }; // Bendri kontaktai (anodas arba katodas) // segmentPins = Dp, A, B, C, D, E, F, G // Segmentų pinų map'as byte ledPins[] = {7, 8, 9, 2, 3, 4, 5, 6}; // Segmentų pajungimas // Nustatymai PrintTo7Seg Seg7(numOfDigits, digPins, ledPins, COMMON_CATHODE); // Arba anodas, pagal indikatorių void setup() { Seg7.autoscroll(); // Atomatinis kursoriaus pastūmimas } // čia reikalingas, nes rašyti pradedu į // paskutinį (4) LED indikatorių void loop() { for (int skaicius = 0; skaicius <= 9999; skaicius++) { Seg7.clear(); // Išvalom seną informaciją Seg7.setCursor(3); // Nustatom kursorių į 4 indikatorių (0, 1, 2, 3) Seg7.print(skaicius); // Rašom einamąjį skaičių delay(10); // Trumpa pauzė } }
Dar papildomai yra keletas komandų:
setLed(location, led, state);
setDot(location, state);
setDigit(location, data);
getDigit(location);
setCursor(location);
autoscroll(void);
noAutoscroll(void);
clear(void);
home(void);
scrollDisplayLeft(void);
scrollDisplayRight(void);
Print();
Taip taip, dedikuotas straipsnis kolegai Mindaugui. Trumpai apie davikli, tai – ankščiau buvusio Dallas Semiconductor o dabar Maxim Integrated sensoriukas DS18B20, mūsų atveju kukliam TO-92 korpuse. Beje, aprašymas vienas iš detaliausių kada nors mano matytų. Pajungimo schema paprasta, viskas taip, kaip parodyta aprašyme:
Programoje naudojamos dvi bibliotekos:
#include <OneWire.h>
#include <DallasTemperature.h>
Pirmoji yra čia, o antroji yra čia.
O čia vat ir programėlė, rašanti temperatūrą:
#include <OneWire.h> #include <DallasTemperature.h> // Įėjimai OneWire pinas(2); // Nustatom, kad duomenys vaikščios antru pinu // Išėjimai // Nustatymai DallasTemperature sensoriai(&pinas); // Perduodam pino duomenis DallasT bibliotekai void setup(void) { Serial.begin(9600); sensoriai.begin(); } void loop(void) { sensoriai.requestTemperatures(); // Komanda, temperatūrų užklausimui Serial.println("Daviklio temperatura"); Serial.print(sensoriai.getTempCByIndex(0)); // Daviklio temperatūra C Serial.println(" C"); Serial.print(sensoriai.getTempFByIndex(0)); // Daviklio temperatūra F Serial.println(" F"); Serial.print(sensoriai.getResolution()); // Gaunama daviklio rezoliucija (9, 10, 11, 12) Serial.println(" bit rezoliucija"); // temperaturos zingsniai 0.5°C, 0.25°C, 0.125°C ir 0.0625°C Serial.print(sensoriai.getDeviceCount(), DEC); // Davikliu kiekis, dešimtainiu formatu Serial.println(" daviklis /-u"); Serial.println(" "); delay (1000); }
Labai nesudėtinga programėlė, gavosi labai trumpa, nes norėjau prasisukti su kuo mažiau teksto, prisioptimizavau tiek, kad net jokio kintamojo nereikia :).
// Iejimai const int raudonas_pot = A0; // ******************************** const int zalias_pot = A1; // * Nustatom potenciometru pinus * const int melynas_pot = A2; // ******************************** // Isejimai const int raudonas_led = 3; // ******************************** const int zalias_led = 5; // * Nustatom PWM isejimus LEDams * const int melynas_led = 6; // ******************************** void setup() { pinMode (raudonas_led, OUTPUT); // *************************************** pinMode (zalias_led, OUTPUT); // * Nustatom, kad LEDu pinai - isejimai * pinMode (melynas_led, OUTPUT); // *************************************** digitalWrite (raudonas_led, HIGH); // *************************************** digitalWrite (zalias_led, HIGH); // * Inicializuojam LEDus (isjungiam) * digitalWrite (melynas_led, HIGH); // *************************************** } void loop() { analogWrite (raudonas_led, map (analogRead (raudonas_pot), 0, 1023, 0, 255)); analogWrite (zalias_led, map (analogRead (zalias_pot), 0, 1023, 0, 255)); analogWrite (melynas_led, map (analogRead (melynas_pot), 0, 1023, 0, 255)); }
Pačios programos gavosi tik trys eilutės, po vieną kiekvienam LEDui. Logika tokia – rašom (analorWrite) į atitinkamo LEDo išėjimą (pvz, raudonas_led) reikšmę, kuri gaunama „pavertus” (map) nuskaitytą potenciometro vertę (analogRead (raudonas_pot)) į vertes nuo 0 iki 255 (0, 1023, 0, 255). Šito map’inimo reikia todėl, kad nuskaityto potenciometro reikšmės kinta nuo 0 iki 1023, o išėjimo PWM’as valdomas vertėm nuo 0 iki 255 (8 bitų PWM). Taigi, nenuMAPinus persipildys skaitliukas, ir nuo 0 iki 255 viskas bus OK, nuo 256 iki 512 (ir 513 – 768, ir 768 – 1023) vėl elgsis taip, lyg būtų nuo 0 iki 255, tai sukant potenciometrą bus net 4 zonos, kur LEDas nuo tamsaus keisis į maksimaliai degantį. Dar toks niuansas – Arduino Due ir Zero su defaultiniu 8 bitų PWMu gali būti nustatytas dirbti aukštesne 12 bitų rezoliucija, ir dirbti su reikšmėm nuo 0 iki 4095 (komanda analogWriteResolution(12)).
Ir trumpas video:
Patobulinimas – naudoti skaitmeninius potenciometrus, o ne tokius, analoginius/varžinius. Mano atveju RGB LEDas buvo su bendru anodu, jeigu kartais tektų pakeistį į LED su bendru katodu – truputį keičiasi ir programa. Iš esmės užtektų pakeisti tik čia:
digitalWrite (raudonas_led, LOW);
digitalWrite (zalias_led, LOW);
digitalWrite (melynas_led, LOW);
Toks trumpas straipsniukas, atsiradęs dėl to, kad kolega užsimanė pamirksinti LEDus taip, kaip mirksi specialiųjų tarnybų stroboskopiniai mirksiukai (tipo police strobe). Pats greičiausias būdas – jamam Arduino Uno ir nesunkiai parašom tokią programėlę. Berašydamas, kaip visada sugalvojau patobulinti galutinį variantą ir finale turim ir stroboskopinį ir dimeruojantį variantą. Programėlė:
// Kintamieji: int x = 0; const int mirksejimo_kiekis = 10; const int mirksejimo_trukme = 20; const int laikas_tarp_pusiu = 150; int sviesumas = 0; int pokytis = 1; // Isejimo pinai: const int raudonas_led = 9; const int melynas_led = 10; // Iejimu pinai: const int mygtukas = A0; // Programa, keisti reiktu tik virsuje void setup() { pinMode(raudonas_led, OUTPUT); pinMode(melynas_led, OUTPUT); pinMode(mygtukas, INPUT); } void loop() { if (digitalRead(mygtukas) == HIGH) { mirksejimas(); } else { dimeris(); } } //-------------------- Mirksejimo programele ------------------------ int mirksejimas() { for (x = 0; x <= mirksejimo_kiekis; x++) { analogWrite(raudonas_led, HIGH); delay(mirksejimo_trukme); analogWrite(raudonas_led, LOW); delay(mirksejimo_trukme); } delay (laikas_tarp_pusiu); for (x = 0; x <= mirksejimo_kiekis; x++) { analogWrite(melynas_led, HIGH); delay(mirksejimo_trukme); analogWrite(melynas_led, LOW); delay(mirksejimo_trukme); } delay (laikas_tarp_pusiu); } //-------------------- Dimeriavimo programele ------------------------ int dimeris() { analogWrite(raudonas_led, sviesumas); analogWrite(melynas_led, -sviesumas); sviesumas = sviesumas + pokytis; if (sviesumas == 0 || sviesumas == 255) { pokytis = -pokytis ; } delay(2); }
Viskas čia paprasta, plius įdėjau ir keletą komentarų, bet visgi jei bus klausimų – prašom, komentaruose bandysiu atsakyti. Mėlynas ir raudonas 1W galios LEDai jau važiuoja, taigi, ne už ilgo turėtų būti ir veikimo video :).
2015.11.03
štai ir video… Nors stroboskopo efektas nelabai gražiai įsirašė:
