MP3 přehrávač a bluetooth s dálkovým ovladačem

pro Arduino

Programy zdarma, Arduino návody, tratě pro Open Rails a MSTS.

V důchodu mám dost času na vymýšlení různých pitomostí, zvláště teď v zimě, kdy jinak není moc do čeho píchnout. Zde je jedna z nich.
Napadlo mne vyrobit MP3 přehrávač + bluetooth reproduktor s dálkovým ovládáním s obousměrnou komunikací. To znamená, že na ovladači je kromě tlačítek i displej, kde se zobrazuje název právě přehrávaného souboru, jeho pořadí, doba trvání s odečtem a celkový počet souborů. Klasický infra snímač zde použít nejspíš nelze, takže jsem ke komunikaci použil 2.4GHz modul s LT8920 s připojený přes sběrnici SPI.
Modul LT8920 je prodáván ve dvou verzích (viz schéma níže), kdy použít se dá kterákoliv z nich. Modul je titěrný a při pájení je třeba dávat pozor. Je potřeba připojit celkem osm vodičů, viz tabulka níže ve schématu. Na typ XY-WA se vodiče pájí přímo, čtyři z jedné strany a čtyři z druhé. Typ XY-WB umožňuje připájet piny a vodiče připojit k nim.

Stanice - verze s STM8S103F3

Použití Arduino MEGA, nebo i UNO (viz níže uvedená verze stanice) mi přišlo poněkud předimenzované. Stanice nedělá nic jiného, než krátké přenosy mezi sběrnicí SPI a UARTem. Pokusil jsem se o jakousi minimalistickou verzi v assembleru pomocí procesorové desky STM8S103F3. Podrobnosti a návod je zde..

Stanice - verze s Arduino MEGA 2560

Jako přehrávač je zde modul BT201, který má zabudováno opravdu mnoho funkcí a je ovládán (kromě interních tlačítek) pomocí seriového portu (UART). Kvůli toho jsem ve stanici použil Arduino MEGA, protože má více seriových portů, než ten jeden jediný, který má UNO a který je navíc použit pro USB komunikaci s počítačem.
UNO samozřejmě použít lze, buď s knihovnou SoftwareSerial.h, nebo přes ten jeho seriový port. V tom případě se však musí před nahráním programu z USB, modul BT201 odpojit (RX, TX) a po nahrání zase připojit. Tohle však fakticky znemožňuje ladění pomocí seriového monitoru v Arduino IDE. Pokud někdo bude chtít použít knihovnu SoftwareSerial, tak modul BT201 (alepoň u mne) měl defaultně nastavenou rychlost 115200Bd, což tato knihovna neumožňuje. Rychlost je pak třeba na něčem snížit.
Sběrnici SPI pro komunikační modul LT8920 2.4GHz je třeba zapojit podle tabulky pro UNO, která je níže ve schématu.

stáhnout toto schéma v PDF

Chtěl jsem zachovat možnost ovládat hlasitost potenciometrem na stanici, aniž bych použil nějaký nf zesilovač připojený na sluchátkový výstup zvukového modulu BT201. Dal jsem tedy potenciometr přímo na výkonový výstup modulu BT201. Potenciometr má trochu netypickou hodnotu 100R (menší jsem nesehnal). Koupit se dá zde, včetně ostatních pasivních součástek (tlumivka, kondenzátory). Reproduktor je galvanicky oddělen od jezdce potenciometru kondenzátorem 100u.
Reproduktor se samozřejmě dá připojit přímo k výkonovému výstupu BT201 (piny SPK). Potenciometr, ani výstupní kondenzátor pak není potřeba a hlasitost se reguluje pouze ovladačem.
Odrušovací člen s tlumivkou 1.5mH a kondenzátory 220n a 100u není nutný, pokud použijete kvalitní napájecí zdroj.

Zdrojový kod stanice (Arduino MEGA) stáhnout


// BezDratak na dalkove ovladani - PRIJIMAC (SERVER) 
// muze prehravat MP3 aslouzit jako bluetooth reproduktor
//
// rizeno kontroleram Ardiono MEGA 2560
// osazeno modulem BT201 (prehravac) a LT8920 (vysilac/prijimac 2.4 GHz)

#define noDEBUG

#define pinCS     49 //A1 //5
#define pinRST    48 //A2 //6
#define pinPKT    47 //A3 //4
#define maxlen    64

#include <SPI.h>
#include "LT8920.h"

//2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484
#define wifiCanal 2483 - 2402 // nastaveny kanal 2400 - 2482

LT8920 lt(pinCS, pinPKT, pinRST);

uint8_t response[maxlen];
uint8_t uartBuffer[maxlen];
volatile int responseCount = 0;

// -- Bezdratový vysilac+priimac 2,4GHz XY-WB s IO LT8920 ----------------------------------------------

void initLT() {
  SPI.begin();
  SPI.beginTransaction(SPISettings(12000000, MSBFIRST, SPI_MODE1)); //12000000
  SPI.setClockDivider(SPI_CLOCK_DIV64);   //SPI_CLOCK_DIV16
  lt.begin();
  lt.writeRegister(35, 0x0F00);           //Setting the number of repeated dispatches to 255
  lt.setCurrentControl(1, 2);             //sila a zesileni
  lt.setDataRate(LT8920::LT8920_1MBPS);   //:LT8920_1MBPS, LT8920_62KBPS 
  lt.writeRegister(45, 0x0080);           //pro 1MB/s 0x0152, pro nizsi 0x0552
  lt.setChannel(wifiCanal);               //2402 + n --> 2484 
  lt.setSyncWord(0x123A123B123C123D);     //volitelne ID, modul komunikuje s jinym modulem
  lt.startListening();                    //     pouze pokud ma stejne ID
}

bool charOK(char c) {
  if (c == '_') return true;
  if (c == '+') return true;
  if (c == '.') return true;
  return (isAlphaNumeric(c));
}

uint8_t readUART(int waitTime) {  
  #ifdef DEBUG
  Serial.print("UART: ");   
  #endif
  int t = waitTime;
  uint8_t c;
  uint8_t result = 0;
  bool m = true;
  do {
    while (Serial1.available()) {
      c = Serial1.read();
      #ifdef DEBUG
      Serial.print(char(c));
      #endif
      if ((c == 32) || (c == '-') || (c == '_')) {
        m = true; //po mezere velke pismeno
        continue;
      }
      if (c >= 127) c = 95; //misto diakritiky podtrzitko
      if (charOK(c)) {
        if (m) {
          uartBuffer[result] = toupper(c);
          m = false;
        }
        else 
          uartBuffer[result] = tolower(c);
        if (result < maxlen - 2) result++;
      }
      t = waitTime;
    }  
    delay(1);
    t--;
  } while (t > 0);
  uartBuffer[result] = 0;  
  #ifdef DEBUG
  Serial.println(); Serial.println(result);
  Serial.write(uartBuffer, result); Serial.println();
  for (byte i = 0; i < result; i++) { Serial.print(uartBuffer[i], HEX); Serial.print(" "); } 
  Serial.println();
  #endif
  return result;
}

uint8_t ltResponse() { //prijme data z wifi a posle do BT201; 0=OK, 1=chyba crc, 2=spatna delka, 3 = prazdny buffer
  if (responseCount < 0) return 1; //crc  //int n = lt.read(response, maxlen - 1);
  if (responseCount >= maxlen) return 2; //spatna delka
  if (responseCount == 0) return 3; //nic neprislo
  response[responseCount] = '\0';
  Serial1.write(response, responseCount);    
  Serial1.println();
  Serial1.flush();
  #ifdef DEBUG
  Serial.print("ltResponse: "); Serial.write(response, responseCount); Serial.println();
  #endif
  return 0;
}

bool toSend() { //obsluhovane odpovedi z VT201
  if (uartBuffer[0] == 'M') {
    if (uartBuffer[1] == '1') return true; // poradi souboru
    if (uartBuffer[1] == '2') return true; // pocet souboru
    if (uartBuffer[1] == 't') return true; // doba trvani souboru v sec
    if (uartBuffer[1] == 'k') return true; // odehrany cas souboru v sec
    if (uartBuffer[1] == 'f') return true; // nazev souboru
    if (uartBuffer[1] == 'v') return true; // notifikace zmeny souboru
    if (uartBuffer[1] == 'p') return true; // 0=stop, 1=play, 2=pause
    if (uartBuffer[1] == 'u') return true; // notifikace vyjmuti (MU+04) nebo zastrceni (MU+03) pametovky
  }  
  return (uartBuffer[0] == 'Q'); //vsechny odpovedi query
}

bool ltSend() { //odesle data z BT201 na wifi
  bool result = false;
  uint8_t n = readUART(128);  
  if (n < 4) return false;
  bool ts = toSend();
  if (ts) {
    result = (lt.sendPacket(uartBuffer, n));
    uint8_t p[] = {'M', 'u', '+', '0', '4', 0x0A};
    if (memcmp(uartBuffer, p, 5) == 0) { //vyjmuti pametovky
      delay(1000);
      lt.sendPacket(p,  6);
      #ifdef DEBUG
      Serial.println("vyjmuti karty");
      #endif
    }
  }
  lt.startListening();
  #ifdef DEBUG
  Serial.print("ltSend: "); Serial.print(ts); Serial.print("; "); Serial.print(n); Serial.print("; "); 
  Serial.write(uartBuffer, n); Serial.println();
  #endif
  return result;
}

void sendError(uint8_t result) {
  uint8_t resultbuf[4] = {'R', 'E', '+', result};
  lt.sendPacket(resultbuf, 4);
}

// -- Bluetooth 5.0+MP3+handsfree, modul BT201 ---------------------------------------------------------

void atInit(char* at, int waitTime) {
  #ifdef DEBUG
  Serial.print("atInit: "); Serial.print(at);
  #endif
  Serial1.print(at);
  readUART(waitTime);
}

void initBT() { 
  /*
  Serial1.begin(9600);      //puvodni rychlost
  atInit("AT+CT03", 1024);  //nova rychlost
  atInit("AT+CZ", 5000);    //reset BT201, do 5 sec
  Serial1.end();            //po provedeni cele zapoznamkovat!!!
  delay(1000);
  */
  Serial1.begin(38400);    //nastavena rychlost
  char p1[] = "AT+CZ\r\n\0";
  atInit(p1, 2000);   //reset BT201, do 2 sec
  char p2[] = "AT+CK00\r\n\0";
  atInit(p2, 1000); //bluetooth nenajede automaticky //atInit("AT+B400", 512);//atInit("AT+B500", 512); 
  char p3[] = "AT+CA03\r\n\0";
  atInit(p3, 1000);  //hlasitost 
  char p4[] = "AT+CM03\r\n\0";
  atInit(p4, 1000); //pametova karta atInit("AT+CM03", 1000); //
  delay(1000);
  char p5[] = "AT+CM03\r\n\0";
  atInit(p5, 1000); //pametova karta atInit("AT+CM03", 1000); //
  char p6[] = "AT+AA00\r\n\0";
  atInit(p6, 1000); //STOP atInit("AT+CB", 500);    //pause
  char p7[] = "AT+CA08\r\n\0";
  atInit(p7, 500);  //hlasitost 
}  

// ----------------------------------------------------------------------------------------------------

void setup() {
  #ifdef DEBUG
  Serial.begin(115200);
  Serial.println("LT9820");
  #endif
  delay(3000); // cas pro najeti modulu
  initLT();
  initBT();
}

void loop() {    
  while (lt.available()) { //odpoved z wifi posle do BT201
    responseCount = lt.read(response, maxlen - 1);
    lt.startListening();
    uint8_t err = ltResponse();
    responseCount = 0;
    if (err) sendError(err | 0x30);
    lt.startListening();
    #ifdef DEBUG
    Serial.print("response: "); Serial.println(err);
    #endif
  }
  if (Serial1.available()) { //odpoved z BT201 posle na wifi
    bool err = ltSend();
    lt.startListening();
    #ifdef DEBUG
    Serial.print("sent: "); Serial.println(err);
    #endif
  }

  #ifdef DEBUG
  if (Serial.available()) {
    String s = Serial.readString();
    Serial.print("> "); Serial.println(s);
    Serial1.println(s); //Serial1.write(Serial.read()); 
  }   
  #endif  
}

aktualizováno 5.3.2025

Ovladač

Zapojení ovladače je jednoduché. Na Arduino UNO je nasazený LCD shield 16 x 2 a k němu je připojen komunikační modul LT8920. V mém případě je použit LT8920 typ XY-WA, kdy modul je připájen přímo k desce shieldu. Udělat to však lze i jinak.
Na LCD shieldu je šest tlačítek - select, left, up, down, right a reset. Reset je "natvrdo", ten programově využít nelze. Ostatní tlačítka jsou naprogramována takto:

