Arduino SPI Daten senden

[Mgns (Gast)]

Moin,

ich bin leider noch ein ziemlicher Anfänger in der Programmierung der 
SPI eines Arduinos. Deswegen möchte ich im ersten Schritt lediglich 
erstmal sehen, dass ich einzelne Befehle aussenden kann. Das Ganze gucke 
ich mir dann über ein digitales Oszilloskop an.
(Der Arduino empfängt Befehle per Bluetooth über MATLAB.)

Ich habe dazu folgenden Code geschrieben:

#include <SoftwareSerial.h>
#include <SPI.h>

int TxD;
int RxD;
int data;
const byte WAKEUP  = 0b00000010;
unsigned long nextMillis = 0;
SoftwareSerial bluetooth(TxD, RxD);

/* SPI pin numbers:
  SCK   13  // Serial Clock.
  MISO  12  // Master In Slave Out.
  MOSI  11  // Master Out Slave In.
  SS    10  // Slave Select*/

void setup() {
  Serial.begin(9600);
  nextMillis = millis();
  bluetooth.begin(9600);                                                                                    
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV128);
}

void loop()
{
  if (bluetooth.available() > 0)
  {
    data = bluetooth.read();
    Serial.print(data);
    Serial.print("\n");

    if (data == 'H')
    {
      digitalWrite(SS, LOW);                      /* Turn SlaveSelect Level to low*/
      delay(5);                                   /* all delays for stability*/
    }
    else if (data == 'U')
    {
      SPI.transfer(WAKEUP);                       /* Turn off standby mod*/
      Serial.println("Turn off standby Sent.");
      delay(5);
    }
  else if (data == 'Z')
    {
      digitalWrite(SS, HIGH);                   /* Turn SlaveSelect Level to high*/
    }
  }
}

Der Teil, bei dem ich das Level vom SlaveSelect verändere funktioniert.
Aber ich kann mittels des Oszilloskops nicht sehen, dass Daten 
ausgesendet werden. Kann mir jemand sagen, was ich dafür ändern muss?
Nach meinem Verständnis müsste bei jedem Takt ja ein Bit gesendet 
werden.

Vielen Dank im voraus!
M

[Einer K. (Gast)]

Mgns schrieb:
> Der Teil, bei dem ich das Level vom SlaveSelect verändere funktioniert.
Genau da liegt der Irrtum!
Es sieht auf dem Oszi so aus, als wenn es funktioniert.
Macht aber was anderes, als du glaubst.


> digitalWrite(SS, LOW);
Wenn du deinen SS nicht vorher zum Output machst, dann schaltet der SPI 
"Baustein" bei Low an SS in den Slavemode.
Dann kommt kein Takt und auch keine Daten.

Steht auch so im Datenblatt deines Prozessors.
Auch in der Arduino SPI Doku wird es erwähnt.



Also in setup():
> digitalWrite(SS, HIGH);
> pinMode(SS,Output);
(ja, in dieser Reihenfolge)
Dann tuts das auch.

[Mgns (Gast)]

Vielen Danke! Habe ich hinzugefügt!

Ich kann eine Veränderung des Levels des SS weiterhin sehen, allerdings 
nicht, dass irgendwelche Bits übertragen werden.
Ich habe mit "SPI.setClockDivider(SPI_CLOCK_DIV128);" meine CLK auf 
125kHz gesetzt oder? Das müssten doch ca. 8µs für jeden Takt sein. 
Deswegen habe ich mein Oszilloskop auf 1µs/div gestellt. (Bin auch 
andere Auflösungen durchgegangen, nur immer sicher zugehen).
Habt ihr 'ne Idee, was ich anders einstellen müsste?
Benutze ein "AnalogDiscovery 2" von Digilent.

[Einer K. (Gast)]

Siehst du denn den Takt?

[Mgns (Gast)]

Ne, den sehe ich ebenfalls nicht.

[Einer K. (Gast)]

Du verwendest einen Arduino Mega?

[Mgns (Gast)]

Ah, das hätte ich dazuschreiben können natürlich... Ich verwende einen 
Arduino Uno, sorry!

[Einer K. (Gast)]

Tja, dann weiß ich auch nicht....

Gerade mit dem UNO getestet:

#include <SPI.h>

const byte WAKEUP  = 0b00000010;


/* 
 *  
 *  SPI pin numbers:
 *  Arduino UNO/Nano/Pro Mini
  SCK   13  // Serial Clock.
  MISO  12  // Master In Slave Out.
  MOSI  11  // Master Out Slave In.
  SS    10  // Slave Select
 */

void setup() 
{
  digitalWrite(SS, HIGH);
  pinMode(SS,OUTPUT);
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV8);
}

void send()
{
  digitalWrite(SS, LOW);
  SPI.transfer(WAKEUP); 
  digitalWrite(SS, HIGH);
}

