Arduino, nybörjarfråga. [Löst]

[RadioDJ]

Nu kommer lite fler frågor från en nybörjare angående Arduino.

Jag ska nu försöka förklara så att alla förstår.

Jag skickar in till Arduinon via rs-232 ett kommando: SOP132 (siffran kan vara mellan 0-255).
Siffran talar om vilken av 8 utgångar som ska slås på. Binärt ser det ut så här: 10000100.

Att plocka ut SOP är redan klart men jag har problem med att plocka ut vare 1:a och 0:a för sig.
Dessa värde ska sedan användas för att slå av eller på en utgång.

Någon som har förslag på kod??

[sodjan]

Vad betyder "jag har problem" lite mer konkret?
Har du t.ex någon kod som du har testat med?
Det går att använda bit-operationer eller divisioner.

Har du googlat "arduino testing a bit" T.ex:

http://forum.arduino.cc/index.php/topic,6441.0.html
http://playground.arduino.cc/Code/BitMath

> Siffran talar om vilken av 8 utgångar som ska slås på.

Menar du "vilken" eller menar du "vilka" ?
Du har ju två "ettor" i exemplet.

[sodjan]

En annan sak...

När du skriver "SOP132!", menar du då "S", "O", "P", "1", "2", "3" ?
Eller menar du "S", "O", "P" samt en enda byte med värdet 0-255?

