daily pastebin goal
31%
SHARE
TWEET

TonUINO with WS2812 LED

a guest Dec 29th, 2018 173 in 126 days
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <DFMiniMp3.h>
  2. #include <EEPROM.h>
  3. #include <JC_Button.h>
  4. #include <MFRC522.h>
  5. #include <SPI.h>
  6. #include <SoftwareSerial.h>
  7.  
  8. #include <FastLED.h> // FastLED-Library einbinden
  9.  
  10. #include <Adafruit_NeoPixel.h> Adafruit Neopixel-Library einbinden
  11.   #ifdef __AVR__
  12.   #include <avr/power.h>
  13.   #endif
  14.   #define PIN 6
  15.   #define NUM_LEDS 24
  16.   Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);
  17.  
  18.  
  19. // FastLED define und Brightness für Adafruit Neopixel
  20.   FASTLED_USING_NAMESPACE
  21.   #if defined(FASTLED_VERSION) && (FASTLED_VERSION < 3001000)
  22.   #warning "Requires FastLED 3.1 or later; check github for latest code."
  23.   #endif
  24.   #define DATA_PIN    6
  25.   //#define CLK_PIN   4
  26.   #define LED_TYPE    WS2812
  27.   #define COLOR_ORDER RGB
  28.   #define NUM_LEDS    24
  29.   CRGB leds[NUM_LEDS];
  30.   #define BRIGHTNESS1          5  // Helligkeit für FastLED Low (wenn z.B. KEINE Musik gespielt wird)
  31.   #define BRIGHTNESS2          30 // Helligkeit für FastLED High (wenn z.B Musik gespielt wird)
  32.   #define BRIGHTNESS3          50 // Helligkeit für FastLED bei Bestätigung z.B. Blinken o.ä.
  33. #define STARTBRIGHTNESS     50    // Helligkeit für ADAFRUIT-Library
  34.   #define FRAMES_PER_SECOND  120
  35.   uint8_t gHue = 0; // rotating "base color" used by many of the patterns
  36.  
  37. // DFPlayer Mini
  38. SoftwareSerial mySoftwareSerial(2, 3); // RX, TX
  39. uint16_t numTracksInFolder;
  40. uint16_t currentTrack;
  41. uint8_t volume; // Volume Variable
  42. uint8_t minVolume;
  43. uint8_t maxVolume;
  44.  
  45. // this object stores nfc tag data
  46. struct nfcTagObject {
  47.   uint32_t cookie;
  48.   uint8_t version;
  49.   uint8_t folder;
  50.   uint8_t mode;
  51.   uint8_t special;
  52. };
  53.  
  54. nfcTagObject myCard;
  55.  
  56. static void nextTrack(uint16_t track);
  57. int voiceMenu(int numberOfOptions, int startMessage, int messageOffset,
  58.               bool preview = false, int previewFromFolder = 0);
  59.  
  60. bool knownCard = false;
  61.  
  62. // implement a notification class,
  63. // its member methods will get called
  64. //
  65. class Mp3Notify {
  66.   public:
  67.     static void OnError(uint16_t errorCode) {
  68.       // see DfMp3_Error for code meaning
  69.       Serial.println();
  70.       Serial.print("Com Error ");
  71.       Serial.println(errorCode);
  72.     }
  73.     static void OnPlayFinished(uint16_t track) {
  74.       Serial.print("Track beendet");
  75.       Serial.println(track);
  76.       delay(100);
  77.       nextTrack(track);
  78.       // hier LED abschalten ?!
  79.     }
  80.     static void OnCardOnline(uint16_t code) {
  81.       Serial.println(F("SD Karte online "));
  82.     }
  83.     static void OnCardInserted(uint16_t code) {
  84.       Serial.println(F("SD Karte bereit "));
  85.     }
  86.     static void OnCardRemoved(uint16_t code) {
  87.       Serial.println(F("SD Karte entfernt "));
  88.     }
  89. };
  90.  
  91. static DFMiniMp3<SoftwareSerial, Mp3Notify> mp3(mySoftwareSerial);
  92.  
  93. // Leider kann das Modul keine Queue abspielen.
  94. static uint16_t _lastTrackFinished;
  95. static void nextTrack(uint16_t track) {
  96.   if (track == _lastTrackFinished) {
  97.     return;
  98.   }
  99.   _lastTrackFinished = track;
  100.  
  101.   if (knownCard == false)
  102.     // Wenn eine neue Karte angelernt wird soll das Ende eines Tracks nicht
  103.     // verarbeitet werden
  104.     return;
  105.  
  106.   if (myCard.mode == 1) {
  107.     Serial.println(F("Hörspielmodus ist aktiv -> keinen neuen Track spielen"));
  108.     //    mp3.sleep(); // Je nach Modul kommt es nicht mehr zurück aus dem Sleep!
  109.   }
  110.   if (myCard.mode == 2) {
  111.     if (currentTrack != numTracksInFolder) {
  112.       currentTrack = currentTrack + 1;
  113.       mp3.playFolderTrack(myCard.folder, currentTrack);
  114.       Serial.print(F("Albummodus ist aktiv -> nächster Track: "));
  115.       Serial.print(currentTrack);
  116.     } else
  117.       //      mp3.sleep();   // Je nach Modul kommt es nicht mehr zurück aus dem Sleep!
  118.     { }
  119.   }
  120.   if (myCard.mode == 3) {
  121.     currentTrack = random(1, numTracksInFolder + 1);
  122.     Serial.print(F("Party Modus ist aktiv -> zufälligen Track spielen: "));
  123.     Serial.println(currentTrack);
  124.     mp3.playFolderTrack(myCard.folder, currentTrack);
  125.   }
  126.   if (myCard.mode == 4) {
  127.     Serial.println(F("Einzel Modus aktiv -> Strom sparen"));
  128.     //    mp3.sleep();      // Je nach Modul kommt es nicht mehr zurück aus dem Sleep!
  129.   }
  130.   if (myCard.mode == 5) {
  131.     if (currentTrack != numTracksInFolder) {
  132.       currentTrack = currentTrack + 1;
  133.       Serial.print(F("Hörbuch Modus ist aktiv -> nächster Track und "
  134.                      "Fortschritt speichern"));
  135.       Serial.println(currentTrack);
  136.       mp3.playFolderTrack(myCard.folder, currentTrack);
  137.       // Fortschritt im EEPROM abspeichern
  138.       EEPROM.write(myCard.folder, currentTrack);
  139.     } else {
  140.       //      mp3.sleep();  // Je nach Modul kommt es nicht mehr zurück aus dem Sleep!
  141.       // Fortschritt zurück setzen
  142.       EEPROM.write(myCard.folder, 1);
  143.     }
  144.   }
  145. }
  146.  
  147. static void previousTrack() {
  148.   if (myCard.mode == 1) {
  149.     Serial.println(F("Hörspielmodus ist aktiv -> Track von vorne spielen"));
  150.     mp3.playFolderTrack(myCard.folder, currentTrack);
  151.   }
  152.   if (myCard.mode == 2) {
  153.     Serial.println(F("Albummodus ist aktiv -> vorheriger Track"));
  154.     if (currentTrack != 1) {
  155.       currentTrack = currentTrack - 1;
  156.     }
  157.     mp3.playFolderTrack(myCard.folder, currentTrack);
  158.   }
  159.   if (myCard.mode == 3) {
  160.     Serial.println(F("Party Modus ist aktiv -> Track von vorne spielen"));
  161.     mp3.playFolderTrack(myCard.folder, currentTrack);
  162.   }
  163.   if (myCard.mode == 4) {
  164.     Serial.println(F("Einzel Modus aktiv -> Track von vorne spielen"));
  165.     mp3.playFolderTrack(myCard.folder, currentTrack);
  166.   }
  167.   if (myCard.mode == 5) {
  168.     Serial.println(F("Hörbuch Modus ist aktiv -> vorheriger Track und "
  169.                      "Fortschritt speichern"));
  170.     if (currentTrack != 1) {
  171.       currentTrack = currentTrack - 1;
  172.     }
  173.     mp3.playFolderTrack(myCard.folder, currentTrack);
  174.     // Fortschritt im EEPROM abspeichern
  175.     EEPROM.write(myCard.folder, currentTrack);
  176.   }
  177. }
  178.  
  179. // MFRC522
  180. #define RST_PIN 9                 // Configurable, see typical pin layout above
  181. #define SS_PIN 10                 // Configurable, see typical pin layout above
  182. MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522
  183. MFRC522::MIFARE_Key key;
  184. bool successRead;
  185. byte sector = 1;
  186. byte blockAddr = 4;
  187. byte trailerBlock = 7;
  188. MFRC522::StatusCode status;
  189.  
  190. #define buttonPause A0
  191. #define buttonUp A1
  192. #define buttonDown A2
  193. #define busyPin 4
  194.  
  195. #define LONG_PRESS 1000
  196.  
  197. Button pauseButton(buttonPause);
  198. Button upButton(buttonUp);
  199. Button downButton(buttonDown);
  200. bool ignorePauseButton = false;
  201. bool ignoreUpButton = false;
  202. bool ignoreDownButton = false;
  203.  
  204. uint8_t numberOfCards = 0;
  205.  
  206. bool isPlaying() {
  207.   return !digitalRead(busyPin);
  208. }
  209.  
  210. void setup() {
  211.   // Adafruit Animation zum Start
  212.   strip.begin();
  213.   strip.show(); // Initialize all pixels to 'off'
  214.   strip.setBrightness(STARTBRIGHTNESS);
  215.   rainbowCycle(2); //RainbowCycle von Adafruit abspielen
  216.   //  colorWipe(strip.Color(255, 0, 0), 30); // Gruen
  217.   //  colorWipe(strip.Color(0, 255, 0), 30); // Rot
  218.   //  colorWipe(strip.Color(0, 0, 255), 30); // Blau
  219.   colorWipe(strip.Color(0, 0, 0), 0); // AUS
  220.   strip.show();
  221.  
  222.   // FastLED
  223.   // delay(3000); // 3 second delay for recovery
  224.   FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip); // tell FastLED about the LED strip configuration
  225.   FastLED.setBrightness(BRIGHTNESS1);
  226.   fill_solid(leds, NUM_LEDS, CRGB::Purple);
  227.   FastLED.show();
  228.  
  229.   Serial.begin(115200); // Es gibt ein paar Debug Ausgaben über die serielle
  230.   // Schnittstelle
  231.   randomSeed(analogRead(A0)); // Zufallsgenerator initialisieren
  232.  
  233.   Serial.println(F("TonUINO Version 2.0"));
  234.   Serial.println(F("(c) Thorsten Voß"));
  235.  
  236.   // Knöpfe mit PullUp
  237.   pinMode(buttonPause, INPUT_PULLUP);
  238.   pinMode(buttonUp, INPUT_PULLUP);
  239.   pinMode(buttonDown, INPUT_PULLUP);
  240.  
  241.   // Busy Pin
  242.   pinMode(busyPin, INPUT);
  243.  
  244.   // DFPlayer Mini initialisieren
  245.   mp3.begin();
  246.   mp3.setVolume(8); // Startlautstärke
  247.   volume = 8;
  248.   minVolume = 1; //  minimale Lautstärke
  249.   maxVolume = 19; // maximale Lautatärke
  250.  
  251.  
  252.   // NFC Leser initialisieren
  253.   SPI.begin();        // Init SPI bus
  254.   mfrc522.PCD_Init(); // Init MFRC522
  255.   mfrc522
  256.   .PCD_DumpVersionToSerial(); // Show details of PCD - MFRC522 Card Reader
  257.   for (byte i = 0; i < 6; i++) {
  258.     key.keyByte[i] = 0xFF;
  259.   }
  260.  
  261.   // RESET --- ALLE DREI KNÖPFE BEIM STARTEN GEDRÜCKT HALTEN -> alle bekannten
  262.   // Karten werden gelöscht
  263.   if (digitalRead(buttonPause) == LOW && digitalRead(buttonUp) == LOW &&
  264.       digitalRead(buttonDown) == LOW) {
  265.     Serial.println(F("Reset -> EEPROM wird gelöscht"));
  266.     for (int i = 0; i < EEPROM.length(); i++) {
  267.       EEPROM.write(i, 0);
  268.     }
  269.   }
  270.  
  271. }
  272.  
  273. void loop() {
  274.   do {
  275.     // FastLED
  276.     if (isPlaying()) {    // Prüfung, ob MP3 abgespielt wird, wenn ja, dann jeweilige LED-Animation abspielen
  277.       FastLED.setBrightness(BRIGHTNESS2); // Helligkeit 2 während Animatuion beim Abspielen
  278.      
  279.       if (myCard.mode == 1) { // Hörspielmodus -> zufälligen Track wiedergeben
  280.         rainbowWithGlitter(); // FastLED's rainbowWithGlitter ausführen
  281.       }
  282.       if (myCard.mode == 2) { // Album Modus -> kompletten Ordner wiedergeben
  283.         rainbow();            // FastLED's  Regenbogen ausführen
  284.       }
  285.       if (myCard.mode == 3) { // Party Modus -> Ordner in zufälliger Reihenfolge
  286.         confetti();           // FastLED's  confetti ausführen
  287.       }      
  288.       if (myCard.mode == 4) { // Einzel Modus: eine Datei aus dem Ordner abspielen
  289.         sinelon();        // FastLED's  sinelon ausführen
  290.       }          
  291.       if (myCard.mode == 5) { // Hörbuch Modus: kompletten Ordner spielen und Fortschritt merken
  292.         rainbow();            // FastLED's  Regenbogen ausführen
  293.       }          
  294.       FastLED.show(); // send the 'leds' array out to the actual LED strip
  295.       FastLED.delay(1000 / FRAMES_PER_SECOND); // insert a delay to keep the framerate modest
  296.       EVERY_N_MILLISECONDS( 20 ) { gHue++; } // slowly cycle the "base color" through the rainbow
  297.     }
  298.    
  299.     mp3.loop();
  300.     // Buttons werden nun über JS_Button gehandelt, dadurch kann jede Taste doppelt belegt werden
  301.     pauseButton.read();
  302.     upButton.read();
  303.     downButton.read();
  304.  
  305.     if (pauseButton.wasReleased()) {
  306.       if (ignorePauseButton == false)
  307.         if (isPlaying()) {
  308.           mp3.pause();
  309.           // FastLED.clear (); // alle LEDs ausschalten
  310.           // fill_rainbow( leds, NUM_LEDS, 0, 5); // Rainbow Füllung
  311.           FastLED.setBrightness(BRIGHTNESS1);
  312.           fill_solid(leds, NUM_LEDS, CRGB::Purple);
  313.           FastLED.show(); // Befehl zum LED Ring senden
  314.         }
  315.         else {
  316.           mp3.start();
  317.         }
  318.       ignorePauseButton = false;
  319.     } else if (pauseButton.pressedFor(LONG_PRESS) &&
  320.                ignorePauseButton == false) {
  321.       if (isPlaying())
  322.         mp3.playAdvertisement(currentTrack);
  323.       else {
  324.         knownCard = false;
  325.         mp3.playMp3FolderTrack(800);
  326.         Serial.println(F("Karte resetten..."));
  327.         resetCard();
  328.         mfrc522.PICC_HaltA();
  329.         mfrc522.PCD_StopCrypto1();
  330.       }
  331.       ignorePauseButton = true;
  332.     }
  333.  
  334.     if (upButton.pressedFor(LONG_PRESS)) {
  335.       if (volume < maxVolume) {
  336.       Serial.println(F("Volume Up"));
  337.       mp3.increaseVolume(); // Laustärke erhohen
  338.         volume = mp3.getVolume(); // aktuelle Lautstärke abfragen und in Variable schreiben
  339.         Serial.println(volume);
  340.       FastLED.setBrightness(BRIGHTNESS3);
  341.       fill_solid(leds, NUM_LEDS, CRGB::Red);
  342.       FastLED.show();
  343.       FastLED.delay(500);
  344.       //FastLED.clear (); // alle LEDs ausschalten
  345.       FastLED.setBrightness(BRIGHTNESS1);
  346.       fill_solid(leds, NUM_LEDS, CRGB::Purple);
  347.       FastLED.show();
  348.       ignoreUpButton = true;
  349.       } else {
  350.       ignoreUpButton = true;
  351.       }
  352.     } else if (upButton.wasReleased()) {
  353.       if (!ignoreUpButton)
  354.         nextTrack(random(65536));
  355.       else {
  356.         ignoreUpButton = false;
  357.       }
  358.     }
  359.  
  360.     if (downButton.pressedFor(LONG_PRESS)) {
  361.       if (volume > minVolume) {
  362.       Serial.println(F("Volume Down"));
  363.       mp3.decreaseVolume(); // Laustärke verringern
  364.         volume = mp3.getVolume(); // aktuelle Lautstärke abfragen und in Variable schreiben
  365.         Serial.println(volume);
  366.       FastLED.setBrightness(BRIGHTNESS3);
  367.       fill_solid(leds, NUM_LEDS, CRGB::Blue);
  368.       FastLED.show();
  369.       FastLED.delay(500);
  370.       // FastLED.clear (); // alle LEDs ausschalten
  371.       FastLED.setBrightness(BRIGHTNESS1);
  372.       fill_solid(leds, NUM_LEDS, CRGB::Purple);
  373.       FastLED.show();
  374.       ignoreDownButton = true;
  375.       }
  376.     } else if (downButton.wasReleased()) {
  377.       if (!ignoreDownButton)
  378.         previousTrack();
  379.       else
  380.         ignoreDownButton = false;
  381.     }
  382.     // Ende der Buttons
  383.   } while (!mfrc522.PICC_IsNewCardPresent());
  384.  
  385.   // RFID Karte wurde aufgelegt
  386.  
  387.   if (!mfrc522.PICC_ReadCardSerial())
  388.     return;
  389.  
  390.   if (readCard(&myCard) == true) {
  391.     if (myCard.cookie == 322417479 && myCard.folder != 0 && myCard.mode != 0) {
  392.  
  393.       knownCard = true;
  394.       _lastTrackFinished = 0;
  395.       numTracksInFolder = mp3.getFolderTrackCount(myCard.folder);
  396.       Serial.print(numTracksInFolder);
  397.       Serial.print(F(" Dateien in Ordner "));
  398.       Serial.println(myCard.folder);
  399.  
  400.       // Hörspielmodus: eine zufällige Datei aus dem Ordner
  401.       if (myCard.mode == 1) {
  402.         Serial.println(F("Hörspielmodus -> zufälligen Track wiedergeben"));
  403.         currentTrack = random(1, numTracksInFolder + 1);
  404.         Serial.println(currentTrack);
  405.         mp3.playFolderTrack(myCard.folder, currentTrack);
  406.       }
  407.       // Album Modus: kompletten Ordner spielen
  408.       if (myCard.mode == 2) {
  409.         Serial.println(F("Album Modus -> kompletten Ordner wiedergeben"));
  410.         currentTrack = 1;
  411.         mp3.playFolderTrack(myCard.folder, currentTrack);
  412.       }
  413.       // Party Modus: Ordner in zufälliger Reihenfolge
  414.       if (myCard.mode == 3) {
  415.         Serial.println(F("Party Modus -> Ordner in zufälliger Reihenfolge wiedergeben"));
  416.         currentTrack = random(1, numTracksInFolder + 1);
  417.         mp3.playFolderTrack(myCard.folder, currentTrack);
  418.       }
  419.       // Einzel Modus: eine Datei aus dem Ordner abspielen
  420.       if (myCard.mode == 4) {
  421.         Serial.println(
  422.           F("Einzel Modus -> eine Datei aus dem Odrdner abspielen"));
  423.         currentTrack = myCard.special;
  424.         mp3.playFolderTrack(myCard.folder, currentTrack);
  425.       }
  426.       // Hörbuch Modus: kompletten Ordner spielen und Fortschritt merken
  427.       if (myCard.mode == 5) {
  428.         Serial.println(F("Hörbuch Modus -> kompletten Ordner spielen und "
  429.                          "Fortschritt merken"));
  430.         currentTrack = EEPROM.read(myCard.folder);
  431.         mp3.playFolderTrack(myCard.folder, currentTrack);
  432.       }
  433.     }
  434.  
  435.     // Neue Karte konfigurieren
  436.     else {
  437.       knownCard = false;
  438.       setupCard();
  439.     }
  440.   }
  441.   mfrc522.PICC_HaltA();
  442.   mfrc522.PCD_StopCrypto1();
  443. }
  444.  
  445. int voiceMenu(int numberOfOptions, int startMessage, int messageOffset,
  446.               bool preview = false, int previewFromFolder = 0) {
  447.   int returnValue = 0;
  448.   if (startMessage != 0)
  449.     mp3.playMp3FolderTrack(startMessage);
  450.   do {
  451.     pauseButton.read();
  452.     upButton.read();
  453.     downButton.read();
  454.     mp3.loop();
  455.     if (pauseButton.wasPressed()) {
  456.       if (returnValue != 0)
  457.         return returnValue;
  458.       delay(1000);
  459.     }
  460.  
  461.     if (upButton.pressedFor(LONG_PRESS)) {
  462.       returnValue = min(returnValue + 10, numberOfOptions);
  463.       mp3.playMp3FolderTrack(messageOffset + returnValue);
  464.       delay(1000);
  465.       if (preview) {
  466.         do {
  467.           delay(10);
  468.         } while (isPlaying());
  469.         if (previewFromFolder == 0)
  470.           mp3.playFolderTrack(returnValue, 1);
  471.         else
  472.           mp3.playFolderTrack(previewFromFolder, returnValue);
  473.       }
  474.       ignoreUpButton = true;
  475.     } else if (upButton.wasReleased()) {
  476.       if (!ignoreUpButton) {
  477.         returnValue = min(returnValue + 1, numberOfOptions);
  478.         mp3.playMp3FolderTrack(messageOffset + returnValue);
  479.         delay(1000);
  480.         if (preview) {
  481.           do {
  482.             delay(10);
  483.           } while (isPlaying());
  484.           if (previewFromFolder == 0)
  485.             mp3.playFolderTrack(returnValue, 1);
  486.           else
  487.             mp3.playFolderTrack(previewFromFolder, returnValue);
  488.         }
  489.       } else
  490.         ignoreUpButton = false;
  491.     }
  492.  
  493.     if (downButton.pressedFor(LONG_PRESS)) {
  494.       returnValue = max(returnValue - 10, 1);
  495.       mp3.playMp3FolderTrack(messageOffset + returnValue);
  496.       delay(1000);
  497.       if (preview) {
  498.         do {
  499.           delay(10);
  500.         } while (isPlaying());
  501.         if (previewFromFolder == 0)
  502.           mp3.playFolderTrack(returnValue, 1);
  503.         else
  504.           mp3.playFolderTrack(previewFromFolder, returnValue);
  505.       }
  506.       ignoreDownButton = true;
  507.     } else if (downButton.wasReleased()) {
  508.       if (!ignoreDownButton) {
  509.         returnValue = max(returnValue - 1, 1);
  510.         mp3.playMp3FolderTrack(messageOffset + returnValue);
  511.         delay(1000);
  512.         if (preview) {
  513.           do {
  514.             delay(10);
  515.           } while (isPlaying());
  516.           if (previewFromFolder == 0)
  517.             mp3.playFolderTrack(returnValue, 1);
  518.           else
  519.             mp3.playFolderTrack(previewFromFolder, returnValue);
  520.         }
  521.       } else
  522.         ignoreDownButton = false;
  523.     }
  524.   } while (true);
  525. }
  526.  
  527. void resetCard() {
  528.   do {
  529.     pauseButton.read();
  530.     upButton.read();
  531.     downButton.read();
  532.  
  533.     if (upButton.wasReleased() || downButton.wasReleased()) {
  534.       Serial.print(F("Abgebrochen!"));
  535.       mp3.playMp3FolderTrack(802);
  536.       colorWipe(strip.Color(0, 255, 0), 30); // Wipe in Rot
  537.       strip.show();
  538.       colorWipe(strip.Color(0, 0, 0), 0); // AUS
  539.       strip.show();
  540.       delay(3000);
  541.       FastLED.setBrightness(BRIGHTNESS1);
  542.       fill_solid(leds, NUM_LEDS, CRGB::Purple);
  543.       FastLED.show();
  544.       return;
  545.     }
  546.   } while (!mfrc522.PICC_IsNewCardPresent());
  547.  
  548.   if (!mfrc522.PICC_ReadCardSerial())
  549.     return;
  550.   Serial.print(F("Karte wird neu Konfiguriert!"));
  551.   setupCard();
  552. }
  553.  
  554. void setupCard() {
  555.   mp3.pause();
  556.   Serial.print(F("Neue Karte konfigurieren"));
  557.  
  558.   // Ordner abfragen
  559.   myCard.folder = voiceMenu(99, 300, 0, true);
  560.   blink_green_one();
  561.   FastLED.setBrightness(BRIGHTNESS1);
  562.   fill_solid(leds, NUM_LEDS, CRGB::Purple);
  563.   FastLED.show();
  564.  
  565.   // Wiedergabemodus abfragen
  566.   myCard.mode = voiceMenu(6, 310, 310);
  567.  
  568.   // Hörbuchmodus -> Fortschritt im EEPROM auf 1 setzen
  569.   EEPROM.write(myCard.folder, 1);
  570.  
  571.   // Einzelmodus -> Datei abfragen
  572.   if (myCard.mode == 4)
  573.     myCard.special = voiceMenu(mp3.getFolderTrackCount(myCard.folder), 320, 0,
  574.                                true, myCard.folder);
  575.  
  576.   // Admin Funktionen
  577.   if (myCard.mode == 6)
  578.     myCard.special = voiceMenu(3, 320, 320);
  579.  
  580.   // Karte ist konfiguriert -> speichern
  581.   mp3.pause();
  582.   writeCard(myCard);
  583. }
  584.  
  585. bool readCard(nfcTagObject *nfcTag) {
  586.   bool returnValue = true;
  587.   // Show some details of the PICC (that is: the tag/card)
  588.   Serial.print(F("Card UID:"));
  589.   dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size);
  590.   Serial.println();
  591.   Serial.print(F("PICC type: "));
  592.   MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
  593.   Serial.println(mfrc522.PICC_GetTypeName(piccType));
  594.  
  595.   byte buffer[18];
  596.   byte size = sizeof(buffer);
  597.  
  598.   // Authenticate using key A
  599.   Serial.println(F("Authenticating using key A..."));
  600.   status = (MFRC522::StatusCode)mfrc522.PCD_Authenticate(
  601.              MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid));
  602.   if (status != MFRC522::STATUS_OK) {
  603.     returnValue = false;
  604.     Serial.print(F("PCD_Authenticate() failed: "));
  605.     Serial.println(mfrc522.GetStatusCodeName(status));
  606.     return;
  607.   }
  608.  
  609.   // Show the whole sector as it currently is
  610.   Serial.println(F("Current data in sector:"));
  611.   mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector);
  612.   Serial.println();
  613.  
  614.   // Read data from the block
  615.   Serial.print(F("Reading data from block "));
  616.   Serial.print(blockAddr);
  617.   Serial.println(F(" ..."));
  618.   status = (MFRC522::StatusCode)mfrc522.MIFARE_Read(blockAddr, buffer, &size);
  619.   if (status != MFRC522::STATUS_OK) {
  620.     returnValue = false;
  621.     Serial.print(F("MIFARE_Read() failed: "));
  622.     Serial.println(mfrc522.GetStatusCodeName(status));
  623.   }
  624.   Serial.print(F("Data in block "));
  625.   Serial.print(blockAddr);
  626.   Serial.println(F(":"));
  627.   dump_byte_array(buffer, 16);
  628.   Serial.println();
  629.   Serial.println();
  630.  
  631.   uint32_t tempCookie;
  632.   tempCookie = (uint32_t)buffer[0] << 24;
  633.   tempCookie += (uint32_t)buffer[1] << 16;
  634.   tempCookie += (uint32_t)buffer[2] << 8;
  635.   tempCookie += (uint32_t)buffer[3];
  636.  
  637.   nfcTag->cookie = tempCookie;
  638.   nfcTag->version = buffer[4];
  639.   nfcTag->folder = buffer[5];
  640.   nfcTag->mode = buffer[6];
  641.   nfcTag->special = buffer[7];
  642.  
  643.   return returnValue;
  644. }
  645.  
  646.  
  647. // LED-Part von Adafruit-Library
  648. void colorWipe(uint32_t c, uint8_t wait) { // Adafruit´s - Fill the dots one after the other with a color
  649.   for (uint16_t i = 0; i < strip.numPixels(); i++) {
  650.     strip.setPixelColor(i, c);
  651.     strip.show();
  652.     delay(wait);
  653.   }
  654. }
  655. void rainbowCycle(uint8_t wait) { // Adafruit´s Rainbow Cycle
  656.   uint16_t i, j;
  657.   for (j = 0; j < 256 * 2; j++) { // 1 cycles of all colors on wheel
  658.     for (i = 0; i < strip.numPixels(); i++) {
  659.       strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
  660.     }
  661.     strip.show();
  662.     delay(wait);
  663.   }
  664. }
  665. // Input a value 0 to 255 to get a color value.
  666. // The colours are a transition r - g - b - back to r.
  667. uint32_t Wheel(byte WheelPos) {
  668.   WheelPos = 255 - WheelPos;
  669.   if (WheelPos < 85) {
  670.     return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  671.   }
  672.   if (WheelPos < 170) {
  673.     WheelPos -= 85;
  674.     return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  675.   }
  676.   WheelPos -= 170;
  677.   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  678. }
  679.  
  680.  
  681. // LED-Part von FastLED-Library
  682. void rainbow() // FastLED's built-in rainbow generator
  683. {
  684.   fill_rainbow( leds, NUM_LEDS, gHue, 7);
  685. }
  686. void rainbowWithGlitter()   // built-in FastLED rainbow, plus some random sparkly glitter
  687. {
  688.   rainbow();
  689.   addGlitter(80);
  690. }
  691. void addGlitter( fract8 chanceOfGlitter)
  692. {
  693.   if ( random8() < chanceOfGlitter) {
  694.     leds[ random16(NUM_LEDS) ] += CRGB::White;
  695.   }
  696. }
  697. void confetti()   // random colored speckles that blink in and fade smoothly
  698. {
  699.   fadeToBlackBy( leds, NUM_LEDS, 10);
  700.   int pos = random16(NUM_LEDS);
  701.   leds[pos] += CHSV( gHue + random8(64), 200, 255);
  702. }
  703. void sinelon()   // a colored dot sweeping back and forth, with fading trails
  704. {
  705.   fadeToBlackBy( leds, NUM_LEDS, 20);
  706.   int pos = beatsin16( 13, 0, NUM_LEDS-1 );
  707.   leds[pos] += CHSV( gHue, 255, 192);
  708. }
  709. void blink_green_one()
  710. {
  711.   FastLED.setBrightness(BRIGHTNESS3);
  712.   fill_solid(leds, NUM_LEDS, CRGB::Green);
  713.   FastLED.show();
  714.   FastLED.delay(500);
  715.   delay(130);
  716.   FastLED.clear (); // alle LEDs ausschalten
  717.   FastLED.show();
  718. }
  719.  
  720.  
  721. // TonUINO Part
  722. void writeCard(nfcTagObject nfcTag) {
  723.   MFRC522::PICC_Type mifareType;
  724.   byte buffer[16] = {0x13, 0x37, 0xb3, 0x47, // 0x1337 0xb347 magic cookie to
  725.                      // identify our nfc tags
  726.                      0x01,                   // version 1
  727.                      nfcTag.folder,          // the folder picked by the user
  728.                      nfcTag.mode,    // the playback mode picked by the user
  729.                      nfcTag.special, // track or function for admin cards
  730.                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  731.                     };
  732.  
  733.   byte size = sizeof(buffer);
  734.  
  735.   mifareType = mfrc522.PICC_GetType(mfrc522.uid.sak);
  736.  
  737.   // Authenticate using key B
  738.   Serial.println(F("Authenticating again using key B..."));
  739.   status = (MFRC522::StatusCode)mfrc522.PCD_Authenticate(
  740.              MFRC522::PICC_CMD_MF_AUTH_KEY_B, trailerBlock, &key, &(mfrc522.uid));
  741.   if (status != MFRC522::STATUS_OK) {
  742.     Serial.print(F("PCD_Authenticate() failed: "));
  743.     Serial.println(mfrc522.GetStatusCodeName(status));
  744.     mp3.playMp3FolderTrack(401);
  745.     return;
  746.   }
  747.  
  748.   // Write data to the block
  749.   Serial.print(F("Writing data into block "));
  750.   Serial.print(blockAddr);
  751.   Serial.println(F(" ..."));
  752.   dump_byte_array(buffer, 16);
  753.   Serial.println();
  754.   status = (MFRC522::StatusCode)mfrc522.MIFARE_Write(blockAddr, buffer, 16);
  755.   if (status != MFRC522::STATUS_OK) {
  756.     Serial.print(F("MIFARE_Write() failed: "));
  757.     Serial.println(mfrc522.GetStatusCodeName(status));
  758.     mp3.playMp3FolderTrack(401);
  759.     FastLED.setBrightness(BRIGHTNESS3);
  760.     colorWipe(strip.Color(0, 255, 0), 30); // Wipe in Rot
  761.     strip.show();
  762.     colorWipe(strip.Color(0, 0, 0), 0); // AUS
  763.     strip.show();
  764.     delay(3200);
  765.     FastLED.setBrightness(BRIGHTNESS1);
  766.     fill_solid(leds, NUM_LEDS, CRGB::Purple);
  767.     FastLED.show();
  768.   }
  769.   else {
  770.     mp3.playMp3FolderTrack(400); // MP3 Ansage dass die Karte konf ist
  771.     FastLED.setBrightness(BRIGHTNESS3);
  772.     colorWipe(strip.Color(255, 0, 0), 30); // Wipe in Gruen
  773. //    colorWipe(strip.Color(0, 0, 255), 30); // Wipe in Blau
  774.     strip.show();
  775.     colorWipe(strip.Color(0, 0, 0), 0); // AUS
  776.     strip.show();
  777.     delay(3200);
  778.     FastLED.setBrightness(BRIGHTNESS1);
  779.     fill_solid(leds, NUM_LEDS, CRGB::Purple);
  780.     FastLED.show();
  781.   }
  782.   Serial.println();
  783.   delay(100);
  784. }
  785.  
  786. /**
  787.    Helper routine to dump a byte array as hex values to Serial.
  788. */
  789. void dump_byte_array(byte *buffer, byte bufferSize) {
  790.   for (byte i = 0; i < bufferSize; i++) {
  791.     Serial.print(buffer[i] < 0x10 ? " 0" : " ");
  792.     Serial.print(buffer[i], HEX);
  793.   }
  794. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top