select - krátký stisk: play / pause
select - dlouhý stisk: výběr zdroje zvuku z BT201

left - SD karta
up/down - bluetooth
right - USB flash disk
select - zpět beze změny

left - krátký stisk: o soubor zpět
left - dlouhý stisk: o složku zpět
right - krátký stisk: o soubor vpřed
right - dlouhý stisk: o složku vpřed
up - krátký stisk: zesílit hlasitost
up - dlouhý stisk: rychlý posun vpřed
down - krátký stisk: zeslabit hlasitost
down - dlouhý stisk: rychlý posun vzad
reset: reset Arduino UNO (mimo modul BT201)

Pokud přibližně minutu nebude stisknuto žádné tlačítko, zhasne podsvit displeje, kvůli šetření napájení. Při zapnutém podsvitu je odběr ovladače 170mA a při zhasnutém necelých 50mA. Při stisku jakéhokoliv tlačítka, kromě resetu, se displej opět rozsvítí. Displej se také rozsvítí při změně skladby (souboru).
Na displeji ovladače se zobrazuje pořadí skladby, celkový počet skladeb a zbývající čas, do konce právě přehrávané skladby. Navíc i název právě přehrávaného souboru. Názvy souborů, bývají všelijak spotfořené, jsem ze staré školy a diakritiku v názvech nemám rád. Mnohdy to dělá problémy. Displej má šířku šestnáct znaků a pokud je název delší, zobrazí se POSLEDNÍCH šestnáct znaků z názvu. Z názvu jsou navíc vylučovány mezery, pomlčky a podobně, stejně jako přípona MP3. Znaky diakritiky jsou nahrazovány podtržítkem. Vše se dá změnit případnou úpravou programu ovladače.

stáhnout toto schéma v PDF

Zdrojový kod ovladač (Arduino UNO) stáhnout


// BezDratak na dalkove ovladani - OVLADAC (KLIENT) 
// muze prehravat MP3 a slouzit jako bluetooth reproduktor
//
// Ovladac rizeny kontroleram Ardiono UNO
// osazeno LCD shieldem a LT8920 (vysilac/prijimac 2.4 GHz)

#define noDEBUG

#define pinCS       A1 //5
#define pinRST      A2 //6
#define pinPKT      2  // A3 4
#define pinLCD      10
#define maxlen      64
#define btnSelect   0x01 //tlacitka
#define btnLeft     0x02
#define btnRight    0x03
#define btnUp       0x04
#define btnDown     0x05
#define btnSelect2  0x81 //tlacitka s dlouhym stiskem
#define btnLeft2    0x82
#define btnRight2   0x83
#define btnUp2      0x84
#define btnDown2    0x85
#define dispOff     80
#define maxErrors   8
#define noMode      -1
#define btMode      1
#define usbMode     2
#define sdMode      3
#define divisor     1500

//2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484
#define wifiCanal 2483 - 2402 // nastaveny kanal 

#include <SPI.h>
#include <LT8920.h>
#include <LiquidCrystal.h>

LT8920 lt(pinCS, pinPKT, pinRST);
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);  // inicializace LCD displeje

bool dispOn, waitResponse;
uint8_t seq, errors;
uint16_t mp3Order, mp3Count;
int8_t state = -1;
int8_t mode;
int dispTime;
int responseCount;
unsigned long mp3Time, mp3Elapsed, pressTime;
unsigned long secs = 0;
char mp3File[17];
uint8_t response[maxlen + 1];
uint8_t currentCmd[maxlen];

// -----------------------------------------------------------------------------------------------------

void clearTimes() {
  mp3Time = 0;
  mp3Elapsed = 0;  
}

void clearValues(bool all) {
  seq = 0;
  errors = 0;
  mp3File[0] = '\0';
  mp3Order = 0;
  clearTimes();
  if (all) {
    mp3Count = 0;
    mode = noMode;
  }
}

// -- LCD shield 16x2 ----------------------------------------------------------------------------------

void initLCD() {
  dispTime = dispOff;
  dispOn = true;
  lcd.begin(16, 2);
  pinMode(pinLCD, OUTPUT); 
  digitalWrite(pinLCD, HIGH);
  lcd.print(F("BezDratak"));
  lcd.setCursor(0, 1);
  lcd.print(F("MP3 a Bluetooth"));
}

void lcdLine(uint8_t r, char info[]) {
  lcd.setCursor(0, r);
  lcd.print(info);
  for (byte i = strlen(info); i < 16; i++) lcd.print(" ");
}

void lcdInfo() {
  if (!dispOn) return;
  if (mode == btMode) {
    lcd.clear();
    lcd.print(F("   BLUETOOTH    "));
    lcd.setCursor(0, 1);
    lcd.print(F("  reproduktor   "));
    return;
  }
  char e[] = " \0";
  lcdLine(0, e);
  lcd.setCursor(0, 0);
  if (mp3Order > 0) lcd.print(mp3Order); else lcd.print("---");
  lcd.print("/");
  if (mp3Count > 0) lcd.print(mp3Count); else lcd.print("---");
  lcd.setCursor(9, 0);
  lcd.print("|");
  unsigned long r = mp3Time;
  if (r == 0) {
    if (mode == usbMode) lcd.print(F(" [USB]")); 
    if (mode == sdMode) lcd.print(F("  [SD]"));
  } else {      
    if (mp3Elapsed < mp3Time) r = mp3Time - mp3Elapsed;
    int m = r / 60;
    int s = r % 60;
    if (m < 100) lcd.print(" ");
    if (m < 10) lcd.print("0");
    lcd.print(m); 
    lcd.print(":");  
    if (s < 10) lcd.print("0");
    lcd.print(s);
  }
  lcdLine(1, mp3File);
}

void lcdOn() {
  dispTime = dispOff;
  dispOn = true;
  digitalWrite(pinLCD, HIGH);
  lcdInfo();
}

uint8_t readKey() {
  uint8_t result = 0xFF;
  pressTime = 0;
  int n = analogRead(0);
  if (n < 95) result = btnRight;  //Vpravo(RIGHT)
  if ((n > 95)  && (n < 150)) result = btnUp;  //Nahoru(UP)
  if ((n > 150) && (n < 350)) result = btnDown;  //Dolu(DOWN)
  if ((n > 350) && (n < 500)) result = btnLeft;   //Vlevo(LEFT)
  if ((n > 500) && (n < 750)) result = btnSelect;  //Vyber(SELECT)
  if (result < 255) { // test dlouhy stisk
    unsigned long t = millis();
    bool w = true;
    while (analogRead(0) < 750) {
      pressTime = millis() - t;
      if (w && (pressTime > 1200))  {
        w = false;
        lcd.setCursor(14, 0);
        lcd.print(" *");
      }
    }  
    if (pressTime > 1200) result = result | 0x80; //byl dlouhy stisk
    if (pressTime < 100) result = 0xFF; //prilis kratky stisk
    #ifdef DEBUG
    Serial.println("readKey ----------------------------------------------"); 
    Serial.print(result, HEX); Serial.print("; analog: "); Serial.println(n); 
    #endif   
  }
  return result;
}

uint8_t selectMode() {
  lcd.clear();
  lcd.print("  Vyber zdroje  ");
  delay(1000);
  lcd.clear();
  lcd.print("up/down: bltooth");
  lcd.setCursor(0, 1);
  lcd.print("left:sd righ:usb");
  unsigned long t = millis();
  while ((millis() - t) < 8000) {
    uint8_t k = readKey();
    if (k < 255) return k;
  }
  return btnSelect;
}

// -- Bezdratový vysilac+priimac 2,4GHz XY-WB s IO LT8920 ----------------------------------------------

void initLT() {
  SPI.begin();
  SPI.beginTransaction(SPISettings(12000000, MSBFIRST, SPI_MODE1)); //12000000
  SPI.setClockDivider(SPI_CLOCK_DIV16);   //SPI_CLOCK_DIV16
  lt.begin();
  lt.writeRegister(35, 0x0F00);           //Setting the number of repeated dispatches to 255 (F)
  lt.writeRegister(9, 0x8400);            //setCurrentControl(8, 4); //vykona
  lt.setDataRate(LT8920::LT8920_1MBPS);  //LT8920_62KBPS 1MBPS, pri nizsich rychlostech je neustale chyba CRC
  lt.writeRegister(45,  0x0080);          //doporucene nastaveni pro 1MB/sec
  lt.setChannel(wifiCanal);               //2402 + n
  lt.setSyncWord(0x123A123B123C123D);     //volitelne ID, modul komunikuje s jinym modulem pouze pokud ma stejne ID
}

void ltSend(char* cmd) { //odesle data na wifi 
  uint8_t n = strlen(cmd);
  currentCmd[0] = 0;
  if (n == 0) return;
  if (n < maxlen - 2) {
    for (byte i = 0; i < maxlen; i++) currentCmd[i] = 0;
    memcpy(currentCmd, cmd, n); 
    waitResponse = lt.sendPacket(currentCmd, n);
    if (waitResponse) {
      lt.startListening();
      interrupts();
      #ifdef DEBUG
      Serial.print("Sent: "); Serial.print(cmd); Serial.print("; seq"); Serial.println(seq);
      #endif
    }
  } 
}

// -- cteni nazvu souboru MP3 -----------------------------------------------------------------------------

int lastDot(char p[]) {
  int result = strlen(p) - 1;
  for (int i = result; i >= 0; i--) {
    if (p[i] == '.') return i;
  }
  return result;
}

void getName(char respStr[]) { //prevezme jmeno souboru, poslednich 16 znaku bez pripony
  for (byte i = 0; i < 16; i++) mp3File[i] = '\0';  
  char* p = respStr;
  p += 3;
  int tecka = lastDot(p);
  #ifdef DEBUG
  Serial.print("lastDot: "); Serial.println(tecka); 
  #endif
  p[tecka] = '\0';
  int8_t n = strlen(p);
  int8_t ix = 0;
  int8_t s = n - 16; //ignorovat priponu .mp3
  if (s < 0) s = 0;
  for (byte i = s; i < n; i++) {
    char c = p[i];
    if (byte(c) == 13) return;
    if (byte(c) > 32) {
      mp3File[ix] = c;
      ix++;
      if (ix >= 16) return;
    }  
  }
}

// -- dekodovani prijate pakety --------------------------------------------------------------------------

uint16_t atValue(char* pattern, char* buf, uint16_t defa, bool* found) {
  *found = false;
  char* p = strstr(buf, pattern);
  if (p == NULL) return defa;
  *found = true;
  p += 3;
  uint16_t result = strtol(p, NULL, 16);
  #ifdef DEBUG
  Serial.print("atValue: "); Serial.print(pattern); Serial.print(" = "); Serial.println(result);
  #endif
  return result;
}

bool testMode(char* respStr) {
  bool found;
  char p[] = "Qm+\0";
  uint8_t n = atValue(p, respStr, mode, &found);
  if (found) {
    if (mode != n) clearValues(true); //pri zmene modu nacist vse znovu
    mode = n;
  }
  return found;
}

bool testState(char* respStr) {
  bool found;
  char p[] = "Mp+\0";
  state = atValue(p, respStr, state, &found);
  return found;
}

bool testOrder(char* respStr) {
  bool found;
  char p[] = "M1+\0";
  uint16_t n = atValue(p, respStr, mp3Order, &found);
  if (found && (mp3Order != n)) {
    if (mp3Order > 0) clearValues(false); //jiny soubor
    mp3Order = n; 
    lcdOn();   
  }
  return found;
}

bool testCount(char* respStr) {
  bool found;
  char p[] = "M2+\0";
  int n = atValue(p, respStr, mp3Count, &found);
  if (found) mp3Count = n; 
  return found;
}

bool testTime(char* respStr) {
  bool found;
  char p[] = "Mt+\0";
  mp3Time = atValue(p, respStr, mp3Time, &found); 
  return found;
}
  
bool testElapsed(char* respStr) {   
  bool found;
  char p[] = "Mk+\0";  
  mp3Elapsed = atValue(p, respStr, mp3Elapsed, &found);
  return found;
}

bool testFilename(char* respStr) {
  char* p = strstr(respStr, "Mf+");
  if (p) getName(respStr);
  return (p != NULL);  
}

// ---------------------------------------------------------------------------------------------------

void parseResponse() { //zpracuje prijata data z wifi 
  char respStr[maxlen];

  #ifdef DEBUG
  for (byte i = 0; i < responseCount; i++) { 
    Serial.print(response[i], HEX);  
    Serial.print(" "); 
  } 
  Serial.println((char*)response);
  #endif
  
  byte t = 0;
  for (byte i = 0; i < responseCount; i++) {
    char c = response[i]; 
    if (c == 10) break;
    respStr[t] = c;
    t++;
  }
  respStr[t] = '\0';

  #ifdef DEBUG
  Serial.print("Response: "); Serial.println(respStr); 
  #endif

  if (testMode(respStr)) return;
  if (testState(respStr)) return;
  if (testOrder(respStr)) return;
  if (testCount(respStr)) return;
  if (testTime(respStr)) return;
  if (testElapsed(respStr)) return;
  if (testFilename(respStr)) return;
}

//--------------------------------------------------------------------------------------------------------

void goFolder(bool fwd) { //o slozku vpred/zpet
  char cmd[16];
  if (mp3Count > 0) {
    if (fwd) strcpy(cmd, "AT+AA06\0"); else strcpy(cmd, "AT+AA07\0");
    ltSend(cmd);
  }  
  clearValues(false);
}

byte pressCnt() {
  if (pressTime > 5000) return 50; else return (pressTime / 100);
}

bool musicMode(char* p) {
  uint8_t m = selectMode();
  switch (m) {
    case btnLeft: strcpy(p, "AT+CM03\0"); return true;
    case btnRight: strcpy(p, "AT+CM02\0"); return true;
    case btnDown: ;
    case btnUp: strcpy(p, "AT+CM01\0"); return true;
    default: return false;
  }
}

void svcKey(uint8_t k) { //cteni klaves ovladace
  if (!dispOn) { //pouze rozsviti displej
    lcdOn();
    delay(200);
    return;
  }   
  seq = 1;
  dispTime = dispOff;
  char cmd[16];
  switch (k) {
    case btnSelect: // play/pause
      strcpy(cmd, "AT+CB\0");
      ltSend(cmd);
      return;
    case btnLeft: // o jeden zpet
      clearValues(false); 
      strcpy(cmd, "AT+CD\0");
      ltSend(cmd);
      return;
    case btnRight: // o jeden dal
      clearValues(false);
      strcpy(cmd, "AT+CC\0");
      ltSend(cmd);
      return;
    case btnUp: // zesilit
      strcpy(cmd, "AT+CE\0"); 
      ltSend(cmd);
      return;
    case btnDown: // zeslabit
      strcpy(cmd, "AT+CF\0"); 
      ltSend(cmd);
      return;
    case (0x80 | btnSelect): // vyber zdroje Bluetooth, USB, SD
      if (musicMode(cmd)) {
        clearValues(true);
        ltSend(cmd);
        return;
      }
      return;
    case (0x80 | btnLeft): // o slozku zpet
      goFolder(false); 
      return;
    case (0x80 | btnRight): // o slozku dal 
      goFolder(true); 
      return; 
    case (0x80 | btnDown): // posun zpet
      strcpy(cmd, "AT+AA05\0"); 
      for (byte i = 0; i < pressCnt(); i++) {
        ltSend(cmd); 
        delay(200);
      }
      clearTimes();
      return;
    case (0x80 | btnUp): // posun vpred
      strcpy(cmd, "AT+AA04\0");      
      for (byte i = 0; i < pressCnt(); i++) {
        ltSend(cmd); 
        delay(200);
      }
      clearTimes();
      return;
  }
}

void svcBT201() { //prubezna komunikace s BT201  
  #ifdef DEBUG
  Serial.print("svcBT201 mode: "); Serial.print(mode); Serial.print("; seq: "); Serial.print(seq);
  Serial.print("; sec: "); Serial.println(secs);
  #endif
  char p[16]; 
  for (byte i = 0; i < 16; i++) p[i] = 0;
  switch (seq) {
    case 0: //zjisteni modu, nebo stavu
      if (dispOn) {
        strcpy(p, "AT+QM\0"); 
        ltSend(p);
      } else seq++;  
      break; 
    case 1: //nazev aktivniho souboru
      if ((mode > btMode) && (strlen(mp3File) == 0)) {
          strcpy(p, "AT+MF\0"); 
          ltSend(p);
      } else seq++;
      break;
    case 2: //celkovy pocet souboru na pametove karte, nebo poradi aktivniho souboru
      if (mode > btMode) {
          if (mp3Count == 0) strcpy(p, "AT+M2\0"); else strcpy(p, "AT+M1\0");
          ltSend(p);
      } else seq++;
      break;
    case 3: //celkovy cas aktivniho souboru
      if (dispOn && (mode > btMode)) {
        if (mp3Order == 0) strcpy(p, "AT+M1\0");
        else if (mp3Time == 0) strcpy(p, "AT+MT\0"); 
        else strcpy(p, "AT+MK\0");
        ltSend(p);
      } else seq = 0;
      break;
  } 
} 

// ----------------------------------------------------------------------------------------------------

void ltEvent() {  
  if (waitResponse && lt.available()) {
    noInterrupts(); 
    responseCount = lt.read(response, maxlen - 1);
    #ifdef DEBUG
    Serial.print("Interrupt: "); Serial.println(responseCount); Serial.println((char*)currentCmd);
    #endif
  }  
}

void setup() {
  #ifdef DEBUG
  Serial.begin(115200);
  Serial.println("LT9820");
  #endif
  clearValues(true);
  initLCD();
  initLT();
  currentCmd[0] = '\0';
  responseCount = 0;
  response[0] = 0;
  waitResponse = false;  
  attachInterrupt(digitalPinToInterrupt(pinPKT), ltEvent, HIGH);  
}

void loop() {
  unsigned long pp = millis() / divisor;
  uint8_t k = readKey();
  if (k < 0xFF) {
    svcKey(k);
    secs = millis() / divisor;
    return;
  }   
  if (secs != pp) {
    secs = pp;
    if (dispOn && (dispTime == 0)) {
      lcd.clear();
      digitalWrite(pinLCD, LOW);      
      dispOn = false;
      return;
    } else {
      if (dispTime > 0) dispTime--;
    }
    if (waitResponse) {
      #ifdef DEBUG
      Serial.print("Odpover neprisla: "); Serial.println(responseCount); Serial.println((char*)currentCmd);
      #endif
      lcd.setCursor(9, 0);
      lcd.print("!");
      waitResponse = false;
      secs = millis() / divisor;
      return;
    }
    svcBT201();
  }
  
  if (waitResponse && (responseCount > 0)) {
    response[responseCount] = 0;
    parseResponse();
    errors = 0;
    seq++;
    if (seq > 3) seq = 0;
    responseCount = 0;
    response[0] = 0;
    currentCmd[0] = 0;
    waitResponse = false;
    lcdInfo();
  }  
}

aktualizováno 18.4.2025

Co je potřeba:

Moduly pro stanici:

Modul LT8920 typ XY-WA, nebo XY-WB
Arduino MEGA2560
Zvukový modul BT201 (MP3 přehrávač a bluetooth 5.0)
Reproduktor 4 - 8 ohm
Jako zdroj může být libovolný napáječ 8 - 12V, pokudmožno dobře odrušený.
Potenciometr 100R a další pasivní součástky, viz schema.

Moduly pro ovladadač:

Modul LT8920 typ XY-WA, nebo XY-WB
Arduino UNO
LCD shield 16 x 2
Pro napájení 2 x článek 3.7V
s držákem Použít však můžete v podstatě jakékoliv články, tak aby daly alespoň 7V

Software:

Pro modul LT8920 je použita knihovna LT8920.h. Komunikace mezi stanicí a ovladačem je asynchronní, po odeslání pakety (dotazu) se hned nečeká na odpověď. V jiné smyčce se pak snímají požadovaná data (pořadí, celkový počet, čas a název souboru).
Důležitý je výběr kanálu, na kterém bude komunikovat ovladač se stanicí. Wifiny, bluetooth a nevím co všechno ještě používají stejné pásmo 2.4GHz. Zde je nastaven kanál 83 (skoro okraj pásma). U stanice a ovladače musí být kanál stejný. Kanál se nastavuje v obou zdrojácích na tomto řádku:

#define wifiCanal 2483 - 2402

kde kanál se vypočítá výrazem: frekvence kanálu v MHz - 2402

Poznámka na závěr

Modul BT201 má mnoho dalších funkcí a celý tento "projekt" by šel dál rozvíjet. Chtělo by to jiný ovladač, s více tlačítky a možná i většímm displejem.
Modul umožňuje nahrávání z mikrofonu, místo přímého výstupu do reproduktoru, se může ke sluchátkovému výstupu modulu připojit stereofonnní zesilovač, atd, atd... Snad někdy příště :-).

Programy zdarma, Arduino návody, tratě pro Open Rails a MSTS.

Vzkazník - dotazy, názory, připominky, hlášení chyb, atd:
jméno (e-mail): E-mail nebude nikde zveřejněn, uveďte jej, pouze pokud si přejete odpověď.
text: