2014 m. lapkričio 26 d., trečiadienis

SPALVOS! arba RGB LED valdymas

Nuėjau į Lemoną ir netyčia, savo nelaimei užmačiau trijų šviesos diodų RGB modulį. Iki tol niekada nebuvau dirbęs su RGB šviesos diodais - nei konstravęs, nei jungęs prie paruoštų valdiklių, ir todėl besikeičiančios stende prijungto modulio spalvos dar labiau masino ir kvietė nupirkt tą modulį. Tai, kad kaip tik dabar konstruoju naują, didesnį terariumą savo žalčiui, tik prisidėjo prie noro nusipirkti diodus, nes apšvietimas būtų visai į temą prie planuojamo vidaus dekoravimo. Žodžiu, įvertinęs visus "už" ir nutylėjęs visus "prieš" jau turiu tą modulį.

Kiek žinau, tokio tipo įrenginiai skaitmeniniais įtaisais gali būti valdomi PWM pagalba. Apie pagrindinius PWM principus jau esu aprašęs ankstesniame straipsnyje, tačiau ten aprašytas realizavimas yra nenaudojantis AVR mikrovaldiklių tam skirtų galimybių, ir buvo padarytas tik pačiam pagrindiniam parodymui. Tačiau AVR šeimos mikrovaldikliai turi tam skirtą įrangą, kuria PWM signalas gali būti formuojamas tik įrašant tam tikras reikšmes į registrus. Tiesa, AVR mikrovaldikliai gali generuoti keletą PWM tipų, iš kurių naudosiu ir šiame straipsnyje aprašysiu tik vieną - "Fast PWM".
Norint mikrovaldikliu valdyti mano turimus švieos diodus, reikia keleto papildomų detalių. Šis modulis valdomas +12V įtampa, kai tuo tarpu mikrovaldiklio išėjimuose įtampa yra +5 V. Tam naudojami tranzistoriniai raktai, o būtent šiuo atveju naudojau lauko tranzistorius dėl paprastumo. Su šitais neturiu daug patirties, tiesą sakant, jos neturiu išvis, jei neskaityt keleto bandymų juos lituot paauglystėje. Pasirausęs detalių atsargose radau tris vienodus lauko tranzistorius IRFZ46N, kurie maždaug 50 kartų viršijo man reikalingą galingumą, tačiau pirmam kartui, ypač kai nereikia taupyti vietos - tiks, vis pirkt nereikės.
Valdymui panaudojau mikrovaldiklį ATtiny2313 - tai pats pirmas mano bandytas valdiklis, kuris iki šiol dirba už bandomąjį triušį. Svarbiausia, kad jis turi pakankamai atminties, kadangi tokių bandymų metu jos taupyti visai nenoriu, bei turi 4 PWM išėjimus: 2 iš jų 8 bitų tikslumo, kiti du - 16 bitų tikslumo. Bitai šiuo atveju nusako, kiek gali būti reikšmių nuo siauriausio PWM impulso iki plačiausio, t.y. pastovaus +5V signalo. 8 bitų atveju gali būti max. 256 laipteliai, tuo tarpu 16 bitų PWM išėjimas gali generuoti 65535 laiptelius nuo siauriausio iki plačiausio impulso. Kadangi planuoju šviesos spalvą keisti užduodamas RGB kodą (trys baitai, po baitą kiekvienai spalvai), 8 bitų PWM signalo man pakako. Žinoma, 16 bitų PWM gali dirbti ir kaip 8 bitų, todėl sunkumų šioje vietoje neiškilo.
Viso projekto vizija - per UART''ą mikrovaldiklio gautas šviesos kodas (trys baitai) atvaizduojamas ant RGB diodų, kiekvieną baitą priskiriant kiekvienai spalvai.
SCHEMA
Štai mano naudojamo ATtiny2313 išvadai:

Šiam projektui aktualūs, neskaitant maitinimo ir kvarcinio rezonatoriaus (nebūtinas, bet pas mane jis yra, todėl ir čia bus nupiešta:) ), PWM išėjimai ir USART prievadas. Pastarąjį kol kas paliksiu ramybėje, apsistosiu ties PWM išvadais.
AVR mikrovaldikliuose PWM išėjimai žymimi OCxn žymėmis, kas reiškia "Output Compare", jo eilės numeris (x) ir jo kanalo numeris (A arba B). Šiame mikrovaldiklyje naudosiu OC0A, OC1A, OC1B išėjimus. OC0A priklauso 8 bitų PWM, OC1n - 16 bitų. Atitinkamai juos naudosiu R, G ir B spalvų šviesos diodams valdyti (Raudona, Žalia, Mėlyna). Ką reiškia "Output Compare" pasistengsiu paaiškinti rašydamas apie PWM formavimą.
Apsisprendus, kokius išvadus naudosiu, galima braižyti schemą:

RGB LED moduliai būna dviejų tipų: bendru katodu ir bendru anodu. Mano atveju - bendras anodas, t.y. pastoviai prijungta +12V įtampa, o tranzistoriais komutuojamas minusas. Nuspalvintas kvadratas - LED modulis. ISP jungtis - programavimui (šiuo metu naudoju anksčiau aprašytą USBtiny), UART jungtis - spalvos kodo gavimui. Be kvarcinio rezonatoriaus ir 33pF kondensatorių galima apsieiti, nes naujas  mikrovaldiklis dirba 1Mhz dažniu iškart - tokiu atveju pasikeis vėliau aprašyti registrų parametrai. Čia ir visa schema, kurios pagrindinis bjaurumas yra dviejų įtampų reikalingumas. To galima išvengti naudojant mažos įtampos RGB šviesos diodus - tokiu atveju nereikės tranzistorių, diodus jungiant tiesiai prie mikrovaldiklio per 0,5-1 kiloomų rezistorių.
PWM REALIZAVIMAS
Baigus junginėti scemą (aš susikaišiojau ją ant maketinės plokštės, kuri, turiu pastebėti, labai puikus daiktas tokiems bandymams) galima pasiaiškinti, kaip veikia ir kaip nustatomas PWM signalas AVR mikrovaldiklyje. Šiam tikslui yra skirti keletas registrų, į kuriuos įrašant tam tikrus bitus nurodytų prievadų funkcija pasikeičia. Mikroschemos aprašyme, 62 puslapyje labai išsamiai aprašytas registrų valdymas. Viso teksto nekartosiu, paminėsiu tik reikalingiausias dalis.
Pirmiausia, žinoma, reikia nustatyti prievadą kaip išėjimą (DDRB=0b00111000;). Visam kitam reikalingi tik du registrai kiekvienai PWM kanalų porai, t.y. pirmiems dviems 8 bitų kanalams naudojami du registrai, o kitiems dviems 16 bitų kanalams naudojami dar du registrai. Papildomai naudojami dartrys registrai nustatyti impulso pločiui kiekvienai spalvai - apie tai kiek žemiau. Į registrus reikšmes galima rašyti ir tiesiogiai priskiriant skaičių, ir naudojant bitų postūmį. Naudojant pastarąjį būdą, akivaizdžiai matosi, kokie registro bitai įjungiami, kurie išjungiami, nes kiekvienas bitas registre, kaip pamatysite iš mikrovaldiklio aprašymo, turi savo pavadinimą.
8 bitų PWM kanalams, iš kurių naudosiu tik vieną raudonos spalvos diodui, valdyti naudojami registrai TCCR0A ir TCCR0B. 16 bitų kanalams, kurių bus išnaudojami tik 8 bitai, valdyti (žaliai ir mėlynai spalvai) bus naudojami registrai TCCR1A ir TCCR1B. Impulso pločiui nustatyti naudojami atitinkamai OCROA, OCR1AL, OCR1BL spalvoms R, G ir B
Kaip veikia PWM generavimas ir ką valdo tie registrai? Mikrovaldiklis paleidžia skaičiuką, kuris skaičiuoja nuo 0 iki 255. Tokio skaičiavimo grafikas atrodytų taip:


Rodyklės rodo skaitliuko reikšmės kitimo kryptį. Skaitliukas, pasiekęs maksimalią reikšmę (ji nebūtinai turi būti 255, bet šiam kartui to nereikia) nunulinamas, ir vėl skaičiuojama iš pradžios, iki kol pasiekiamas maksimumas. Pats skaitliukas nevaldo nieko. Tačiau registrais galima nustatyti ribą, kurią skaitliukui pasiekus kažkas gali būti įjungiama arba išjungiama. Pavyzdžiui, išėjimas (mikrovaldiklio išvadas) gali būti įjungiamas, skaitliuko reikšmei esant mažiausiai, ir išjungiamas, pasiekus tam tikrą reikšmę, kuri sutampa su registre įrašyta reikšme. Tai atrodys maždaug šitaip:


Raudona linija nuspalvotas fizinis mikrovaldiklio įtampos lygis. Tokiu atveju skaitliukio pradedans skaičiuoti, esant minimaliai reikšmei mikrovaldiklio išėjime nustatomas +5V įtampos lygis, o skaitliukui pasiekus reikšmę "50" - išėjime nustatomas 0V įtampos lygis. Šiame paveiksliuke impulso plotis keičiamas nuo 50 iki 200 skaitliuko reikšmės. Viskas vyksta tokia seka: į registrą įrašomas skaičius (tarkim, kaip paveiksliuko pirmo skaičiavimo - 50). Skaičiukui kaskart padidėjus vienetu jo reikšmė sulyginama su registre įrašyta reikšme, ir jei jos sutampa - įvykdomas kažkoks veiksmas, paveiksliuko atveju - išjungiama įtampa ant išvado. Štai kodėl išvadai vadinami Output Compare.
Grįžtu prie registrų. Kiekvienas registras (nebūtinai PWM) yra sudarytas iš 8 bitų, t.y. viename registre galima saugoti 8 skirtingas reiškmes (yra/nėra). Čia naudojami registrai veikia taip pat. Pažiūrime, kaip atrodo registras mikrovaldiklio aprašyme:
 
Bit7 ir Bit6 valdo mums reikalingo PWM išėjimo veikimą. Pagal aprašyme esančią lentelę pasirenkame, kad įtampa išėjime būtų įjungiama, kai skaitliukas bus nunulintas, ir išjungiama, kai bus registruotas skaitliuko reikšmės sutapimas su į registrą įrašyta reikšme, t.y. COM0A1 nustatome loginiam vienetui, COM0A0 - loginiam nuliui. Analogiškai veikia ir 5 bei 4 bitai, tik jie valdo išėjimą, kurio mes nenaudojame (OC0B). Bitai 1 ir 0 (WGM01 ir WGM00) nurodo, kokio tipo (formos) signalas bus generuojamas PWM išėjime. Iš viso jų yra 6 variantai, mums reikia FAST PWM (Mode 3, žr. aprašymą). Tam nustatome tiek WGM01, tiek WGM00 loginiam vienetui. Nustatyti galima įrašant dvejetainį skaičių į registrą:
TCCR0A=0b10000011;
arba įrašant dešimtainį skaičių, atitinkanti aukščuiau esantį dvejetainį, arba naudojant bitų postūmius, ką ir matysite žemiau programoje.
Sekantis registras, valdantis šią 8 bitų PWM išėjimų porą, yra TCCR0B:

Čia mums svarbūs tik pirmi trys bitai (CS00-CS02), kuriais nustatomas skaitliuko skaičiavimo dažnis. Mikrovaldiklio aprašyme duota formulė  (67 puslapyje) pagal kurią galima apsiskaičiuoti, kokiu dažniu veiks PWM išėjimai. PWM išėjimo dažnis svarbus tuo, kad jeigu jis bus per mažas, akis matys šviesos diodų mirksėjimą. Šis dažnis priklauso nuo mikrovaldiklio veikimo dažnio. Tačiau dažnai mikrovaldiklio veikimo dažnis daug didesnis, nei reikalingas PWM išėjimui, todėl TCCR0B registro pirmais trimis bitais galima nustatyti, kiek kartų mikrovaldiklio dažnis bus sumažinamas skaitliuko skaičiavimaui. Galimi variantai yra: naudoti tiesiogiai pagrindinį dažnį, pagrindinį dažnį dalinti iš 8, 64, 256 arba 1024. Mano atveju naudosiu dalintą iš 8, rezultate PWM dažnis bus, berods, virš 200 Hz, jei neklystu. Tokiu atveju įrašomas 1 tik į CS01. Tie skaičiai keisis, jei nebus naudpojamas kvarcinis rezonatorius - tokiu atveju reikės paskaičiuot reikšmes pagal norimą dažnį.
Ir paskutinis registras raudonos spalvos valdymui - reikšmės, ties kuria mikrovaldiklio išėjime bus išjungiama įtampa, įrašymas. Tam skirtas registras OCR0A, kuriam reikės tiesiog priskirti norimą reikšmę. Ta reikšmė galės būti nuo 0 iki 255 (8 bitai), ir tai nustatys impulso plotį.
Yra viena svarbi pastaba, kuri aprašyme kažkodėl atspausdinta sumažintu šriftu :) Teoriškai, į OCR0A įrašius 0 (nulį) impulsai neturėtų atsirasti, t.y. jokios įtampos ant mikrovaldiklio išėjimo neturėtų būti. Tačiau taip nėra - skaitliuko nunulinimo metu vis dėl to trumpam įjungiama įtampa išėjime, todėl visiškai užgesinti šviesos diodo nepavyks. Tai bus galima padaryti išjungiant PWM funkciją išėjime, t.y. į TCCR0A atitinkamus bitus įrašant 0 (COM0A1 ir COM0A2).
16 bitų PWM nustatomas atitinkamai, skirtumas tik WGM bituose - reikia nurodyti, kad bus dirbama 8 bitų PWM režime, taip pat reikšmė, ties kuria generuojamas sutapimas, bus įrašoma į žemesnį registrą OCR1AL (kadangi šis PWM skaitliukas yra 16 bitų, o registras - 8 bitų, visa reikšmė įrašoma per du registrus - pirmi aštuoni bitai ir paskutiniai aštuoni. Mums reikia įrašyti pirmus aštuonis bitus, nekreipiant dėmesio į kitus).
Viso šito aprašymas truko visai netrumpai, kas bus juokinga, pamačius, kokio ilgumo programa :)
#include <avr/io.h>
int main() {
  DDRB=0b00111000; // PB2-PB4 nustatomi kaip isejimai
  PORTB=0; // PB2-PB4 isjungiami
  // (1<<COM0A1) - nustatomas bitas, nurodantis ijungti itampa nunulinus skaitliuka
  //(1<<WGM01) | (1<<WGM00) - nurodoma, koks signalas bus formuojamas, siuo atveju Fast PWM
  TCCR0A= (1<<COM0A1) | (1<<WGM01) | (1<<WGM00);
  // (1<<CS01) | (0<<CS00) - nurodoma, koks daznio daliklis naudojamas apskaiciuoti PWM dazni
  TCCR0B= (1<<CS01) | (0<<CS00);
  // analogiskai kaip TCCR0A ir TCCR0B
  TCCR1A= (1<<COM1A1) | (1<<COM1B1) | (1<<WGM10);TCCR1B= (1<<WGM12) | (1<<CS11) | (0<<CS10);
  OCR0A=125; 
  // raudonos spalvos diodo impulso plotis (125 is 255 galimu, t.y. 50 proc)OCR1AL=125;
  // zalios spalvos diodo impulso plotis (125 is 255 galimu, t.y. 50 proc)OCR1BL=125;
  // melynos spalvos diodo impulso plotis (125 is 255 galimu, t.y. 50 proc)
  while(1);   // amzinas ciklas}



Viskas paaiškinta komentaruose. Tokią programą įrašius į mikrovaldiklį, šviesos diodai veiks maždaug 50 proc. galios, švies baltai. Įrašius kitokią reikšmę, galima pažiūrėti kiek reguliuojamas galingumas. Atitinkamai įrašius skirtingas reikšmes bus išgaunama kitokia spalva. Pasižaidimui galima daryti ciklą, kurio metu bus pakeičiamos visos spalvos - tai nėra taip paprasta, kaip galvojau iš pradžių. Neradau formulės, pagal kurią apskaičiuojamas visų trijų spalvų intensyvumas, todėl teko daryti šešis atskirus etapus (ciklus), kurių metu keitėsi viena spalva, t.y. intensyvumas didėjo arba mažėjo. Štai šie šeši etapai:
1. Raudona - 255; Žalia - 0; Mėlyna didėja nuo 0 iki 255;
2. Raudona mažėja nuo 255->0; Žalia - 0; Mėlyna - 255;
3. Raudona - 0; Žalia - 0->255; Mėlyna - 255;
4. Raudona - 0; Žalia - 255; Mėlyna - 255->0;
5. Raudona - 0->255; Žalia - 255; Mėlyna - 0;
6. Raodona - 255; Žalia - 255->0; Mėlyna - 00;
Ciklus pasirašykite patys, tai nėra labai sudėtinga. O jei žinote, kaip tai padaryti vienu ciklu pagal kokią formulę - parašykite komentaruose.

Tačiau matyti visą laiką tą pačią šviesą neįdomu, be to, pirminis šio projekto tikslas buvo spalvos valdymas per USART prievadą.
VALDYMAS / DUOMENŲ GAVIMAS
USART (Universal synchronous asynchronous receiver transmitter) naudoja tą patį protokolą, kaip ir kompiuterio COM prievadas, t.y. nuoseklusis duomenų perdavimas Full-Duplex režimu (vienas laidas duomenų siuntimui - Tx, kitas - gavimui - Rx). Nuo kompiuterio COM prievado skiriasi tik įtampų lygiais, kuriuos galima suderinti panaudojus MAX232 mikroschemą.
Šis prievadas mikrovaldiklyje taip pat valdomas registrų pagalba. Šiam kartui apžvelgsiu tik duomenų gavimą. Geras straipsnelis pradžiai yra čia - ten pasižaidimui bei supratimui galima į terminalą pasiuntinėti simbolius. Mano atveju reikės nusiųsti tris 8 bitų skaičius, ko paprastas Hyperterminal (buvo Windows XP) arba PuTTy (nemokamas) negali - šie tik siunčia simbolį, kuris užkoduojamas tuo 8 bitų skaičiumi ir tada perduodamas USART protokolu. Į tai kol kas nesigilinsiu, išpsręsim vėliau, dabar reikai mikrovaldikliui liepti pasiimti tuos duomenis.
Vėlgi, visa informacija randama mikrovaldiklio aprašyme, paminėsiu tik naudojamus registrus:
UBRRL registre nurodomas, koks duomenų greitis (bps) naudojamas. Mano atveju nustatytas 9600bps greitis, tam į registrą reikia įrašyti reikšmę 25
UBBRL = 25;
Kitas registras:
UCSRB= (1<<RXCIE) | (1<<RXEN) ; // interupts ir enable TX RX

Čia registro bitai įjungiami naudojant bitų postūmius. RXCIE įjungia duomenų gavimo pertrauktį (interrupt), o RXEN - įjungia duomenų gavimą. Principas toks: kai duomenys ateina į USART (paprastai tai būna vienas baitas plius keli valdymo bitai, apie juos esu rašęs anksčiau), jie padedami į tam skirtą registrą, ir generuojama pertrauktis. Pertraukties metu mikrovaldiklis, nepriklausomai nuo tuo metu vykdytos programos, šoka į nustatytą programos vietą ir vykdo ten esantį kodą - mūsų atveju gautą baitą priskirsime vienos iš spalvų intensyvumui (0-255). Tai atlikęs, mikrovaldiklis grįžta prie anksčiau vykdytos programos. Gautas baitas saugomas registre UDR, kurį galima priskirti kintamajam arba kitam registrui.
Kiek kebliau yra tai, kad mums reikia gauti tris baitus, ir tik tada juos įrašyti į PWM impulso pločio valdymo registrus. Tam padariau paprastą gautų baitų skaičiavimą. Štai programa:
#define red OCR0A
#define green OCR1AL
#define blue OCR1BL
#include <avr/io.h>
#include <avr/interrupt.h>
volatile uint8_t nr=0; // gauto baito numeris spalvos kodui
volatile uint8_t R=0; // raudonos spalvos kodas
volatile uint8_t G=0; // zalios spalvos kodas
volatile uint8_t B=0; // melynos spalvos kodas
// funkcija visiskam LED isjungimui: pwm(0) isjungia diodus o pwm(1) - ijungia 
void pwm (uint8_t onoff) {  
  if (onoff==0) {
          TCCR0A= (0<<COM0A1) | (1<<WGM01) | (1<<WGM00);
          TCCR1A= (0<<COM1A1) | (0<<COM1B1) | (1<<WGM10);        
          } else if (onoff==1) {
                      TCCR0A= (1<<COM0A1) | (1<<WGM01) | (1<<WGM00);            
                      TCCR1A= (1<<COM1A1) | (1<<COM1B1) | (1<<WGM10);            
                      }
}
int main() {
    DDRB=0b00111000; // PB2-PB4 nustatomi kaip isejimai    
    PORTB=0; // PB2-PB4 isjungiami    
    pwm(0);// kol kas pwm isjungiamas    
    TCCR0B= (1<<CS01) | (0<<CS00);    
    TCCR1B= (1<<WGM12) | (1<<CS11) | (0<<CS10);    
    UBRRL=25; // nustatomas UART 9600bps greitis    
    UCSRB= (1<<RXCIE) | (1<<RXEN); // interupts ir enable RX    
    sei(); // leidziamos pertrauktys    
    //visoms spalvoms impulso plotis - 0    
    red=0;    
    green=0;    
    blue=0;    
    while(1); // amzinas ciklas    
    }
    ISR(USART_RX_vect) { // cia soka programa, jei generuojama pertrauktisswitch (nr) 
    { // tikrina, kuris baitas gaunamas    
    case 0: //0 gautu, gaunamas pirmas baitas        
    R=UDR; // raudonai spalvai priskiriamas gauta reiksme        
    nr++;        
    break;    
    case 1: //1 gautas, gaunamas antras baitas        
    G=UDR; // zaliai spalvai priskiriama gauta reiksme        
    nr++;        
    break;    
    case 2: //2 gauti, gaunamas trecias baitas,        
    B=UDR; // melynai spalvai priskiriama gauta reiksme        
    nr=0;        
    if (R||G||B) { // jeigu ne visos reiksmes nuliai            
    pwm(1); // ijungti PWM            
    red=R; // nustatomas raudonos spalvos impulso plotis            
    green=G;// nustatomas zalios spalvos impulso plotis            
    blue=B;// nustatomas melynos spalvos impulso plotis            
    } else { // jeigu visos reiksmes nuliai                
      pwm(0); // isjungiamas PWM                
      }        
      break;    
      }
      }   



Čia jau sau palengvinau gyvenimą panaudodamas tris pirmas eilutes: kompiliatorius, pamatęs šias komandas, kompiliavimo metu radęs atitinkančius žodžius (pvz "red") juos pakeičia į nurodytą (OCR0A) - taip nereikia atsiminti visų registrų pavadinimų. Taip pat yra funkcija pwm(), kuri leidžia greičiau išjungti ir įjungti PWM, kai to reikia. Gal būt toks būdas ir yra šiek tiek kreivas, tačiau šiam kartui veikia :)
Kita rogramos dalis pakankamai, manau, pakomentuota, ir įsikėlus ją į mikrovaldiklio atmintį galima pradėt žaisti.
Liko paskutinė užduotis:
SPALVOS KODO NUSIUNTIMAS PER COM PRIEVADĄ
Jeigu susiprogramavote mikrovaldiklį duota programa, pasileidę, pavyzdžiui, PuTTy programą ir atsidarę COM prievadą, prie kurio per suderinimo mikroschemą prijungtas mikrovaldiklis, galite spaudinėdami klaviatūros mygtukus žiūrėti, kaip keičiasi spalvos. Tačiau raidės ir skaičiai siunčiami kodais nuo 32 iki beveik šimto(berods, reikia pasitikslinti). Norint siųsti visą intervalą nuo 0 iki 255 mums reikės rašyti dar vieną programą, dabar jau kompiuteryje, kuri išsiųstų reikiamus skaičius. Kita galimybė - yra terminalinės programos (kaip PuTTy), kurios leidžia siųsti ir skaičius vietoj simbolių, tačiau čia to neaprašinėsiu.
Tokios programos rašymui naudosiu programavimo kalbą Python - tai aukšto lygio, pakankamai nauja ir sparčia populiarėjanti programavimo kalba, kuri tinka visoms platformoms - man tai šiuo atveju aktualu todėl, kad visus derinimo darbus darau Windows aplinkoje, o valdysiu jau iš Debian linux, kuri sukasi mano RaspberryPi kompiuteryje. Be to, per Python labai paprasta prieiti prie nuoseklaus prievado kompiuteryje (COM), ko negaliu pasakyti apei kitas, žemesnio lygio programavimo kalbas. Žinoma, Python trūkumas - sąlyginai lėtas jos veikimas, bet tokioms užduotims to greičio pilnai pakanka, o jei jo ir pritrūks - galima naudoti C kalba parašytas dalis, bet čia ne apie tai.
Python programavimo kalboje priėjimas prie COM prievado vykdomas per serial modulį (pyserial), kurį reikia papildomai parsisiųsti ir instaliuoti. Tai padarius galima atsidaryti programą IDLE, kurioje iškart rašant komandas galima stebėti, kaip kas vyksta. Pyserial puslapyje yra keletas visai paprastų pavyzdžių, kaip atsidaryti prievadą ir kaip siųsti juo duomenis, ko man pilnai pakanka.
Pavyzdžiui, įveskite (eilutės gale spausti "Enter"):
import serial
ser=serial.Serial(0)
ser.write(chr(250)); ser.write(chr(250)); ser.write(chr(250));

Pirma eilutė įkrauna serial modulį, antra - atidaro COM1 prievadą, trečia - išsiunčia tris baitus, t.y. reikšmes 250, 250 ir dar kartą 250. Gavę šią komandą diodai turėtų šviesti balta ryškia spalva.
Tačiau vėlgi, taip valdyti bus įdomu tik kai nesinorės pamatyti veiksmo :) Štai elementari, visiškai neoptimizuota programa visų spalvų atvaizdavimui. IDLE aplinkoje spauskite File>New window  ir įklijuokite tokį kodą:
import serial
ser = serial.Serial(0)
max=250
R=max
G=0
B=0
for a in range (1,10):
    for i in range (1, max):
        B=i        
        ser.write(chr(R))        
        ser.write(chr(G))       
        ser.write(chr(B))
    for i in range (1, max):   
        R=max-i        
        ser.write(chr(R))        
        ser.write(chr(G))        
        ser.write(chr(B))     
    for i in range (1, max):      
        G=i        
        ser.write(chr(R))        
        ser.write(chr(G))        
        ser.write(chr(B))           
    for i in range (1, max):    
        B=max-i        
        ser.write(chr(R))        
        ser.write(chr(G))        
        ser.write(chr(B))    
    for i in range (1, max):    
        R=i        
        ser.write(chr(R))        
        ser.write(chr(G))        
        ser.write(chr(B))           
    for i in range (1, max):        
        G=max-i        
        ser.write(chr(R))        
        ser.write(chr(G))        
        ser.write(chr(B))

 



