Alimentation haut parleur 8 ohms 1W

Bonjour Yanoo

içi un exemple de transmision de flux audio par WiFi (en UDP) avec un ESP8266 :

Mico I2C _> ESP8266 -> WiFi (UDP) -> ordinateur

Je viens de tester "à l'arrache" les 2 versions hyper basiques avec un arduino nano et le sketch toneMelody

  1. avec une simple résistance de 220 ohms en série du haut parleur sur la patte D8
    => ça marche mais il faut vraiment tendre l'oreille pour l'entendre :smiley:

  2. avec un PN2222A et une résistance de 1 kilo-ohm en sortie de la patte D8 de l'arduino sur la base et une de 10 ohms en série du haut parleur sur le collecteur
    => c'est de suite un peu plus puissant :smiley: :smiley:

J'avais par défaut utilisé une résistance de 220 ohms pour le test 1), mais pense que je vais aussi tester avec une résistance de 150 pour voir si ça donne un peu plus de puissance en sortie
(22 mA avec une résistance de 220 ohms -> je préfère ne pas trop descendre en dessous de 150 ohms car ça fait déjà 5V / 150 ohms = 33 mA, ce qui s'approche pour moi déjà largement assez des limites de 40 mA par patte que je vois sur la doc

Si j'arrive à avoir une puissance sonore équivalente à celle fournie par le PN2222A sans avoir m'en servir, je penses que je baserais de suite la soluce 2), cf. avec PN2222A car je trouve que ça prend plus de la place / connectique qu'autre chose à première vue pour ce type d'usage basique ...

Je commencerais à mettre ça sur l'ESP8266 en fin de journée et commencerais à regarder pour y gérer la transmission d'un signal sonore en WiFi entre mon PC et l'ESP8266

Je ne recevrais les PAM8403 et les dfPlayer que demain et les MAX98357A que d'ici le début du mois prochain normalement
=> je commencerais les tests dessus dès que je les reçois et vous tiens au courant
(ce serait trop cool que j'arrive néanmoins dès ce soir ou demain à pouvoir transmettre un signal sonore via l'utilisation du serveur HTTP facilement installable sur l'ESP8266 => je croise les doigts pour que ça passe facile vite fait / bien fait :slight_smile: :slight_smile: )

:rocket: !!!

avec un ESP8266 la sortie par NPN devra tenir compte du courant maxi de 12mA par sortie (Data sheet en 5.1)

Ark, c'est seulement 12mA sur l'ESP8266 ?

=> dans ce cas, pas trop le choix, ca passera donc via le PN2222A alors ... même si ça me fait un peu plus de filoche/connectique à y caser en plus de la version sans :smiley: :smiley:

M'enfin bon, je pense que ça passera plutôt par le PAM8403 dès que je l'aurais reçu demain ou mieux le MAX98357A en début du mois prochain
(pour le dfPlayer, je ne ferais que quelques tests rapides mais pense qu'il ne me servira à rien dans mon cas précis, car spécialement concu pour lire des fichiers depuis une carte SD et sortir le son en analogique, pas du tout pour gérer des flux audio en temps-réel à première vue ... :frowning: :frowning: )
[quoique ... si avec un peu de chance la partie carte SD peut y rester utilisable en tant que simple lecteur de carte SD que je pourrais rajouter en rab dans le sac à dos miniature du robot, ça pourrais m'être utile pour y mémoriser en local les chemins effectués/à faire en priorité, des mots/phrases clés ou ce genre de trucs ...]

Je viens de recevoir mes PAM8403 et mes DFPlayer :slight_smile:

En attendant, j'ai trouvé la librairie ESP8266SAM sur le net qui fait la synthèse vocale
(cf. tu lui mets un texte en entrée et elle te lit en sortie sur un speaker ou un composant I2S)

=> je pense que je vais l'utiliser sur mes robots
(déjà testé la synthèse vocale sur PC via eSpeak pour n'extraire que le texte d'une page HTML / URL et le lire vocalement ... ou pour automatiquement déblatérer des conneries en boucle :smiley: :smiley: )
[avec une bonne dizaines de sujets, de verbes et de compléments que tu prends aléatoirement, c'est que ça peut vite fait en dire des "conneries à la petit nègre" :smiley: :smiley: ]

ESP8266SAM utilise la librairie ESP8266Audio pour envoyer le son vers la sortie mais je n'ai pas encore trouvé dans les sources comment il l'utilise exactement
(je me suis vite fait perdu dans les sources à essayer de comprendre comment la synthèse vocale y fonctionne et avoue n'y avoir strictement rien compris avec leur int Code"trucà5chiffres"() et leurs variables unsigned char mem"trucà2chiffres" à gogo dans le code :smiley: :smiley: )
=> je vais continuer à fouiner dans les sources pour voir comment SAM fonctionne de concert avec la librairie ESP8266Audio afin d'y définir le type de sortie à utiliser
(cf. en direct sur le haut parleur ou via I2S d'après ce que j'ai compris => ne me reste plus qu'à trouver où ça se définit dans le code source maintenant :smiley: :smiley: )

Pour la gestion du Wifi, je pense que j'utiliserais tout simplement les objets WiFiServer et WiFiClient pour gérer assez facilement l'envoi et la réception des différents messages comme le code IR à émettre pour piloter le robot ou le texte qu'il devra énoncer ou envoyer à ses camarades par exemples

M'enfin bon, je prend en "preum's" la synthèse vocale, puis m'attaque ensuite à la partie IR
(j'ai déjà par le passé réussi à bien décoder les infos envoyés par les télécommandes des robots sur un arduino nano mais n'en ai encore jamais envoyés + ni fait l'un ni l'autre sur ESP8266 => je verrais bien mais ça devrait passer : à coup sûr je devrais galérer un pneu beaucoup mais ça devrait passer :smiley: :smiley: )

Je m'occuperais par le suite du problème d'alimentation de l'ESP8266 via un accu, après avoir mesuré la consommation de 'ESP8266 en pleine charge une fois que j'y aurais ajouté un capteur de mouvement et un capteur de son
(peut-être même que j'y rajouterais un DHT11/22 et un capteur de lumière afin qu'ils puissent se la jouer à la style "j'suis un météorologue [du temps présent]" en plus du "je crois avoir entendu quelqu'un parler ou détecté qqchose bouger dans le coin" :smiley: :smiley: )

Je vous tiendrait au courant de l'avancement à chaque étape

J"ai trouvé où l'on doit déclarer le type de sortie à utiliser
=> je n'avais tout simplement pas encore regardé le code du sketch Speak.ino , c'est en tout début : suffisait qu'arrive son tour d'être lu :smiley:
(ESP8266SAM/examples/Speak at master · earlephilhower/ESP8266SAM · GitHub)

#include <Arduino.h>
#include <ESP8266SAM.h>
#include <AudioOutputI2S.h>

AudioOutputI2S *out = NULL;

void setup()
{
out = new AudioOutputI2S();
out->begin();
}

Bonsoir

le 'détournement' de l'I2S vers un DAC delta sigma (interne à l'ESP) est décrit sur le dépot d ela librairie audio de Earl Philhower :
https://github.com/earlephilhower/ESP8266Audio#software-i2s-delta-sigma-dac-ie-playing-music-with-a-single-transistor-and-speaker

SAM ? D'après mes souvenirs, pas très doué pour la langue française.... Le portage que vient de faire Earl Phillower est l'occasion de réécouter cette voix de synthèse des ordis 8bits

Merci, Al1fch

J'y vois "Note that with this interface, depending on the transistor used, you may need to disconnect the Rx pin from the driver to perform serial uploads." dans le lien que tu m'as donné

Ca veut bien dire qu'il faudra que je débranche le fil qui va de la patte Rx de l'ESP8266 vers la base du transistor 2N3904 pour charger le sketch dans l'ESP8266 ?

Même si je relie l'ES266 à mon PC via l'USB pour y charger les sketchs ?

J'utilise pour l'instant systématiquement le port USB pour ajouter des infos de debug sur la sortie série dans l'IDE Arduino et y télécharger le sketch mais n'utiliserais plus à terme le port USB car y utiliserais un accu + step-up 5V pour l'alimenter et redirigerais plutôt de préférence, si c'est possible, la sortie série du texte vers des messages envoyés sur l'interface HTML du PC en WiFi

Est-il de plus possible de préparer l'ESP8266 pour que la mise à jour du sketch puisse se faire en WiFi plutôt qu'en USB ou via un convertisseur USB / TTL ?

Ceci afin de pouvoir mettre à jour le sketch sur l'ESP8266 "on the air" via le WiFi, cf. de pouvoir le mettre à jour sans ne plus rien avoir à y toucher physiquement
(ce serait alors vraiment le top car je pourrais alors mettre à jour indépedamment chacun des robots sans rien n'avoir à toucher sur eux une fois qu'ils seront installés dans le sac à dos des robots)

Concernant le côté SAM, ce n'est pas bien grave si le son qui en ressort fait assez "métallique" / 8bits d'antant pour les débuts tant que le son sortira via un "simple hack" résistance + 2N3904 sur la sortie I2S :smiley:

Par contre, quand je recevrais le MAX98357A d' Adafruit d'ici la fin du mois, là il me faudra alors peut-être effectivement passer à quelque chose de "plus mieux" que SAM car ce sera du 16 bits que je pense utiliser en 22 Khz mono

Le but final n'étant pas d'avoir un qualité hifi "haut de gamme" en 44 Khz stéréo non plus, mais simplement que les robots puissent parler de façon relativement intelligible, et de temps en temps pousser la chansonnette, tout en ne cherchant pas à fleurter avec les limites physiques des composants car je voudrais que ce soit plutôt du "solide/fiable" que du "tip-top mais qui lâche au boût de quelques heures" :smiley: :smiley:

Bonjour

Oui. de par sa conception la sortie 'dac' l2S d'un ESP8266 est figeé sur RX0, (Data Sheet Table 1.5) mieux vaut éviter les mélanges ds infos sur cette patte par ou psse tous les code flashés 'par câble'

Est-il de plus possible de préparer l'ESP8266 pour que la mise à jour du sketch puisse se faire en WiFi plutôt qu'en USB ou via un convertisseur USB / TTL ?

OUi : injecter d'abord un code conçu avec option OTA ('On The Air) puis faire les mise à jours suivantes par WIFi
On trouve de nombreux exemples de travail en OTA. Plusieurs sur cet excellent site , tant pour ESP8266 que ESP32:
Conséquence : moins de place disponible en mémoire Flash puis qu'il faut stocker deux versions successives du code. Mémoire Flash à partager entre les deux zones de code, un éventuel systeme de fichiers et autres bricoles...

En voyant ton ambitieux 'chantier' yanoo , je ne comprend pas pourquoii tu restes sur l'ESP8266
l'ESP32 parait mieux dimensionné pour ton projet offre une assez grand flexibilité pour le positionnement des signaux sur les pattes (par exemple les E/S des deux canaux I2S peuvent être placées sur presque tout GPIO)

En ne cherchant pas à fleurter avec les limites physiques des composants car je voudrais que ce soit plutôt du "solide/fiable" que du "tip-top mais qui lâche au boût de quelques heures"

C'est une façon de voir les choses partagée par de nombreux intervenants de ce forum , qui préfèrent pour cela tenir compte des précieuses informations fournies par les concepteurs des puces !!

Bonjour Yannoo

J'ai vu que tu parlais de i2S (je ne connais pas), en lisant de la doc je suis tombé sur ce module
image

Cordialement
jpbbricole

Merci pour les infos, Al1fch et Jpbbricole

@Al1fch

Je vais utiliser un câble que je couperais en deux pour y mettre une jonction mâle/femelle au milieu qui sera facilement accessible depuis la poche arrière du micro sac à dos, ceci afin de pouvoir désactiver rapidement / simplement la patte RX0 sans avoir à tout déballer du sac à dos du robot

Je regarderais par la suite pour injecter un code conçu avec l'option OTA afin de pouvoir faire les mises à jours suivantes en OTA.
(avant je vérifierais bien que la taille des 2 codes et autres trucs rentrent bien dans la mémoire flash en y laissant avec une bonne marge de sécurité tant qu'à faire)

Je suis resté sur l'ESP8266 car en ai pas mal en stock + avait pris des ESP32 mais en version CAM et ai été vite fait degoûté du fait qu'il ne restait quasiment plus de patte libre en raison de la webcam embarquée :frowning:
=> je passerais sur des ESP32 (sans CAM) une fois que ce sera fonctionnel sur plusieurs ESP8266 : ce sera pour le prochain upgrade matériel "profond", je pense le mois prochain, quelques temps après la réception/test du MAX98357Z sur un ESP8266 pour voir la différence entre la version "barbare via transistor branchée au speaker" qu'il y aura sur les autres et celle bien plus propre passant par le MAX98357A :smiley: :smiley:

Pour info, on peut bien chaîner plusieurs composants sur le bus I2S et/ou l'ESP32 permet de gérer plusieurs bus I2S distincts les uns des autres ?
(vu qu'il peut gérer l'I2S sur quasiment toutes les pattes, ce serait vraiment le top si par exemple je voudrais utiliser un composant I2S d'un côté de l'ESP32 et un autre composant I2S carrément de l'autre côté car ça permettrait de ne pas avoir de fils qui passent en dessous ou en dessus de l'ESP32 => ça ferait donc "plus propre" si l'utilisation de 2 composants I2S bien distincts seraient nécessaires par exemple)

@jpbbricole

Vu que l'espace est très limité dans le sac à dos des robots, je pense que je ne pourrais pas trop passer par ce type de boitier car il y prendrait trop de place :frowning:
=> je regarderais néanmoins ça par la suite car le fait qu'il encapsule pas mal de choses bien proprement dans un boîtier permettrait d'avoir des systèmes bien plus fiables/costauds que celui que je m'apprête à faire où le sac à dos sera rempli de fils et de composants "en vrac" dans tous les sens :smiley: :smiley:
(mais pour commencer, je préfère être le plus "bare-métal" possible au début pour bien comprendre comment ça marche exactement tout ça => je commencerais à utiliser un vue plus "high level" quand je commencerais à relativement bien gérer/dominer tout ça et y préférerais alors assez sûrement le style d'approche par ce type de périphérique "all in one" afin de privilégier une conception rapide/simplifié au max qu'un conception "version amateur" )
[ça me permettra de plus par la suite de pouvoir comparer bien plus judicieusement en terme de qualité/prix entre plusieurs versions/marques car je ne vois actuellement pas trop l'intérêt de passer par du 44 Khz ou même 96 Khz ** + en stéréo ** sur un mini speaker qui ne fonctionnera qu'en mono et qui ne devrait pas sortir un son de bien grande qualité dont la différence serait spécialement audible au dessus de 22 Khz => techniquement, c'est déjà de 4 à 8x plus de ressources CPU / mémoire qui seraient alors squattés inutilement pour queudalle dans l'histoire :smiley: :smiley: ]

oui l'ESP32CAM est 'spécial' ! si on n'insère aps d carte SD on a accès à qq GPIOs

ma connaissance de l'I2S reste très limitée. !!
il me semble qeue contrairement çà l'I2C on ne peour pas multiplier les périphériques divers sur un bus I2S
on peut pat contre y relier un dac/ampli pour le canal gauche et un pour le canal droit

l'ESP32 possède deux canaux I2S indépendants (il faudrait éplucher la Data Sheet pour découvrir d'éventuelles conraintes ou limitations ). Pour ma part je n'ai pas encore dépassé l'utilisation d'un unique canal I2S, soit en entrée pour micro (sonomètre , babyphone WiFi ), soit en sortie pour un DAC/Ampli (radio Web)

'bare metal' : dans ce cas j'utilise les cartes à ESP32 les plus dépouillées et j'ajoute le strict nécessaire.
bare ESP32

Pour entendre parler SAM (synthèse vocale de l'époque héroîque des ordis 8 bits) :
https://simulationcorner.net/index.php?page=sam

et Chanter : https://simulationcorner.net/SAM/sing.wav

Effectivement, le résultat n'est pas vraiment terrible :smiley: :smiley:

=> je pense que je vais passer via des signaux sonores bien plus convenables qui arriveront en WiFi plutôt que de vouloir y préférer la synthèse vocale :smiley: :smiley:

Je passerais peut-être via un ESP32 plutôt qu'un ESP8266 par la suite mais j'ai tellement été dégoûté des bien trop nombreuses limitations en E/S de l'ESP32 CAM que pas trop pressé de retourner sur un ESP32 pour le "générique/plein de trucs dessus"
(par contre, royal l'ESP32 CAM pour envoyer l'image de sa webcam dans un flux HTTP que l'on peut très facilement avoir sur un butineur ou analyser/traiter via un programme maison => très bon produit en tant que webcam miniature WiFi si on n'est pas trop regardant sur la qualité/définition d'image mais pas glop du tout pour y ajouter quoi que ce soit en rab :frowning: :frowning: )

J'ai pris pour mauvaise habitude de prendre tout ce qui est "truc à plein de pattes", typiquement les processeurs/controleurs/"arduino like", avec les pattes pré-soudés car j'en ai déjà grillés à faire des soudures dessus avec mes grosses papates pleines de doigts + surtout pas spécialement as de la soudure :smiley: :smiley:

Aucun problème tant que moins de 8 pattes ET avec un pas de 2.54 mm, mais au dessus, style les composants en surface CMS, je préfère largement les acheter déjà soudés sur carte et couper au pire les pattes qui ne seront plus nécessaires et courber celles qui le sont sur la carte si je veux limiter la hauteur ou la longueur du système

Pour la soudure, je viens néanmoins de m'équiper la semaine dernière d'un poste de soudure "pas trop mal" avec la chaleur réglable + différents types de pannes interchangeables + bon étain + des bras permettant de tenir le composant en l'air pendant que je fait la soudure mais je ne pense pas que ça fera de moi un as de la soudure pour autant :smiley: :smiley:

Pour la synthèse vocale, je pense que je passerais plutôt par un système client/serveur sur un poste Linux qui recevra/générera automatiquement des demandes de phrases à "speaker" et renverra en retour un flux audio que pourra alors faire ressortir le robot sur son mini haut-parleur

Style le robot envoie une commande get à un serveur Apache sur le poste Linux, qui génèrera alors les paroles vocales à produire via eSpeak et enverra en retour le fichier .wav sur le robot pour qu'il le prononce

Ou streamera un/des flux audios à la place d'un fichier .wav si cela est plus simple à gérer ou doit concerner plusieurs robots avec des accents/genres différents par exemples

Se serait bien qu'un des robots ai une voix masculine, l'autre une voix féminine et le troisième une voix plus robotique/"n'importe nawak-ique" :smiley: :smiley:
=> j'aurais alors l'occasion de pouvoir y gérer un type de personnalité propre à chacun des robots, style Moa = relativement égoïste, Toa = "parle peu de lui/elle même mais beaucoup des autres" et Noo = relativement partageur(euse)/empathique :smiley: :smiley:

Un raspberry pi alimenté par une batterie externe qui rêgnerait sur le robot aspirateur pourrait parfaitement faire l'affaire je pense ... + ça me permettra d'y adjoindre une webcam pour surveiller/filmer de façon plus globale l'ensemble des robots et précisément pouvoir diriger indépendamment chacun des robots en y ajoutant un bon zest de reconnaissance d'image/mouvement + mémorisation/génération des chemins suivis/à suivre
(en rab, il pourra simuler la télécommande du robot-aspirateur afin de le diriger/commander sans n'avoir à toucher à quoi que ce soit sur le robot aspirateur dont j'aimerais bien conserver la garantie tant que valable ...)
[reste à comprendre comment fonctionne la télécommande du robot aspirateur car c'est pas de l'infrarouge à première vue => je ne sais pas trop c'est quoi en fait :frowning: :frowning: ]

Mon robot aspirateur a déjà une webcam intégré d'origine mais le flux vidéo est seulement accessible via une application spécifique sur tablette/téléphone Android qui permet de plus de commander le robot via cette interface mais je n'arrive toujours pas à capturer ce/ces flux sous Linux :frowning: :frowning:
(c'est qu'ils se cachent bien à première vue ces vilains flux :smiley: :smiley: )

Ou donner la possibilité d'utiliser les deux pour la synthèse vocale, cf. passer par défaut par le serveur Apache distant s'il arrive à se connecter en Wifi avec, ou utiliser SAM s'il n'arrive pas/plus à se connecter au serveur Apache ou tout simplement pas/plus au réseau WiFi local

=> de la sorte, il pourra toujours évoluer/parler même si la connection WiFi ou le service Apache distant ne marchent plus pour une raison X ou Y ... bien que dans un mode fortement dégradé dans ce cas, il est vrai :smiley: :smiley:

=> je vais faire "mumuse" avec SAM en local et la partie cliente sur les robots + service Apache sous Raspbian pour la partie synthèse vocale et vous tiendrais au courant de l'avancement de cette partie dès que je commence à avoir quelque chose de fonctionnel

Bonsoir,

J'ai enfin réussi à faire du Text To Speech sur mon ESP8266 à partir d'une page HTML externe :smiley: :smiley:

J'ai commencé par la plus simple version hardware utilisant un transistor 2N3904, une résistance de 1 Kohm et la sortie I2S trafiquée (pin RX de l'ESP8266) comme indiqué à l'url suivante

GitHub - earlephilhower/ESP8266Audio: Arduino library to play MOD, WAV, FLAC, MIDI, RTTTL, MP3, and AAC files on I2S DACs or with a software emulated delta-sigma DAC on the ESP8266 and ESP32

J'ai utilisé le schéma suivant sur l'ESP8266

#include <Arduino.h>
#include <WiFiClient.h>
#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <ESP8266WebServer.h>

#include <ESP8266SAM.h>
// #include <AudioOutputI2S.h>
#include <AudioOutputI2SNoDAC.h>

const char* ssid = "SET YOUR SSID HERE";
const char* password = "SET YOUR SSID PASSWORD HERE";

ESP8266WebServer server(80);

AudioOutputI2S  *out = NULL;
ESP8266SAM      *sam = NULL;


unsigned char mySpeed = 72;
unsigned char myPitch = 64;
unsigned char myMouth = 128;
unsigned char myThroat = 128;

ADC_MODE(ADC_VCC);


void InitSerial()
{
  Serial.begin(115200);
  delay(1000);
  Serial.println("=====================");
  Serial.println("Init Serial"); 
}

void InitWifi()
{
  Serial.print("Init WIFI ");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address : ");
  Serial.println(WiFi.localIP());

  if (MDNS.begin("esp8266")) {
    Serial.println("MDNS responder started");
  }

  Serial.println("HTTP server started");
  Serial.println("");
}

void InitI2S()
{
  Serial.println("Init AudioOutputI2S");
  // out = new AudioOutputI2S();
  out = new AudioOutputI2SNoDAC();
  out->begin();
}

void InitSAM()
{
  Serial.println("Init SAM");
  sam = new ESP8266SAM;

  sam->SetSpeed(mySpeed);
  sam->SetPitch(myPitch);
  sam->SetMouth(myMouth);
  sam->SetThroat(myThroat);
}

void Inits()
{
  InitSerial(); 
  
  InitI2S();
  
  InitSAM();
  
  InitWifi();  
}

void SayViaSAM( String str )
{
  Serial.print("Saying : ");
  Serial.println(str);

  sam->Say(out, str.c_str() );
}

void HandleRoot() {
  Serial.println("handleRoot()");
  server.send(200, "text/plain", "hello from esp826 12E \r\n");
}

void HandleTension()
{
    float mesureADC = ESP.getVcc();
    float tension=mesureADC/1023.00; // cf ADC sur 10 bits
    char strTension[30];
    
    tension=tension*3.27/2.89; // cf calibrage de mon NodeMCU
    Serial.print("Tension alimentation : ");
    Serial.print(tension);
    Serial.println(" V");
    sprintf(strTension, "tension = %1.1f volts \n", tension);
    
    server.send(200, "text/plain", strTension );
}

void HandleNotFound() {
  
  String message = "File Not Found\n\n";
  message += "URI: ";
  message += server.uri();
  message += "\nMethod: ";
  message += (server.method() == HTTP_GET) ? "GET" : "POST";
  message += "\nArguments: ";
  message += server.args();
  message += "\n";
  for (uint8_t i = 0; i < server.args(); i++) {
    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
  }
  server.send(404, "text/plain", message);
}

void HandleInline()
{
  server.send(200, "text/plain", "this works as well");
}

void HandleHello()
{
  server.send(200, "text/plain", "Welcome, my name is Noo, Yannoo !");
  SayViaSAM("Welcome, my name is Noo, Yannoo !");
}

void HandleSay()
{
  server.send(200, "text/plain", server.argName(0) );
  SayViaSAM( server.argName(0) );
}

void HandleSpeed()
{
  Serial.print("Speed set to ");
  Serial.println(server.argName(0).toInt());
  
  mySpeed = server.argName(0).toInt();

  sam->SetSpeed(mySpeed);

  server.send(200, "text/plain", "speed changed to " + server.argName(0) );
  
}

void HandlePitch()
{
  Serial.print("Pitch set to ");
  Serial.println(server.argName(0).toInt());
  
  myPitch = server.argName(0).toInt();

  
  sam->SetPitch(myPitch);
  server.send(200, "text/plain", "Pitch changed to " + server.argName(0) );
 
}

void HandleMouth()
{
  Serial.print("Mouth set to ");
  Serial.println(server.argName(0).toInt());
  
  myMouth = server.argName(0).toInt();
  
  sam->SetMouth(myMouth);

  server.send(200, "text/plain", "mouth changed to " + server.argName(0) );
 
}

void HandleThroat()
{

  Serial.print("Throat set to ");
  Serial.println(server.argName(0).toInt());
  
  myThroat = server.argName(0).toInt();

  sam->SetThroat(myThroat);
  server.send(200, "text/plain", "throat changed to " + server.argName(0) );
}

void ServerCalls()
{
  server.on("/", HandleRoot);
  server.on("/inline", HandleInline);
  server.on("/hello", HandleHello );
  server.on("/say", HandleSay );
  server.on("/tension", HandleTension);
  
  server.on("/speed", HandleSpeed);
  server.on("/pitch", HandlePitch);
  server.on("/mouth", HandleMouth);
  server.on("/throat", HandleThroat);

  server.onNotFound(HandleNotFound);
}
 
void setup()
{
  
  Inits();
 
  ServerCalls();

  server.begin();
}



void loop()
{
  server.handleClient();
  MDNS.update();
}

Et je viens de commencer à faire du Text To Speech avec grâce à ce type d'url

http://192.168.0.xxx/say?Hello%20everybody

=> le son est effectivement vraiment mauvais mais je voudrais néanmoins essayer d'y obtenir une voix ressemblant au français
(si je met une phrase en anglais, c'est assez compréhensible mais ça devient strictement incompréhensible si j'y met des phrases en français :frowning: )

Existe-t-il des paramêtres "pas trop mal" à donner à SAM pour qu'il prononce le texte de façon "assez française" à la place de "uniquement à l'anglaise" ?
(cf. typiquement via les fonctions SetSpeed, SetPitch, SetMouth ou SetThroat par exemples)

A noter que je vais essayer d'ici la fin de semaine de passer par un composant I2S MAX98357 plutôt qu'en direct via une sortie I2S trafiquée mais ne pense absolument pas que cela resoudra en quoi que soit le problème de "francisation" qui vient à mon avis bien plus de SAM que d'autre chose ... :frowning:

A noter de plus que je ne prévois à terme d'utiliser SAM que quand la connection WiFi ne fonctionnera pas/plus, cf. quand l'ESP8266 pourra uniquement travailler en local = pas de connection WiFi possible, donc pas si grave que ça s'il n'est pas "simplement francisable"
(dans le code actuel, il utilise obligatoirement une connection WiFi mais c'est juste pour essayer de jouer un peu en dynamique sur les paramêtres des différentes fonctions sam->Set* sans avoir systématiquement à recompiler le sketch à chaque changement de l'un d'eux, ce qui est assez long et rébarbatif à la longue ...)