Arduino programoptimalizálás - hogyan? (I/O kezelés)

zolsza

Sziasztok! Kezdőként nem értem, hogy az alábbi két program Ardunio uno panelen EXT1 silddel miért nem ugyan azt csinálja. A két program:

Első:
int Analog1 = analogRead(2);
void setup ()
{
Serial.begin (9600);

}
void loop()
{
Serial.print(Analog1);
Serial.println(",");
delay(5000);
}

Második:

void setup ()
{
Serial.begin (9600);
analogRead(2);
}
void loop()
{
Serial.print(analogRead(2));
Serial.println(",");
delay(5000);
}

Első folyamatosan 0 érteket ad soros-porton, második teszi a dolgát és tudom változtatni a soros-porton kiirt kódot az EXT1 sild analog2 bemenetén lévő potenciométer segítségével.

Mit csinálok rosszul. Szerintem mindkét programnak ugyan azt kellene csinálnia.

Az elso esetben FIX erteket adsz.
Valamint szerintem tul komplex az ertek ilyen jellegu megadasa (az elso esetben).

kapu48

Már mért lenne egyforma a 2 programod???
Gondolkozz 1 kicsit!
Ami előtte van a „void loop() { ……. }”-nak csak 1* hajtódok végre, a program indulásakor.
És csak a „void loop() { …közötti rész…. }”- ismétlődik végtelenszer.

zolsza

Kód: Egész kijelölése

int x0;                              // változok definiálása
int x1;
int x2;
int x3;
int x4;
int x5;
int y0;
int y1;
int y2;
int y3;
int y4;
int y5;
int y6;
int y7;
int y8;
int y9;
int y10;
int y11;
int y12;
int y13;
int pwm1;
int pwm2;
int pwm3;
int pwm4;
int pwm5;
int pwm6;

void setup ()   
{
  Serial.begin (9600);        // Soros porti komonikacio inditasa
} 
void loop() 
{  
  x0 = analogRead(A0);         //portok beolvasása
  x1 = analogRead(A1);
  x2 = analogRead(A2);
  x3 = analogRead(A3);
  x4 = analogRead(A4);
  x5 = analogRead(A5);
  y0 =digitalRead(0);
  y1 =digitalRead(1);
  y2 =digitalRead(2);
  y3 =digitalRead(3);
  y4 =digitalRead(4);
  y5 =digitalRead(5);
  y6 =digitalRead(6);
  y7 =digitalRead(7);
  y8 =digitalRead(8);
  y9 =digitalRead(9);
  y1 =digitalRead(1);
  y11 =digitalRead(11);
  y12 =digitalRead(12);
  y13 =digitalRead(13);

  pwm1= (x0);                 
  byte pwm11=pwm1/4;
  analogWrite(y3,pwm11);
  pwm2= (x1);
  byte pwm21=pwm2/4;
  analogWrite(y5,pwm21);
  pwm3= (x2);
  byte pwm31=pwm3/4;
  analogWrite(y6,pwm31);
  pwm4= (x3);
  byte pwm41=pwm4/4;
  analogWrite(y9,pwm41);
  pwm5= (x4);
  byte pwm51=pwm5/4;
  analogWrite(y10,pwm51);
  pwm6= (x5);
  byte pwm61=pwm6/4;
  analogWrite(y11,pwm61);


  Serial.println("ANALOG");        // Analog portok kiiratása
  Serial.print("A0: ");
  Serial.print(x0);                   
  Serial.print("; ");
  Serial.print("A1: ");
  Serial.print(x1);                   
  Serial.print("; ");
  Serial.print("A2: ");
  Serial.print(x2);                   
  Serial.print("; ");
  Serial.print("A3: ");
  Serial.print(x3);                   
  Serial.print("; ");
  Serial.print("A4: ");
  Serial.print(x4);                   
  Serial.print("; ");
  Serial.print("A5: ");
  Serial.print(x5);                   
  Serial.println("; ");
  Serial.println("DIGITALIS");  //Digitális portok kiiratása
  Serial.print("D0:       ");
  Serial.print(y0);
  Serial.println(",");
  Serial.print("D1:       ");
  Serial.print(y1);                   
  Serial.println(",");
  Serial.print("D2:       ");
  Serial.print(y2);                   
  Serial.println(",");
  Serial.print("D3:  ");
  Serial.print("PWM: ");
  Serial.print(pwm11, DEC);
  Serial.println(".");
  Serial.print("D4:       ");
  Serial.print(y4);                   
  Serial.println(",");
  Serial.print("D5:  ");
  Serial.print("PWM: ");
  Serial.print(pwm21, DEC);                   
  Serial.println(".");
  Serial.print("D6:  ");
  Serial.print("PWM: ");
  Serial.print(pwm31, DEC);                   
  Serial.println(".");
  Serial.print("D7:       ");
  Serial.print(y7);                   
  Serial.println(",");
  Serial.print("D8:       ");
  Serial.print(y8);                   
  Serial.println(",");
  Serial.print("D9:  ");
  Serial.print("PWM: ");
  Serial.print(pwm41, DEC);                   
  Serial.println(".");
  Serial.print("D10: ");
  Serial.print("PWM: ");
  Serial.print(pwm51, DEC);                   
  Serial.println(".");
  Serial.print("D11: ");
  Serial.print("PWM: ");
  Serial.print(pwm61, DEC);                   
  Serial.println(".");
  Serial.print("D12:      ");
  Serial.print(y12);                   
  Serial.println(",");
  Serial.print("D13:      ");
  Serial.print(y13);                   
  Serial.println(",");
  delay(5000);                     // 5 mp késleltetés
}

Ez a program egy Ardunio Uno
panel digitális és analóg portjainak értékét írja ki soros porton, illetve a 6 darab analóg bemenetet párosítottam a 6 darab PWM kimenettel. Változok azért is vannak az elején, mert későbbiekben processing segítségével szeretném számítógépről vezérelni a panelt. Amennyiben valakinek van ötlete hogy a program méretét hogyan lehetne csökkenteni, azt köszönöm.

Arduino alatt : Sehogy.
a fordítási mechanizmusba kell belenyúlni (rendszerszint, mélyen)...

A könnyű programozásnak ez az ára.
De a M328-as chipbe nem fér bele?

Bascom-AVR alatt a méret az ötöde kb...

zolsza

Sajnos Bascom-ban még nem vagyok "otthon". Jelenleg egy Bascom demoval probálkozom, de a kódméretből azt gondoltam hogy demoban nem fog menni, viszont jó hír, hogy ha Bascom-ban ötöde lenne akkor nekifekszem annak is.

y1 =digitalRead(1);

2x szerepel a kódban!

kapu48

Ha már időt-energiát fektetsz valamelyik program megtanulásában válasz valami jobbat, mint az Ardúnió!
Ennek nagyon korlátozottak a lehetőségei! Ráadásul egészen más neveket használ, mint a gyári AVR adatlapokon szereplő elnevezések! Ezért a látszólag könnyen megírt programértelmezés eléggé zavaros.

Kód optimizálás lehetne, ha nem Bitenként olvasod vagy írod a Be/Kimeneteket hanem Byteonként!
Ez viszont már a Hardwer optimizálásánál kezdődik! Vagyis a Bemenetek 1 Porton legyenek. A kimenetek szintén 1-ben másikon.

Gerifield

kapu48 írta:Ha már időt-energiát fektetsz valamelyik program megtanulásában válasz valami jobbat, mint az Ardúnió!

Ezzel vitába szállnék, kezdésnek jó, mivel szintén C szintaxist használ és aki még nem programozott ilyet, annak nagy segítség.
Innen ha legalább az alapok megvannak könnyebb lesz tovább tanulni!

kapu48

Velem felesleges vitatkoznod!
Mert úgysem fogsz rávenni, hogy tanuljam meg ezeket az egyedi elnevezéseket, csak az ardunió kedvéért!:
x0 = analogRead(A0); //portok beolvasása
x1 = analogRead(A1);
x2 = analogRead(A2);
x3 = analogRead(A3);
x4 = analogRead(A4);
x5 = analogRead(A5);
y0 =digitalRead(0);
y1 =digitalRead(1);
y2 =digitalRead(2);
y3 =digitalRead(3);
y4 =digitalRead(4);
y5 =digitalRead(5);
y6 =digitalRead(6);
y7 =digitalRead(7);
y8 =digitalRead(8);
y9 =digitalRead(9);
y1 =digitalRead(1);
y11 =digitalRead(11);
y12 =digitalRead(12);
y13 =digitalRead(13);

Viszont ha már annyira pártolod, inkább tanácsokat osztanál!
Mert olyan személy, aki segítene ezen a nyelven szinte =0val itt a fórumon!

Gerifield

Hmm analogRead-nél nem kell oda az A betű, mivel alapból az arduinokon összesen 6 analóg bement van. (0..5)
Szóval simán analogRead(0), analogRead(1)....

Amúgy az arduinoknál egyszerűbb eszköz nincs...
Aznap, hogy kézhez kaptam már elég sok mindent meg tudtam vele csinálni. Annó nézegettem a "sima" AVR programozást, azzal azért jóval több szívás van.
Kis, egyszerű projektekhez ennél gyorsan prototípus készítő módszer nincs.

Tanácsot szívesen osztok, ha van kérdés.
Az "egyedi" elnevezésekről annyit, hogy itt a referencia, alig van pár parancs....
http://arduino.cc/en/Reference/HomePage
(Ami van, az pedig jól dokumentál + igen sok library van, ami külön előny!)

De ha nem tetszik, ne használd, viszont kezdőknek (és olyanoknak akik már ismerik) nagyon is ideális dolog ez!
(Amúgy én a Bascomtól viszolygok kicsit, nálam a programozás a C-nél, illetve a C szerű nyelveknél kezdődik... Vagy akkor már inkább asm...)

kapu48

Köszönöm a linket ismerem!
De semmit nem tudtam meg belőle!
Most ha nézem az AVR adatlapját, akkor melyik is a „digitalRead(1); Port?
Még ezt nevezed 1*űnek?

Akkor már inkább Gcc-t kelene tanulni!
Az legalább értelmes időtöltés lenne! Mert máshól is felhasználható.
Nem csak ezeken az egyedi latin alap kártyákon.

Nono, mielőtt hajtépés lenne:

Az arduinio a Physical Computing alapelvet valósítja meg. Azaz külső fizikai jelből valami függvény alapján fizikai valamit készít. Erre adódott egy "script" nyelv, azaz mindent függvénnyel végzel. És az e mögötti fordító a gcc. Következmény: C szintaktika, HW elrejtve előled, de gyors eredmény, pazarló és nagy kód.
És többen ezen túlléptek, és kész függvénykönyvtárakat használnak (melynek a belső felépítését nem tudják (nem is akarják, mert nem is szükséges) megismerni. Itt hamar előjöhetnek az Arduino korlátai (nagy kódméret, nincs optimalizálva) és az én eszközöm felélesztéséhez már nincs elég ismerem.

Ezután jött a Bascom-AVR. Teljes AVR készlet programozható + xMega. Belső függvények gyakorlatilag utasítások. Kódméret kisebb, és a teljes chiphez hozzáférsz. Azza nem csak alkalmazod, hanem programozod az egyes eljárásokat.

Ezután gcc, ahol a HW, SW és a chipet egyszerre kell megtanulnod:(.
előny: sok kód van, de áttekinthetetlen. Stabil programozói tudáshoz a Bascomban 1 hónap az a gcc esetén ~2-4 hónapnak felel meg.

kapu48

Most szerintem a probléma, hogy nincsen a fórumon 1 ember aki értelmezni tudná azt a 100 sor programot amit idemásolt zolsa! Így segítség nélkül maradt!
Vagyis halott nyelv az ardúnió! Amire nem szabad drága időt pazarolni!

Gerifield

kapu48 írta:Köszönöm a linket ismerem!
De semmit nem tudtam meg belőle!
Most ha nézem az AVR adatlapját, akkor melyik is a „digitalRead(1); Port?
Még ezt nevezed 1*űnek?

Akkor már inkább Gcc-t kelene tanulni!
Az legalább értelmes időtöltés lenne! Mert máshól is felhasználható.
Nem csak ezeken az egyedi latin alap kártyákon.

http://arduino.cc/en/Main/ArduinoBoardUno
Itt a képen a magyarázat. "Felül" vannak a digitáls portok, "alul" az analóg és a tápot szolgáltatók.
Elég egyszerű, bár nem teljesen logikos csak úgy ránézésre, ez tény.

/A gcc, mint ahogy Robert is mondta maga egy fordító program.
(http://gcc.gnu.org/)/

Valóban, az arduino-ban kicsit már magasabb szinten dolgozik az ember, ez eredményez(het) kevésbé optimalizált kódot. (Persze itt is megvannak az eszközök az optimalizálásra!)

DE mint már mondtam az arduino is ugyan úgy C-t használ, mint amivel akár az AVR chipeket közvetlenül lehet programozni, mindösszesen van pár plussz eljárás, ami előre meg van írva.
Az itt tanult dolgokat később igen jól fel lehet használni!

@Robert: Ne aggódj, nem lesz.

EDIT:
"Vagyis halott nyelv az ardúnió! Amire nem szabad drága időt pazarolni! "
Ez a kijelentés eléggé nagy butaság, több szempontból is.
Az arduino "nyelve" C, amit igenis hasznos tanulni. (Illetve még pontosabban a Wiring nevű nyelv egy még jobban könnyített változata.)
Halottnak pedig nem éppen halott, a neten temérdek leírás és segítség van hozzá, egy halom projektet csinálnak ezzel a kütyüvel, mert míg mondjuk más nyelven/natív C-ben megírsz egy több száz soros programot, az ebben lehet, hogy csak 2-3 sorban megvan. Pont azért, mert már egy rakat libet elkészítettek hozzá.

Értelmezni pedig tudom a kódját én is, de ha szánnál rá 1 percet és van programozási tapasztalatod neked sem esne nehezedre.

Ennyit csinál a cucc:
1. Definiál egy rakat int típusú változót. (Amit lehetne 1 sorba, vagy akár tömbként is csinálni!)
2. Beolvassa minden port értékét az egyes változókba.
3. Ez picit zavaros, de ahogy nézem PWM jelet küld ki pár porton.
4. Az USB-n keresztül a terminálra kiírja az értékeket.
5. Vár 5 másodpercet, majd megismétli.

De ezt leírta ő is.
A kérdése az optimalizálásra irányult.
Erre most "belerejtettem" a megoldást az 1. pontba.
A változó deklarálás történhet egy int kiírása után is, pl:
int x0, x1, x2, x3;

De én inkább a tömbös módszert választanám.
Vagyis, hogy definiálsz egy tömböt és a megfelelő indexen lévő elemeket töltöd fel benne az értékekkel.
Pl 13 digitális port olvasása tömbbe:

Kód: Egész kijelölése

int ertekek[13];
int i;
for(i=0; i<13; i++){
  ertekek[i] = digitalRead(i);
}

Ezzel a pár sorral kiváltottam a kódból kb 26 sort.
(És ez C kód, nincs benne a digitalRead parancson kívül SEMMI arduino specifikus dolog!)

Újra hangsúlyozom NEM felesleges ez!
(Amúgy meg az arduino lap annyiban tér el kb egy sima AVR-től, hogy rá van kötve egy külső oszcillátor, nem az AVR belsőjével dolgozik.
Na meg persze ott vannak a plussz áramkörök, amik a programozást segítik, de ha nincsenek és a chip fel van programozva, akkor is működne a dolog!

Fordítás után ugyan úgy gépi kód keletkezik ebből is, mint bármilyen más nyelvből...)