Jeigu viskas gerai, pamatysite besikeičiančias spalvas, ir tai pasikartos 10 kartų.
Šiam kartui tiek - pagrindas padarytas, sekantis žingsnis bus susigalvoti ir apsirašyti, kaip pas žaltį keisis spalvos priklausomai nuo paros meto ir/arba apšvietimo. Yra mintis panaudoti kokį nors fotoelementą ir su juo tikrinti to paties mikrovaldiklio pagalba, koks yra apšviestumas aplinkoje, bet čia jau ateities planai. Taip pat pasižaidimui galima bandyti pasidaryti gudresnę vartotojo sąsają Python kalboje, reaguojančią į kažkokį duomenų įvedimą. Žodžiu, kaip ir visada, kai tai susįję su programavimu: vietos fantazijai yra iki valiai.

Štai nufilmuota, kaip atrodo visų spalvų rodymas. Į detalių gausą ant maketinės plokštės nekreipti dėmesio, ten dar du projektai be šito :) LED modulis paslėptas už balto lapo, nes kitu atveju šviesa per stipri - reiktų mažint intensyvumą, ką dabar daryt pritingiu.
www.youtube.com/v/UrzUIqams3A


Jeigu turite pastabų - išsakykite jas komentaruose. Sėkmės!

Komentarų nėra:

Rašyti komentarą