Sitop_pse200u


Google-Suche auf MEINE-SCHALTUNG.de :





Online Rechner

Chronik

Dauerkalender


Die magische Matrix und der Zauberknopf

Mit lediglich einer RGB-Matrix, Arduino und einigen wenigen elektronischen Bauteilen kann man eine interessante Schaltung zusammenstellen. Eine Schaltung, die Gedanken lesen kann. Das Prinzip ist einfach, das Ergebnis verblüffend.

Es geht so:
Man aktiviert zunächst die Matrix, die aus 64 Leuchtdioden besteht. Jede Leuchtdiode leuchtet mit einer via Zufall zugeordneten Farbe. Die möglichen Farben sind: Rot, Blau, Gelb, Weiß, Pink und Grün.
Anschließend denke man sich eine zweistellige Zahl, die kleiner als 80 ist. Von der Zahl wird dann die Quersumme, die durch Addition der beiden Ziffern gebildet wird, abgezogen. Die Ergebniszahl stellt die Nummer der Leuchtdiode auf der Matrix, derer Farbe durch „Gedanken Lesen“ die Schaltung erraten soll, dar.
Durch Betätigen des Zauberknopfs werden die „magischen“ Vorgänge gestartet und schließlich die gesuchte Farbe auf der Matrix angezeigt.

Beispiel:
Die gedachte Zahl ist 64.
Die Ergebniszahl beträgt dann: 64 – (6+4) = 64 – 10 = 54.

RGB-Matrix 8x8

RGB Matrix 8x8

RGB Matrix 8x8 (CJMCU)

Arduino Uno

Arduino Uno

Arduino Uno

Arduino


Spannungsregler

Spannungsregler

Spannungsregler mit LM2596 und 7-Segment-Anzeige.

Spannungsregler mit LM2596


Der Schaltplan

Schaltplan

Schaltplan

Der Schalter S1 besteht in dieser Ausführung aus zwei Schließern. Der erste Schließer ist mit dem digitalen Eingang D12 des Arduino verbunden und wird im Programm für die Umschaltung der Betriebsarten verwendet. Der zweite Schließer mit dem Kondensator C2 und den Widerständen R2 und R3 stellt eine Erweiterung für den Zufallsgenerator dar.
Mit der Funktion „random()“ wird eine Zufallszahl generiert, beim Programmstart jedoch immer die gleiche. Um jeweils andere Zufallszahlen zu bekommen, benötigt die Funktion „random()“ einen Startwert, der bei jedem Start einen anderen Wert annimmt. Dazu kann ein analoger Eingang (hier A0) benutzt werden, an dem sich das Potenzial ständig ändert. Bei jeder Betätigung des Tasters S1 wird der Kondensator ein wenig aufgeladen. Da die Dauer der Betätigung jeweils anders ist, baut sich auf dem Kondensator jeweils ein anderes Potenzial auf. Der Wert der Spannung wird im Programm ausgelesen und als Startwert für die „random()“-Funktion verwendet. Die Zuordnung des Startwertes wird mit der Funktion „randomSeed()“ realisiert.

Das Programm (Sketch)

// *****************************************************************************************
// Die magische Matrix mit dem Zauberknopf
// Arduino UNO mit 8x8 RGB-Matrix
// IDE 1.8.16
// *****************************************************************************************
#include <Adafruit_NeoPixel.h>                               // Bibliothek Adafruit_NeoPixel

#define LED_PIN    7
#define LED_COUNT 64

Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

int Zauberknopf = 12;                                        // Ergebnis - Taster
int Pixel;                                                   // Pixel-Nummer 0 bis 63
int Wartezeit;
int Farbe_Nr;                                                // Aktuelle Pixelfarbe
int Gesuchte_Farbe;    
bool Umschaltung;                                            // 0-Start, 1-Lösung              

int Matrix_64 [] = {  0,  1,  2,  3,  4,  5,  6,  7,         // Matrix 8x8
                      8,  9, 10, 11, 12, 13, 14, 15,
                     16, 17, 18, 19, 20, 21, 22, 23,
                     24, 25, 26, 27, 28, 29, 30, 31,
                     32, 33, 34, 35, 36, 37, 38, 39,
                     40, 41, 42, 43, 44, 45, 46, 47,
                     48, 49, 50, 51, 52, 53, 54, 55,
                     56, 57, 58, 59, 60, 61, 62, 63 };
int Matrix_36 [] = {  9, 10, 11, 12, 13, 14,                  // Matrix 7x7 
                     17, 18, 19, 20, 21, 22, 
                     25, 26, 27, 28, 29, 30, 
                     33, 34, 35, 36, 37, 38, 
                     41, 42, 43, 44, 45, 46, 
                     49, 50, 51, 52, 53, 54 };  
int Matrix_16 [] = { 18, 19, 20, 21,                          // Matrix 6x6
                     26, 27, 28, 29, 
                     34, 35, 36, 37, 
                     42, 43, 44, 45 };
int Matrix_4 [] =  { 27, 28, 35, 36 };                        // Matrix 4x4
int Geheimnis_Zahlen [] = { 8, 17, 26, 35, 44, 53, 62 };      // "Magische" Felder (-1)

void setup() {                                                // SetUp
    pinMode (Zauberknopf, INPUT_PULLUP);
 
    strip.begin();           
    strip.show();            
    strip.setBrightness(20); 
}

void loop() {                                                 // Hauptprogramm
    if ((digitalRead(Zauberknopf) == LOW) && !Umschaltung) {  // Start
        strip.clear();
        LED_show(4, 100);
        randomSeed(analogRead(A0));
        LED_show(16, 200);
        LED_show(36, 400);
        LED_show(64, 600);
        Gesuchte_Farbe = Farbe_Nr;                            // Gesuchte Farbe festgelegt
        for (int i = 0; i < 7; i++) {
            Pixel = Geheimnis_Zahlen [i];
            Farben (Gesuchte_Farbe);                          // "Magische" Felder werden belegt
        }
        Umschaltung = true;
    }
    if ((digitalRead(Zauberknopf) == LOW) && Umschaltung) {   // Lösung start
        LED_show(64, 600);
        strip.clear();
        LED_show(36, 400);
        strip.clear();
        LED_show(16, 200);
        strip.clear();
        LED_show(4, 100);
        for (int i = 0; i < 4; i++) {                         // Ergebnis Anzeige
            Pixel = Matrix_4 [i];
            Farben (Gesuchte_Farbe);
        }
        Umschaltung = false;
    }
}

void LED_show (int Menge, int Schleife) {                     // Blinkende Pixel via Zufall
                                                              // bestimmen
    for (int i = 1; i < Schleife; i++) {
        switch (Menge) {
            case 4:  { int Zufall = random (0,4);             // Matrix 2x2
                       Pixel = Matrix_4 [Zufall];
                       Wartezeit = 12; 
                       break; } 
            case 16: { int Zufall = random (0,16);             // Matrix 4x4
                       Pixel = Matrix_16 [Zufall];
                       Wartezeit = 8;
                       break; }
            case 36: { int Zufall = random (0,36);             // Matrix 6x6
                       Pixel = Matrix_36 [Zufall];
                       Wartezeit = 4;
                       break; }
            case 64: { int Zufall = random (0,64);             // Matrix 8x8
                       Pixel = Matrix_64 [Zufall];
                       Wartezeit = 1;
                       break; }                       
        }
        Farbe_Nr = random (1, 7);                             // Pixel-Farbe bestimmen
        delay (Wartezeit);
        Farben (Farbe_Nr);
    }
}

void Farben (int Nummer) {                                    // Pixel anzeigen

    switch (Nummer) {
        case 1: { strip.setPixelColor(Pixel, 255, 0, 0);      // Rot
                  break; }
        case 2: { strip.setPixelColor(Pixel, 0, 255, 0);      // Grün
                  break; }
        case 3: { strip.setPixelColor(Pixel, 0, 0, 255);      // Blau
                  break; }
        case 4: { strip.setPixelColor(Pixel, 255, 255, 0);    // Gelb
                  break; }
        case 5: { strip.setPixelColor(Pixel, 255, 0, 255);    // Pink
                  break; }
        case 6: { strip.setPixelColor(Pixel, 255, 255, 255);  // Weiss
                  break; }
    } 
    strip.show();
}

// *****************************************************************************************        
      

Mit dem Taster S1, den wir als den Zauberknopf definieren, wird ständig zwischen zwei Betriebsarten umgeschaltet: Aufgabe Stellung und Lösung der Aufgabe. Die aktuelle Betriebsart wird in der Variable "Umschaltung" gespeichert. Während der Aufgabe Stellung werden nach und nach die Pixel der Matrix eingeschaltet. Jedem Pixel wird per Zufall eine bestimmte Farbe zugeordnet. Die letzte Farbe bleibt in der Variable „Gesuchte_Farbe“ gespeichert. Diese Farbe ist die Lösung. Bevor die Start-Sequenz abgeschlossen wird, werden die Pixel mit Nummer 9, 18, 27, 36, 45, 54 und 63 genau mit dieser Farbe belegt. Diese Pixel-Nummern sind in der Variable „Geheimnis_Zahlen []“ gespeichert. Da die Pixel der Matrix intern mit null beginnend gezählt werden, sind die hier stehenden Zahlen um 1 kleiner.

Pixelbelegung

Pixelbelegung. Alle gegenzeichneten Pixel haben die gleiche Farbe.

Hinter dieser Vorgehensweise verbirgt sich eine mathematische Regel, die besagt: Das Ergebnis der Subtraktion einer zweistelligen Zahl und ihrer Quersumme ergibt als Ergebnis eine Zahl, die ein Vielfaches von neun darstellt.

z.B.:
45 – (4+5) = 45 – 9 = 36 (= 4*9)
23 – (2+3) = 23 – 5 = 18 (=2*9)
78 – (7+8) = 78 – 15 = 63 (=7*9)
usw.

Das heißt, bereits in diesem Moment steht die Lösung fest. Nachdem der „Zauberknopf“ erneut betätigt wird, wird die Lösung angezeigt.


Die Testschaltung

Testschaltung

Testschaltung


Kurzvideo


Weitere Themen:


Google-Suche auf MEINE-SCHALTUNG.de :


Home Impressum Datenschutz