Ez a cikk a [kapcs_ki=57] című cikk folytatása. Dióhéjban annyit, hogy abban a cikkben eljutottunk odáig, hogy egy kapcsolót megnyomtunk, és több méterre tőlünk bekapcsolt egy led.

A mostani cikkben pedig már megvalósítunk egy alap adatátvitelt. Két PIC segítségével soros adatokat fogunk átvinni. Ez a rész kimerül majd abban, hogy a soros adatátvitelt megvalósítjuk. De a III. részben már vezetéknélküli hőmérőt fogunk építeni.

RS232 - Soros adatátvitel szabványa

Nézzük is át, hogy mit és hogyan kell csinálni. Nagyon jó lenne, ha ezekkel a modulokkal lehetne soros adatokat közvetlen átvinni. Vagyis a PIC Tx kimenetére rákötjük az adót. De ezt sajnos nem tehetjük meg, több okból is. A soros adatok átvitelénél sok olyan van, ami meggátol minket az egyszerű kivetelezésben.
Mindenek előtt nézzük meg, hogy is néz ki egy soros adat.
Egy byte átvitele soros szabvánnyal a következő. Mint láthatjuk vagy egy START BIT. Mikor nyugalmi állapotban van a soros kimenet, akkor logikai 1 van rajta. Mikor elkezdünk küldeni adatot, akkor generálódik egy START BIT. Ez indítja a kommunikációt. Ezután a küldendő 1 byteot felbontjuk bitekre (ADAT BITEK). Itt a 211-es értéket küldjük át soroson. 221, vagyis $D3 hexába.
Ezután következik egy paritás bit. A paritásbit a hibajelzés legegyszerűbb, és a legsűrűbben használt formája. Két féle paritás létezik a RS232 szabványnál. A páros, és a páratlan. A paritás bit számolás úgy néz ki, hogy megszámoljuk az 1-es biteket az ADAT BITEK folyamban. A páros paritás esetén arra törekszünk, hogy páros számban legyenek az 1-esek. Páratlan paritás esetén pedig jól megfigyelhetjük a folyamatot az ábrán. Ez egy páratlan paritás bites ellenőrzés, mivel ha megnézzük 5 db 1-es bit van. Mivel a paritás a páratlanságra törekszik, ezért ő nulla. Ha páros paritás lenne, akkor ott 1-es értéket venne fel, hiszen 5 db 1-es bit + egy 1-es paritás = 6 db 1-es bit.
És végül pedig jön egy STOP BIT ami megint a logikai 1-es állapotban tartja a soros vonalat.
Az alsó négyszögjel az egy órajel. De nekünk most nincs rá szükségünk mivel aszinkron adatátvitellel foglalkozunk, de azért érdemes megjegyezni, hogy a szürke szaggatott vonalak azt az időpontot jelentik, mikor a vevő eszköz "megméri" a bejövő jelet.

Most jöjjön a következő unalmas elméleti rész. Az rádió modulok - mint már említettem - nagy hátránya, hogy nem képes folyamatos jelet átvinni. Általában ilyen 250ms-es kis indítójelet visznek át. Gondolom ezt az előző cikkben észrevettük, hogy hiába tartjuk nyomva a gombot, a led akkor is csak felvillan. Most szidhatjuk a gyártót meg mindenkit, de később megtudjuk, hogy nem hiába működik ez így.
Másik dolog amit érdemes megjegyezni, hogy miért is nem tudunk közvetlen adatot átvinni. Vegyük azt a példát mikor a 255 (hexa: $FF) -öt akarjuk átvinni. A 255 binárisan: 11111111. Namármost... Ha ezt az adatot akarjuk átküldeni, akkor az adó nem fogja ezt nekünk megtenni, és mivel menet közben ki fog kapcsolni ezért kb annyi fog ebből átmenni, hogy 11100000. Az első még azért egyes, mert ott még be volt kapcsolva az adó, de utánna már kikapcsolt...

Vezeték nélküli kommunikáció adatvesztései
Mivel ezek a modulok a szabad 433,92MHz-en kommunikálnak, így sok zavarral találkozhatunk. Bármilyen furcsán is hangzik, egy ilyen vevővel képesek vagyunk venni egy kapu-távnyitó, vezeték nélküli csengő, vezeték nélküli hőmérő jelét is. És lehet hogy valaki pont akkor csenget a szomszédban, mikor mi éppen egy világot megmentő adatot akarunk átvinni rádión. Ekkor belezavar nekünk a jelbe szépen a csengetés. De nagyobb a valószínűsége, hogy egy vezeték nélküli hőmérő fog nekünk nehezíteni a dolgunkon, miközben fejlesztünk, mivel az mondjuk minden 2-3 mp-en elküldi a hőmérsékletet a vevő állomásnak. Egy kis kitérő. Nálam fejlesztés közben a vevő mindig vette a vevő modul a vezeték nélküli Logitech egerem és billentyűzetem jelét. Nem sugároztam semmit, mégis egyfolytában vett a vevő rész.
Általában ezeket az eszközöket nem tudjuk bezavarni, mivel ők már védték a kommunikációjukat ez ellen. Már csak nekünk kell ezt megtenni, és akkor végeredményében azt kapjuk, hogy megfér majd vezeték nélküli rendszerünk a többi ugyan azon a frekvencián kommunikáló eszközzel, minden különösebb zavar nélkül.

Manchester kódolás
A vezetéknélküli kommunikációhoz, fejlesztették ki a Manchester kódolást. Ez a kódolási forma kb. 50 éve ki van találva. Jóval lassabb adatátvitelre képes - soros vonalon - mint ha simán küldenénk a biteket, de viszont van egy beépített hibajavítása. Most mondhatjuk, dehát a sorosnál is ott van a paritás bit. Az miért nem elég? Azért nem elég, mert az csak annyit tesz, hogy páros/páratlanra egészít ki. Vegyük azt a példát, hogy a küldendő adatban 5 db 1-es bit van. Igenám de a rádión abból elveszett kettő. Vagyis maradt 3. Az páratlan, így egyezni fog a paritás bit, vagyis azt érzékeljük a vevő oldalon, hogy az adat tökéletesen átjött. Közben nem.
A manchester kódolósnál egy bájt átviteléhez két bájtot kell küldenünk.
A következőképpen néz ki:
- A logikai 1-es szintet átalakítjuk 10-re. (nem tíz, hanem egy és nulla)
- A logikai 0-ás szint pedig a 01 lesz.
Vagyis: át akarjuk küldeni az 11100011-et (decimálisban: 227, vagy $E3 hexa) Ez úgy alakítjuk át, hogy a végeredmény a következő lesz:

Eredeti kód:	1	1	1	0	0	0	1	1
Manchester kód:	10	10	10	01	01	01	10	10

Így láthatjuk, hogy a kódolt adatnál minden bitet két bittel írunk le, és nincsen folyamatos jel. Mindig csak pillanatokra kapcsoljuk ki-be.

Ezzel el is készültünk. Erre a kódolásra írunk egy függvényt, és máris ide-oda lehet kódolni.
Ahhoz hogy a kódolás folyamatát megértsük, belinkelem ide, azért bekódoló függvényemet.

//================================================================
int16 man_encode(int unenc) {
//================================================================
int odd_byte,even_byte,temp;

odd_byte=unenc&0xAA;
temp=(~unenc&0xAA)>>1;
odd_byte=odd_byte|temp;

even_byte=unenc&0x55;
temp=(~unenc&0x55)<<1;
even_byte=even_byte|temp;
return((int16)odd_byte<<8)|even_byte;
}

Ez is C-ben van írva. De ebből szerintem nagyon jól látszik a kódolás folyamata. Mindig egyel jobbra shift-eljük a biteket.
A dekódoló sem bonyolult, a kódja a következő:

//================================================================
int man_decode(int16 enc) {
//================================================================
int odd_byte,even_byte;

odd_byte=(int)(enc>>8);
if((odd_byte&0xAA)^((~odd_byte&0x55)<<1)) {
receive_error=1;
return(0);
} else odd_byte&=0xAA;
even_byte=(int)enc;
if((even_byte&0x55)^((~even_byte&0xAA)>>1)) {
receive_error=1;
return(0);
} else even_byte&=0x55;
receive_error=0;
return(odd_byte|even_byte);
}

Próbakapcsolás a következő oldalon...