Pesonligen tycker jag inte om att skicka binära data över en vanlig
RS232 linje, så jag skulle välja det första alternativet (eller kanske
något helt annat sett att skicka det, t.ex med ett kommando som
har nurmet på utgången och on/off kodat på ett tydliga sett. Jag
vill normalt ha ett protokol där jag kan haka på en vanlig terminal
och köra kommandona manuellt utan problem. Eller för att se
kommendona från källan på terminalen.

Var kommer ata från? Är deet något som du kan påverka eller kommer
det från en box/apparat som är som den är, så att säga?

[jesse]

Hur långt har du fått det till att fungera?
Vilka är de 8 utgångarna?

Har du lyckats läsa av de tre tecknen som är siffror "1" "3"! och "2" och omvandla dessa till ett heltal?

Om du har lyckats med det, så skickar du ju bara ut talet som det är på porten där utgångarna finns:

t.ex.

Kod: Markera allt

uint8t heltal;
heltal = .... (på något vis läser du in tecknen från RS232 och omvanslar till ett heltal)
PORTC = heltal;

porten är ju en 8-bitars port - skicker du ut 'heltal' på porten så kommer ju bitarna att innehålla just det talet, på binärt vis:

132 = 1000 0100

högsta biten (som motsvarar 128) är bit 7 och motsvaras av portens utgång nr. 7 , i det här fallet PC7. Lägsta biten skickas ut på PC0.

[sodjan]

Väldigt mycket gissande där...
En sak som vi dock faktiskt *vet* är att det är en Arduino.
Från http://www.arduino.cc/en/Reference/PortManipulation:

"Why use port manipulation?
Generally speaking, doing this sort of thing is not a good idea. Why not? Here are a few reasons:

Det finns även en del fördelar listade, den intresserade kan läsa vidare på sidan ovan...

[Krille Krokodil]

Det första du kan göra är att omvandla dina tre siffror till en byte, tecknet 0 har värdet 0x30, så du börjar med att dra bort det:

EnByte = 100 * (Siffra1 - 0x30) + 10 * (Siffra2 - 0x30) + (Siffra3 - 0x30);

Sedan kan du testa varje utgång för sig med if(EnByte & 0b00000001), if(EnByte & 0b00000010) osv och tända eller släcka utgången beroende på om den biten är 1 eller 0.

[sodjan]

Kan vi inte vänta tills vi vet hur formatet faktiskt ser ut?
D.v.s vad "SOP132 (siffran kan vara mellan 0-255)" betyder...

Om jag skull satsa en tia på något så vore det nog Krilles variant.
Men det blir ändå bara spekulationer just nu.

[jesse]

Väldigt mycket gissande där...

Jo,visst. men man kan se det som ledande frågor också. Så att TS får lite ledtrådar om vilken information som är relevant för att vi ska kunna hjälpa till.

[RadioDJ]

Problemet löst.
Tack för alla hjälpbara ledtrådar.

[SeniorLemuren]

Tack för det? Det hör till god ton att förklara hur problemet löstes. Det finns fler här som av intresse följer en tråd för att kanske lära något av andras problem och lösningar.

[sodjan]

Det är inget annat än väldigt dålig stil att inte beskriva lösningen.
Men det finns ju all chans att rätta till det...

[RadioDJ]

Okej här kommer min lösning i korthet.
Fick börja med att dela på bokstäver och siffror (string.substring()), sedan omvandla string siffrorna till int (string.toint()).
Efter det så gjorde jag en fuling för att ta redan på vilken av de 8 bitarna som var satt. Jag lyckades inte med de ledtrådar som Ni gav mig. Började med att dela talet med 128, om svaret = 1. Ja, denna bit satt (uför det som ska göras). Sedan talet % 128 för att få fram resterande av talet - 128 och så vidare ner till 0.

Lite omständigt men det var det sättet som jag lyckades.

Finns det en bättre lösning så är jag intresserad att ta del av den.

[sodjan]

OK.

Det betyder alltså att svaret var "ja" då jag tidigare frågade :

> När du skriver "SOP132", menar du då "S", "O", "P", "1", "2", "3" ?

Var det så svårt att svara på det? Om du inte förstog frågan så
säg då det i så fall.

> Jag lyckades inte med de ledtrådar som Ni gav mig.

Vad hände? Och vad provade du med mer konkret?
Upprepade divisioner som du testade med fungerar ju men det
är ingen speciellt effektiv metod.

Sen har det funnits ett antal frågor till i tråden som sannolikt var
intressanta för de som frågade. Att bara skita i det är dåligt.

[jesse]

Började med att dela talet med 128 ...

Det finns smartare sätt att ta reda på om en bit i ett tal är "etta" (vilket du säkert förstår, men du känner inte till dem).

Det finns något som kallas "bitwise operators" som man ofta har stor nytta av i mikrokontroller-världen.

Men innan vi går in på dessa är det bäst att vi gör klart några fakta om hur positiva heltal representeras i en dator/processor.

Tänk dig en variabel:

Kod: Markera allt

int mitt_tal;
mitt_tal = 132;

Du kan själv räkna ut att i talet 132 så är bit7 och bit2 ettor, eftersom det även kan skrivas 1000 0100 binärt.
Men hur ska processorn veta det?

Även om du skriver mitt_tal = 132; så lagras talet alltid binärt inne i processorn, antingen i ett internt register, eller i SRAM. Så vad processorn egentligen ser är:

mitt_tal = 0b10000100; (man skriver alltid 0bxxxx när man ska visa att det är ett binärt tal man menar, skriver man inte det så är det underförstått att talet är ett decimaltal. du kan även skriva talet i hexadecimal form 0x84 eller oktadecimal form, 0204 (alla tal som börjar med nolla tolkas som oktadecimala tal)

Oavsett hur du skriver talet i ditt program så är det alltid innerst inne ett binärt tal. (Jo, datorer känner ju bara igen nollor och ettor, inget annat!)

Nu till bitvisa operatorer:

& = bitvis 'och'
| = bitvis 'eller'

för en enda bit så ger dessa operatorer följande resultat:

0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1

0 | 0 = 0
0 | 1 = 1
1 | 0 = 1
1 | 1 = 1

För tal med flera bitar så utförs operationen på varje bit för sig. t.ex:

0b00001111 & 0b11001100 = 0b00001100 och
0b00001111 | 0b11001100 = 0b11001111.

Detta kan man använda om man vill välja ut en eller flera bitar för att kolla om de är 'etta'.

T.ex vill du veta om bit7 är etta i 'mitt_tal'?

Då gör du följande:

Kod: Markera allt

if ((mitt_tal & 0b10000000) != 0) 
{
    // ja - bit 7 är en etta
}
else
{
    // nej - bit 7 är en nolla
}

sedan vill du kolla bit6:

Kod: Markera allt

if ((mitt_tal & 0b01000000) != 0) 
{
    // ja - bit 6 är en etta
}
else
{
    // nej - bit 6 är en nolla
}

..osv...

(istället för 0b01000000 kan du givetvis skriva 64 eller 0x40 om du vill. Det är samma sak, men kanske är lättare att läsa och mindre risk att skriva fel)

Hoppas du gillade min lilla bit-guide.