Yes, we can! 

Sorry,das musste jetzt sein.

Aus meiner Modellbauzeit weiß ich das ich analog und digital Servos mischen konnte.
Also müßten die Signame vom Empfänger zu Servo gleich sein.

Hallo,
zunächst mal kann ich nur empfehlen den Beispielcode aus der Lib zu nehmen.
den receive, der zeigt die alles an was von der Touchosc kommt.
Egal was du da in die oberfläche gebaut hast.
so habe ich das auch gemacht.
Man kann soweit ich das jetzt im Kopf habe folgendes auslesen:
Die IP des senders
die adresse des Buttons/Reglers das ist die /1/xxx standartmäßig.
die erste ziffer steht für die erste Seite man kann ja mehrere erstellen.
danach folgt in der regel der name des Objekts.
z.B. /1/Fader_blue
Bei dieser Matrix kommt danach noch die Position also so /1/matrix/1/3
und dann kommt noch ein Value also ein wert.
Ich meine der kommt immer in float aber wenn du dort was hin schickst, so habe ich das zumindest im gefühl ist string irgendwie besser.

Das string blue="/1/blue" mache ich nur vorher weil ich (durch fehlende c kenntnisse) nicht wußte wie ich die strings vergleiche und es ging eben nur wenn ich vorher meinen wert in eine variable stecke und dann zwei variablen vergleiche als eine variable mit einen string direkt zu vergleichen.


Danke jomelo für den Tip!
Das reicht mir so und werdendas einbauen.

Gruß
Thorsten

Ich schon wieder  
Ich wollte zum einen mal die Designs hoch laden damit man das besser testen kann und zum anderen habe ich eine frege:
Ich habe ja für jede Farbe und jede Led einen Wert gespeichert:
int valueBlue[64]   ={0,0,0,0,...}
int valueRed[64]    ={0,0,0,0,...}
int valueGreen[64]  ={0,0,0,0,...}
Gibt es ein Kommando um die Werte alle auf einmal zurück zu setzen?
Weil mir ist aufgefallen das ich zwar mit clear mein Arduino wieder dunkel mache aber die Werte sind ja noch da.
Heiß, drücke ich erneut auf eine Position wird dieser zustand wieder hergestellt.
Sowas wie:
valueRed[].clear

Danke schon mal...



PS:
Hier noch mal eine Erweiterung mit drei Fadern die sich je nach ausgewählter Position einstellen. Schneller ist es dadurch aber nicht geworden.
In dem rainbow-Tab hat sich nichts geändert!

Code:

#include <SPI.h>
#include <Ethernet.h> // version IDE 0022
#include <Z_OSC.h>
#include <Wire.h>

// Krams für die Netzwerkverbindung
byte myMac[] = { 0xDE, 0xAD, 0xBE, 0xFE, 0xFE, 0xED };
byte myIp[]  = { 192, 168, 1, 4 };
int  serverPort  = 8000;
byte gateway[] = { 192, 168, 1, 1 };    // ROUTER
byte subnet[] = {255, 255, 255, 0 };    // SUBNET
byte destIp[] =  { 192, 168, 1, 3 };
int  destPort = 9000;

// Ein paar Variablen
uint16_t i;
float floatValue;
boolean ifPos;
int Pos;
int xPos;
int yPos;
char adresse[10];
String blue = "/1/blue";
String red = "/1/red";
String green = "/1/green";
String touchPos = "/1/pos/";
String loeschen = "/1/clear";
// Datenspeicher für jede Farbe an jedem Ort
int valueBlue[64]   ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int valueRed[64]    ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int valueGreen[64]  ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

// OSC-Kram initialisieren
Z_OSCServer server;
Z_OSCMessage *rcvMes;
Z_OSCClient client;

// Setup-Routine
void setup(){
//Serial.begin(19200);
  Serial.println();
  Serial.print("init LAN");
  Ethernet.begin(myMac ,myIp);
  server.sockOpen(serverPort);
  Serial.println(" <-OK");
// Rainbowduino löschen
  setupRainbow(); // rainbow initialisieren
}

// Loop schleife
void loop(){
  if(server.available()){
    rcvMes=server.getMessage();
      for(i=0 ; i<rcvMes->getArgsNum(); i++){
        switch( rcvMes->getTypeTag(i) ){
          case 'f':       
            floatValue = rcvMes->getFloat(i);
            String adress = rcvMes->getZ_OSCAddress();
            // #################### Ist auf die Matrix gedrueckt worden? ############################
            if(adress.startsWith("/1/pos")){
              Pos = (adress.charAt(7)-48)+((adress.charAt(9)-48)*8-8)-1; // Position  auslesen
              xPos =adress.charAt(7)-48;
              yPos = adress.charAt(9)-48;
              adress.toCharArray(adresse,11);
              Z_OSCMessage posMessage; 
              posMessage.setAddress(destIp,destPort);
              Z_OSCMessage redMessage; 
              redMessage.setAddress(destIp,destPort);
              Z_OSCMessage blueMessage; 
              blueMessage.setAddress(destIp,destPort);
              Z_OSCMessage greenMessage; 
              greenMessage.setAddress(destIp,destPort);
              if (floatValue==1){
                char buffer[10];
                posMessage.setZ_OSCMessage(adresse , "s" ,"1");
                blueMessage.setZ_OSCMessage("/1/blue" , "s" ,itoa(valueBlue[Pos],buffer,10));
                redMessage.setZ_OSCMessage("/1/red" , "s" ,itoa(valueRed[Pos],buffer,10));
                greenMessage.setZ_OSCMessage("/1/green" , "s" ,itoa(valueGreen[Pos],buffer,10));
                ifPos = 1;
                Serial.println((float)valueBlue[Pos]);
                Serial.println((float)valueRed[Pos]);
                Serial.println((float)valueGreen[Pos]);
              }
              if (floatValue==0) {
                posMessage.setZ_OSCMessage(adresse , "s" ,"0");
                blueMessage.setZ_OSCMessage("/1/blue" , "s" ,"0");
                redMessage.setZ_OSCMessage("/1/red" , "s" ,"0");
                greenMessage.setZ_OSCMessage("/1/green" , "s" ,"0");
                ifPos =0;
              }
              client.send(&posMessage);
              posMessage.flush();
              client.send(&redMessage);
              redMessage.flush();
              client.send(&blueMessage);
              blueMessage.flush();
              client.send(&greenMessage);
              greenMessage.flush();   
            }
            if (ifPos == 1){
             
              Serial.println(blue);
              if(adress.startsWith("/1/blue")){
                valueBlue[Pos] = (int)floatValue;
               
              }
              if(adress.startsWith("/1/red")){
               valueRed[Pos] = (int)floatValue;
               
              }
              if(adress.startsWith("/1/green")){
                valueGreen[Pos]= (int)floatValue;
               
              }
        setRainbow();
        Serial.print ("Position: ");
        Serial.print (Pos);
        Serial.print ("\t Blau: ");
        Serial.print (valueBlue[Pos]);
        Serial.print ("\t Rot: ");
        Serial.print (valueRed[Pos]);
        Serial.print ("\t Gruen: ");
        Serial.print (valueGreen[Pos]);
        Serial.print ("\t Value: ");
        Serial.print ((int)floatValue);
        Serial.print ("\t Adresse: ");
        Serial.println (rcvMes->getZ_OSCAddress());
           }
           if(loeschen==rcvMes->getZ_OSCAddress()){
           Serial.print("clear");
             if (floatValue== 1.0)  setupRainbow();
           }
           break;
      }
    }
  }   
}

Update:
Ich habe mal ein wenig weiter rum gebastelt und es nun auch geschafft Daten an das iPad zu senden.
Bei meinem Versuchsaufbau ist bei dem Multi-Toggle das locale feedback ausgeschaltet und wird vom Arduino übernommen.

Naja und den rest kann man im Video sehen:




Hier auch wieder der Code:

Code:

#include <SPI.h>
#include <Ethernet.h> // version IDE 0022
#include <Z_OSC.h>
#include <Wire.h>

// Krams für die Netzwerkverbindung
byte myMac[] = { 0xDE, 0xAD, 0xBE, 0xFE, 0xFE, 0xED };
byte myIp[]  = { 192, 168, 1, 4 };
int  serverPort  = 8000;
byte gateway[] = { 192, 168, 1, 1 };    // ROUTER
byte subnet[] = {255, 255, 255, 0 };    // SUBNET
byte destIp[] =  { 192, 168, 1, 3 };
int  destPort = 9000;

// Ein paar Variablen
uint16_t i;
float floatValue;
boolean ifPos;
int Pos;
int xPos;
int yPos;
char adresse[10];
String blue = "/1/encoder_blue";
String red = "/1/encoder_red";
String green = "/1/encoder_green";
String touchPos = "/1/pos/";
String loeschen = "/1/clear";
// Datenspeicher für jede Farbe an jedem Ort
int valueBlue[64]   ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int valueRed[64]    ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int valueGreen[64]  ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

// OSC-Kram initialisieren
Z_OSCServer server;
Z_OSCMessage *rcvMes;
Z_OSCClient client;

// Setup-Routine
void setup(){
//Serial.begin(19200);
  Serial.println();
  Serial.print("init LAN");
  Ethernet.begin(myMac ,myIp);
  server.sockOpen(serverPort);
  Serial.println(" <-OK");
// Rainbowduino löschen
  setupRainbow();
}

// Loop schleife
void loop(){
  if(server.available()){
    rcvMes=server.getMessage();
      for(i=0 ; i<rcvMes->getArgsNum(); i++){
        switch( rcvMes->getTypeTag(i) ){
          case 'f':        
            floatValue = rcvMes->getFloat(i);
            String adress = rcvMes->getZ_OSCAddress();
            //  Ist auf die Matrix gedrueckt worden?
            if(adress.startsWith("/1/pos")){
              Pos = (adress.charAt(7)-48)+((adress.charAt(9)-48)*8-8)-1; // Position  auslesen
              xPos =adress.charAt(7)-48;
              yPos = adress.charAt(9)-48;
              adress.toCharArray(adresse,11);
              Z_OSCMessage message;  
              message.setAddress(destIp,destPort);
              if (floatValue==1){
                message.setZ_OSCMessage(adresse , "s" ,"1");
                ifPos = 1;
              }
              if (floatValue==0) {
                message.setZ_OSCMessage(adresse , "s" ,"0");
                ifPos =0;
              }
              client.send(&message);
              message.flush();  
            }
            if (ifPos == 1){
              if(blue==rcvMes->getZ_OSCAddress()){
                if (floatValue==1.0)  if (valueBlue[Pos]<15)valueBlue[Pos]++; setRainbow();
                if (floatValue==-1.0)  if (valueBlue[Pos]>0)valueBlue[Pos]--; setRainbow();
              }
              if(red==rcvMes->getZ_OSCAddress()){
                if (floatValue== 1.0)  if (valueRed[Pos]<15)valueRed[Pos]++; setRainbow();
                if (floatValue==-1.0)  if (valueRed[Pos]>0)valueRed[Pos]--; setRainbow();
              }
              if(green==rcvMes->getZ_OSCAddress()){
                if (floatValue== 1.0)  if (valueGreen[Pos]<15)valueGreen[Pos]++; setRainbow();
                if (floatValue==-1.0)  if (valueGreen[Pos]>0)valueGreen[Pos]--; setRainbow();
              }
        
      //  Serial.print ("Position: ");
      //  Serial.print (Pos);
      //  Serial.print ("\t Blau: ");
      //  Serial.print (valueBlue[Pos]);
      //  Serial.print ("\t Rot: ");
      //  Serial.print (valueRed[Pos]);
      //  Serial.print ("\t Gruen ");
      //  Serial.println (valueGreen[Pos]);
           }
           if(loeschen==rcvMes->getZ_OSCAddress()){
      //     Serial.print("clear");
             if (floatValue== 1.0)  setupRainbow();
           }
           break;
      }
    }
  }    
}

Für den Rainbowduino:

Code:

#include <stdio.h>
#include <avr/pgmspace.h>


//  Befehlsstruktur definieren
#ifndef WireCommands_h
#define WireCommands_h
#define MAX_WIRE_CMD          0x80
#define CMD_NOP               0x00
#define CMD_SWAP_BUF          0x10
#define CMD_COPY_FRONT_BUF    0x11
#define CMD_SHOW_AUX_BUF      0x12
#define CMD_CLEAR_BUF         0x20
#define CMD_SET_PAPER         0x21
#define CMD_SET_INK           0x22
#define CMD_CLEAR_PAPER       0x25
#define CMD_DRAW_PIXEL        0x26
#define CMD_DRAW_LINE         0x27
#define CMD_DRAW_SQUARE       0x28
#define CMD_PRINT_CHAR        0x2A
#define CMD_DRAW_ROW_MASK     0x2B
extern unsigned char CMD_totalArgs[MAX_WIRE_CMD];
#endif
// Argumentenanzahl für jeden Befehl speichern
unsigned char CMD_totalArgs[MAX_WIRE_CMD] PROGMEM = {
//  0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - A - B - C - D - E - F
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,    // 0 - 0x00 -> 0x0F
    0,  2,  1,  2,  1,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,    // 1 - 0x10 -> 0x1F
    3,  3,  3,  0,  0,  0,  2,  4,  4,  0,  3,  3,  0,  0,  0,  0,    // 2 - 0x00 -> 0x2F
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,    // 3 - 0x00 -> 0x3F
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,    // 4 - 0x00 -> 0x4F
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,    // 5 - 0x50 -> 0x5F
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,    // 6 - 0x60 -> 0x6F
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0     // 7 - 0x70 -> 0x7F
//  0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - A - B - C - D - E - F
};
//  sendCMD deklarieren
void sendCMD(byte address, byte CMD, ... );
// Krams vorbereiten (fest)
unsigned char RainbowCMD[20];
unsigned char State = 0;  
unsigned long timeout;
byte remoteAddr = 0x10;


void setupRainbow() {
  Serial.print("init Rainbow");
  RainbowCMD[0] = 'r';                              // Keine Ahnung
  sendCMD(0x10, CMD_SET_PAPER, 0, 0, 0);            // Inhalte löschen
  sendCMD(0x10, CMD_SET_INK, 0xF, 0xF, 0xF);
  sendCMD(0x10, CMD_CLEAR_PAPER);
  sendCMD(0x10, CMD_SWAP_BUF);
  sendCMD(0x10, CMD_CLEAR_PAPER);
  Serial.println(" <- OK");
 
}


// ############################### setRainbow ##############################
void setRainbow(){
  sendCMD(0x10, CMD_COPY_FRONT_BUF);
  sendCMD(0x10, CMD_SET_INK, valueRed[Pos], valueGreen[Pos], valueBlue[Pos]);
  sendCMD(0x10, CMD_DRAW_PIXEL,toByte(xPos-1),toByte(yPos-1));  
  sendCMD(0x10, CMD_SWAP_BUF);
}





// ############################ Funktionen ###################################

unsigned char toByte(int i) {
  return map(i, -128, 127, 0, 255);
}



void sendCMD(byte address, byte CMD, ... ) {
  int i;
  unsigned char v;
  byte t;
  va_list args;                     // Create a variable argument list
  va_start(args, CMD);              // Initialize the list using the pointer of the variable next to CMD;
  
  RainbowCMD[1] = CMD;              // Stores the command name
  t = pgm_read_byte(&(CMD_totalArgs[CMD]))+2;  // Retrieve the number of arguments for the command
  for (i=2; i < t; i++) {
    v = va_arg(args, int);          // Retrieve the argument from the va_list    
    RainbowCMD[i] = v;              // Store the argument
  }
  
  sendWireCommand(address, t);      
}

void sendWireCommand(int Add, byte len) {
  unsigned char OK=0;
  unsigned char i,temp;
  
  while(!OK)
  {  
    switch (State)
    {
    case 0:                          
      Wire.beginTransmission(Add);
      for (i=0; i<len ;i++) Wire.send(RainbowCMD[i]);
      Wire.endTransmission();    
      delay(5);  
      State=1;                      
      break;
    case 1:
      Wire.requestFrom(Add,1);  
      if (Wire.available()>0)
        temp=Wire.receive();    
      else {
        temp=0xFF;
        timeout++;
      }
      if ((temp==1)||(temp==2)) State=2;
      else if (temp==0) State=0;
    
      if (timeout>10) {   // war 5000
      Serial.print("Rainbow-TimeOut");
        timeout=0;
        State=2;
      }
      delay(5);
      break;
    case 2:
      OK=1;
      State=0;
      timeout=0;
      break;
    default:
      State=0;
      break;
    }
  }
}

Der code ist sicher ausbaufähig aber vielleicht hilft es ja schon jemanden.



Edit:
Negativ bei meinem Aufbau:
Die Encoder senden solange man dreht auch Signale raus, auch wenn die Farbe z.B. voll an ist.
Es wird zwar dann nichts ausgewertet aber solange kann nichts neues gemacht werden.
Verhindern könnte man das nur durch Schieberegler oder Drehregler mit absoluter Position.
Dann müsste man allerdings die Regler bei einer neuen Position erst setzen.
Vielleicht probiere ich das mal aus.

Ich habe mal wieder ein bisschen rum gespielt und wollte mein Ergebnis hier mal bekannt geben.
Für die, die es interessiert:
Ich wollte mal meinen Arduino über iPad/iPhone steuern aber ohne das ein PC laufen muss.
Da ich zunächst nichts gefunden hatte habe ich MIT processing meine ersten Versuche gemacht.
Dann habe ich aber adrOSC gefunden.
Dies lief leider nicht (zumindest habe ich es nicht ans laufen bekommen).
Dann habe ich Z_OSC gefunden (hier im PlayGround) http://www.arduino.cc/playground/Interfacing/MaxMSP ganz unten!

