Pages: [1] 2 3   Go Down
Author Topic: Erhaltene Daten über Serialport auf SD-karte schreiben und auslesen  (Read 3232 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Sr. Member
****
Karma: 2
Posts: 272
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hallo miteinander, wollte mich erneut bedanken für die Hilfe mit dem SD-modul.
So nun habe ich mir eine GUI mit VB.net geschrieben die mir Steuerbefehle(im String format) an dem Arduino sendet und diese auf einer SD-Karte in eine .txt abspeichert. Anhand einer KOntrollzahl die von meiner GUI versendet wird, soll dann der Arduino erkennen, ob er senden oder empfangen soll.
Ich möchte diese auf nach bedarf wieder von der SD-Karte auslesen und an die GUI senden.

Mein Problem ist, dass ich soweit komme , dass er die commands.txt auf der SD-Karte erstellt, aber er mir die gesendeten Strings nicht dort abspeichert und somit kann ich sie auch nicht auslesen.

Mein zweites Problem ist, dass wenn ich anhand der GUI die Daten vom arduino auslesen möchte(Habe einen Button receive) , versucht er die Daten aus der SD auszulesen und über serialport auszulesen (ohne Erfolg, da nichts geschrieben wird), versuche ich es ein zweites mal , sagt er SD karte nicht erkannt. Obwohl die SD karte immer von dem Cardinfo, READWRITE Sketch erkannt wird.

Hier nochmal mein Code:
Code:
/*Code zum Empfangen und Senden von Daten über Serialport (GUI<-> Arduino) */
/*Die Daten werden in eine SD-Karte innerhalb von commands.txt abgespeichert*/


//Globale Variablen
/*----------Varaiblen fürs Senden---------------------------------------*/
int ist_senden= 1; //Falls Arduino an GUI sendet
const int ledPin1= 22;  //Mit Digital PIN 22 verbundene Led  (senden)-(rote led)
/*----------------------------------------------------------------------*/

/*----------Variablen fürs Empfangen------------------------------------*/
const int ledPin2= 23; //MIt Digital PIN 23 verbundene Led (empfangen)-(gelbe led)
int ist_receive=2; //Falls Arduino von GUI empfangen soll


/*-----------SD Card-----------------------------------------------------*/
/* Verbindung - SPI an Mega2560
**MISO - pin 51
**MOSI - pin 50
**CLK - pin 52
**SS/CS (Chipselect) - pin 4  -> Standard chipselect pin 53
!!-----pin 53 somit als OUTPUT legen , da nicht verwendet-----*/

#include <SD.h>
int const chipSelect=53; //pin 4 für CS/SS-pin
String dataString;  //Variable zum SpeiSern von Serialport-Daten
File Datei; //um file zu öffnen bzw. auch zu

/*----------------------------------------------------------------------*/
/*-----------Auswahlvariable für Swtich-Case----------------------------*/
int inByte=0; //Variable wo das Empfangene kontrollbit abgespeichert wird(als Byte)
/*----------------------------------------------------------------------*/

/*----------- Hier beginnt das Programm---------------------------------*/

/*----------------Standard einstellung, die konstant sind in void setup()-*/

void setup()
{
  Serial.begin(9600); //Serialport öffnen mit baudrate 9600
  //pinMode(ledPin1, OUTPUT); //ledPin1(senden LED), wird als Output gesetzt
  //pinMode(ledPin2, OUTPUT); //ledPin2 (empf. LED), wird als Output gesetzt
 
  pinMode(53, OUTPUT); //da standard-Pin CS/SS nicht verwendet diesen als OUTPUT legen
 
}
/*------------------------------------------------------------------------*/


/*---------------------------Diese Funktionen werden ständig abgefragt in loop---*/
void loop()
{
    if (Serial.available() > 0) //Prüfen , ob mindestens ein Zeichen im Port vorhanden ist (Hier prüfe ich , ob senden oder EMpfangen)
  {
    inByte = Serial.read(); //lese zeichen au und speichere in chr vom typ char
     
 
  switch (inByte)
  {

    /*Senden der Daten von Arduino zur GUI*/   
    case 1:
   
              blink_send();
              //Aufruf der Funktion zum auslesen von SD
              read_SD();
             
             
             
              break; //beende case 1
   
    /* Von GUI empfangen*/         
    case 2:
              if (Serial.available() > 0 )
             
              {
                //dataString= String(Serial.read()); //zuerst casten das gelesen in String und dann in Stringvarible abspeichern
                //dataString += ",";
                //Aufruf er Funnkrion, um Daten aus SerialPort in SD zu speichern
                write_SD();
               
              }
                blink_receive();
               
               break;
           
   }
  }
}
//############################################################################################################################################################//
//++++++++++++++++++++++++++++++++++++Funktionenbereich: Alle Funktionen, die innerhalb des Programms aufgerufen werden+++++++++++++++++++++++++++++++++++++++//
//############################################################################################################################################################//

/*---------------------funktion für das Blinken beim senden an GUI----------------------*/
/*---------------------Blink funktion 0,5sek an und 0,5sek aus--------------------------*/

/*Rote LED*/

void blink_send()
{
 
  digitalWrite(ledPin1, HIGH); //leuchtet
  delay(500); //leuchtet 0,5 sek
  digitalWrite(ledPin1, LOW); //aus
  delay(500);
 
}
/*-------------------------------------------------------------------------------------*/


/*----------Funktion die in Case 2 aufegrufen wird, damit LED blinkt-------------------*/

/*gelbe LED*/

void blink_receive()
{
  digitalWrite(ledPin2, HIGH); //leuchtet
  delay(500); // 0,5sek an
  digitalWrite(ledPin2,LOW); //aus
  delay(500); //0,5sek aus
 

 
/*-------------------------------------------------------------------------------------*/

 //---------------------Funktion, die in SD-Karte speichert-----------------------------//     
void write_SD()
{
 
   Serial.print("Initializing SD Card.....");
   if(!SD.begin(chipSelect)){
     Serial.println("Initialization failed, card not present!");
     return;
   }
   Serial.println("card initialized.");
   Datei= SD.open("commands.txt", FILE_WRITE);
   if (!Datei){
     Serial.println("Error to open commands.txt");
   }
   dataString=String(Serial.read());
   Datei.println(dataString); //Schreibe inhalt in SD-Karte
   Datei.flush(); //Schliessen damit daten in SD gespeichert werden
   
}
   
//------------------------------------Funktion zum Auslesen der SD-Card-------------------------------------//
void read_SD(){
  Serial.print("Initializing SD Card.......");
  if (!SD.begin(chipSelect)){
    Serial.println("Initialization failed, card not present!");
    return; //tue nichts
  }
  Serial.println("card initialized.");
  //Öffne Datei commands.txt
  Datei=SD.open("commands.txt");
 
  //wenn File/Datei vorhanden
  if(Datei){
    //lese solange file aus bis nichts mehr zu lesen ist
    while (Datei.available()){
      Serial.write(Datei.read()); //Schreibe an port Inhalt , das von Sd ausgelesne wird
    }
   
    //Nach lesen Datei schliessen
    Datei.close();
  }
    else
    //falls Datei nicht geöfnet werden konnte
    Serial.println("error opening commands.txt");
    Serial.write(13); //Carriage return line feed
    Serial.print("It is not possible to read out the file");
}   
//-------------------------------------------------------------------------------------------------------//



Bräuchte wieder euren Rat.
Logged

Offline Offline
Edison Member
*
Karma: 38
Posts: 1170
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Zumindest einen Punkt kann ich klären:

SD.begin(chipSelect) kann nur einmal ausgeführt werden.

Wenn du SD.begin() zum zweiten Mal ausführst, kommt ein Fehler.

Abhilfe findest du hier:      
SD Card hot swap - oder: wie merke ich dass die SD entfernt wurde?
In Reply 8 und 9 findest du die Lösung.

Gunther
Logged

Grüße
Gunther

Offline Offline
Sr. Member
****
Karma: 2
Posts: 272
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

HI Gunther,

danke dir, deshalb der Fehler den ich dir beschrieben habe, beim zweiten auslesen der Karte, das sie nicht initialisiert wird?

Warum ist das so?

und zum anderen Problem bzw. zum allgemein Problem mit dem Schreiben auf der SD wüsstest du nichts ?

Danke dir für deine Hilfe. Du kannst die Sachen einfach richtig gut erklären smiley-grin
Logged

Offline Offline
Sr. Member
****
Karma: 2
Posts: 272
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Danke dir Gunther, warst wieder eine sehr gute Hilfe.
Das hat funtioniert mit dem mehrmaligen Aufruf von Sd.Begin.
Warum hat das root diesen einfluss?
Ist es vllt. weil du direkt auf die sd karte schreibst und wenn du diese offen hast und du sie nicht schliesst, kannst du sie nicht mehrmals initialisieren?


Jetzt bin ich noch an dem Schrieben von den Strings an der SD karte dran und auslesen, aber irgendwie kommem ich da nicht weiter smiley-sad.


« Last Edit: April 11, 2013, 07:19:50 am by milito » Logged

Germany
Offline Offline
Faraday Member
**
Karma: 59
Posts: 3071
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

1.
Wenn du eine 2 empfängst, fragst du gleich wieder if (Serial.available()). Vermutlich sind aber weitere Zeichen noch gar nicht da, denn Serial ist langsam.
Danach kommst du nie mehr hierhin.

2.
Strings sind übrigens böse, besonders wenn sie so verwendet werden wie du es eigentlich machen willst ( jeweils einen Buschstaben anfügen )
char empfangsPuffer[80];  // besser


3.
Sendest du eine binäre 2 oder einen Buchstaben, die '2'  ?


Übrigens.
Dass du den Arduino als Externspeicher verwendest, ist hoffentlich nur ein Nebeneffekt, um die Beschreibung der eigentlichen Aufgabe nicht zu kompliziert zu machen. Das wäre sehr löblich, Danke.
Logged

Offline Offline
Sr. Member
****
Karma: 2
Posts: 272
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hi michael_x, also der Arduino dient eigentlich dazu da die erhalten daten abzuspeichern (vor verlust zu schützen) aber hauptsächlich um mit dem erhalten steuerkommando das i2c board anzusteuern.
ich würde zb einen befehl senden wollen folgendermaßen: 0110101 , soll nur ein beispiel seinen, auslesen kann und damit das Board steuern kann , verstehst du?
Logged

Offline Offline
Sr. Member
****
Karma: 2
Posts: 272
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

1.
Wenn du eine 2 empfängst, fragst du gleich wieder if (Serial.available()). Vermutlich sind aber weitere Zeichen noch gar nicht da, denn Serial ist langsam.
Danach kommst du nie mehr hierhin.

2.
Strings sind übrigens böse, besonders wenn sie so verwendet werden wie du es eigentlich machen willst ( jeweils einen Buschstaben anfügen )
char empfangsPuffer[80];  // besser


3.
Sendest du eine binäre 2 oder einen Buchstaben, die '2'  ?


Übrigens.
Dass du den Arduino als Externspeicher verwendest, ist hoffentlich nur ein Nebeneffekt, um die Beschreibung der eigentlichen Aufgabe nicht zu kompliziert zu machen. Das wäre sehr löblich, Danke.


Wie mienst du punkt 2.? und 3? wo wäre da der unterschied?
 verstehe den Ansatz von dir nicht , wie ich es in meiner Syntax einbringe sorry.
Ja und zu deinem 1., warum komme ich nicht wieder dahin?
ich sende ja meine Zeichen (Steuerparameter) über die GUI anhand von einem Button (Send) via Serial.
« Last Edit: April 11, 2013, 08:00:51 am by milito » Logged

Germany
Offline Offline
Faraday Member
**
Karma: 59
Posts: 3071
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

In deiner Syntax ist es noch auf Kommentar gesetzt

Ich meine sowas in Punkt 2:

Code:
   /* Von GUI empfangen*/         
    case 2:
        {
           byte pos =0;
           static char buffer[80];
           delay (10); 
           while (Serial.available() && pos < 79)
           {
             buffer[pos++] = Serial.read();
             delay(2); // speed min. 57600 
           }
           buffer[pos] = 0; // Endekennung
           // Aufruf der Funktion, um Daten in SD zu speichern
           write_SD(buffer);

Quote
ich würde zb einen befehl senden wollen folgendermaßen: 0110101 , soll nur ein beispiel seinen, auslesen kann und damit das Board steuern kann , verstehst du?

Nicht ganz: wo ist da die 2, damit Arduino "Befehl wird gesendet" erkennt ?

Passiert das nur einmal, bei Programmstart / nach Arduino Reset ?

zu 3. Wenn du fragst, wo der Unterschied ist...

Wenn du statt der '2' auch ein 'A' senden könntest, ist es Text.
Wenn du statt der 2 eine 65 sendest und die als 'A' in einer text-Datei landet, war es binär zwischen der GUI und dem Arduino.
Wenn du die GUI mit dem SerialMonitor simulieren kannst, ist es Text.
Text ist zum Testen einfacher.

Die einfachste Wandlung der Buchstaben '0' ... '9'  in Zahlen geht durch Subtraktion der '0'.

Du musst also sowas

Code:
   if (Serial.available() > 0) //Prüfen , ob mindestens ein Zeichen im Port vorhanden ist (Hier prüfe ich , ob senden oder EMpfangen)
   {
      inByte = Serial.read() - '0' ;  //lese zeichen : Es sollte '1' oder '2' gekommen sein, speichere binär als 1 oder 2.
      // was machen wir, wenn wir nicht synchron sind und irgendwas anderes gekommen ist ???
   }

an einer Stelle machen, wo es nicht mit nachfolgenden Daten verwechselt wird.
Logged

Offline Offline
Sr. Member
****
Karma: 2
Posts: 272
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hi michael,

also zu diesem Punkt
Code:
if (Serial.available() > 0) //Prüfen , ob mindestens ein Zeichen im Port vorhanden ist (Hier prüfe ich , ob senden oder EMpfangen)
   {
      inByte = Serial.read() - '0' ;  //lese zeichen : Es sollte '1' oder '2' gekommen sein, speichere binär als 1 oder 2.
      // was machen wir, wenn wir nicht synchron sind und irgendwas anderes gekommen ist ???
   }

die 1 bzw 2 wird vom der GUI jedesmal ausgesendet,  wenn ich in der GUI den Button send oder receive drücke.
z.b. drücke ich send, sendet der VIsual basic code über den Serialport eine 2. die der Arduino dann erkennt und durch den Switch case mit 1 und 2 weiß er dann, was er zu tun hat. Und diese Kontrollvariablen, werden jedesmal gesendet, wenn ich auf die Buttons drücke.
« Last Edit: April 11, 2013, 09:12:29 am by milito » Logged

Offline Offline
Sr. Member
****
Karma: 2
Posts: 272
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Das mit Punkt zwei hat nicht funktioniert. wenn ich es so schreibe wie oben in deinem Bsp kommt die meldung: too many arguments in function void write:SD().
Bzw. in meiner txt.datei wird nichts geschrieben
« Last Edit: April 11, 2013, 09:39:48 am by milito » Logged

Germany
Offline Offline
Faraday Member
**
Karma: 59
Posts: 3071
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Also empfängt der Arduino z.B.
 "20110101"
, um  mit write_SD "0110101" auf die SD Karte zu schreiben ?

Ob zwischen der ersten '2' und den nächsten Zeichen einige wenige millisekunden Pause ist, ist bei serieller Kommunikation nie sicher und immer möglich. Andersrum: Auch wenn die '2' und der Rest von verschiedenen Stellen in deinem VB Programm kommen, kann der Arduino eine Lücke nicht immer erkennen.

Woran wird das Ende erkannt?
- Es sind immer  7 Zeichen  nach der '2'
- Es kommt z.B. mindestens 10 oder 100 msec lang nichts mehr
- Es wird ein Zeilenende-Zeichen mitgesendet
- Es gibt besondere Anfang/Ende - Zeichen und in Wirklichkeit wird   "2<0110101>" gesendet

alles ist erstmal möglich, aber mir noch unklar.
Der einzige der das festlegt, bist du. Für beide Seiten ( VB und Arduino ).

Wenn VB eine "1" sendet, wird von der SD gelesen und an den PC zurückgesendet.
VB sendet nach der "1" nichts mehr, bis der Benutzer wieder einen Knopf drückt.  
- richtig ?

PS: Du meinst sicher
too many arguments in function void write_SD()

Stimmt. In meinem Bsp. ist kein void write_SD()  definiert.
Wo willst du es ändern und warum nicht smiley-wink
Logged

Offline Offline
Sr. Member
****
Karma: 2
Posts: 272
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Ja genau die 1 bzw. 2. wird immer nur dann gesendet, wenn ich auf den Sende bzw Empfang Button drücke, sonst nie.

Ja leider schreibt er mir immer noch nichts rein smiley-sad.
Entweder bin ich blind oder sehe den Wald lauter Bäumen nicht mehr

Schau mal bitte:

Code:
/*Code zum Empfangen und Senden von Daten über Serialport (GUI<-> Arduino) */
/*Die Daten werden in eine SD-Karte innerhalb von commands.txt abgespeichert*/


//Globale Variablen
/*----------Varaiblen fürs Senden---------------------------------------*/
int ist_senden= 1; //Falls Arduino an GUI sendet
const int ledPin1= 22;  //Mit Digital PIN 22 verbundene Led  (senden)-(rote led)
/*----------------------------------------------------------------------*/

 byte pos= 0;
 static char buffer[80];

/*----------Variablen fürs Empfangen------------------------------------*/
const int ledPin2= 23; /*MIt Digital PIN 23 verbundene Led (empfangen)-(gelbe led) */
int ist_receive=2; //Falls Arduino von GUI empfangen soll


/*-----------SD Card-----------------------------------------------------*/
/* Verbindung - SPI an Mega2560
**MISO - pin 51
**MOSI - pin 50
**CLK - pin 52
**SS/CS (Chipselect) - pin 4  -> Standard chipselect pin 53
!!-----pin 53 somit als OUTPUT legen , da nicht verwendet-----*/

#include <SD.h>
int const chipSelect=53; //pin 4 für CS/SS-pin
String dataString;  //Variable zum SpeiSern von Serialport-Daten
File Datei; //um file zu öffnen bzw. auch zu

/*----------------------------------------------------------------------*/
/*-----------Auswahlvariable für Swtich-Case----------------------------*/
int inByte=0; //Variable wo das Empfangene kontrollbit abgespeichert wird(als Byte)
/*----------------------------------------------------------------------*/

//*----------- Hier beginnt das Programm---------------------------------*//

//*------Standard einstellung, die konstant sind in void setup()---------*//

void setup()
{
  Serial.begin(9600); //Serialport öffnen mit baudrate 9600
  //pinMode(ledPin1, OUTPUT); //ledPin1(senden LED), wird als Output gesetzt
  //pinMode(ledPin2, OUTPUT); //ledPin2 (empf. LED), wird als Output gesetzt
 
  pinMode(53, OUTPUT); //da standard-Pin CS/SS nicht verwendet diesen als OUTPUT legen
 
}
/*------------------------------------------------------------------------*/


/*-------Diese Funktionen werden ständig abgefragt in loop----------------*/
void loop()
{
    if (Serial.available() > 0) //Prüfen , ob mindestens ein Zeichen im Port vorhanden ist (Hier prüfe ich , ob senden oder EMpfangen)
  {
    inByte = Serial.read(); //lese zeichen au und speichere in chr vom typ char
     
 
  switch (inByte)
  {

    /*Senden der Daten von Arduino zur GUI*/   
    case 1:
   
              blink_send();
              //Aufruf der Funktion zum auslesen von SD
              read_SD();
             
             
             
              break; //beende case 1
   
    /* Von GUI empfangen*/         
    case 2:
              if (Serial.available() > 0 )
             
              {
               
                byte pos= 0;
                static char buffer[80];
                delay(10);
                while (Serial.available() && pos < 79){
                  buffer [pos++] = Serial.read();
                }
                buffer[pos]= 0;
               
                 
               
                //String(Serial.read()); //zuerst casten das gelesen in String und dann in Stringvarible abspeichern
                //dataString += ",";
                //Aufruf er Funnkrion, um Daten aus SerialPort in SD zu speichern
                write_SD();
               
              }
                blink_receive();
               
               break;
           
   }
  }
}
//############################################################################################################################################################//
//++++++++++++++++++++++++++++++++++++Funktionenbereich: Alle Funktionen, die innerhalb des Programms aufgerufen werden+++++++++++++++++++++++++++++++++++++++//
//############################################################################################################################################################//

/*---------------------funktion für das Blinken beim senden an GUI----------------------*/
/*---------------------Blink funktion 0,5sek an und 0,5sek aus--------------------------*/

/*Rote LED*/

void blink_send()
{
 
  digitalWrite(ledPin1, HIGH); //leuchtet
  delay(500); //leuchtet 0,5 sek
  digitalWrite(ledPin1, LOW); //aus
  delay(500);
 
}
/*-------------------------------------------------------------------------------------*/


/*----------Funktion die in Case 2 aufegrufen wird, damit LED blinkt-------------------*/

/*gelbe LED*/

void blink_receive()
{
  digitalWrite(ledPin2, HIGH); //leuchtet
  delay(500); // 0,5sek an
  digitalWrite(ledPin2,LOW); //aus
  delay(500); //0,5sek aus
 

 
/*-------------------------------------------------------------------------------------*/

 //---------------------Funktion, die in SD-Karte speichert-----------------------------//     
void write_SD()
{
 
   Serial.print("Initializing SD Card.....");
   if(!SD.begin(chipSelect)){
     Serial.println("Initialization failed, card not present!");
     return;
   }
   Serial.println("card initialized.");
   Datei= SD.open("commands.txt", FILE_WRITE);
   if (!Datei){
     Serial.println("Error to open commands.txt");
   }
   for (int i=0; i < 79; i++){
     
   //dataString=String(Serial.read());
   Datei.println(buffer[i]); //Schreibe inhalt in SD-Karte
   //delay(500);
   }
   Datei.flush(); //Schliessen damit daten in SD gespeichert werden
   
}
   
//------------------------------------Funktion zum Auslesen der SD-Card-------------------------------------//
void read_SD(){
  Serial.print("Initializing SD Card.......");
  Serial.write(13); //Carriage_Return Line feed
  /*if (card.init(SPI_HALF_SPEED, chipSelect)){
    Serial.println("SD Card detected");
  }
  else{
    Serial.println(" No SD Card detected ");
  }
  delay(1000); */
  if (!SD.begin(chipSelect)){
    Serial.println("Initialization failed, card not present!");
    return;  //tue nichts
   
  }
  Serial.println("Card was detected");
  //Öffne Datei commands.txt
  Datei=SD.open("COMMANDS.txt");
 
  //wenn File/Datei vorhanden
  if(Datei){
    //lese solange file aus bis nichts mehr zu lesen ist
    while (Datei.available()){
      Serial.write(Datei.read()); //Schreibe an port Inhalt , das von Sd ausgelesne wird
    }
   
    //Nach lesen Datei schliessen
    Datei.close();
  }
    else
    //falls Datei nicht geöfnet werden konnte
    Serial.println("error opening commands.txt");
    Serial.write(13); //Carriage return line feed
    Serial.print("It is not possible to read out the file");
}   
//-------------------------------------------------------------------------------------------------------//



Danke dir für deine Mühe

Logged

Germany
Offline Offline
Faraday Member
**
Karma: 59
Posts: 3071
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

wenn du
    case 2:
in
   case '2':
ändern würdest, sollte es zumindest mal blinken.

Dann kannst du dir entweder nochmal durchlesen, was ich über Text statt Zahlen gesagt habe, oder anders rauskriegen was es damit auf sich hat.

Ein "Problem" ist, dass
 Serial.print(1);
 Serial.print('1');
 Serial.print("1");
drei völlig verschiedene Sachen sind, die "leider" alle das gleiche Ergebnis liefern. Das solltest du verstehen.

Was passiert, wenn du in deinem sketch
Code:
Serial.print("Testausgabe :"); Serial.println(inByte);
einfügst? Dein VB Programm sollte sowas irgendwo anzeigen,
damit du eine Testmöglichkeit hast.
Logged

Germany
Offline Offline
Faraday Member
**
Karma: 59
Posts: 3071
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Außerdem dann hast du             
   static char buffer[80];
zweimal definiert.
Auf die Karte würde natürlich nicht der geschrieben, den du über Serial gelesen hast, aber das ist mir erstmal egal,
solange mir nicht klar ist, warum du 80 Zeilen mit je einem Buchstaben '0' schreibst.

Wenn du schon Datei.println verwendest, warum nicht einfach Datei.println(buffer); ?

Einfacher wäre natürlich, wenn du die globale Variable buffer löscht und einfach der Funktion write_SD sagen würdest, was sie schreiben soll.

Code:
void write_SD(char * buf) {
// open usw.
  Datei.println(buf);
  Datei.close();


in case '2': natürlich mit write_SD(buffer) aufrufen smiley-wink

Oder du löscht die lokale Variable buffer, dann wird dein globaler buffer ( der das Attribut static übrigens nicht braucht ) auch gefüllt.
Logged

Offline Offline
Sr. Member
****
Karma: 2
Posts: 272
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote

    case 2:
in
   case '2':
ändern würdest, sollte es zumindest mal blinken.

Quote
also wenn ich das in '2' in dem case ändere geht es nicht, da ich diese kontrolvariable in vb in char umwandle und dann versende es geht aber mit 2 siehe vb code:
Code:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_save_i2c.Click

    End Sub
    Dim inputdata As String
    Dim kontrol_receive As Integer = 1 'kontrolvariable für Empfangen von Arduino


    Private Sub Button1_Click_1(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_i2c_receive.Click
        RichTextBox1.ForeColor = Color.Black


        '/------Kontrollvariale an Arduino =1 , somit weiß er das er an GUI senden soll---/
        If Not SerialPort_i2c.IsOpen = True Then
            SerialPort_i2c.Open()

        End If

        SerialPort_i2c.Write(Chr(kontrol_receive))

Quote
Was passiert, wenn du in deinem sketch
Code:
Serial.print("Testausgabe :"); Serial.println(inByte);
einfügst? Dein VB Programm sollte sowas irgendwo anzeigen,
damit du eine Testmöglichkeit hast.

Habe das mal in dem SD_wrtie geschrieben. wenn ich in meiner VB-gui den receive button drücke(sendet 1 als char an Arduino), habe ich also ausgabe eine 1

Ich verstehe nichts mehr, kann es echt daran liegen, dass er mir nichts in meine txt.datei schreibt?
Logged

Pages: [1] 2 3   Go Up
Jump to: