Besoin de conseils : Boite à histoires / musiques

Besoin de conseils : Boite à histoires / musiques - Nano-ordinateur, microcontrôleurs, FPGA - Electronique, domotique, DIY

Marsh Posté le 15-09-2023 à 09:09:33    

Bonjour,
 
J'ai pour projet de faire une boite à histoires type Lunii.
Mon projet comprendra :
 
une batterie
un écran tactile
un ou deux HPs (à voir)
une carte SD
un bouton ON/OFF physique
un bouton volume
(en tactile)
 
Fonctions :
 
Lire des fichiers MP3 soit simplement comme une musique, soit avec des choix interactifs (par exemple choisir un personnage, un lieu etc) [ cette seconde partie est optionnelle pour l'instant]
Afficher un menu stop/play
Afficher un menu de sélection (probablement pour commencer, sous la forme de deux boutons précédent/suivant + un bouton "Home" ) sur l'écran tactile
Avoir un menu paramètre pour désactiver si besoin certaines fonctionnalités si présentes sur la carte (comme le wifi/BT)
pouvoir éteindre l'appareil
pouvoir régler le volume.
La taille : ça sera un peu plus grand/large que la boite à histoire de lunii j'imagine l'écran devant faire dans les 3/5 pouces idéalement (par ex 4.3).
Concernant le boitier, j'ai un ami qui dispose d'un laser de découpe donc ça sera sur du bois.
 
 
Ce que je recherche sur ce forum ce sont des conseils de matériels à choisir pour réaliser ce projet et surtout qui fonctionnent. Je pense qu'en tant que connaisseurs ou habitués, ça sera plus rapide de vous demander.
 
Merci d'avance !
 
EDIT :
 
Suite à pas mal de recherches on m'a conseillé de passer sur de l'ESP32. En cherchant un peu quoi acheter, je me suis perdu dans ces recherches.
 
Donc j'ai surtout besoin de conseils sur la liste du matos afin que ça puisse fonctionner ensemble. Le code je vais gérer.
 
 
 
J'ai repéré quelques trucs :
- ESP32-WT32-SC01 PLUS (https://fr.aliexpress.com/item/1005004267336768.html) -> à voir si je peux y mettre un HP et une batterie (si oui lesquels)
- ESP32-S3-LCD-EV-Board-2 (introuvable)
- ESP32-S3 HMI (IPS 4.3) (https://fr.aliexpress.com/item/1005005633096413.html) -> à voir si je peux y mettre un HP et une batterie (si oui lesquels)
- monter avec un ensemble de pièces (c'est là que je bloque aussi, je ne sais pas trop quoi acheter), mais à base d'ESP-S3 je  pense
 
Merci !


Message édité par headquaker le 15-09-2023 à 14:32:19

---------------
j'ai craqué mais ça va c'est pas trop cher :o
Reply

Marsh Posté le 15-09-2023 à 09:09:33   

Reply

Marsh Posté le 15-09-2023 à 14:23:54    

Tu pars de loin visiblement... Tu as un peu d'expérience/des connaissances en électronique? Un fer à souder (même si tu prend des modules faudra peut-être rajouter un câble ou ...), un multi même basique?
 
Plusieurs points en vrac:
 
-Déjà merci de nettoyer les liens Ali, TOUT ce qui vient après le point d'interrogation c'est du tracking.
 
-Les boutons tactiles sont plus complexes car il faut un contrôleur ou un CI dédié qui gère ça tout en limitant la consommation de courant.
 
-Justement parlant d'énergie, un conseil, ne prend pas de batteries Li* chez Ali. Perso je suis pas convaincu de la qualiteuh et c'est pas sans danger ces bestioles... Aussi il faudrait faire au moins un calcul rapide pour voir ce que ça donne avec le ESP, il a des modes "sleep" ou similaire? Et un écran, enfin surtout l'éclairage, ça bouffe...
 
-Pour du MP3 depuis carte SD faut de la puissance de calcul, donc ESP obligatoire et à voir si c'est suffisant / si on trouve des lib (tu veux partir sur du code Arduino je suppose?). Un proc' 8 bits genre les Arduino "classiques" ne va pas le faire.


---------------
Si vous ouvrez un sujet merci de ne pas le "laisser mourir" subitement et de le marquer comme "résolu" le cas échéant!
Reply

Marsh Posté le 15-09-2023 à 14:35:48    

je sais qu'arduino ne serait pas suffisant.
En électronique, un peu, j'ai du matos et un ami qui maitrise bien aussi les soudures.
 
Ca ne me dérange pas de partir sur du bouton physique.
Je voulais même prendre un écran type E-paper comme les liseuses.
Pour l'énergie, je ne sais pas encore où je vais acheter. S'il existe des bonnes marques de batterie, je prends. Je veux une belle autonomie comme l'actuelle Lunii que nous avons. (donc plusieurs jours)


Message édité par headquaker le 15-09-2023 à 14:38:37

---------------
j'ai craqué mais ça va c'est pas trop cher :o
Reply

Marsh Posté le 16-09-2023 à 12:26:22    

J'ai pris un kit ESP32 S3 pour déjà voir si mon concept tient la route. avec un petit écran et pour m'entrainer aussi.


---------------
j'ai craqué mais ça va c'est pas trop cher :o
Reply

Marsh Posté le 23-09-2023 à 22:55:22    

mon concept marche bien pour l'instant.
Pause/Play : OK
Volume Down/UP : OK
Titre précédent / suivant : OK
Désactivation du Wifi & BT : OK
 
Petite vidéo :
https://www.youtube.com/shorts/AbkSwMBzGEQ
 
Prochaine étape : gestion des albums.
 
Ensuite : portage du concept sur un ESP32-S3 IHM avec écran tactile.
A prévoir en plus :
- Gestion des images sur les albums
- Menu settings protégé par mot de passe
- Gestion de la batterie
- Gestion de la luminosité de l'écran
- Le design de l'interface (basique car pour enfant)
- Le boitier + protection de l'écran


Message édité par headquaker le 24-09-2023 à 01:02:58

---------------
j'ai craqué mais ça va c'est pas trop cher :o
Reply

Marsh Posté le 02-10-2023 à 13:39:04    

J'ai besoin d'aide sur le code, ne maitrisant pas du coup cpp.
 
Je suis capable de lire un fichier MP3, et j'ai déjà beaucoup de code qui fonctionne bien pour effectuer des opérations telles que suivant, pause, etc.
 
Le problème est que ce code fonctionnait avec une structure SD où tous les fichiers MP3 se trouvaient à la racine.
 
Ce que je souhaite, c'est être en mesure de passer d'un dossier à un autre et de lire des fichiers MP3 à l'intérieur de ces dossiers.
 
Pourriez-vous m'aider ?
 
Je suis au courant de connecttoSD et connecttoFS, mais je n'arrive pas à les faire fonctionner avec FS, et je ne veux pas utiliser de chemins statiques comme ici.

Code :
  1. String filePath = "/m/RandomFolder1/" + filename;
  2.   audio.connecttoSD(filePath.c_str());


SD Card structure

Code :
  1. root
  2. root/h
  3. root/m
  4.  root/m/RandomFolder1
  5.   root/m/RandomFolder1-1.mp3
  6.   root/m/RandomFolder1-2.mp3
  7.   root/m/RandomFolder1-3.mp3
  8.   ...
  9.  root/m/RandomFolder2
  10.   root/m/RandomFolder2-1.mp3
  11.   root/m/RandomFolder2-2.mp3
  12.   root/m/RandomFolder2-3.mp3
  13.   ...
  14.  root/m/RandomFolderX
  15.   root/m/RandomFolderX-1.mp3
  16.   root/m/RandomFolderX-2.mp3
  17.   root/m/RandomFolderX-3.mp3
  18.   ...


 

Code :
  1. #include "Arduino.h"
  2. #include "Audio.h"
  3. #include "FS.h"
  4. #include "SPI.h"
  5. #include "SD.h"
  6. #include <Wire.h>
  7. #include <vector>
  9. #define TFT_BL 2
  11. #define SD_SCK 12 // CLK
  12. #define SD_MISO 13 // D0
  13. #define SD_MOSI 11 // CMD
  14. #define SD_CS 10 // CLK
  16. #define I2S_DOUT 17
  17. #define I2S_BCLK 0
  18. #define I2S_LRC 18
  20. const unsigned long VOL_CHANGE_DELAY = 500; // Delay between volume changes
  21. const unsigned long DISPLAY_VOLUME_DURATION = 3000; // Display volume for 3 seconds
  23. struct Music_info
  24. {
  25.   String name;
  26.   int length;
  27.   int runtime;
  28.   int volume;
  29.   int status;
  30.   int mute_volume;
  31. } music_info = {"", 0, 0, 0, 0, 0};
  33. Audio audio;
  34. File musical;
  35. std::vector<String> mp3Files;
  36. int currentSongIndex = -1;
  37. bool isPlaying = false;
  39. void setup()
  40. {
  41.   Serial.begin(115200);
  42.   pin_init();
  43.   sd_init();
  44.   musical = SD.open("/m" );
  45.   if (!musical || !musical.isDirectory())
  46.   {
  47.     Serial.println("Failed to open /M directory" );
  48.     return;
  49.   }
  52.   // Load the list of MP3 files in the first album (subdirectory) under /M/
  53.   loadMP3Files();
  55.   // Check if there are MP3 files in the album
  56.   if (mp3Files.size() > 0)
  57.   {
  58.     // Start playing the first MP3 file
  59.     currentSongIndex = 0;
  60.       audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  61.   audio.setVolume(15); // Adjust the initial volume as needed
  62.     playMP3File(mp3Files[currentSongIndex]);
  63.   }
  64.   else
  65.   {
  66.     Serial.println("No MP3 files found in the first album" );
  67.   }
  68. }
  70. void loop()
  71. {
  72.   //handleAudio();
  73.   // Your other main loop code can go here
  74.   audio.loop();
  75. }
  77. //---- Device init --------------------------------------------------
  78. void pin_init()
  79. {
  80.   pinMode(TFT_BL, OUTPUT);
  81.   digitalWrite(TFT_BL, HIGH);
  82. }
  84. void sd_init()
  85. {
  86.   pinMode(SD_CS, OUTPUT);
  87.   digitalWrite(SD_CS, HIGH);
  88.   SPI.begin(SD_SCK, SD_MISO, SD_MOSI);
  89.   SPI.setFrequency(400000);
  90.   if (!SD.begin(SD_CS, SPI))
  91.   {
  92.     Serial.println("Card Mount Failed" );
  93.     while (1)
  94.       ;
  95.   }
  96.   else
  97.   {
  98.     Serial.println("SD OK" );
  99.   }
  100. }
  102. void loadMP3Files()
  103. {
  104.   mp3Files.clear();
  105.   File entry;
  107.   // Open the first album (subdirectory) in /M/
  108.   File album = musical.openNextFile();
  109.   if (!album || !album.isDirectory())
  110.   {
  111.     Serial.println("No albums found in /M directory" );
  112.     return;
  113.   }
  115.   // Load the list of MP3 files in the first album
  116.   while (File entry = album.openNextFile())
  117.   {
  118.     if (!entry.isDirectory() && String(entry.name()).endsWith(".mp3" ))
  119.     {
  120.       mp3Files.push_back(String(entry.name()));
  121.     }
  122.   }
  123.   album.rewindDirectory();
  124. }
  126. void playMP3File(const String &filename)
  127. {
  128.   Serial.println("Playing: " + filename);
  129.   //Serial.println("Folder: " + SD.name());
  131.   // Extract the name of the MP3 file without the extension
  132.   int dotIndex = filename.lastIndexOf("." );
  133.   if (dotIndex != -1)
  134.   {
  135.     String nameWithoutExtension = filename.substring(0, dotIndex);
  137.     // Assuming 'music_info' is a struct or object with a 'name' member variable
  138.     music_info.name = nameWithoutExtension;
  139.   String filePath = "/m/RandomFolder1/" + filename;
  140.   audio.connecttoSD(filePath.c_str());
  142.     isPlaying = true;
  143.   }
  144.   else
  145.   {
  146.     Serial.println("Invalid filename" );
  147.   }
  148. }
  152. void handleAudio()
  153. {
  154.   if (isPlaying)
  155.   {
  156.     if (!audio.isRunning())
  157.     {
  158.       // Audio playback has finished
  159.       Serial.println("Playback finished" );
  160.       isPlaying = false;
  162.       // Add logic here to advance to the next MP3 file or perform other actions
  163.       // For example, you can increment currentSongIndex and call playMP3File again
  164.       if (currentSongIndex < mp3Files.size() - 1)
  165.       {
  166.         currentSongIndex++;
  167.         playMP3File(mp3Files[currentSongIndex]);
  168.       }
  169.       else
  170.       {
  171.         Serial.println("No more MP3 files to play" );
  172.       }
  173.     }
  174.   }
  175. }


---------------
j'ai craqué mais ça va c'est pas trop cher :o
Reply

Marsh Posté le 08-10-2023 à 11:27:24    

Bonjour j'ai un code qui marche, je sais qu'il y a pleins de conneries, faut que je l'optimise maintenant
 

Code :
  1. #include "Arduino.h"
  2. #include "Audio.h"
  3. #include "FS.h"
  4. #include "SPI.h"
  5. #include "SD.h"
  6. #include <Wire.h>
  7. #include <vector>
  8. #include <lvgl.h>
  9. #include <ui.h>
  10. #include <Arduino_GFX_Library.h>
  12. #define TFT_BL 2
  14. #define SD_SCK 12 // CLK
  15. #define SD_MISO 13 // D0
  16. #define SD_MOSI 11 // CMD
  17. #define SD_CS 10 // CLK
  19. #define I2S_DOUT 17
  20. #define I2S_BCLK 0
  21. #define I2S_LRC 18
  23. #define GFX_BL DF_GFX_BL // default backlight pin, you may replace DF_GFX_BL to actual backlight pin
  25. #if defined(DISPLAY_DEV_KIT)
  26. Arduino_GFX *gfx = create_default_Arduino_GFX();
  27. #else /* !defined(DISPLAY_DEV_KIT) */
  29. Arduino_ESP32RGBPanel *bus = new Arduino_ESP32RGBPanel(
  30.     GFX_NOT_DEFINED /* CS */, GFX_NOT_DEFINED /* SCK */, GFX_NOT_DEFINED /* SDA */,
  31.     40 /* DE */, 41 /* VSYNC */, 39 /* HSYNC */, 42 /* PCLK */,
  32.     45 /* R0 */, 48 /* R1 */, 47 /* R2 */, 21 /* R3 */, 14 /* R4 */,
  33.     5 /* G0 */, 6 /* G1 */, 7 /* G2 */, 15 /* G3 */, 16 /* G4 */, 4 /* G5 */,
  34.     8 /* B0 */, 3 /* B1 */, 46 /* B2 */, 9 /* B3 */, 1 /* B4 */
  35. );
  36. // option 1:
  37. // ST7262 IPS LCD 800x480
  38. Arduino_RPi_DPI_RGBPanel *gfx = new Arduino_RPi_DPI_RGBPanel(
  39.     bus,
  40.     800 /* width */, 0 /* hsync_polarity */, 8 /* hsync_front_porch */, 4 /* hsync_pulse_width */, 8 /* hsync_back_porch */,
  41.     480 /* height */, 0 /* vsync_polarity */, 8 /* vsync_front_porch */, 4 /* vsync_pulse_width */, 8 /* vsync_back_porch */,
  42.     1 /* pclk_active_neg */, 12000000 /* prefer_speed */, true /* auto_flush */);
  43. #endif /* !defined(DISPLAY_DEV_KIT) */
  44. /*******************************************************************************
  45. * End of Arduino_GFX setting
  46. ******************************************************************************/
  48. /*******************************************************************************
  49. * Please config the touch panel in touch.h
  50. ******************************************************************************/
  51. #include "touch.h"
  53. Audio audio;
  54. File musical;
  55. std::vector<String> mp3Files;
  56. int currentSongIndex = -1;
  57. bool isPlaying = false;
  58. bool playbackFinished = false; // Flag to detect playback completion
  60. struct Music_info
  61. {
  62.     String name;
  63.     int length;
  64.     int runtime;
  65.     int volume;
  66.     int status;
  67.     int mute_volume;
  68. } music_info = {"", 0, 0, 0, 0, 0};
  70. // Structure for storing file information
  71. struct FileInfo
  72. {
  73.     String parentFolder;
  74.     String currentFolder;
  75.     String shortFileName;
  76.     String fullPath;
  77. };
  79. std::vector<FileInfo> fileInfoList; // Store file information
  81. // Structure for storing folder information
  82. struct FolderInfo
  83. {
  84.     String parentFolder;
  85.     String currentFolder;
  86.     std::vector<FileInfo> files;
  87. };
  89. std::vector<FolderInfo> folderInfoList; // Store folder information
  91. /* Change to your screen resolution */
  92. static uint32_t screenWidth;
  93. static uint32_t screenHeight;
  94. static lv_disp_draw_buf_t draw_buf;
  95. static lv_color_t *disp_draw_buf;
  96. static lv_disp_drv_t disp_drv;
  98. // Add a variable to keep track of the current folder
  99. String currentFolder = "/m"; // Start with the root folder
  101. void setup()
  102. {
  103.     // Hardware initialization
  104.     pin_init();
  105.     sd_init();
  107.     // Init Display
  108.     gfx->begin();
  110.     gfx->fillScreen(RED);
  111.     delay(500);
  112.     gfx->fillScreen(GREEN);
  113.     delay(500);
  114.     gfx->fillScreen(BLUE);
  115.     delay(500);
  116.     gfx->fillScreen(BLACK);
  117.     delay(500);
  118.     lv_init();
  119.     delay(10);
  120.     touch_init();
  121.     screenWidth = gfx->width();
  122.     screenHeight = gfx->height();
  123. #ifdef ESP32
  124.     disp_draw_buf = (lv_color_t *)heap_caps_malloc(sizeof(lv_color_t) * screenWidth * screenHeight / 4, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
  125. #else
  126.     disp_draw_buf = (lv_color_t *)malloc(sizeof(lv_color_t) * screenWidth * screenHeight / 4);
  127. #endif
  128.     if (!disp_draw_buf)
  129.     {
  130.         Serial.println("LVGL disp_draw_buf allocate failed!" );
  131.     }
  132.     else
  133.     {
  134.         lv_disp_draw_buf_init(&draw_buf, disp_draw_buf, NULL, screenWidth * screenHeight / 4);
  136.         /* Initialize the display */
  137.         lv_disp_drv_init(&disp_drv);
  138.         /* Change the following line to your display resolution */
  139.         disp_drv.hor_res = screenWidth;
  140.         disp_drv.ver_res = screenHeight;
  141.         disp_drv.flush_cb = my_disp_flush;
  142.         disp_drv.draw_buf = &draw_buf;
  143.         lv_disp_drv_register(&disp_drv);
  145.         /* Initialize the (dummy) input device driver */
  146.         static lv_indev_drv_t indev_drv;
  147.         lv_indev_drv_init(&indev_drv);
  148.         indev_drv.type = LV_INDEV_TYPE_POINTER;
  149.         indev_drv.read_cb = my_touchpad_read;
  150.         lv_indev_drv_register(&indev_drv);
  152.         // Loading interface
  153.         ui_init();
  155.         lv_obj_add_event_cb(ui_btPrevious, playPreviousSong, LV_EVENT_PRESSED, NULL);
  156.         lv_obj_add_event_cb(ui_btPlay, playNextSong, LV_EVENT_PRESSED, NULL);
  157.         lv_obj_add_event_cb(ui_btPause, tooglePlayPause, LV_EVENT_PRESSED, NULL);       
  158.         lv_obj_add_event_cb(ui_btNext, playNextSong, LV_EVENT_PRESSED, NULL);
  159.         lv_obj_add_event_cb(ui_btStop, stopSong, LV_EVENT_PRESSED, NULL);
  160.         lv_obj_add_event_cb(ui_btHome, ui_event_btHome, LV_EVENT_PRESSED, NULL);
  161.         lv_obj_add_event_cb(ui_btUp, goToPreviousFolder, LV_EVENT_PRESSED, NULL);
  162.         lv_obj_add_event_cb(ui_btDown, goToNextFolder, LV_EVENT_PRESSED, NULL);
  163.         lv_obj_add_event_cb(ui_btHistory, ui_event_btHistory, LV_EVENT_PRESSED, NULL);
  164.         lv_obj_add_event_cb(ui_btMusical, setMusicalMode, LV_EVENT_PRESSED, NULL);
  165.         lv_obj_add_event_cb(ui_sliderVolume, changeVolume, LV_EVENT_VALUE_CHANGED, NULL);
  167.         // Setup MP3
  168.         audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  169.         audio.setVolume(7); // Adjust the initial volume as needed
  171.     // Set the root directory to "/m"
  172.     //setRootDirectory(currentFolder); // Set the root directory to the current folder
  173.     //printFolderInfoList();
  174.     // Add more debugging statements
  175.     //Serial.print("After setRootDirectory: " );
  176.     //Serial.println(fileInfoList.size());
  178.     // Play the first MP3 file if available
  179.     //playFirstMP3IfAvailable();
  181.     // Add a delay to ensure serial output is visible before the loop starts
  182.     //delay(1000); // You can adjust the delay time as needed
  183.     }
  184. }
  186. void loop()
  187. {
  188.     // Your other main loop code can go here
  189.     audio.loop();
  191.     lv_event_t lv_event;
  192.     checkAndPlayNextSong(&lv_event);
  194.     // Check if playback is finished
  195.     if (playbackFinished && isPlaying)
  196.     {
  197.         isPlaying = false;
  198.         playbackFinished = false; // Reset the flag
  199.     }
  201.     lv_timer_handler(); /* let the GUI do its work */
  202.     delay(2);
  203. }
  205. // Functions
  206. /* Display flushing */
  207. void my_disp_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p)
  208. {
  209.     uint32_t w = (area->x2 - area->x1 + 1);
  210.     uint32_t h = (area->y2 - area->y1 + 1);
  212. #if (LV_COLOR_16_SWAP != 0)
  213.     gfx->draw16bitBeRGBBitmap(area->x1, area->y1, (uint16_t *)&color_p->full, w, h);
  214. #else
  215.     gfx->draw16bitRGBBitmap(area->x1, area->y1, (uint16_t *)&color_p->full, w, h);
  216. #endif
  218.     lv_disp_flush_ready(disp);
  219. }
  221. void my_touchpad_read(lv_indev_drv_t *indev_driver, lv_indev_data_t *data)
  222. {
  223.     if (touch_has_signal())
  224.     {
  225.         if (touch_touched())
  226.         {
  227.             data->state = LV_INDEV_STATE_PR;
  229.             /*Set the coordinates*/
  230.             data->point.x = touch_last_x;
  231.             data->point.y = touch_last_y;
  232.         }
  233.         else if (touch_released())
  234.         {
  235.             data->state = LV_INDEV_STATE_REL;
  236.         }
  237.     }
  238.     else
  239.     {
  240.         data->state = LV_INDEV_STATE_REL;
  241.     }
  242. }
  244. // Function to play an MP3 file
  245. void setMusicalMode(lv_event_t *e)
  246. {
  247.     currentFolder = "/m"; // Set the current folder to /m
  248.     setRootDirectory(currentFolder); // Set the root directory to /m
  249.     playFirstMP3IfAvailable(); // Play the first MP3 file in the new folder if available
  250. }
  252. void playFirstMP3IfAvailable()
  253. {
  254.     if (!fileInfoList.empty())
  255.     {
  256.         currentSongIndex = 0; // Start with the first MP3 file
  257.         const String &firstMP3 = fileInfoList[currentSongIndex].fullPath;
  258.         currentFolder = fileInfoList[currentSongIndex].currentFolder; // Update currentFolder
  259.         playMP3(firstMP3);
  260.     }
  261. }
  263. void playMP3(const String &mp3FilePath)
  264. {
  265.     const char *mp3Path = mp3FilePath.c_str();
  266.     audio.connecttoSD(mp3Path);
  267.     updateTitleLabel();
  268.     isPlaying = true;
  269.     playbackFinished = false; // Reset the flag
  270. }
  272. void checkAndPlayNextSong(lv_event_t *event)
  273. {
  274.     if (isPlaying && !audio.isRunning())
  275.     {
  276.         // Current MP3 file has finished playing, play the next one if available
  277.         currentSongIndex++;
  278.         if (currentSongIndex < fileInfoList.size())
  279.         {
  280.             const String &nextMP3 = fileInfoList[currentSongIndex].fullPath;
  281.             playMP3(nextMP3);
  282.         }
  283.         else
  284.         {
  285.             // All MP3 files in the folder have been played
  286.             isPlaying = false;
  287.         }
  288.     }
  289. }
  291. void playNextSong(lv_event_t *event)
  292. {
  293.     if (currentSongIndex >= 0 && currentSongIndex < fileInfoList.size() - 1)
  294.     {
  295.         currentSongIndex++;
  296.         const String &nextMP3 = fileInfoList[currentSongIndex].fullPath;
  297.         playMP3(nextMP3);
  298.     }
  299.     else if (!fileInfoList.empty())
  300.     {
  301.         // At the last song, play the first song of the folder
  302.         currentSongIndex = 0;
  303.         const String &firstMP3 = fileInfoList[currentSongIndex].fullPath;
  304.         playMP3(firstMP3);
  305.     }
  306. }
  308. void playPreviousSong(lv_event_t *event)
  309. {
  310.     if (currentSongIndex > 0)
  311.     {
  312.         currentSongIndex--;
  313.         const String &prevMP3 = fileInfoList[currentSongIndex].fullPath;
  314.         playMP3(prevMP3);
  315.     }
  316.     else
  317.     {
  318.         // Already at the first song, play it again or handle as needed
  319.         const String &firstMP3 = fileInfoList[0].fullPath;
  320.         playMP3(firstMP3);
  321.     }
  322. }
  324. void replayCurrentSong()
  325. {
  326.     if (currentSongIndex >= 0 && currentSongIndex < fileInfoList.size())
  327.     {
  328.         const String &currentMP3 = fileInfoList[currentSongIndex].fullPath;
  329.         playMP3(currentMP3);
  330.         isPlaying = true;
  331.     }
  332.     else
  333.     {
  334.         // No song is currently playing, so start playing the first one
  335.         playFirstMP3IfAvailable();
  336.     }
  337. }
  339. void stopSong(lv_event_t *event) {
  340.   audio.stopSong();
  341.   isPlaying = false;
  342. }
  344. void tooglePlayPause(lv_event_t *event) {
  345.     audio.pauseResume();
  347.     if (isPlaying) {
  348.       isPlaying = false;
  349.     } else {
  350.       isPlaying = true;
  351.     }
  352. }
  354. void updateTitleLabel() {
  355.     if (currentSongIndex >= 0 && currentSongIndex < fileInfoList.size()) {
  356.         String album = currentFolder; // Use the current folder as the album name
  357.         int lastSlashIndex = album.lastIndexOf('/');
  358.         if (lastSlashIndex != -1) {
  359.             album = album.substring(lastSlashIndex + 1);
  360.         }
  361.         String title = fileInfoList[currentSongIndex].shortFileName;
  362.         lv_label_set_text(ui_labelAlbum, album.c_str());
  363.         lv_label_set_text(ui_labelTitle, title.c_str());
  364.     } else {
  365.         lv_label_set_text(ui_labelAlbum, "" );
  366.         lv_label_set_text(ui_labelTitle, "" );
  367.     }
  368. }
  370. void changeVolume(lv_event_t *event) {
  371.     lv_event_code_t code = lv_event_get_code(event);
  372.    
  373.     if (code == LV_EVENT_VALUE_CHANGED) {
  374.         int volume = lv_slider_get_value(ui_sliderVolume);
  375.         audio.setVolume(volume);
  377.         char volumeText[8];
  378.         snprintf(volumeText, sizeof(volumeText), "%d", volume);
  379.         lv_label_set_text(ui_labelVolume, volumeText);
  380.     }
  381. }
  383. void goToPreviousFolder(lv_event_t *event)
  384. {
  385.     if (folderInfoList.empty()) {
  386.         return;
  387.     }
  389.     int currentFolderIndex = -1;
  390.     for (int i = 0; i < folderInfoList.size(); i++) {
  391.         if (folderInfoList[i].currentFolder == currentFolder) {
  392.             currentFolderIndex = i;
  393.             break;
  394.         }
  395.     }
  397.     if (currentFolderIndex <= 0) {
  398.         currentFolderIndex = folderInfoList.size() - 1;
  399.     } else {
  400.         currentFolderIndex--;
  401.     }
  403.     currentFolder = folderInfoList[currentFolderIndex].currentFolder;
  404.     fileInfoList = folderInfoList[currentFolderIndex].files;
  405.     currentSongIndex = -1;
  408.     playFirstMP3IfAvailable();
  409. }
  411. void goToNextFolder(lv_event_t *event)
  412. {
  413.     if (folderInfoList.empty()) {
  414.         return;
  415.     }
  417.     int currentFolderIndex = -1;
  418.     for (int i = 0; i < folderInfoList.size(); i++) {
  419.         if (folderInfoList[i].currentFolder == currentFolder) {
  420.             currentFolderIndex = i;
  421.             break;
  422.         }
  423.     }
  425.     if (currentFolderIndex == -1) {
  426.         return;
  427.     }
  429.     if (currentFolderIndex == folderInfoList.size() - 1) {
  430.         currentFolderIndex = 0;
  431.         currentFolder = folderInfoList[currentFolderIndex].currentFolder;
  432.         fileInfoList = folderInfoList[currentFolderIndex].files;
  433.     } else {
  434.         currentFolderIndex++;
  435.         currentFolder = folderInfoList[currentFolderIndex].currentFolder;
  436.         fileInfoList = folderInfoList[currentFolderIndex].files;
  437.     }
  439.     updateTitleLabel();
  440.     currentSongIndex = -1;
  442.     playFirstMP3IfAvailable();
  444.     int currentIndex = currentFolderIndex;
  445. }
  447. void printFolderInfoList() {
  448.     Serial.println("Folder Information List:" );
  450.     for (int i = 0; i < folderInfoList.size(); i++) {
  451.         Serial.println("Folder Index: " + String(i));
  452.         Serial.println("Parent Folder: " + folderInfoList[i].parentFolder);
  453.         Serial.println("Current Folder: " + folderInfoList[i].currentFolder);
  454.     }
  455. }
  457. void setRootDirectory(const String &rootDir)
  458. {
  459.     folderInfoList.clear();
  460.     fileInfoList.clear();
  462.     File root = SD.open(rootDir);
  463.     if (!root)
  464.     {
  465.         Serial.println("Failed to open root directory." );
  466.         return;
  467.     }
  469.     collectFolderInfo(root, "", rootDir);
  470.     fileInfoList = folderInfoList[0].files; // Set fileInfoList based on the root folder
  472.     root.close();
  473. }
  475. void collectFolderInfo(fs::File dir, String parentFolder, String currentFolder)
  476. {
  477.     FolderInfo folderInfo;
  478.     folderInfo.parentFolder = parentFolder;
  479.     folderInfo.currentFolder = currentFolder;
  481.     while (File entry = dir.openNextFile())
  482.     {
  483.         String entryName = entry.name();
  485.         if (entry.isDirectory())
  486.         {
  487.             String subfolder = currentFolder + "/" + entryName;
  488.             Serial.print("Entering folder: " );
  489.             Serial.println(subfolder);
  490.             collectFolderInfo(entry, currentFolder, subfolder);
  491.         }
  492.         else
  493.         {
  494.             String fileExtension = entryName.substring(entryName.lastIndexOf('.') + 1);
  495.             // Check if the file has an MP3 extension (you can add other audio file extensions if needed)
  496.             if (fileExtension.equalsIgnoreCase("mp3" ))
  497.             {
  498.                 FileInfo fileInfo;
  499.                 fileInfo.parentFolder = parentFolder;
  500.                 fileInfo.currentFolder = currentFolder;
  501.                 fileInfo.shortFileName = entryName;
  502.                 fileInfo.fullPath = currentFolder + "/" + entryName;
  503.                 fileInfoList.push_back(fileInfo);
  504.             }
  505.         }
  507.         entry.close();
  508.     }
  510.     if (currentFolder != "/m" && currentFolder != "/h" ) {
  511.         folderInfo.files = fileInfoList;
  512.         folderInfoList.push_back(folderInfo);
  513.     }
  514.     fileInfoList.clear();
  516.     Serial.print("File count in " );
  517.     Serial.print(currentFolder);
  518.     Serial.print(": " );
  519.     Serial.println(folderInfo.files.size());
  520. }
  522. void pin_init()
  523. {
  524.     pinMode(TFT_BL, OUTPUT);
  525.     digitalWrite(TFT_BL, HIGH);
  526. }
  528. void sd_init()
  529. {
  530.     pinMode(SD_CS, OUTPUT);
  531.     digitalWrite(SD_CS, HIGH);
  532.     SPI.begin(SD_SCK, SD_MISO, SD_MOSI);
  533.     SPI.setFrequency(400000);
  534.     if (!SD.begin(SD_CS, SPI))
  535.     {
  536.         Serial.println("Card Mount Failed" );
  537.         while (1)
  538.             ;
  539.     }
  540.     else
  541.     {
  542.         Serial.println("SD OK" );
  543.     }
  544. }


---------------
j'ai craqué mais ça va c'est pas trop cher :o
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed