Ihre eigene Farbsensor mit LEDs

  int LED [3] = {9,10,11}, i, j;  // DECLARE RGB PINS

 Leere setup ()
 {
 
   Serial.begin (9600);
   for (i = 0; i <3; i ++) // set LED-Pins an OUTPUT
   pinMode (LED [i], output);
 }

 Leere Schleife ()
 {
  
   for (j = 0; j <3; j ++) // CYCLE PINS
   {
     for (i = 0; i <255; i ++) // Zykluswerte
     {
 
      analogWrite (LED [j], i);
      Serial.println (1024 analogRead (0));  // PRINT VALUES
      Verzögerung (100);
     }
 analogWrite (LED [j], 0);
 Verzögerung (100);

 }
 }

  importieren processing.serial. *;
 
  Serien myport;  // Die serielle Schnittstelle
  schweben xPos = 20, prevtime = 0;  // Horizontale Position des Graphen
 
  Leere setup () {
  // Stellen Sie die Fenstergröße:
  Größe (1300, 700);        
 
  // Liste alle verfügbaren seriellen Ports
  println (Serial.list ());
  // Ich weiß, dass das erste Tor in der Serienliste auf meinem Mac
  // Ist immer mein Arduino, so dass ich zu öffnen Serial.list () [0].
  // Öffnen was auch immer Port ist der, die Sie verwenden.
  myport = new Serien (this, Serial.list () [1], 9600);
  // Keine serialEvent generate (), wenn Sie einen Zeilenumbruch zu erhalten:
  myPort.bufferUntil ('\ n');
  // Setze inital Hintergrund:
  Hintergrund (255);
  }
  Leere draw () {
  // Alles passiert im serialEvent ()
  }
 
  Leere serialEvent (Serial myport) {
  // Den ASCII-String:
  String inString = myPort.readStringUntil ('\ n');
 
  if (inString! = null) {
  // Schneiden Sie Leerzeichen:
  inString = trim (inString);
  // Konvertieren in einen int und Karte auf dem Bildschirm Höhe:
  schweben InByte = float (inString); 
 
  InByte = map (InByte, 0, 1023, 0, Höhe);
 
  // zeichne die Linie:
  Hub (255,0,0);
  Linie (xPos, Höhe, xPos, Höhe - InByte);

  // Am Rand des Bildschirms, gehen Sie zurück zum Anfang:
  if (xPos> = Breite)
  {
    xPos = 20;
    Hintergrund (255);
  }
  sonst
 xPos + = 0,7;
  }
  }

 / * Color Sensor Code - electro18
 Mehr Details finden Sie über das Projekt unter: http://www.instructables.com/id/Your-Own-Color-Sensor-using-LEDs 
 Dieser Code ist Open-Source und wird von http://www.instructables.com/member/electro18/ erstellt
 Es veranschaulicht die Verwendung von LEDs und LDRs als Farbsensor

 Schritte:

 Legen Sie einen weißen Bildschirm vor dem Sensor
 Schalten Sie den arduino
 Lassen Sie es für eine Weile zu kalibrieren
 Sobald es kalibriert ist, werden die Farben RGB wird in regelmäßigen Abständen blinken
 Die prozentuale Zusammensetzung der bestimmten Farbe auf dem Monitor angezeigt werden serielle
 Öffnen Sie die serielle Monitor für die Fehlersuche ang, um die Werte zu überprüfen 

 * /


 int Sensor MinVal, Val [3], colArray [3] = {9,10,11}, gesamt;

 schweben Prozent [3];

 int i, readRGB [3], readMax [3], Domin;  // Variablen deklarieren

 Lang calibtime, prevtime;  // RECORD die Zeit abgelaufen

 Leere setup ()
 {
  
  Serial.begin (9600); 

    for (i = 0; i <3; i ++)
     {
     pinMode (colArray [i], output);  // Die Ausgangspins SET
     }
    
     kalibrieren ();  // RUN Kalibrieren FUNCTION

 }

 Leere Schleife ()
 {

   Gesamt = 0;

    for (i = 0; i <3; i ++) // Check Werte in einer LOOP
   {
      prevtime = millis ();
      while (millis () - prevtime <1000) // Verzögerung zu vermeiden
      {
        analogWrite (colArray [i], Val [i]);  // Schreiben Sie die kalibrierten Werte
        readRGB [i] = 1024 - analogRead (0);
        Verzögerung (50);                                 
      }
  
   digital (colArray [i], 0);
   
   prevtime = millis ();  // RESET TIME
 
   Gesamt = Gesamt + readRGB [i];
  
   }


   for (i = 0; i <3; i ++)
     {
	 Prozent [i] = readRGB [i] * 100.0 / total;  // PRINT IN FORM VON PROZENT
         Serial.print (Prozent [i]);
	 Serial.print ("%");
     }
    
         Serial.println ("");
         Verzögerung (1000);
 
 }

/////////////////////////////////##############################################################################################////////////
  
   Leere kalibrieren () // CALIBRATE FUNCTION
   {
   
       for (i = 0; i <3; i ++)
       {
          while (millis () - calibtime <1000) // FLASH jeder Farbe AT MAX 1 Sekunde
          {
              analogWrite (colArray [i], 255);
              readMax [i] = 1024 analogRead (0);  // RECORD Max-Werte
          }                                              
   
    analogWrite (colArray [i], 0);
    Serial.println (readMax [i]);
    Verzögerung (10);
   
    calibtime = millis ();
   
  }
   
    if (readMax [0] <readMax [1] && readMax [0] <readMax [2]) // den Minimalwert aus ARRAY ERHALTEN
   
       MINVAL = readMax [0];
     
      sonst 
      {
 
        if (readMax [1] <readMax [0] && readMax [1] <readMax [2])
       
        MINVAL = readMax [1];
      
  
       sonst
    
       MINVAL = readMax [2];
    
    }
  
  
     for (i = 0; i <3; i ++)
   {
  
        analogWrite (colArray [i], 10);
        Sensor = 1024 - analogRead (0);  // Kalibrierung zu starten
        Verzögerung (100);
   
     while (Sensor - MINVAL <= -1 || Sensor - MINVAL> = 1) // Die Differenz zwischen Stromwert und THRESHOLD ERHALTEN
        {
          Sensor = 1024 - analogRead (0);
         
          if (Sensor> MINVAL) // erhöhen oder verringern Sie den Wert, um die Helligkeit EQUALIZE
              Val [i] -;
             
              sonst
              Val [i] ++;
             
              Serial.print (1024 analogRead (0));
              Serial.print ("");
              Serial.println (MINVAL);
   
              Verzögerung (50);
   
              Val [i] = constrain (Val [i], 0,255);  // Schränken den Wert B / W 0 - 255
              analogWrite (colArray [i], Val [i]);
        }
 
  analogWrite (colArray [i], 0);
  Verzögerung (50);
 
  }
 
   }