SPI Data

Mit den folgenden zwei Codebesipielen wird gezeigt, wie Werte von einer OpenMV CAM zu einem KeplerBRAIN Roboter übertragen werden können. Dazu wird im Python-Skript eine Liste mit 8 Zahlen definiert. Diese 8 Werte werden laufend vom Mikrocontroller am KeplerBRAIN Roboter über die SPI-Schnittstelle abgefragt.

Damit diese Zahlen in ihrer Reihenfolge beim Empfangen identifiziert werden können, ist die erste Zahl in dieser Liste der Wert 250. Diese darf nicht verändert werden! Nachfolgend können dann die nächsten 7 Stellen in der Liste mit beliebigen Zahlen zwischen 0 und 254 befüllt werden, die man übertragen möchte.

ACHTUNG: Sollte dabei der Wert 250 vorkommen, müsste man zum Identifizieren des ersten Werts der Achtergrutte in beiden Codes (OpenMV und Arduino) eine andere Zahl verwenden, die bei den Daten, die man übertragen möchte, nicht vorkommt.

Die Daten werden also nicht aktiv von der OpenMV Cam gesendet, sondern vom KeplerBRAIN Roboter abgefragt.

Hier wird nun das Senden von 7 Werten (die Zahlen 11, 22, 33, ..., 77) gezeigt. Auswertung von Bilddaten erfolgt in diesen Codebeispielen keine, es soll nur das Bereitstellen und Abfragen von Werten veranschaulicht werden.

Python Skript zum Senden von Werten über die SPI Schnittstelle

import pyb, sensor, image, time, math
 
# ******************** SPI SEND INTERUPT ********************
spi = pyb.SPI(2, pyb.SPI.SLAVE, polarity=0, phase=0)
led_red = pyb.LED(1)
led_green = pyb.LED(2)
spi_list = [250, 1, 2, 3, 4, 5, 6, 7]
spi_data = bytearray(spi_list)
 
def nss_callback(line):
    global spi, spi_data
    try:
        spi.send(spi_data, timeout=1000)
        led_green.on()
        led_red.off()
    except OSError as err:
        led_green.off()
        led_red.on()
        pass
 
pyb.ExtInt(pyb.Pin("P3"), pyb.ExtInt.IRQ_FALLING, pyb.Pin.PULL_UP, nss_callback)
 
# ******************** IMAGE DETECTION ********************
sensor.reset()
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.QQVGA)
sensor.set_vflip(True)
sensor.set_hmirror(True)
sensor.skip_frames(time = 2000)
sensor.set_auto_gain(False)
sensor.set_auto_whitebal(False)
 
while(True):
    # ***** IMAGE DETECTION CODE *****
    img = sensor.snapshot()
 
    # ***** SET and SEND VALUES over SPI to ARDUINO *****
    spi_list[1]=11
    spi_list[2]=22
    spi_list[3]=33
    spi_list[4]=44
    spi_list[5]=55
    spi_list[6]=66
    spi_list[7]=77
    spi_data = bytearray(spi_list)
    # print(spi_list)

Erklärungen zu diesem Skript

Zeile 3-21: # SPI SEND INTERUPT

In diesem Code-Abschnitt wird die OpenMV Cam als SPI Slave mit den entsprechenden Vorgaben für did SPI-Übertragung so konfiguriert, wie dies in den Einstellungen in der KeplerOpenBOT.h Bilbliothek festegelegt ist. Darin enthalten ist auch das Senden von Daten, wenn diese vom Mikrocontroller des KeplerOpenBOT abgefragt werden. In diesem Code-Bereich sind grundsätzlich keine Änderungen durchzuführen.

Zeile 23-31: # IMAGE DETECTION

Ausgehend vom jeweiligen Anwendungsfall wird in diesem Abschnitt wird die Konfiguration des Kamerasensors vorgenommen.

Zeile 34: while(True):

Innerhalb dieser while-Schleife erfolgen zunächst die Auswertung der Bilddaten und im Anschluss daran etwaige Berechnungen, die bereits auf der OpenMV Cam ausgeführt werden sollen. Abschließend werden die ermittelten Zahlen in die Liste spi_list[] an die gewünschten Positionen geschrieben.

Zeile 38-44: spi_list[1]=11, spi_list[2]=22, ...

Um Zahlen in die Liste spi_list[] zu schreiben, werden diese den jeweiligen Plätzen zugewiesen.

Zeile 45: spi_data = bytearray(spi_list)

Wurden die gewünschten Positionen in der Liste mit neuen Werten befüllt, dann muss diese noch in ein Array mit Byte-Werten umgewandelt werden. Somit stehen alle Zahlen, die man übertragen möchte, im Array spi_data. Bei einer Anfrage des KeplerOpenBOT Mikrocontrollers werden die Werte aus diesem Array gesendet.

Arduino Sketch zum Abfragen und Emfangen von Werten der OpenMV

#include "KeplerBRAIN_V4.h"
 
uint8_t value_1 = 0;
uint8_t value_2 = 0;
uint8_t value_3 = 0;
uint8_t value_4 = 0;
uint8_t value_5 = 0;
uint8_t value_6 = 0;
uint8_t value_7 = 0;
 
void setup()
{
  KEPLERBRAIN_INIT();
  WRITE_LCD_TEXT(1,1,"                ");
  WRITE_LCD_TEXT(1,2,"                ");
}
 
void loop()
{
  // read 8 Bytes from OpenMV BEGIN
 
  digitalWrite(SPICAM, LOW);
  delay(1);
 
  if(spi_cam.transfer(1) == 250)
  { 
    value_1 = spi_cam.transfer(0);
    value_2 = spi_cam.transfer(0);
    value_3 = spi_cam.transfer(0);
    value_4 = spi_cam.transfer(0);
    value_5 = spi_cam.transfer(0);
    value_6 = spi_cam.transfer(0);
    value_7 = spi_cam.transfer(0);
  }
 
  digitalWrite(SPICAM, HIGH);
 
  // read 8 Bytes from OpenMV END
 
  WRITE_LCD_TEXT(1, 1, String(value_1)+" "+String(value_2)+" "+String(value_3)+" "+String(value_4));
  WRITE_LCD_TEXT(1, 2, String(value_5)+" "+String(value_6)+" "+String(value_7));
}

Erklärungen zu diesem Programmbeispiel

Zeile 3 - 9: uint8_t value1;

Zunächst werden 7 Variablen vom Typ uint8_t definiert, in welchen die von der OpenMV Cam abgefragten Zahlen abgelegt werden.

Zeile 20 - 38: // read 8 Bytes from OpenMV BEGIN - END

In diesem Code-Abschnitt sind grundsätzlich keine Änderungen vorzunehmen. Laufend werden über die SPI-Schnittstelle Zahlen von der OpenMV Cam abgefragt. Entspricht in diesem Daten-Stream eine Zahl dem Wert 250, so wird diese als erste Zahl der Achtergruppe identifiziert und alle weiteren werden in den Variablen value1, value2, ...abgelegt.

Zeile 40,41: WRITE_LCD_TEXT(1, 1, String(value_1)+" "+String(value_2)+" "+String(value_3)+" "+String(value_4));

Mit diesen Code-Zeilen werden die Zahlen der Variablen value1, value2, ... am Display angezeigt.

Übertagung von Werten aus einem Python-Skript zum einem Arduino-Programm auf einem KelperOpenBOT Roboter