fizikai számítástechnika, arduino

Serial.begin(9600);

Serial.println(val, format);

Az elsővel bekapcsoljuk a soros kommunikációt 9600 bit/sec-on, a másodikkal kiíratjuk a kapott adatokat a serial monitoron.

* val: az érték amit ki akarunk iratni - bármilyen adat lehet

* format: elhagyható, ilyenkor decimális számrendszet használ (ha oda akarjuk írni: DEC a tizes-, HEX a tizenhatos-, OCT a nyolcas-, BIN a kettes számrendsze jele).

SoftwareSerial()

Hívásakor létrehoz egy SoftwareSerial objektumot, azzal a névvel amit megadunk. Ahhoz, hogy a kommunikációt engedélyezzük, meg kell hívnunk a SoftwareSerial.begin() parancsot is.

Szintaxisa:

SoftwareSerial(Rx,Tx)

Paraméterei:

Rx: a szoftveres soros portunk bejövő csatornája

Tx: a szoftveres soros portunk kimenő csatornája

available()

Visszaadja a szoftveres átmeneti tárolóban elérhető berékezett bájtok számát.

Szintaxisa:

mySerial.available()

begin()

Beállítja a soros kommunikáció sebességét (baud rate). A szabvány átviteli sebességek: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 31250, 38400, 57600, és 115200.

Szintaxisa:

mySerial.begin(baudrate)

Parmétere:

baudrate: long típusú változó a fenti szabvány értékek valamelyike

isListening()

Megnézhetjük vele, hogy a kiválasztott szoftveres soros port valóban aktív-e. Boole típusú választ ad vissza értelemszerűen.

Szintaxisa:

mySerial.isListening()

overflow()

A szoftveres soros port átmeneti tárolója 64 bájtot képes elraktározni. Amennyiben ezek nem kerülnek időben kiolvasásra, a tároló túlcsordul – a régi adatok helyét nem veszik át az újak és lemaradunk a közölt információ egy részéről. Ezzel a függvénnyel ellenőrizhetjük, hogy történt-e túlcsordulás. Az ellenőrzést követően a függvény válaszát képező Bool változó hamis állapotba kerül.

Szintaxisa:

mySerial.overflow()

read()

Karakterenként kiolvassa a soros tárolót.

Szintaxisa:

mySerial.read()

peek()

Hasonlóan a read()-hez az utolsó a porton beolvasott karaktert adja vissza, ha nem jött semmi -1 –et.

Szintaxisa:

mySerial.peek()

print()

Adatokat küld a szoftveres soros port Tx csatornájára. A kiírt bájtok számát adja vissza.

println()

Ahogy az a fenti példából is látszik a küldendő adatot automatikusan kiegészíti a “soremelés” kódjával – ugyanúgy mint azt a hardware-es soros portnál már láttuk.

listen()

Több szoftveres soros port használata esetén egyszerre csak egy port kaphatja meg az olvasás jogát. Ezzel a függvénnyel beállíthatjuk, melyik port legyen az, amelyik olvashat. Az összes többi portra érkező adatok elvesznek.

Szintaxisa:

mySerial.listen()

forrás: http://arduino.cc/en/Reference/Serial

Kingbright TC20-11HWA KA

katód pontmátrix LED kijelző, 5mm LEDekkel, piros

Adatlap:

A sorok pin számai: 9, 14, 8, 12 vagy 5, 1, 7, 2.

Az oszlopoké: 13, 3, 4 vagy 11, 10, 6.

Bekötés:

Az LEDpanel sorok elé 100 Ohmos ellenállások (barna-fekete-fekete-fekete-barna) kellenek.

A panel lábainak számozása a bal alsó lábnál kezdődik és az óramutató járásával ellenkező irányban nő, tehát alul balról jobbra 1-7-ig, felül jobbról balra 8-14-ig.

Arduino Digitális pin (kimenet)  | LED panel Pin (bemenet)

• 2|9 (sor 1.)
• 3|14 (sor 2.)
• 4|8 (sor 3.)
• 5|12 vagy 5 (sor 4.)
• 6|1 (sor 5.)
• 7|7 (sor 6.)
• 8|2 (sor 7.)
  
  
• 9|13 (oszlop 1.) 
• 10|3 (oszlop 2.)
• 11|4 vagy 11 (oszlop 3.)
• 12|10 (oszlop 4.)
• 13|6 (oszlop 5.)

Ahhoz hogy egy LED világítson egy sort és egy oszlopot is manipulálnunk kell.

Arduino Library:

Frequency Timer2 Arduino library-t le kell tölteni és telepíteni kell:

http://arduino.cc/playground/Code/FrequencyTimer2 vagy

http://www.pjrc.com/teensy/td_libs_FrequencyTimer2.html

Arduino kód:

#include <FrequencyTimer2.h>

