- STM32F103C8 I2C Übersicht
- I2C-Pins in STM32F103C8
- I2C-Pins in Arduino
- Erforderliche Komponenten
- Schaltplan und Anschlüsse
- I2C-Programmierung in STM32
- Erklärung zur Master-STM32-Programmierung
- Erklärung zur Slave-Arduino-Programmierung
In unseren vorherigen Tutorials haben wir etwas über die SPI- und I2C-Kommunikation zwischen zwei Arduino-Boards gelernt. In diesem Tutorial werden wir eine Arduino- Karte durch die Blue Pill- Karte STM32F103C8 ersetzen und über den I2C-Bus mit der Arduino- Karte kommunizieren.
STM32 bietet mehr Funktionen als das Arduino-Board. Es wäre also großartig, die Kommunikation zwischen STM32 und Arduino mithilfe des SPI- und I2C-Busses kennenzulernen. In diesem Tutorial werden wir den I2C-Bus für die Kommunikation zwischen Arduino und STM32F103C8 verwenden und im nächsten Tutorial mehr über den SPI-Bus erfahren. Weitere Informationen zur STM32-Karte finden Sie in anderen STM32-Projekten.
STM32F103C8 I2C Übersicht
Wenn wir I2C (Inter Integrated Circuits) in STM32F103C8 Blue Pill Board mit Arduino Uno vergleichen, werden wir sehen, dass Arduino einen ATMEGA328-Mikrocontroller und STM32F103C8 ARM Cortex-M3 enthält. STM32 hat zwei I2C-Busse, während Arduino Uno nur einen I2C-Bus hat und STM32 schneller als Arduino ist.
Weitere Informationen zur I2C-Kommunikation finden Sie in unseren vorherigen Artikeln
- Verwendung von I2C in Arduino: Kommunikation zwischen zwei Arduino-Boards
- I2C-Kommunikation mit dem PIC-Mikrocontroller PIC16F877
- Verbindung von 16X2 LCD mit ESP32 über I2C
- I2C-Kommunikation mit dem MSP430 Launchpad
- Schnittstelle zwischen LCD und NodeMCU ohne Verwendung von I2C
- Wie man mit Multi-Kommunikation (I2C SPI UART) in einem einzigen Programm von Arduino umgeht
I2C-Pins in STM32F103C8
SDA: PB7 oder PB9, PB11.
SCL: PB6 oder PB8, PB10.
I2C-Pins in Arduino
SDA: A4-Pin
SCL: A5-Stift
Erforderliche Komponenten
- STM32F103C8
- Arduino Uno
- LED (2-Nr.)
- Druckknopf (2-Nr.)
- Widerstände (4-Nr.)
- Steckbrett
- Kabel anschließen
Schaltplan und Anschlüsse
Die folgende Tabelle zeigt die Verbindung zwischen STM32 Blue Pill und Arduino Uno für die Verwendung des I2C-Busses. Es werden nur zwei Drähte benötigt.
|
STM32F103C8 |
Arduino |
Pin Beschreibung |
|
B7 |
A4 |
SDA |
|
B6 |
A5 |
SCL |
|
GND |
GND |
Boden |
Wichtig
- Vergessen Sie nicht, Arduino GND und STM32F103C8 GND miteinander zu verbinden.
- Schließen Sie dann einen Pull-Down-Widerstand von 10k separat an die Druckknopfstifte beider Platinen an.
In diesem STM32 I2C-Tutorial konfigurieren wir den STM32F103C8 als Master und Arduino als Slave. Beide Karten sind separat mit einer LED und einem Druckknopf verbunden.
Um die I2C-Kommunikation in STM32 zu demonstrieren, steuern wir die Master-STM32-LED mithilfe des Slave-Arduino-Drucktastenwerts und die Slave-Arduino-LED mithilfe des Master-STM32F103C8-Drucktastenwerts. Diese Werte werden über den I2C-Kommunikationsbus gesendet.
I2C-Programmierung in STM32
Die Programmierung ähnelt dem Arduino-Code. Das Gleiche
Dieses Tutorial enthält zwei Programme, eines für Master STM32 und eines für Slave Arduino. Komplette Programme für beide Seiten finden Sie am Ende dieses Projekts mit einem Demonstrationsvideo.
Erklärung zur Master-STM32-Programmierung
In Master STM32 wollen wir sehen, was passiert:
1. Zunächst müssen wir die Wire-Bibliothek und die Softwire-Bibliothek für die Verwendung der I2C-Kommunikationsfunktionen in STM32F103C8 einbeziehen.
#einschließen
2. In void setup ()
- Wir starten die serielle Kommunikation mit einer Baudrate von 9600.
Serial.begin (9600);
- Als nächstes starten wir die I2C-Kommunikation an Pin (B6, B7).
Wire.begin ();
3. In der Leerenschleife ()
- Zuerst erhalten wir die Daten vom Slave Arduino, also verwenden wir requestFrom () mit der Slave-Adresse 8 und fordern ein Byte an.
Wire.requestFrom (8,1);
Der empfangene Wert wird mit Wire.read () gelesen
Byte a = Wire.read ();
- Abhängig vom vom Slave empfangenen Wert wird die Master-LED mithilfe von Digitalwrite an Pin PA1 ein- oder ausgeschaltet, und der serielle Druck wird zum Drucken des Werts im seriellen Monitor verwendet
if (a == 1) { digitalWrite (LED, HIGH); Serial.println ("Master LED ON"); } else { digitalWrite (LED, LOW); Serial.println ("Master LED OFF"); }}
- Als nächstes müssen wir den Status des Pins PA0 lesen, der der Master-STM32-Druckknopf ist.
int pinvalue = digitalRead (Buttonpin);
- Als nächstes senden Sie den Pin-Wert gemäß der Logik, also verwenden wir if- Bedingung und beginnen dann die Übertragung mit Slave-Arduino mit 8 als Adresse und schreiben dann den Wert gemäß dem Druckknopf-Eingabewert.
if (pinvalue == HIGH) { x = 1; } else { x = 0; } Wire.beginTransmission (8); Wire.write (x); Wire.endTransmission ();
Erklärung zur Slave-Arduino-Programmierung
1. Zunächst müssen wir die Wire-Bibliothek für die Verwendung von I2C-Kommunikationsfunktionen einbeziehen.
#einschließen
2. In void setup ()
- Wir starten die serielle Kommunikation mit einer Baudrate von 9600.
Serial.begin (9600);
- Starten Sie als nächstes die I2C-Kommunikation an Pin (A4, A5) mit der Slave-Adresse 8. Hier ist es wichtig, die Slave-Adresse anzugeben.
Wire.begin (8);
Als nächstes müssen wir die Funktion Wire.onReceive aufrufen , wenn der Slave den Wert vom Master empfängt, und die Funktion Wire.onRequest aufrufen, wenn der Master den Wert vom Slave anfordert.
Wire.onReceive (receiveEvent); Wire.onRequest (requestEvent);
3. Als nächstes haben wir zwei Funktionen, eine für das Anforderungsereignis und eine für das Empfangsereignis
Für Anfrage Ereignis
Wenn der Master STM32 einen Wert vom Slave anfordert, wird diese Funktion ausgeführt. Diese Funktion übernimmt den Eingabewert vom Slave-Arduino-Druckknopf und sendet mithilfe von Wire.write () ein Byte (1 oder 0) an den Master STM32 entsprechend dem Drucktastenwert .
void requestEvent () { int value = digitalRead (Buttonpin); if (Wert == HIGH) { x = 1; } else { x = 0; } Wire.write (x); }}
Für Empfangsereignis
Wenn der Master Daten mit der Slave-Adresse (8) an den Slave sendet, wird diese Funktion ausgeführt. Diese Funktion liest den empfangenen Wert vom Master und speichert ihn in einer Variablen vom Typ Byte und verwendet dann die if- Logik, um die Slave-LED abhängig vom empfangenen Wert ein- oder auszuschalten. Wenn der empfangene Wert 1 ist, leuchtet die LED auf und für 0 erlischt die LED.
void receiveEvent (int howMany) { Byte a = Wire.read (); if (a == 1) { digitalWrite (LED, HIGH); Serial.println ("Slave LED ON"); } else { digitalWrite (LED, LOW); Serial.println ("Slave LED OFF"); } delay (500); }}
Ausgabe
1. Wenn wir den Druckknopf am Master STM32 drücken, leuchtet die an Slave Ardiono angeschlossene LED auf (weiß).
2. Wenn wir nun den Druckknopf auf der Slave-Seite drücken, leuchtet die an den Master angeschlossene LED (rot) und wenn die Taste losgelassen wird, erlischt die LED.
3. Wenn beide Drucktasten gleichzeitig gedrückt werden, leuchten beide LEDs gleichzeitig und bleiben eingeschaltet, bis die Tasten gedrückt werden
So findet die I2C-Kommunikation in STM32 statt. Jetzt können Sie jeden I2C-Sensor mit der STM32-Karte verbinden.
Die vollständige Codierung für Master STM32 und Slave Arduino finden Sie unten mit einem Demonstrationsvideo