Mehrere Werte über Serielle Schnittstelle an Arduino ausgeben

  • VB.NET

Es gibt 31 Antworten in diesem Thema. Der letzte Beitrag () ist von ebrithil.

    Mehrere Werte über Serielle Schnittstelle an Arduino ausgeben

    Hallo zusammen,
    ich versuche gerade ein kleines Programm in Visual Basic 2010 zu schreiben, mit dem ich 2 LED's über die Serielle Schnittstelle eine Leuchtdauer zuweisen kann (siehe Anhang).
    Da ich noch Anfänger bin, weiß ich bisher nur, wie ich einen festen Wert sende, wie mache ich dies jedoch bei den NumericUpDown-Feldern (in diesen stelle ich die Leuchtdauer der LED ein). Noch dazu müssen den Werten eine bestimmte Variable (z.B A und B) zugewiesen werden, damit sie der Arduino der jeweiligen LED zuweisen kann.
    Ich hoffe jemand kann mir helfen :D
    Viele Grüße J.
    Bilder
    • LED.jpg

      56,6 kB, 320×325, 277 mal angesehen
    Willkommen im Forum. :thumbup:
    Möglicherweise bin ich der einzige hier, der keine Arduino an seinem Rechner hat.
    Was sagt denn das Handbuch zu Deinem Problem?
    Wie sind die Befehle zu formatieren?
    Dann könnte sich Deine Frage lediglich noch auf eine kleine String-Formatierung beziehen und alles läuft dann ganz fix. :D
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!
    Hmmm...
    Handbuch hab ich keins :)
    und was mit Befehle formatieren gemeint ist habe ich auch nicht so ganz verstanden.

    Meine Frage ist eher, was in diese beiden Lücken muss:

    VB.NET-Quellcode

    1. Private Sub NumericUpDown1_ValueChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles NumericUpDown1.ValueChanged
    2. --> HIER <--
    3. End Sub
    4. Private Sub NumericUpDown2_ValueChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles NumericUpDown2.ValueChanged
    5. --> HIER <--
    6. End Sub

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Arduino_VB“ ()

    Arduino_VB schrieb:

    Meine Frage ist eher, was in diese beiden Lücken muss
    Eher nichts.
    Diese Events werden angesprungen, sobald sich ein Wert in der NumericUpDown-Box ändert.

    Wann soll denn das Leuchten starten?
    Beim Klick auf Verbinden?
    Einmal oder periodisch?
    --
    If Not Program.isWorking Then Code.Debug Else Code.DoNotTouch
    --

    VB.NET-Quellcode

    1. Private Sub StartButton_Click(...) Handles StartButton.Click
    2. Arduino_Send ("LED1 " & NumericUpdown1.Value.ToString)
    3. Arduino_Send ("LED2 " & NumericUpdown2.Value.ToString)
    4. End Sub
    Oder habe ich etwas falsch verstanden?
    --
    If Not Program.isWorking Then Code.Debug Else Code.DoNotTouch
    --
    Schau dir mein Arduino Tutorial in meiner Signatur an, da wid erklärt wie du werte an den Arduino Senden kannst.
    Mein Erstes Tutorial: Erweitertes Arduino Tutorial

    Simpler D&D FTP Uploader: Edge-Load
    Kurzer Hinweis: Der Arduino ist in C programmierbar.
    Der Arduino braucht also auch noch sein Programm welches die eingehenden Daten verarbeitet und nutzt!

    Dann lässt sich über das SerialPort Control einfach eine Byte-weise Verbindung zum Arduino aufbauen und Daten senden.
    #define true ((rand() % 2)? true: false) //Happy debugging suckers
    Ich gebe KEINE Hilfe per PN! Es gibt für ALLES nen Forum/Thread!
    Ich hab mir das Tutorial mal durchgelesen, jedoch bin ich mir immer noch nicht sicher,wie ich die beiden NumericUpDown in einen String mache und trenne. Hier ein Versuch:

    VB.NET-Quellcode

    1. Private Sub StartButton_Click(...) Handles StartButton.Click
    2. SerialPort1.Write(NumericUpDown1.Value|NumericUpDown2.Value)
    3. SerialPort1.Write(vbCr)
    4. End Sub

    Der | soll die Trennung der Werte sein.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Arduino_VB“ ()

    Möchte der Emptänger Bytes empfangen
    oder
    möchte der Emptänger einen Unicode-String empfangen?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!
    Dann probier es mal so:

    VB.NET-Quellcode

    1. Dim txt = String.Format("{0}|{1}{2}", Me.NumericUpDown1.Value, Me.NumericUpDown2.Value, Environment.NewLine)
    2. Me.SerialPort1.WriteLine(txt)
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!

    RodFromGermany schrieb:

    Dann probier es mal so:

    VB.NET-Quellcode

    1. Dim txt = String.Format("{0}|{1}{2}", Me.NumericUpDown1.Value, Me.NumericUpDown2.Value, Environment.NewLine)
    2. Me.SerialPort1.WriteLine(txt)
    Ich habe ne kleine Frage dazu. Ist es absicht, dass zwischen {1} und {2} kein Strich ist? Warum überhaupt 0,1 und 2? Wo muss das Enter hin?
    Und wie werte ich das z.B 2400|920 Enter am Arduino aus, damit es getrennt wir und der Strich als Trennung erkannt wird?
    Klick auf das Schlüsselwort Format und drück F1: MSDN
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!

    ebrithil schrieb:

    Schau dir mein Arduino Tutorial in meiner Signatur an, da wid erklärt wie du werte an den Arduino Senden kannst.
    Hi habe das Turoial ausproiert, leider klappt es bei mir nicht. ich habe das bei meinem Arduino code eingebaut, da ich keine festen Strings, aber die eingabe von meiner GUI, die ich senden möchte. Es klappt leider nicht.

    bekomme folgende ausgabes siehe folgendes bild.

    Hier mein 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)
    /*----------------------------------------------------------------------*/

    /*#define BUFSIZE 80
    byte pos= 0;
    char buffer[BUFSIZE]; */
    char inText[300];
    int index;
    char Byte;


    /*----------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=Serial.read();
    if (inByte ==13)

    index=0;
    memset(&inText[0], 0, sizeof(inText));
    }//endif 1

    else
    if (index < 300)
    {
    inText[index]= inByte;
    index += 1;
    }//endif2
    //end if (big)
    write_SD(inText);
    blink_receive();

    break; //end switch case2

    }//end switch
    } //end fu
    }
    //############################################################################################################################################################//
    //++++++++++++++++++++++++++++++++++++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(char* inText) //* ist zeiger auf zeichen in char array
    {

    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");
    }

    Datei.println(inText); //Schreibe inhalt in SD-Karte
    Datei.close(); //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
    //delay(500);
    }

    //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");

    //Serial.print("Testausgabe :"); Serial.println(inByte);

    }
    //-------------------------------------------------------------------------------------------------------//


    Könnte mir da jemand helfen ?
    Bilder
    • 2013-04-15_114231.png

      245 Byte, 52×81, 2.955 mal angesehen
    Also zu deinem Code:

    Quellcode

    1. inByte = Serial.read(); //lese zeichen au und speichere in chr vom typ char
    2. switch (inByte)
    3. case 1:
    4. blink_send();
    5. //Aufruf der Funktion zum auslesen von SD
    6. read_SD();
    7. break; //beende case 1
    8. /* Von GUI empfangen*/
    9. case 2:
    10. if (Serial.available()>0)
    11. {
    12. Byte=Serial.read();
    13. if (inByte ==13)
    14. index=0;
    15. memset(&inText[0], 0, sizeof(inText));
    16. }//endif 1
    17. else
    18. if (index < 300)
    19. {
    20. inText[index]= inByte;
    21. index += 1;
    22. }//endif2
    23. //end if (big)
    24. write_SD(inText);
    25. blink_receive();
    26. break; //end switch case2


    Hier liest du das empfangene Byte aus.
    Und lässt es dann testen ob es 1 oder 2 ist.

    Und falls es 2 ist, liest du ein neues Byte aus welches du auf ENTER also 13 überprüfst und der Rest wird gespeichert.

    Dann ist eine nicht sehr logische Abfolge.

    Ich müsste aber deinen VB Code sehen um zu beurteilen woran der Fehler liegt.


    mfg Ebrithil
    Mein Erstes Tutorial: Erweitertes Arduino Tutorial

    Simpler D&D FTP Uploader: Edge-Load
    HI danke für

    ebrithil schrieb:

    Also zu deinem Code:

    Quellcode

    1. inByte = Serial.read(); //lese zeichen au und speichere in chr vom typ char
    2. switch (inByte)
    3. case 1:
    4. blink_send();
    5. //Aufruf der Funktion zum auslesen von SD
    6. read_SD();
    7. break; //beende case 1
    8. /* Von GUI empfangen*/
    9. case 2:
    10. if (Serial.available()>0)
    11. {
    12. Byte=Serial.read();
    13. if (inByte ==13)
    14. index=0;
    15. memset(&inText[0], 0, sizeof(inText));
    16. }//endif 1
    17. else
    18. if (index < 300)
    19. {
    20. inText[index]= inByte;
    21. index += 1;
    22. }//endif2
    23. //end if (big)
    24. write_SD(inText);
    25. blink_receive();
    26. break; //end switch case2


    Hier liest du das empfangene Byte aus.
    Und lässt es dann testen ob es 1 oder 2 ist.

    Und falls es 2 ist, liest du ein neues Byte aus welches du auf ENTER also 13 überprüfst und der Rest wird gespeichert.

    Dann ist eine nicht sehr logische Abfolge.

    Ich müsste aber deinen VB Code sehen um zu beurteilen woran der Fehler liegt.


    mfg Ebrithil
    Danke für deine ANtwort, also mein programm bzw arduino soll durch die 1 bzw 2 erken , ob er der GUI den Inhalt aus der Sd karte senden muss oder ob er von der GUI was empfangen soll.
    zu dem enter-> es ist so gedacht , wenn die zeichenfolge von der GUI komplett gesendet wurde, soll ein Enter mitgesendet werden, damit der Arduino weiß, die Zeichenfolge ist fertig.

    Falls die Kontrollzahl eine 1 ist, soll er von von SD auslesen und an gui senden. Die 1 wird an dem arduino gesendet, wenn ich in meiner GUI den button receive drücke.


    Drücke ich den BUtton senden, wird an dem Arduino eine 2 gesendet und damit weiß er dass er von der GUI zeichen erhält und diese in die SD schreiben muss.



    Hier mein VB.Code zu dem Senden und empfangen meiner GUI:


    Brainfuck-Quellcode

    1. Dim inputdata As String
    2. Dim kontrol_receive As Integer = 1 'kontrolvariable für Empfangen von Arduino
    3. Private Sub Button1_Click_1(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_i2c_receive.Click
    4. RichTextBox1.ForeColor = Color.Black
    5. '/------Kontrollvariale an Arduino =1 , somit weiß er das er an GUI senden soll---/
    6. If Not SerialPort_i2c.IsOpen = True Then
    7. SerialPort_i2c.Open()
    8. End If
    9. SerialPort_i2c.Write(Chr(kontrol_receive)) 'muss in char gekcastet werden ,da arduino diesen in byte umwandelt
    10. 'SerialPort_i2c.Write(kontrol_receive)
    11. '---------------------------------------------------------------------------------/
    12. '/---------Der von dem EventHandler in die Variable gesetzte Text wird an die RTB angehängt------/
    13. RichTextBox1.Text = inputdata
    14. '/-----------------------------------------------------------------------------------------------/
    15. 'If Cmbport_i2c.Text = "" Then
    16. 'MsgBox("Please select COM-Port to read from Arduino ")
    17. 'End If
    18. End Sub
    19. Private Sub DataReceived(ByVal sender As Object, ByVal e As System.IO.Ports.SerialDataReceivedEventArgs) Handles SerialPort_i2c.DataReceived
    20. 'das was an buffer ist wird an variable drangehängt und somit nicht ueberschrieben
    21. inputdata = inputdata & SerialPort_i2c.ReadExisting
    22. End Sub
    23. Private Sub btn_i2c_clear_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_i2c_clear.Click
    24. RichTextBox1.Clear() 'reinige richtextbox
    25. End Sub
    26. Private Sub btn_exit_i2c_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_exit_i2c.Click
    27. Me.Close() ' Me weil das das eigene fesnter ist'
    28. 'Application.Exit() geht auch'
    29. End Sub
    30. Dim kontrol_sende As Integer = 2 'kontrolvariable für Senden an Arduino
    31. Private Sub btn_i2c_send_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_i2c_send.Click
    32. 'Mit try wird versucht Übertragung an Arduino durchzuführen'
    33. Try
    34. 'öffne Serielle Anschlussverbindung, sofern nicht bereits geöffnet'
    35. If Not SerialPort_i2c.IsOpen Then SerialPort_i2c.Open()
    36. SerialPort_i2c.Write(Chr(kontrol_sende))
    37. 'falls Verbindung zum Device besteht, doch es wird auf sendbutton gedrückt und leere Texbox, meldung + verbindung schliessen
    38. If txtbox_i2c.Text = "" Or Cmbport_i2c.Text = "" Then
    39. SerialPort_i2c.Close()
    40. MsgBox("Please check if you select the COM-Port" & vbCrLf & " Please check the input of the command")
    41. Else 'sonst Schreibe / sende Ínhalt der Textbox an Arduino'
    42. SerialPort_i2c.Write(txtbox_i2c.Text) ' durch vbr = Enter, d.h. wenn ein ganzer String wird ein enter gesendet und arduino weiß ok gsnzer String
    43. SerialPort_i2c.Write(vbCrLf)
    44. MsgBox("Transfer successful")
    45. End If
    46. 'Falls Übertragung fehlschlägt, Catch block um fehler auszubügeln und eigene message von vb'
    47. Catch ex As Exception
    48. MsgBox("Transfer failed - Please check the connection" & vbCrLf & ex.Message)
    49. End Try
    50. 'Nach Übertragung Port wieder freistellen'
    51. If SerialPort_i2c.IsOpen = True Then
    52. SerialPort_i2c.Close()
    53. End If
    54. End Sub
    55. Private Sub txtbox_i2c_TextChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles txtbox_i2c.TextChanged
    56. End Sub
    57. Private Sub btn_stop_i2c_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_stop_i2c.Click
    58. If SerialPort_i2c.IsOpen Then
    59. SerialPort_i2c.Close()
    60. End If
    61. End Sub



    Ich hoffe, das problem kann behoben werden bin da so langsam am verzweifeln. Sorry für die codeformatierung.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „milito“ ()

    Du machst ein grosses Durcheinander von deinem Senden und Empfangen Protokoll.

    mache es zB. so:

    Wenn "$" kommt = Arduino sendet.

    Wenn "$" NICHT kommt, heisst es der Arduino soll empfangen. Das beideutet ab diesem Zeitpunkt wird alles aufgenommen bis ein Enter kommt, danach wird der gespeicherte String geparsed. Bzw in deinem Fall auf die SD-Karte geschrieben.



    mfg Ebrithil
    Mein Erstes Tutorial: Erweitertes Arduino Tutorial

    Simpler D&D FTP Uploader: Edge-Load