Hier hatte ich mehr erfolg!
Ein kleines Video:

Das sieht ja schon mal garnicht so schlecht aus  

Hier der Bastel-Code:

Code:

#include <SPI.h>
#include <Ethernet.h> // version IDE 0022
#include <Z_OSC.h>

byte myMac[] = { 0xDE, 0xAD, 0xBE, 0xFE, 0xFE, 0xED };
byte myIp[]  = { 192, 168, 1, 4 };
int  serverPort  = 8000;
byte gateway[] = { 192, 168, 1, 1 };    // ROUTER
byte subnet[] = {255, 255, 255, 0 };    // SUBNET
  

uint16_t i;
float floatValue;
Z_OSCServer server;
Z_OSCMessage *rcvMes;

void setup(){
 //Serial.begin(19200);
 Ethernet.begin(myMac ,myIp);
 server.sockOpen(serverPort);
 //Serial.println("init");
 
 pinMode(3, OUTPUT);
 pinMode(5, OUTPUT);
 pinMode(6, OUTPUT);
 analogWrite(3,254);
  analogWrite(5,254);
   analogWrite(6,254);
}
  
void loop(){
 if(server.available()){
   Serial.println("empfang");
   rcvMes=server.getMessage();
  
   for(i=0 ; i<rcvMes->getArgsNum(); i++){
     switch( rcvMes->getTypeTag(i) ){
       case 'f':        
         floatValue = rcvMes->getFloat(i);
          
          
          String blue = "/1/blue";
          String red = "/1/red";
          String green = "/1/green";
         if(blue==rcvMes->getZ_OSCAddress()){
           analogWrite(3,floatValue);
         }
          if(red==rcvMes->getZ_OSCAddress()){
           analogWrite(6,floatValue);
         }
         if(green==rcvMes->getZ_OSCAddress()){
          analogWrite(5,floatValue);
        }
        
       break;
     }
   }
  
 }    
}
  

Jetzt will ich mal schauen ob ich damit mal was anstelle was auch Sinn macht.

Soviel erstmal dazu!

Gruß
Thorsten

Hab zwar keine Ahnung aber 15 € find ich jetzt mal ein bissel zu viel.

Was ist denn mit sowas:
http://www.reichelt.de/ICs-LM-LS-/LM-1086-IT3-3/index.html?ACTION=3&GROUPID=2912&ARTICLE=39425&SHOW=1&START=0&OFFSET=100&;PROVID=2402

oder der:
http://www.reichelt.de/ICs-KA-LF-/LF-33-CV/index.html?ACTION=3&GROUPID=2911&ARTICLE=39414&SHOW=1&START=0&OFFSET=100&;PROVID=2402

Das Ding bei Conrad für 13,38€ hat 7A Ausgangsstrom, wer braucht das? 

Das ist richtig.
Die Frage ist wie wichtig ist das?
Ich sag mal beim Aquarium sollte natürlich das Licht in der Zeit wo es an sein sollte auch so lange wie möglich an sein.
Aber mal angenommen es ist nur eine Anwesenheitssimulation dann ist es nicht so tragisch obs mal etwas länger aus ist wie geplant.

Es ist aber eben auch eine Frage der Ansteuerung.
Wenn du sehen kannst obs gerade an ist und es auch an sein sollte kannst du nach einem reset den Status wieder anpassen.
Kannst du das nicht und es ist auch nicht so tragisch wäre mir das erstmal egal und wenn der nächste Schaltzeitpunkt kommt schalte ich einfach in den gewünschten Zustand egal was vorher war.

Hängt halt von den Anforderungen ab.
Und war auch nur ein Gedanke der mir so durch den Kopf geschossen ist.

Noch ein kleines Beispiel:
Rollos. Die Zeituhren fahren um z.B. um 18 Uhr runter egal ob du um 17:45 das schon von Hand getan hast.
Das meinte ich damit.

Gruß
Thorsten

Ich sag nur:
ACHTUNG: bssst, tot!!!
230V sind nicht lustig.

Hallo zusammen,
ich würde es noch etwas anders machen.
Bei den gewünschten Zeiten würde ich mit angeben ob die Zeit zum ein oder zum ausschalten ist.
also 23:00 1 = um 23 Uhr einschalten
und 01:00 0 = um 1 uhr ausschalten
Dann ist es dem System auch egal wann es aktiviert wird (reset zb).
Ich meine das machen auch gekaufte Schaltuhren zum Teil so.

Wenn 1 uhr ist dann wird abgeschaltet weil ich um 1 das Licht aus haben will und nicht weil irgendwann es angegangen ist.
Ist besonders dann wichtig wenn zB nur ein Funksignal an eine Funksteckdose geschickt wird weil ich da ja garnicht weiß ob das Licht gerade an ist oder nicht. Ich weiß aber das ich es aus haben will!

Denke ich zumindest... 

Ich kann dir zwar nicht sagen warum der Text nicht ausgegeben wird aber eins ist mir beim überfliegen aufgefallen.
Du verwendest delays mit 20 sek.
Du weißt schon das in der Zeit nichts mehr anderes geht?
Das Programm bleibt für diese Zeit stehen!

Nur zur Info

Nur im Hauptsketch!
Soweit ich weiß werden in den anderen Sketches nur die benötigten Funktinen ausgelagert.

Aber genau können dir das nur die Profis sagen!

Gruß
Thorsten

bin delber noch nicht so lange dabei aber ich könnte mir vorstellen das du das folgendermaßen hin bekommst:

Code:

sensorValue = analogRead(sensorPin[i]);
if( sensorValue >= PIEZOTHRESHOLD ) {
digitalWrite(ledPin[i],HIGH);  // indicate we're sending MIDI data
Serial.print(i);
Serial.print(",");
Serial.print(sensorValue);
Serial.println();
digitalWrite(ledPin[1],LOW);
}

Du müßtest nur sensorpin und ledpin auch zu arrays machen
so hast du aber nur noch eine if die entsprechend der pads-anzahl aufgerufen wird

ich hoffe ich liege nicht falsch.....

Gruß
Thorsten

Danke für deine Ausführungen!

Mit der Spannung habe ich eigentlich keine Probleme!
Ich bin in der Ausbildung zwar nur auf 60V geeicht worden aber auch 230V haben mich bis jetzt nicht umhauen können.
Würde es aber auch nicht darauf ankommen lasen wenn ich es vermeiden kann.

Ich hatte das ganze über ein DOS-Programm schon an einem Laptop laufen.
Hier habe ich über den Parallelport Transistoren geschaltet die dann Relais für die 230V betätigt haben.
Lief auch eine Zeit lang auf kleineren Partys.
Das VB-Programm sollte die weiterentwiklung sein.

Aber wie gesagt soweit ist es nie gekommen.

Die anzahl der PWM Kanäle währe nicht das Problem da eine aufteilung auf zwei MC oder sogar mehr garnicht schlächt gewesen währe um es flexiebler zu machen beim Partyaufbau.

Trotzdem Danke für die Infos

Hallo zusammen,
kurz die Vorgeschichte:
Ich habe vor langer Zeit mal in VB eine Lichtsteuerung programmiert. Die lief auch soweit ganz gut, zumindest auf dem Monitor.
Es gab nie eine entsprechende Hardware nichtmal kleine Spannungsabfälle.
Es gab dabei zwei Probleme:
1. Nicht genug Ahnung dafür
2. Wer braucht so was schon in seinem damals noch Kinder bzw. Jugendzimmer?

Problem 2 besteht immer noch, dennoch würde ich gerne mal wissen ob und wenn ja wie man so was hätte umsetzten können.

Folgende Vorraussetzungen brachte die software mit:
8 Kanal Lichtorgel mit vielen Programmen (an/aus nicht dimmbar)
8 Zusatzkanäle einzeln schaltbar

Es wurde noch nichts ausgegeben. Es wurde nur eine Routine gestartet in der ich hätte Programmieren können was wo wie ausgegeben wird.
Da ja keine Hardware da war hatte ich da nicht weiter gemacht.

Wenn auch noch ein Sinn da hinter gesteckt hätte, hätte ich auch noch mal alles neu geschrieben mit Dimmfunktion.
Aber das habe ich dann auch bleiben lassen.

Währe das ein Großes Problem gewesen?
Ich sach mal mit arduino - optokopplern - triac - usb - seriel was weiß ich was die 220V Verbraucher zu schalten?

Und was währe es für ein aufwand dies auch noch dimmbar zu machen?


Wie gesagt ist rein theoretisch.

Gruß
MueThoS