void loop()
{
  send();
  //delay(1000);
}

Zuckt wie verrückt.
Perfekt.
Auch mit deinen 125kHz

[Rath Schläger (Gast)]

Arduino Fanboy D. schrieb:
> Zuckt wie verrückt.
> Perfekt.
> Auch mit deinen 125kHz

Wer Arduino kann muss (noch) nicht unbedingt Messen können.

[Mgns (Gast)]

Okay, das ist interessant! Mit deinem Code klappt das bei mir ebenfalls!
Dann muss der Fehler ja bei mir im Code liegen. Aber vielen Dank schon 
mal.

[Mgns (Gast)]

So sieht es mit deinem Code aus, Arduino Fanboy D.
Bei meinem passiert da leider nichts, als würde die Clock durch 
irgendwas blockiert werden.

[S. Landolt (Gast)]

Dann wäre doch ein möglicher Weg, hiervon ausgehend nach und nach 
diese Bluetooth-Zusätze einzubauen und zu schauen, ab wann es nicht mehr 
geht.

[Einer K. (Gast)]

Das
> int TxD;
> int RxD;
kommt mir arg komisch vor.

Ansonsten... außer den schon genannten Dingen... sehe ich da nix 
falsches.

[Veit D. (devil-elec)]

Hallo,

dein SlaveSelect Pin muss an der richtigen Stelle schalten.
Du weißt vorher nicht welche Daten empfangen wurden, dann verheddert 
sich der SS Pegel.

Wenn jetzt kein 'U' kommt, geht der SS nur kurz auf Low und wieder auf 
High.
Kommt ein 'U' rein wird dazwischen noch kurz etwas gesendet.
Es ist sichergestellt das der SS Pin immer auf dem richtigen Pegel 
steht.
Das delay kann auch raus. Meistens benötigen die ICs 50ns Verzögerung. 
Ein Takt dauert aber schon 62,5ns. Das DigitalWrite dauert ca. 4µs. 
Einheiten beachten. Da musst du dir keine Sorgen machen.
Das Serial bei 'U' würde ich rausnehmen. Fürs debuggen noch okay.

#include <SoftwareSerial.h>
#include <SPI.h>

int TxD;
int RxD;
int data;
const byte WAKEUP  = 0b00000010;
unsigned long nextMillis = 0;
SoftwareSerial bluetooth(TxD, RxD);

/* SPI pin numbers:
  SCK   13  // Serial Clock.
  MISO  12  // Master In Slave Out.
  MOSI  11  // Master Out Slave In.
  SS    10  // Slave Select*/

void setup() {
  Serial.begin(9600);
  nextMillis = millis();
  bluetooth.begin(9600);      

  digitalWrite(SS, HIGH);
  pinMode(SS,OUTPUT);  
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV128);
}

void loop()
{
  if (bluetooth.available() > 0)
  {
    data = bluetooth.read();
    Serial.print(data);
    Serial.print("\n");
    
  digitalWrite(SS, LOW); 
  
    if (data == 'H')
    {
      // hier sinnvolle Dinge tun
    }
    else if (data == 'U')
    {
      SPI.transfer(WAKEUP);                       
      Serial.println("Turn off standby Sent.");
    }
    else if (data == 'Z')
    {
      // hier sinnvolle Dinge tun
    }
  
  digitalWrite(SS, HIGH);                  
  }
}

[Veit D. (devil-elec)]

Hallo,

haha :-) , na klar, hier fehlen noch die Pinangaben.

int TxD;
int RxD;
SoftwareSerial bluetooth(TxD, RxD);

also irgendwie sowas

const byte TxD = 8;
const byte RxD = 9;
SoftwareSerial bluetooth(8, 9); // oder Wert vertauschen

[Mgns (Gast)]

Okay, es ist etwas merkwürdig. Aber mit meinem Code funktioniert das 
ganze ebenfalls, wenn ich den SS als Output vorher definiere.
Allerdings nur, wenn ich über MATLAB beispielsweise

 fprintf(bt, 'UU')

schicke. Sende ich hingegen

 fprintf(bt, 'U')

 geht es nicht.
Ich habe das mit jeder beliebigen Kombination und unterschiedlichen 
Befehlen ausprobiert. Immer, wenn ich ein "U" vor dem nächsten Buchstabe 
setze, sendet er den Befehl... Kann mir das jemand erklären? Ich bin 
ziemlich verwirrt.

[Einer K. (Gast)]

Veit D. schrieb:
> na klar, hier fehlen noch die Pinangaben.

Scheinen irgendwie nicht wichtig genug zu sein.....

TxD und RxD von SoftwareSerial und RxD von HardwareSerial alle drei 
Funktionalitäten auf dem gleichen Pin.

Naja... wer es mag....
Der jeweiligen Funktion tut es sicherlich nicht gut.
Zumindest habe ich keinerlei Ahnung, wie das ordentlich funktionieren 
soll.

Denn die Serielle ist kein Bus.

[Veit D. (devil-elec)]

Hallo,

hmm, man sollte nichts in Eile schreiben, Sorry   :-)
eigentlich sollte das vorhin so aussehen ....

const byte TxD = 8;
const byte RxD = 9;
SoftwareSerial bluetooth(RxD, TxD); // oder vertauschen

Ist aber Schwachsinn, weil man kann gleich die Pinnummern der Instanz 
direkt übergeben, dann gibts auch keine Konflikte.

SoftwareSerial bluetooth(8, 9);  // Bsp.

Wenn jetzt immer noch nichts richtig funktioniert, dann bitte erneute 
Problembeschreibung mit aktuellen Sketch.

aktuell würde ich es erstmal so machen

#include <SoftwareSerial.h>
#include <SPI.h>

const byte WAKEUP  = 0b00000010;
SoftwareSerial bluetooth(8, 9);   // RX, TX

/* SPI pin numbers:
  SCK   13  // Serial Clock.
  MISO  12  // Master In Slave Out.
  MOSI  11  // Master Out Slave In.
  SS    10  // Slave Select*/

void setup() {
  Serial.begin(9600);
  bluetooth.begin(9600);
  
  digitalWrite(SS, HIGH);
  pinMode(SS, OUTPUT);
  
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV128);
}

void loop()
{
  if (bluetooth.available() > 0)
  {
    char data = bluetooth.read();
    Serial.println(data);

    if (data == 'H')
    {
      // hier sinnvolle Dinge tun
    }
    else if (data == 'U')
    {
      digitalWrite(SS, LOW);
      SPI.transfer(WAKEUP);
      digitalWrite(SS, HIGH);
      Serial.println("Turn off standby Sent.");
    }
    else if (data == 'Z')
    {
      // hier sinnvolle Dinge tun
    }
  }
  
}

[Mgns (Gast)]

Moin,

aktuell geht es. Allerdings reagiert der Chip nicht auf die Befehle, mal 
schauen woran das nun wieder liegt... :D
Danke für eure Hilfe!

[Einer K. (Gast)]

Mgns schrieb:
> Danke für eure Hilfe!

Bitte bitte, gerne doch!

Hast du denn mittlerweile das
> int TxD;
> int RxD;
> SoftwareSerial bluetooth(TxD, RxD);
Problem verstanden und behoben?

[Mgns (Gast)]

Ja, ich denke schon, dass das jetzt klar geworden ist!
Kurze Frage noch, mit SPI.transfer() kann ich auch Daten empfangen oder?
Aktiviert sich die Clock nur, wenn man dem Arduino mitgibt, dass er 
jetzt Daten lesen muss? Ich benötige ja die Clocktakte am Chip ebenfalls 
zum Daten ausgeben.
Sorry für die vermutlich sehr dummen Fragen! :D

[jo mei (Gast)]

Mgns schrieb:
> die Clock

die Clock  --> die Uhr
der Clock  --> der Takt

[Einer K. (Gast)]

Mgns schrieb:
> Sorry für die vermutlich sehr dummen Fragen! :D

Ob sie dumm sind, weiß ich nicht!
Aber, ich verstehe sie nicht.

Wikipedia: SPI
Schon gelesen?

Mgns schrieb:
> Kurze Frage noch, mit SPI.transfer() kann ich auch Daten empfangen oder?
Natürlich!
So sagt es die Spezifikation.
Die Arduino Doku betätigt es.
Und so wird es auch in der Praxis getan.

Mgns schrieb:
> Ja, ich denke schon, dass das jetzt klar geworden ist!
Und auch behoben?

[Mgns (Gast)]

Arduino Fanboy D. schrieb:
> Und auch behoben?
Ja, so geändert wie ihr es geschrieben habt.

Habe Wikipedia und mehr dazu durchgestöbert, ich glaube grundsätzlich 
weiß ich was ich will, nur bin ich noch limitiert in meiner Denkweise, 
vielleicht macht es ja noch "klick".
Ich verstehe noch nicht ganz, wie das mit dem Datenaustausch 
funktiniert. Also folgendes, wenn ich mit Hilfe des Arduino den Befehl 
xxxx xxxx sende, dann sehe ich gleichzeitig, dass SCLK 8 Takte anliegt. 
Damit mein Chip aber jetzte korrekt darauf reagieren kann, so müsste ich 
diesem ja wieder die Takte meiner SCLK zur Verfügung stellen. Geht das 
darüber, dass ich ihm beispielsweise hiermit "receivedVal = 
SPI.transfer(val)" sage, "ließ mal aus, was so da sein könnte?"

[Einer K. (Gast)]

Lesen und schreiben geschieht gleichzeitig.
Nicht nacheinander.

[Mgns (Gast)]

Kann man denn nach einem einzelnen Bit quasi fragen?
Also wenn man beispielsweise "byte temp = SPI.transfer(0x00);" schreibt?

[Einer K. (Gast)]

Acht Takte führen zu 8 Bit.
Also nein!
Einzelne Bits geht nicht.

[Veit D. (devil-elec)]

Hallo,

lese andere Quellen um den Ablauf von SPI zu verstehen. Die Auswahl ist 
riesig. Hier im Forum gibts auch ein Tutorial Fundus.

Ob ein SPI Device einen Wert gesendet bekommt oder ob ein Wert 
ausgelesen wird, darum kümmert sich die SPI.transfer Methode. Schau dir 
die Bsp. an. Du kannst das natürlich auch zu Fuss machen, lernste noch 
mehr.

Zu deiner letzte Frage. SPI arbeitet Byteweise. Du musst dann das 
empfangene Byte auf dein Bit abfragen. Alles nach der Übertragung.

[Mgns (Gast)]

Danke, dass ihr so geduldig mit mir seid! :)
Ich wühle mich gerade durchs Forum und diversen anderen Seiten und habe 
auf jeden Fall schon einiges durch euch gelernt.
Eine kleine Verständnisfrage.
Wenn ich über die MOSI-Leitung meine Steuersignale ausgebe (bspw. 0000 
0010 oder so), dann wird über den Takt von SCLK meinem ADS1299 
mitgeteilt, jetzt kommt ein Befehl. Damit der IC nun darauf reagieren 
kann und die Möglichkeit zu antworten bekommt, muss ich nun über SCLK 
und MOSI (0000 0000 oder so) senden, damit dieser 8 Takte hat und die 
Bits seinerseits senden kann oder?

[jo mei (Gast)]

Mgns schrieb:
> Danke, dass ihr so geduldig mit mir seid! :)

Danke auch.

Hauptsache du schreibst nicht "der Uhr" oder "die Takt".

Mgns schrieb:
> muss ich nun über SCLK
> und MOSI (0000 0000 oder so) senden, damit dieser 8 Takte hat und die
> Bits seinerseits senden kann oder?

Ja. dabei ist das Datum was du schickst nicht relevant,
Hauptsache du schickst was.

[Mgns (Gast)]

Moin!

Ich habe eine weitere Frage, wer hätte das gedacht! :D
Momentan schicke ich ziemlich unelegant immer einen Byte über die 
Leitung warte kurz schicke den nächsten usw. ... Kann man auch 
Bytepakete schicken und genau definieren, wie viel Pause zwischen den 
einzelnen Paketen sein soll?
Mein Oszilloskop zeigt mir logischerweise immer nur einen Byte an und 
dann den nächsten. Gucke ich mir beispielsweise andere SPI-Protokolle 
an, bspw. das vom ADS1299 mit der ursprünglichen Software erzeugte 
Protokoll beim auslesen der Daten, dann wird mir mit denselben 
Einstellungen immer "mehr" angezeigt.

[S. Landolt (Gast)]

Das kommt auf die Partner an: so kann z.B. ein ATmega mit der 
USART-Schnittstelle im SPI-Mode "am Stück", also ohne Unterbrechung, 
einen Datenblock (514 Bytes) an eine SDCard schicken - danach benötigt 
die SDC eine Pause.

[S. Landolt (Gast)]

PS:
Diese ATmega-Schnittstelle ist gepuffert, man erreicht also eine 
SPI-Rate mit dem halben Systemtakt des ATmega, über beliebig viele Bytes 
hinweg.

[jo mei (Gast)]

Mgns schrieb:
> Ich habe eine weitere Frage, wer hätte das gedacht!

Ich hätte da auch noch was ....

Mgns schrieb:
> einen Byte

--> ein Byte  (das Byte)

Mgns schrieb:
> den nächsten

--> das nächste

[Mgns (Gast)]

Sorry Jo Mei!?
Du hast ja recht!

Wie programmiert man das korrekt? Die Dokumentation von SPI.transfer() 
ist ja mehr als überschaubar...
Also angenommen ich möchte 3 mal das Byte (0000 0001) hintereinander 
wegschicken, dann eine Pause von 3 Takten oder so haben und dann erneut 
das ganze, bis ich 216 Bits verschickt habe.
Also wenn ich den "Dreierblock" habe, würde ich den Rest vermutlich über 
die Delay-Funktion und eine for-Schleife oder while-Schleife regeln.?
Ach ja und noch eine Frage, wieso kann ich nicht 0000 0000 verschicken? 
Jedes andere Byte geht.

[Mgns (Gast)]

Hat sich erledigt, sorry!