Arduino steuern per AutoIt-GUI

Hallo. Ich möchte gerne einen Arduino µController per AutoIt GUI steuern. Am Beispiel gezeigt:
Ich habe RGB-LED-Stripes zu Hause. Diese kann man per Steuerung mit einem µController in verschiedenen Farben zum Leuchten bringen. Damit man sie in einer bestimmten Farbe leuchten lässt kann man sie mit RGB-Farben "füttern". Sprich sende ich 255, 255, 255 so leuchtet sie weiß. Diese Farbe möchte ich jetzt z. B. mit drei Schiebereglern in der GUI von AutoIt verändern können. Ich muss ja nun irgendwie ein Kommando über die serielle Schnittstelle versenden können - wie bewerkstellige ich dies?

Über die Seite bin ich bei meiner Suche auch gestolpert. Ich hatte eigentlich gehofft dass igendwo mal etwas anhand von Beispielen gezeigt wird. War bisher aber nicht so. Ich habe mir die UDF mal heruntergeladen und schaue da gleich mal rein. Kannst du mir ggf. schonmal vorab irgendwelchen hilfreichen Tipps auf den Weg geben?

So! Es funktioniert, aber nicht so wie es soll. Ich habe es gerade mal mit dem Example probiert aus dem Forum. Wenn ich nun einen String Sende über das Example per

_CommSendstring

und diesen String am µController empfange, dann setzt der Controller etwas um, aber nicht das, was gesendet wurde. Mein Arduino-Code sieht folgendermaßen aus:

//rgb_led


// NeoPixel Ring simple sketch (c) 2013 Shae Erisson
// released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library
#include <Adafruit_NeoPixel.h>


// Which pin on the Arduino is connected to the NeoPixels?
#define PIN_vorne            9


// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS      6


// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest
// example for more information on possible values.
Adafruit_NeoPixel pixels_vorne = Adafruit_NeoPixel(NUMPIXELS, PIN_vorne, NEO_GRB + NEO_KHZ800);


int incomingByte = 0;   // for incoming serial data


//------------------------------------------------------------------------------------------------
void setup() { //Beginn des Setups
  pixels_vorne.begin(); // This initializes the NeoPixel library.


  //pinMode(rx_signal_pin_throttle, INPUT);
  Serial.begin(9600);    // initalisierung der seriellen Schnittstelle  
}
//------------------------------------------------------------------------------------------------


void loop() {    //hauptschleife
  if (Serial.available() > 0) {
          // read the incoming byte:
    incomingByte = Serial.read();
   }


  pixels_vorne.setPixelColor(1, pixels_vorne.Color(0, incomingByte, 0)); // Hier müsste die Farbe gesetzt werden, die per Serial.read() (dem gesendeten String) gesendet wird.
  pixels_vorne.show(); // This sends the updated pixel color to the hardware.


}

Ich habe die Zeile mal entsprechend kommentiert in der die Farbe der RGB-LED gesetzt wird.

pixels_vorne.setPixelColor(1, pixels_vorne.Color(0, incomingByte, 0));

Setzt die Farbe der LED. Wichtig ist (0, incomingByte, 0), das setzt die Farbe.
Anteile Rot: 0
Anteile grün: Wird aus dem serial.read() gelesen
Anteile blau: 0

Wenn ich nun also über den Example-Sketch 255 sende, sollte die grüne LED mit voller Leuchtkraft leuchten. Sie glimmt aber nur etwas. Per serial.read() wird also irgendwas empfangen, aber nicht die 255 die ich gesendet habe. Wieso nicht?

Okay, gut zu wissen. Allerdings wäre es dann nett von dir, wenn du zu deinem Ansatz nochmal etwas sagen könntest. Dein Beispiel verstehe ich nicht. Wie kann ich darüber z. B. den String "255" senden sodass er von serial.read() auch als "255" gelesen wird?

Danke für eure ganzen Lösungsansätze. In abgewandelter Form funktioniert die Vorlage von Kilroy schon sehr gut.

@Kilroy: Ich habe dir bereits eine private Nachricht geschrieben, weil ich noch Fragen zu deinem Arduino-Sketch habe. Ich bräuchte da bitte eine kurze Erläuterung zu

Okay. Ich dachte halt da es auch Arduinotechnischer Natur ist klären wir das lieber privat.

Also, das hier ist dein Code:

const int rot = 6; // analog Pin 6
const int gruen = 5; // analog Pin 5
const int blau = 3; // analog Pin 3
void setup() {  
  pinMode(rot, OUTPUT); // OUTPUT
  pinMode(gruen, OUTPUT); // OUTPUT
  pinMode(blau, OUTPUT); // OUTPUT
  Serial.begin(9600); // Serial.begin
}
/* 
    Was passiert:


    AutoIT Schickt erst den Buchstaben dann den Wert.


    Ablauf ---->
    - AutoIT schickt Wert -> Daten empfangen Serial also größer 0
    - wenn gelesener Byte = R -> case 'R'
    - keine Datenempfangen Serial kleiner 1
    - while -> warte da keine Empfangen werden ist kleiner 1
    - AutoIt schickt Wert -> 0-255
    - Daten werden Empfangen also größer 1 -> While weiter
    - analogWrite Wert
    - break -> raus aus dem case
*/
void loop() {
  if (Serial.available() > 0) { // werden Daten empfangen?
    switch(Serial.read()) { // Serial auslesen + Switch  
      case 'R': // wenn R dann
        while (Serial.available() < 1) ;
        analogWrite(rot, Serial.read()); // analogWrite Serial.
        break;
      case 'G': // wenn R dann
        while (Serial.available() < 1) ;
        analogWrite(gruen,  Serial.read());
        break;
      case 'B': // wenn R dann
        while (Serial.available() < 1) ;
        analogWrite(blau,  Serial.read());
        break;
    }
  }
}

Per Autoit schickst du ja erst den Buchstaben für die Farbe, und dann den Wert hinterher. Solange du den Schieber für eine Farbe betätigt wird, wird quasi immer abwechselnd z. B. "R" "125" "R" "125" "R" "125" gesendet. Im Arduinocode fragst du diesen Strom nun ab, soweit klar. Mit deinem switch(Serial.read()) { fragst du ja quasi den seriellen Strom ab. Was genau wird denn hier abgefragt, immer das erste Byte welches gerade gesendet wurde, also quasi erst das Kürzel für Farbe? Und sofern gerade "G" gesendet wurde, greift die entsprechende Case-Anweisung. Dort machst du dann das nächste Serial.Read: analogWrite(rot, Serial.read());
Liest das dann das nächste Byte im Datenstrom? Also das Byte, welches den Wert "125" enthält? Oder ist es Zufall welches Byte gelesen wird? Oder anders gefragt: Wenn ich alle Bytes eines seriellen Datenstroms auslesen möchte, muss ich dann für jedes Byte ein separates serial.read(); machen?

Alles klar, danke dir. Das hilft mir weiter