RaspberryPi an Arduino -senden und empfangen von Strings

Dies ist der code den ich momentan verwende zum senden und empfangen von int-Werte aus einem RaspberryPi an einen Arduino per i2C. Es funktioniert gut für Werte von 0-255, aber wegen der 1-byte-Grenze, etwas größer ausfällt.

Um diese zu umgehen, möchte ich zum senden und empfangen von string-Werten statt, und dann wieder zurück konvertieren in int, wenn nötig.

Welche änderungen würde ich vornehmen muss in den folgenden?

Hier ist mein RPi Python-code

import smbus
import time
# for RPI version 1, use "bus = smbus.SMBus(0)"
bus = smbus.SMBus(1)

# This is the address we setup in the Arduino Program
address = 0x04

def writeNumber(value):
    bus.write_byte(address, value)
    # bus.write_byte_data(address, 0, value)
    return -1

def readNumber():
    number = bus.read_byte(address)
    # number = bus.read_byte_data(address, 1)
    return number

while True:
    try:
        var = int(raw_input("Enter 1 - 9: "))
    except ValueError:
        print "Could you at least give me an actual number?"
        continue

    writeNumber(var)
    print "RPI: Hi Arduino, I sent you ", var
    # sleep one second
    #time.sleep(1)

    number = readNumber()
    print "Arduino: Hey RPI, I received a digit ", number
    print

Und hier ist mein Arduino-code

#include <Wire.h>

#define SLAVE_ADDRESS 0x04
int number = 0;
int state = 0;

void setup() {
    pinMode(13, OUTPUT);
    Serial.begin(9600);         // start serial for output
    // initialize i2c as slave
    Wire.begin(SLAVE_ADDRESS);

    // define callbacks for i2c communication
    Wire.onReceive(receiveData);
    Wire.onRequest(sendData);

    Serial.println("Ready!");
}

void loop() {
    delay(100);
}

// callback for received data
void receiveData(int byteCount){

    while(Wire.available()) {
        number = Wire.read();
        if (Wire.available() > 1)  // at least 2 bytes
        {
          number = Wire.read() * 256 + Wire.read();
        }
        Serial.print("data received: ");
        Serial.println(number);
        //sendData();
        if (number == 1){

            if (state == 0){
                digitalWrite(13, HIGH); // set the LED on
                state = 1;
            }
            else{
                digitalWrite(13, LOW); // set the LED off
                state = 0;
            }
         }
     }
}

// callback for sending data
void sendData(){
    Wire.write(number);
}

Sorry für die (vielleicht) unabhängige Frage, aber warum nicht direkt über die serielle statt? Sind Sie gezwungen, zu verwenden i2c?

InformationsquelleAutor Bachalo | 2014-07-17

1

Überprüfen Sie den folgenden Link:

[http://www.i2c-bus.org/%5D%5B1%5D

Wenn ich Daten senden und zurück-mit I2C-ich war die Umwandlung der string-Zeichen, um bytearrays und Umgekehrt. So, da sind Sie immer bytes senden. Es wird immer Arbeit da, die Sie senden, zahlen zwischen 0-255.

Nicht, ob das hilft, aber zumindest kann Ihnen eine Idee geben.
- ja, aber ich brauche zu senden int-Werte GRÖßER als 255.
- Wenn Sie mit 'unicode', was es ist 2 bytes oder mehr. Sie sind zu haben, um eine Verschiebung der Werte von entweder das erste element oder das zweite element. Oder Sie und erhalten Sie die 16-bit-äquivalent. Ich will hinzufügen, zu der Frage ein kurzes Beispiel.
- Eigentlich. Ich habe eine schnelle Suche, und Sie sollten in der Lage sein, verwenden Sie das folgende python-Modul, um einige der Konvertierungen: Konvertieren zwischen Binär-und ASCII
InformationsquelleAutor rch

Dieses problem hat im wesentlichen zwei teilen: teilen eine ganze Zahl in Ihre bytes und zusammensetzen eine ganze Zahl von bytes. Diese Teile repliziert werden müssen, sowohl auf der Pi und Arduino. Ich werde die Adresse der Pi-Seite zuerst, in Python:

Aufteilung einer integer:

def writeNumber(value):

    # assuming we have an arbitrary size integer passed in value
    for character in str(val): # convert into a string and iterate over it
        bus.write_byte(address, ord(character)) # send each char's ASCII encoding

    return -1

Zusammenbau eine ganze Zahl von bytes:

def readNumber():

    # I'm not familiar with the SMbus library, so you'll have to figure out how to
    # tell if any more bytes are available and when a transmission of integer bytes
    # is complete. For now, I'll use the boolean variable "bytes_available" to mean
    # "we are still transmitting a single value, one byte at a time"

    byte_list = []
    while bytes_available:
        # build list of bytes in an integer - assuming bytes are sent in the same
        # order they would be written. Ex: integer '123' is sent as '1', '2', '3'
        byte_list.append(bus.read_byte(address))

    # now recombine the list of bytes into a single string, then convert back into int
    number = int("".join([chr(byte) for byte in byte_list]))
    return number

Arduino-Seite, in C

Teilen einer Integer:

void sendData(){
    int i = 0;
    String outString = String(number); /* convert integer to string */
    int len = outString.length()+1     /* obtain length of string w/terminator */
    char ascii_num[len];               /* create character array */

    outString.toCharArray(ascii_num, len); /* copy string to character array */

    for (i=0; i<len); ++i){
        Wire.write(ascii_num[i]);
    }
}

Wiederzusammenbau erhielt Integer:
Hinweis: ich habe einige Schwierigkeiten zu verstehen, was Ihre anderen code in diese routine zu tun, so bin ich dabei es zu reduzieren, um nur die Montage der integer.

void receiveData(int byteCount){
    int inChar;
    String inString = "";

    /* As with the Python receive routine, it will be up to you to identify the
       terminating condition for this loop - "bytes_available" means the same thing
       as before */

    while(bytes_available){ 
        inChar = Wire.read();
        inString += char(inChar);
    }

    number = inString.toInt();
}

Habe ich nicht die Materialien zur hand um dies zu testen, es ist also möglich, ich habe die byte-Reihenfolge umgedreht in eine routine oder ein anderes. Wenn Sie finden, Sachen in oder out kommen nach hinten, der einfachste Ort um es zu beheben ist in der Python-Skript mit der eingebauten Funktion Umgekehrt() auf die strings oder Listen.

Verweise (ich habe einige code aus der Arduino Beispiele):

Arduino String Objekte

Arduino-String-Konstruktoren

Python Built-ins chr() und ord()

InformationsquelleAutor skrrgwasme

0

Könnte man wandelt die Zahl in einen string von Ziffern, wie Sie sagte. Aber man könnte auch senden Sie die raw-bytes.

String von Ziffern

Vorteile
- Zahl kann unendlich stellen. Beachten Sie, dass bei der Arduino liest die Zahl als einen string, es ist unendlich, aber Sie können nicht konvertieren Sie Sie alle zu integer, wenn es überläufe des 16-bit (oder 32-bit für Due).
Nachteile
- Variable Größe, so erfordern Sie mehr Aufwand in das Lesen.
- Verschwendung von bytes, weil jede Dezimalstelle wäre ein byte, plus den null-terminator summieren (digits + 1) Größe.
- Mit dezimal-Arithmetik (das ist wirklich nur nützlich für die menschliche zählen), beachten Sie, dass eine "Zahl-zu-string-operation" verwendet auch dezimal-Arithmetik.
- Sie können nicht senden/empfangen von negativen zahlen (es sei denn, Sie senden das minus-signal, verschwenden mehr Zeit und bytes).
Raw bytes

Vorteile
- Anzahl der gesendeten bytes für jede ganze Zahl ist immer 4.
- Können Sie senden/empfangen von negativen zahlen.
- Die bitweise Arithmetik in C++ für das extrahieren jedes byte von der Nummer ist wirklich schnell.
- Python hat bereits die struct Bibliothek, die packt/entpackt jedes byte in eine Zahl zu einem string zu senden/empfangen, so brauchen Sie nicht zu tun, die Arithmetik wie in C++.
Nachteile
- Zahl hat eine begrenzte Reichweite (vorzeichenbehaftete 32-bit-Ganzzahl in unserem Fall, die reicht von -2147483648 zu 2147483647). Aber es spielt keine Rolle, weil kein Arduino verarbeiten kann, mehr als 32-bit sowieso.
So würde ich die raw-bytes-Methode, die ich einige ungetestete Funktionen hier:
```
import struct

# '<i' stands for litle-endian signed integer

def writeNumber(value):
  strout = struct.pack('<i', value)
  for i in range(4):
    bus.write_byte(address, strout[i])
  return -1

def readNumber():
  strin = ""
  for _ in range(4):
    strin += bus.read_byte(address)
  return struct.unpack('<i', strin)[0]
```
Und das Arduino-Teil:
```
void receiveData(int byteCount)
{
    //Check if we have a 32-bit number (4 bytes) in queue
    while(Wire.available() >= 4)
    {
        number = 0;
        for(int i = 0; i < 32; i += 8)
        {
            //This is merging the bytes into a single integer
            number |= ((int)Wire.read() << i);
        }

        Serial.print("data received: ");
        Serial.println(number);

        //...
    }
}

void sendData()
{
    for(int i = 0; i < 32; i += 8)
    {
        //This is extracting each byte from the number
        Wire.write((number >> i) & 0xFF);
    }
}
```
Ich habe keine Erfahrung mit I2C, aber wenn die Warteschlange ist eine FIFO -, dann sollte der code funktionieren.

InformationsquelleAutor Flavio Toribio

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

String von Ziffern

Raw bytes