int idx = 0;
unsigned long last;void setup() {
last = millis();
pinMode( 9, OUTPUT );
pinMode( 10, OUTPUT );
pinMode( 11, OUTPUT );
pinMode( 12, OUTPUT );
pinMode( 13, OUTPUT );

pinMode( 2, OUTPUT );
pinMode( 3, OUTPUT );
pinMode( 4, OUTPUT );
pinMode( 5, OUTPUT );
pinMode( 6, OUTPUT );
pinMode( 7, OUTPUT );
pinMode( 8, OUTPUT );

for( int r = 0; r < 7; r++) {
digitalWrite( r + 2, LOW );
}
for( int c = 0; c < 5; c++) {
digitalWrite( c + 9, HIGH);
}
}byte leds[7][5];

void setPattern( byte pattern[20][5], int idx ) {
for( int r =0; r < 7; r++) {
for( int c = 0; c < 5; c++) {
leds[r][c] = pattern[r + idx][c];
}
}
}

void draw() {for( int r =0; r < 7; r ++ ) {
digitalWrite( r + 2, HIGH );
for( int c=0; c < 5; c ++ ) {
digitalWrite( 13 - c, ( leds[r][c] == 1 ? LOW : HIGH ));
}
delayMicroseconds(900);
digitalWrite( r + 2, LOW );
}
}void loop() {
if ( millis() - last > 400 ) {
idx = (idx == 0 ? 7 : 0);
last = millis();
}byte tmp[14][5] = {
{ 0,0,0,0,0},
{ 0,1,0,1,0},
{ 0,0,0,0,0},
{ 0,1,1,1,0},
{ 0,1,0,1,0},
{ 0,1,1,1,0},
{ 0,0,0,0,0},

{ 0,0,0,0,0},
{ 0,1,0,1,0},
{ 0,0,0,0,0},
{ 0,0,0,0,0},
{ 0,1,1,1,0},
{ 0,0,0,0,0},
{ 0,0,0,0,0},
};setPattern( tmp, idx );
draw();
}

forrás:

http://www.arduino.cc/playground/Main/DirectDriveLEDMatrix

http://arduino.cc/en/Tutorial/RowColumnScanning

http://ericlathrop.com/electronics/LedGrid.php

http://www.local-guru.net/blog/2009/4/3/5x7-led-matrix-on-my-arduino

tone(pin, frequency, duration)

Előre megadott frekvenciájú hullámot general az adott pinen, így egy hang szólal meg a hangszórónkon vagy a piezo buzzer-en. A hullám időtartamát is meg kell határozni, különben addig szól a hang, amíg a noTone() függvény meghívásával meg nem szakítjuk.

• pin: ahová bekötöttük a hangszórót vagy a piezo berregőt
• frequency: a hangjegy frekvenciája Hz-ben megadva (unsigned int)
• duration: a hangjegy hossza milliszekundumban megadva (unsigned long)

 http://arduino.cc/en/Reference/Tone

noTone(pin)

Megállítja a tone() függvény által general hangot. Amenniyben több pinen akarsz lejátszani dallamot, meg kell hívni a noTone()-t mielőtt a másik pinen meghívod a tone()-t.

• pin: ugyanaz a pin, amelyikhez a tone()-t meghívtad

 http://arduino.cc/en/Reference/NoTone

shiftOut(dataPin, clockPin, bitOrder, value)

Kitolja a bájtban szereplő bit adatokat egyenként. Indulhat mindkét oldalról, elejéről vagy végéről is. Az bitek után a bemeneti pinen egy órajel adat (be és kikapcsol) jelzi hogy a következő jön. A parancs meghívása előtt az órajelet ki kell kapcsolni: digitalWrite(clockPin, LOW).

• dataPin: a bitek kimenetének szánt pin (integer)
• clockPin: kapcsoló pin, amikor a dataPin értéke megfelelő, be és kikapcsol
• bitOrder: a kitolás indulásának helyét adja meg: MSBFIRST vagy LSBFIRST paranccsal működik. (Most Significant Bit First = legmagasabb helyiértékű bit először, Least Significant Bit First = legalacsonyabb helyiértékű bit először.)
• value: az adat amit kitol (byte)

Az adat pint és az órajel pint pinMode()-dal be kell állítani kimenetként! 1 byte-tel azaz 8 bit-tel működik.

http://arduino.cc/en/Reference/ShiftOut

shiftIn()

Szintaxis: byte incoming = shiftIn(dataPin, clockPin, bitOrder)

Egyesével behúzza a bájtban szereplő bit adatokat, kezdődhet a legmagasabb vagy a legalacsonyabb helyiértékű bitnél is. Minden egyes bit előtt az órajel pin bekapcsol, az adat pin kiolvassa a soron következő bitet, majd az órajle pin kikapcsol.

• dataPin: a bitek kimenetének szánt pin (integer)
• clockPin: kapcsoló pin, amikor a dataPin értéke megfelelő, be és kikapcsol
• bitOrder: az eltolás indulásának helyét adja meg: MSBFIRST vagy LSBFIRST paranccsal működik. (Most Significant Bit First = legmagasabb helyiértékű bit először, Least Significant Bit First = legalacsonyabb helyiértékű bit először.)

Visszatér: A kiolvasott érték (byte).

http://arduino.cc/en/Reference/ShiftIn

pulseIn(pin, value, timeout)

Kiolvassa az impulzust az adott pinen, ez lehet HIGH vagy LOW. Például ha az értéke HIGH akkor a pulseIn() megvárja még a pin értéke is HIGH lesz és elkezd számolni, ez addig tart még a pin LOW értéket kap, ekkor abbahagyja a számolást. Az impulzus hosszának értékét mikroszekundumban kapjuk vissza. Ha a meghatározott idő alatt (timeout) nem érkezik jel, akkor 0-t kapunk vissza.

• pin: amelyik pinen kiolvasod az impulzust (integer)
• value: az impulzus típusa, HIGH vagy LOW (integer)
• timeout: időtúllépés (opcionális), ha nincs megadva akkor alapból 1 mp, vagy mikroszekundumban kell megadni, várakozási időtartam az impulzus kezdete előtt (unsigned long)

Tehát visszatérhet egy mikorszekundum értéket takaró unsigned long vagy pedig 0.

http://arduino.cc/en/Reference/PulseIn

Az alábbi példában a sorokat és az oszlopokat tudjuk két poti segítségével végig pásztázni úgy hogy mindig csak egy LED világit, ahol a sor és az oszlop egyaránt HIGH jelet kap.

Az alábbi tutorial (http://arduino.cc/en/Tutorial/RowColumnScanning) alapján készült ez az oszlop-sor szkennelős példa, ami egy anód oszlopos mátrixot használ, módosítottam a kódot úgy hogy a lábakat a megfelelő sorrendben felcserélve kötöttem be:

Arduino - LED panel pin párok: 13-6, 12-15, 11-14, 10-8, A2-16, A3-1, A4-11, A5-4, 2-13, 3-12, 4-7, 5-10, 6-9, 7-3, 8-2, 9-5

A mátrix lábainak sorszámozása az alsó rész bal oldalán kezdődik és óramutató járásával ellentétes irányban kell haladni. TC23-11 katód oszlopos zöld panel adatlapján meg lehet nézni hogy melyik oszlop és sor melyik lábra van kivezetve:

ARDUINO KÓD:

//az inicializálásnál a col-t és
//row-t felcseráltem mivel katód a panel:
// oszlopok pin száma, 2d tömbben
const int col[8] = {
2,7,19,5,13,18,12,16 };// sorok pin száma, 2d tömbben
const int row[8] = {
6,11,10,3,17,4,8,9 };// 2d tömb a pixelek helyéhez
int pixels[8][8];// kurzor pozíciója
int x = 5;
int y = 5;void setup() {
// inicializáljuk az I/O pineket kimenetként
// ciklussal:
for (int thisPin = 0; thisPin < 8; thisPin++) {
// kimeneti pinek inicializálása:
pinMode(col[thisPin], OUTPUT);
pinMode(row[thisPin], OUTPUT);
// katód pinekre HIGH-t kell küldeni
// hogy a LED ki legyen kapcsolva!!!
digitalWrite(col[thisPin], HIGH);
}// inicializáljuk a pixel matrix-ot:
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
pixels[x][y] = HIGH;
}
}
}void loop() {
// bemenet kiolvasása:
readSensors();// kirajzolás a panelen:
refreshScreen();
}void readSensors() {
//az utolsó pozíció kikapcsolása:
pixels[x][y] = HIGH;
// szenzor-poti kiolvasása
/// x és y értékekhez:
x = 7 - map(analogRead(A0), 0, 1023, 0, 7);
y = map(analogRead(A1), 0, 1023, 0, 7);
// LOWra állítjuk az új pixel pozícióját
/// a LED bekapcsol
// frissül a képernyő/panel
pixels[x][y] = LOW;}void refreshScreen() {
// ciklussal megszámoljuk az anód sorokat
for (int thisRow = 0; thisRow < 8; thisRow++) {
// anód lábakat bekapcsoljuk
digitalWrite(row[thisRow], HIGH);
// ciklusokkal megszámoljuk a katód oszlopokat
for (int thisCol = 0; thisCol < 8; thisCol++) {
//aktuális pixel állapotát kiolvassuk:
int thisPixel = pixels[thisRow][thisCol];
// amikor a sor HIGH és az oszlop LOW,
// az a led bekapcsol ahol a kettö találkozik:
digitalWrite(col[thisCol], thisPixel);
// kapcsoljuk ki a pixelt:
if (thisPixel == LOW) {
digitalWrite(col[thisCol], HIGH);
}
}
// a sort kapcsoljuk ki:
digitalWrite(row[thisRow], LOW);
}
}