- \n
- ka\u017cda cyfra w wysy\u0142anej liczbie to 1 bajt, np. liczba „1017” to a\u017c 5 bajt\u00f3w (4 cyfry + znacznik ko\u0144ca linii)<\/li>\n
- jest k\u0142opot z odczytem liczb przesy\u0142anych jako napisy, gdy\u017c trzeba je odczytywa\u0107 jako napis (tablica znak\u00f3w) a nast\u0119pnie zamieni\u0107 napis na liczb\u0119 – skoplikowane i powolne. Bez takiej procedury odczytu liczby b\u0119d\u0105 b\u0142\u0119dnie wczytywane i dodatkowo b\u0119d\u0105 pojawia\u0107 si\u0119 nadmiarowe liczby (\u015bmieci) odpowiadaj\u0105ce znacznikowi ko\u0144ca linii.<\/li>\n<\/ul>\n
Dlatego te\u017c musimy zmieni\u0107 spos\u00f3b wysy\u0142ania liczb z Arduino – bez udzia\u0142u Serial.println. <\/p>\n
W\u0142asny protok\u00f3\u0142<\/h2>\n
B\u0119dziemy wykorzystywa\u0107 metod\u0119 Serial.write(<\/strong>dana<\/em>)<\/strong> – kt\u00f3ra wysy\u0142a pojedynczy bajt przez komunikacj\u0119 szeregow\u0105. Nie jest wysy\u0142any \u017caden znacznik ko\u0144ca linii, a na dodatek liczba z zakresu 0..255 wymaga wys\u0142ania tylko jednego bajta – du\u017ca oszcz\u0119dno\u015b\u0107 w por\u00f3wnaniu do Serial.println(). Z tego samego powodu liczba z przedzia\u0142u 0..65535 b\u0119dzie wymaga\u0107 wys\u0142ania tylko 2 bajt\u00f3w. Oszcz\u0119dno\u015b\u0107 na transmisji (a wi\u0119c na szybko\u015bci!) widoczny jest od razu.<\/p>\n
Jest jednak pewien problem – skoro wysy\u0142amy tylko jeden bajt, bo jak wys\u0142a\u0107 liczb\u0119 typu int <\/strong>(czyli 2 bajty)? <\/strong>Przecie\u017c wyj\u015bcia analogowe w Arduino UNO s\u0105 10-cio bitowe, czyli generuj\u0105 liczby z zakresu 0..1023 (2 bajty = int). Rozwi\u0105zujemy to wysy\u0142aj\u0105c te dwa bajty buduj\u0105ce liczb\u0119 typu int<\/strong> oddzielnie – najpierw bajt starszy, potem m\u0142odszy (za chwil\u0119 b\u0119dzie to wyja\u015bnione). Brzmi do\u015b\u0107 zawile, ale tak nie jest – prosz\u0119 przyjrze\u0107 si\u0119 poni\u017cszemu programikowi:<\/p>\n
void setup(){\r\nSerial.begin(9600);\r\n}\r\n\r\nvoid loop(){\r\n int dana = analogRead(A0);\r\n Serial.write( 0xff);\r\n Serial.write( (dana>>8) & 0xff);\r\n Serial.write( dana & 0xff);\r\n}\r\n<\/pre>\nW tym programie wysy\u0142amy liczb\u0119 odczytan\u0105 z portu A0 Arduino jako 3 bajty – dwa bajty to ten odczyt- liczba int, ale przed nim wysy\u0142am „flag\u0119” informuj\u0105c\u0105, \u017ce podaj\u0119 w\u0142a\u015bnie liczb\u0119 typu int. Ta flaga jest potrzebna w sytuacjach, gdy z jakiego\u015b powodu rozsynchronizuje si\u0119 nam transmisja i w\u00f3wczas nie b\u0119dziemy w stanie okre\u015bli\u0107, kt\u00f3ry bajt jest pierwszym, a kt\u00f3ry drugim buduj\u0105cym liczb\u0119 typu int. Dzi\u0119ki istnieniu flagi (u mnie liczby 0xff czyli 255 dziesi\u0119tnie) zawsze b\u0119dziemy wiedzie\u0107 prawid\u0142ow\u0105 kolejno\u015b\u0107. <\/p>\n
Warto\u015b\u0107 flagi nie ma znaczenia, ja wygra\u0142em 255 – ale ka\u017cdy mo\u017ce wpisa\u0107 swoj\u0105 ulubion\u0105 liczb\u0119 z przedzia\u0142u 0..255 (oczywi\u015bcie, gdy zmieni warto\u015b\u0107 flagi to przy odczycie liczby nale\u017cy to uwzgl\u0119dni\u0107).<\/p>\n
W kodowaniu liczby pos\u0142uguj\u0119 si\u0119 poj\u0119ciami „starszego” i „m\u0142odszego” bajtu – w ko\u0144cu liczba typu int<\/strong> to 2 bajty (=16 bit\u00f3w), wi\u0119c pierwszy z nich (pierwsze 8 bit\u00f3w) niech si\u0119 nazywa „starszy”, a drugi (kolejne 8 bit\u00f3w) – „m\u0142odszy”. Kodowanie polega na:<\/p>\n
- \n
- przesuni\u0119cie liczby o 8 bit\u00f3w w prawo, w ten spos\u00f3b mamy now\u0105 liczb\u0119 (w zapisie bitowym) jako 8-zer i 8 bit\u00f3w z pierwotnej liczby, czyli tylko ten „starszy” bajt w\u0142a\u015bnie<\/li>\n
- iloczyn logiczny z bajtem o warto\u015bci 255 (szesnastkowo 0xff) zwr\u00f3ci nam w\u0142a\u015bnie ten starszy bajt – kt\u00f3ry wysy\u0142amy przez Serial.write jako pierwszy<\/li>\n
- iloczyn logiczny danej liczby int bez wykonywania przesuni\u0119cia<\/strong> z bajtem 255 (szesnastkowo 0xff) „wycina” nam starszy bajt, pozostawiaj\u0105c jedynie m\u0142odszy bajt – kt\u00f3ry wysy\u0142amy drugim poleceniem Serial.write<\/li>\n<\/ul>\n
W ten spos\u00f3b wysy\u0142amy liczby odczytywane z portu A0 – przy czym teraz do ich ogl\u0105dania nie mo\u017cemy u\u017cy\u0107 Monitora portu szeregowego<\/em> z Arduino IDE – gdy\u017c zobaczymy tylko „krzaczki” (nawet bez ko\u0144ca linii, no chyba, \u017ce przypadkowo trafi si\u0119 liczba 13 – kt\u00f3ry jest znakiem Entera). Jak wi\u0119c odczytywa\u0107 takie liczby? Trzeba wykona\u0107 operacj\u0119 odwrotn\u0105, czyli:<\/p>\n
- \n
- czeka\u0107 na nadej\u015bcie 3 bajt\u00f3w do portu szeregowego,<\/li>\n
- sprawdzi\u0107, czy pierwszy z nich to nasza flaga – u nas 0xff,<\/li>\n
- je\u015bli nie<\/strong>, to wracam do punktu punktu 1,<\/li>\n
- je\u015bli jednak tak<\/strong>, to wczytujemy kolejny bajt, przesuwamy go w lewo o 8 bit\u00f3w, robimy sum\u0119 logiczn\u0105 ze wczytanym nast\u0119pnym bajtem,<\/li>\n
- wracamy do 1. i odczytujemy kolejn\u0105 liczb\u0119.<\/li>\n<\/ol>\n
Skomplikowane? mo\u017ce tak, mo\u017ce nie… zale\u017cy dla kogo \ud83d\ude09 Czy nasz protok\u00f3\u0142 jest dobry? Tyle o ile… ma co prawda informacj\u0119 o pocz\u0105tku liczby (to plus), ale nie ma jakiej\u015b sumy kontrolnej, sprawdzaj\u0105cej poprawno\u015b\u0107 wys\u0142anej daje (to minus). Ale jest prosty i szybki (przesuwanie lit\u00f3w i liczenie iloczynu\/sumy bitowej to „pestka”, nawet dla Arduino) – to kolejny plus, kt\u00f3ry przewa\u017ca o jego wykorzystaniu. Pami\u0119tajmy, \u017ce zale\u017cy nam na wykre\u015blaniu liczb z otrzymywanych z przetwornika analogowo-cyfrowego Arduino, kt\u00f3ry pracuje z cz\u0119sto\u015bci\u0105 10k – nadaje wi\u0119c 10 000 liczb na sekund\u0119. Sprawdzi\u0142em, \u017ce operacje kodowania liczb w naszym protokole skutkuj\u0105 nadawaniem oko\u0142o 9000 liczb na ka\u017cd\u0105 sekund\u0119, czyli ca\u0142kiem dobrze.<\/p>\n
Podsumowuj\u0105c: nadajemy flag\u0119 (0xff), potem starszy bajt, a potem m\u0142odszy. Kto\u015b mo\u017ce nie zna\u0107 naszego protoko\u0142u i odczytywa\u0107 (dobr\u0105) flag\u0119, a potem 2 bajty ALE<\/strong> my\u015ble\u0107, \u017ce to m\u0142odszy i starszy bajt – w odwrotnej<\/strong> kolejno\u015bci ni\u017c my to zrobili\u015bmy. Wi\u0119c zbudowane przez niego liczba int<\/strong> nie b\u0119dzie t\u0105 liczb\u0105, kt\u00f3r\u0105 my wys\u0142ali\u015bmy. Chc\u0105c unikn\u0105\u0107 nieporozumie\u0144 nale\u017ca\u0142oby zaznajomi\u0107 tak\u0105 osob\u0119 z naszym protoko\u0142em – i teraz ju\u017c rozumiemy, sk\u0105d si\u0119 bierze konieczno\u015b\u0107 standaryzacji w informatyce (i nie tylko).<\/p>\n
Arduino + potencjometr<\/h2>\n
- je\u015bli jednak tak<\/strong>, to wczytujemy kolejny bajt, przesuwamy go w lewo o 8 bit\u00f3w, robimy sum\u0119 logiczn\u0105 ze wczytanym nast\u0119pnym bajtem,<\/li>\n
![\"5\"](\"http:\/\/physics.uwb.edu.pl\/wf\/fi-bot\/wp-content\/uploads\/sites\/6\/2017\/01\/5-300x169.jpg\")
<\/p>\n![\"oscy2\"](\"http:\/\/physics.uwb.edu.pl\/wf\/fi-bot\/wp-content\/uploads\/sites\/6\/2017\/01\/oscy2.png\")
<\/p>\n