Stap 9: Beetje bonzen voorbeeld
Met behulp van I2C gaat om binaire gegevens te sturen naar een adres van een apparaat dat naar de verzoeken van de microcontroller, (master apparaat luistert) zodra een verzoek is ontvangen door het apparaat (slave), het apparaat zendt een of meer bytes aan gegevens terug naar de microcontroller.
Is in leren hoe te programmeren mededelingen aan I2C apparaten of proberen te reverse engineer gegevens vanuit I2C apparaten dat u hebt om te kijken naar de gegevens in het binaire vorm.
Ik krijgt u een eenvoudig voorbeeld van hoe dit te doen met behulp van de methoden die u zojuist hebt geleerd.
In het leren van de I2C is het vaak verstandig om te bestuderen van andere programma's programmeurs hebben geschreven, dus u kunt leunen hoe gegevens worden doorgegeven tussen microcontrollers en apparaten.
Dus voor ons voorbeeld die we naar een programma fragment van sommige RobotC programmacode die is geschreven kijken zullen aan het bit bang een I2C-apparaat.
Ik heb een monster bits geneukt C programma geschreven in RobotC door Xander die een Robot Blog genaamd beweert genomen:
http://botbench.com/blog/2011/02/20/bit-banged-I2C-master-on-robotc-for-Arduino/#Comment-2674
In dit blog-artikel is hij beetje bonzen van een I2C-programma om te communiceren met een LED-matrix LED-lampjes knipperen in een reeks.
Wij zullen nabouwen de for-lus wordt hij gebruikt voor het verzenden van een reeks bits aan de array LED.
Als je hebt nooit geprogrammeerd, kunt u Google variabelen, for-lus, functies en tijdens loops.
Hier is het codefragment dat we kijken naar zullen:
terwijl (waar) {}
for (int i = 0; ik < 8; i ++) {}
PCF8574write (~ (1 << i));
wait1Msec(50);
}
}
Normaal gesproken zou ik schrijven een klein Python programma om te printen op de waarden van de for-lus. Maar aangezien ik veronderstel iedereen is nieuw voor de programmering en Booleaanse logica zal ik handmatig typen uit elke iteratie van de lus.
Speciale opmerking: Python biedt geen ondersteuning voor een gegevenstype byte, dus in ons steentje bonzen voorbeeld gaan we gebruiken de modulo operator om weer te geven van een geheel getal als een niet-ondertekende byte. Google inf u assistentie, gelieve
Bijvoorbeeld: als we uitvoeren van de in het volgende voorbeeld: >>> ~ (1 << 0), in Python krijgen we -2, als we vervolgens gebruikt >>> bin(-2), we krijgen '-0b10'. Het probleem is opgelost en een volledige 8 bits-type in het volgende weergeven:
>>> bin (-2% 256)
'0b11111110'
Om te kunnen goed zien wat er gaande is met bits willen we zien de volledige 8 bits.
De While is een lus voor eeuwig, negeren dit voor nu.
De for-lus lussen waar de variabele is ik gelijk van 0 tot en met 7.
PCF8574write() is een aangepaste functie die we niet als onderdeel van dit artikel bespreken zullen. U kunt verwijzen naar de code om te zien wat deze functie doet op uw eigen.
Wat wij zijn geïnteresseerd in is de waarde van i en wat binair getal wij aan de functie PCF8574write() doorgeven.
Laat vertalen van elke iteratie van de lus:
Laat type uit elke iteratie van de lus in Python:
De variabele ik opgestart uit als 0 en eindigt op een waarde van 7:
>>> ~ (1 << 0)
-2
Laat deze expressie uit elkaar trekken. Wij zijn het uitvoeren van een bitsgewijze niet op de volgende waarde. We links verschuiven de waarde 1, ik keer.
Dat wil zeggen wij niet 1 << 0. Wij zijn stukjes van rechts naar links, duwen. In de eerste lus zijn we links verschuiven 1, 0 keer of wij niet het meest significante beetje.
Dus als we kijken naar de binaire waarde van -2 krijgen we:
>>> bin (~ (1 << 0))
'0b10'
Laat blijven, u binnenkort het patroon.
>>> ~ (1 << 0)
-2
>>> bin (-2% 256)
'-0b11111110'
>>> ~ (1 << 1)
-3
>>> bin (-3% 256)
'-0b11111101'
>>> ~ (1 << 2).
-5
>>> bin (-5% 256)
'-0b11111011'
>>> ~ (1 << 3)
-9
>>> bin (-9% 256)
'-0b11110111'
>>> ~ (1 << 4)
-17
>>> bin (-17% 256)
'-0b11101111'
>>> ~ (1 << 5)
-33
>>> bin (-33% 256)
'-0b11011111'
>>> ~ (1 << 6)
-65
>>> bin (-65% 256)
'0b10111111'
>>> ~ (1 << 7)
-129
>>> bin (-129% 256)
'-0b1111111'
De eerste 0 wordt in dit geval weggelaten.
Het moet lezen '-0b01111111'
Als u dit nog niet hebt gedaan, ga nu naar de web-pagina en Bekijk de video:
http://botbench.com/blog/2011/02/20/bit-banged-I2C-master-on-robotc-for-Arduino/#Comment-2674
Nu kijken naar de bit patronen zeer nauw.
Merk op dat als de voor lus dat verhoogt de 0-bits naar links bewegen houdt.
Ik zal proberen niet te verwarren u te veel nu, (er is een andere bitsgewijze AND en een schuifbewerking naar links in de i2c_write()-functie), de prioriteit is het begrijpen van Booleaanse operaties en het gebruik van Python om u te helpen bij het begrijpen van deze Booleaanse operaties. Als u omhoog ernaar denkt, reverse-engineering de i2c_write() functie om te zien hoe de patronen bits verder verwerkt voordat ze worden verzonden naar de LED-array.
In het werken met microcontrollers wanneer een beetje hoog, met een waarde van 1, is normaal gesproken een apparaat is ingeschakeld. Als een beetje laag, is met een 0-waarde van een apparaat uitgeschakeld.
Bericht dat we met 8 bits werken en onze LED-array 8 heeft LED's. Ja, dat klopt. Elke keer als we ingesteld een beetje op, weer met een waarde van 1, we op de LED. Als wij bitwaarde ingesteld op 0 of de bit verrekening, wij ook nog eens uitzetten van de LED.
Bekijk nu de video opnieuw. Nu beeld dat beide for-lussen, één in de main functie en de for-lus in de i2c_write functie worden uitgevoerd zo snel of sneller dan de LED's knipperen.
De logica in de i2c_write() is het uitvoeren van een beetje meer complexe logica, gebruik python om te visualiseren hoe de hoge of lage bits staten veranderen zoals de 8 bits worden versterkt door de for-lus.
Gelieve te houden leren over microcontrollers en Booleaanse operaties, zoals deze de bouwstenen te programmeren microcontrollers zijn.
