Arduino Forum

International => Italiano => Generale => Topic started by: magpa on Sep 22, 2018, 01:17 pm

Title: ARDUINO E VOCE
Post by: magpa on Sep 22, 2018, 01:17 pm
Buongiorno a tutti. Mi sto cimentando a gestire la voce con arduino o suoi derivati (ESP8266), ma ho riscontrato che ne Arduino UNO ne esp8266 ce la fanno a eseguire un loop in meno di 125 micro sec che mi servirebbero per avere 8000 campioni al secondo.
Cosa strana è che i primi cicli li compie in 15 microsec(ottimo) e poi dal 33-34esimo in poi salta a 434; tutto con solo 3 istruzioni così riportato sotto:
Code: [Select]

void loop() {

   time1 = micros();
   Serial.println(time1-lastRead);
   lastRead = time1;
   

}

Cosa entra in gioco al 33-34 ciclo? mi potreste dare una mano a risolvere oppure a aggiungere magari qualche hardware specializzato per rimediare a quest lentezza?
Grazie a tutti.
Title: Re: ARDUINO E VOCE
Post by: gpb01 on Sep 22, 2018, 01:35 pm
Buongiorno,
essendo il tuo primo post nella sezione Italiana del forum, nel rispetto del regolamento di detta sezione (… punto 13, primo capoverso), ti chiedo cortesemente di presentarti IN QUESTO THREAD (http://forum.arduino.cc/index.php?topic=113640.0) (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con MOLTA attenzione il su citato REGOLAMENTO (http://forum.arduino.cc/index.php?topic=149082.0) ... Grazie. :)

Guglielmo
Title: Re: ARDUINO E VOCE
Post by: uwefed on Sep 22, 2018, 07:30 pm
Dopo che Ti sei presentato facci vedere il Tuo sketch.
Ciao UWe
Title: Re: ARDUINO E VOCE
Post by: magpa on Sep 23, 2018, 07:57 am
Buongiorno a tutti. Poiché avevo trovato il login esistente pensavo avessi già fatto il post di benvenuto forse come dite bene l'avrò fatto in inglese. Mi scuso e mi presento.
Sono un ing pensionato che si diletta da qualche anno con arduino e in special modo con gli ESP8266 e mi sono arredato casa di questi oggettini.

Poiché ci si spinge sempre più avanti nei progetti, ed essendo qui in buona compagnia, credo che frequenterò il forum in maniera assidua diversamente che nel passato visto anche la semplicità di quello che facevo.
Title: Re: ARDUINO E VOCE
Post by: magpa on Sep 23, 2018, 08:04 am
Quello che sto facendo relativamente alla mie esperienze di telecomunicazioni è il campionamento della voce di un mic a 8000volte al sec quindi un campione ogni 125usec.
Solo che il buon esp8266 il loop lo esegue in maniera un po' particolare per non dire strana. Infatti se eseguite lo sketch qui di seguito ve ne renderete conto. I primi cicli sono di 15usec i successivi di 430. Che significa questo? dove sbaglio?

Sketch:
Code: [Select]

unsigned long lastRead = micros();
unsigned long time1;

void setup() {
Serial.begin(115200);
delay(10);
lastRead = micros();
}


void loop() {

  time1 = micros();
  Serial.println(time1-lastRead);
  lastRead = time1;
 

}
Title: Re: ARDUINO E VOCE
Post by: gpb01 on Sep 23, 2018, 08:27 am
>magpa:   ti ricordo che in conformità al regolamento (http://forum.arduino.cc/index.php?topic=149082.0), punto 7, devi editare i tui post (quindi NON scrivendo un nuovo post, ma utilizzando il bottone More -> Modify che si trova in basso a destra del tuo post) e racchiudere il codice all'interno dei tag CODE (... sono quelli che in edit inserisce il bottone con icona fatta così: </>, tutto a sinistra).

In pratica, tutto il tuo codice dovrà trovarsi racchiuso tra due tag: [code] _il _tuo_ codice_ [/code] così da non venire interpretato e non dare adito alla formazione di caratteri indesiderati o cattiva formattazione del testo. Grazie. :)

Guglielmo
Title: Re: ARDUINO E VOCE
Post by: gpb01 on Sep 23, 2018, 08:33 am
... dopo di che ... NON puoi inserire una Serial.print() nel loop() in cui misuri il tempo ... Serial.print() ti altera tutti i tempi a causa dei buffers e del suo funzionamento.

Acquisisci il tempo iniziale, fai un'operazione, acquisisci l tempo finale e DOPO stampi la differenza tra fine ed inizio, NON con in mezzo una Serial.print() !!!

Non solo, se devi raggiungere certe velocità, ho idea che dovrai scordarti il "framework wiring" (ovvero le funzioni che ti mette a disposizione l'ambiente Arduino) e dovrai programmare accedendo direttamente hai registri.

Guglielmo
Title: Re: ARDUINO E VOCE
Post by: magpa on Sep 23, 2018, 09:24 am
Grazie gpb01 togliendo la print e mettendola dopo aver fatto un centinaio di loop il tempo per ciclo scende drasticamente a 5-6 usec e tutti uguali.

L'ultima tua considerazione mi turba. Ossia mi stai dicendo che invece di utilizzare le istruzioni dell'IDE di arduino potrei intervenire direttamente sui registri come se si stesse programmando in Assembler o linguaggio macchina? Questo si che mi mette di buon umore. Dove posso trovare doc ed esempi di questa programmazione?

Grazie infinite per il tuo impagabile aiuto; l'avevo detto di essere in buona compagnia, anzi ottima.
Ciao



Non so se sto facendo la mossa giusta. Spero di eseguire quello che suggerisci ossia modificare l'ultimo mio post e quindi poi Save. Giusto? Così è OK per te?
Title: Re: ARDUINO E VOCE
Post by: gpb01 on Sep 23, 2018, 09:32 am
... le indicazioni te le do, ma tu fai cortesemente quanto ti ho chiesto al post #5 ;)
Grazie,

Guglielmo
Title: Re: ARDUINO E VOCE
Post by: gpb01 on Sep 23, 2018, 09:34 am
Esempio di come manipolare direttamente i registri delle "PORT" della MCU di Arduino ... QUI (http://www.leonardomiliani.com/2013/manipoliamo-direttamente-le-porte-logiche-di-una-mcu/) ... dovrebbe chiarirti le idee di come si usano direttamente porte e registri attraverso l'IDE.

Per altri approfondimenti ... QUESTO (https://www.avrfreaks.net/) è il posto giusto dove cercare (... non è legato all'ambiente Arduino, ma più alle MCU Atmel), mentre QUI (http://www.gammon.com.au/forum/bbshowpost.php?bbtopic_id=123) ... cose interessati in ambiente Arduino ;)


Guglielmo
Title: Re: ARDUINO E VOCE
Post by: SukkoPera on Sep 23, 2018, 04:38 pm
Sì ma lui sta lavorando su un ESP8266 se non ho capito male...
Title: Re: ARDUINO E VOCE
Post by: gpb01 on Sep 23, 2018, 05:25 pm
Sì ma lui sta lavorando su un ESP8266 se non ho capito male...
Mah, lui dice ...

... Mi sto cimentando a gestire la voce con arduino o suoi derivati (ESP8266), ma ho riscontrato che ne Arduino UNO ne esp8266 ce la fanno a eseguire un loop in meno di 125 micro sec che mi servirebbero per avere 8000 campioni al secondo....
... quindi credo che ESP8266 fosse un ripiego sperando in una maggiore velocità ... ::)

Guglielmo
Title: Re: ARDUINO E VOCE
Post by: Etemenanki on Sep 23, 2018, 06:01 pm
Io invece ho un dubbio di tipo diverso ... da "ex" tecnico audio part-time (molto "ex", parliamo dell'alba dei campionatori, quasi :P), eravamo abituati a campionare le frequenze ad almeno 5 volte la massima frequenza utile ... dato che la voce in media va da 300Hz a 3KHz (salvo casi particolari), al minimo si campionava a 15KHz, di solito, e solo per applicazioni "non-hifi" (per l'HI-FI o applicazioni estreme si arrivava anche a campionare a 50KHz) ... con 8KHz di campionamento, se lo devi usare in ambito audio, al massimo ci campioni in modo decente 1600Hz, e potresti avere qualche disturbo di tipo "chopping" dato dal fatto che anche gli 8KHz a cui campioni rientrano nella frequenza udibile ... sicuro che ti bastano ?
Title: Re: ARDUINO E VOCE
Post by: magpa on Sep 23, 2018, 07:00 pm
Diciamo che le prove le sto facendo campionando al livello telefonico quindi con una frequenza di max 4Khz e quindi un campionamento almeno il doppio quindi 8000 campioni al sec. Un campione catturato ogni 125usec.
Ed è questo intervallo che vorrei ottenere dall'ESP8266 e penso che con gli accorgimenti di gpb01 credo ci si arrivi. Sto ancora provando.
Grazie dell'interessamento.

Spero a breve di darvi notizie positive.
Ciao a tutti
Title: Re: ARDUINO E VOCE
Post by: gpb01 on Sep 23, 2018, 07:57 pm
... penso che con gli accorgimenti di gpb01 credo ci si arrivi. Sto ancora provando.
Occhio perché le guide che ti ho dato sono per ATmega328P NON per ESP8266 ... che ha nomi di PORT e registri completamenti diversi ed anche le modalità di accesso diretto.

Perché non usare una Arduino MKRxxxx che monta un CORTEX-M0 la cui documentazione, per la programmazione "bare-metal" è ampiamente disponibile ?

Guglielmo

P.S.: Sto ancora aspettando che sistemi il codice come ti ho già chiesto più volte ...
Title: Re: ARDUINO E VOCE
Post by: docdoc on Sep 24, 2018, 09:41 am
Beh non ho mai provato ad acquisire audio da Arduino, ma stando a quanto ho letto credo che per acquisire una voce a livello telefonico (max 4kHz quindi campionare a 8kHz, ma bastano anche 4kHz) credo sia alla portata di Arduino UNO (se penso che facevo una cosa analoga con un povero ZX Spectrum che acquisiva ad 1 bit col suo Z80 a 8MHz...). Quindi intanto ti direi di vedere se QUI (https://www.instructables.com/id/Arduino-Audio-Input/) trovi indicazioni utili.

Poi però devi anche considerare che questi dati, che a 8kHz (limitamoci a 8 bit, non i 10 standard) sono 8kbyte al secondo, che di fatto è un PCM, e non si sa se tu debba campionare una porzione o sia un flusso da acquisire per un tempo indefinito. Il problema successivo, abbastanza importante direi, è che questo flusso lo devi poi "usare" o memorizzare, o trasferire... Se la CPU è impegnata nell'acquisizione non so se hai abbastanza tempo anche per farci "qualcosa". Insomma, a che ti serve?


 
Title: Re: ARDUINO E VOCE
Post by: magpa on Sep 25, 2018, 10:30 am
Scusa non pensavo ti riferissi anche a post passati, comunque eseguita correzione in entrambi quelli passati.

Sono di nuovo qui per un consiglio e/o suggerimento.

Come sai sto tentando di memorizzare la voce e fare quindi un wav per ascoltarlo. Sono riuscito dietro tuoi suggerimenti a catturare dalla porta A0 dove ho piazzato il microfono 8000 campioni al secondo mediante la analogRead(A0).
Fatto questo volevo costruire un file wav ma quello che ottengo è una schifezza molto distorto; si capisce a malapena . Ora mi domando: una volta acquisito il campione con la analogread, lo stesso dato di 2 byte lo scrivo nel file o lo dovrei manipolare in qualche modo?

Spero che tu come al solito risolva brillantemente anche questo problema. Grazie.

paolo
P.S. Naturalmente prima dei dati ho inserito l'header dello wav che viene riconosciuto regolarmente.

Title: Re: ARDUINO E VOCE
Post by: magpa on Sep 25, 2018, 10:48 am
Ho capito ci sono 2 pagine nella conversazione e la mia risposta è andata in coda alla seconda anche se l'avevo scritta nello spazio della prima pagina. Le mie considerazioni erano rivolte infatti a gpb01 credendo di scrivere subito dopo il suo messaggio.

Comunque non avevo letto il tuo docdoc ma nel codice tu fai riferimento a un DAC e un ADC o sono solo istr di ARDUINO? Sinceramente mai utilizzate. Nel primo caso però dovrei acquistare un oggettino del genere per continuare a provare.

Se usassi invece solo arduino da ciò che ho detto nei post subito precedenti mi sapresti dare la modalità corretta di memorizzazione dei campioni letti perchè il suono che viene fuori è un gracchio quasi incomprensibile.
Grazie
paolo
Title: Re: ARDUINO E VOCE
Post by: magpa on Sep 25, 2018, 11:11 am
Purtroppo ho il vizio di non leggere tutto fino in fondo ma di andare un po' a grandi passi anche per il tempo che è sempre più tiranno.
Ora rileggendo un po' meglio, ma  hai fatto un trattato per gestire input ed output veramente degno di plauso. Ora quando il tempo me lo permette lo leggerò più attentamente. Grazie
paolo
Title: Re: ARDUINO E VOCE
Post by: zoomx on Sep 26, 2018, 05:01 pm
@magpa
Che microfono usi? Quale circuito usi? L'Arduino legge solo tensioni tra 0 e 5V, niente tensioni negative.
Una basetta con MAX4466  (https://www.aliexpress.com/snapshot/.html?orderId=506363962167343)e relativo microfonino dovrebbe andare bene.

@docdoc
tra gli esempi della libreria TMRpcm ce n'è uno che scrive i dati acquisiti sulla SD.
Title: Re: ARDUINO E VOCE
Post by: magpa on Oct 11, 2018, 08:27 am
Ciao zoomx scusa il ritardo della risposta ma sono stato fuori in altre faccende affaccendato. Ritorno ora a trattare la voce con arduino.
Si uso un micro del genere che menzioni tu ma campionando la voce a 8khz, inviandola poi tramite wifi e risentirla al telefono non è un granchè. Sinceramenteavrei necessità di 2 certezze: primo campionando il segnale in UINT_16 audio = analogread(A0) e poi replicarlo sul telefono.

UINT_16 value = analogread(A0)
audioBuffer[i++] = value & 0xff;
audioBuffer[i++] = value >>8 & 0xff

l'audio buffer lo trasferisco verso il telefono dove un app me lo memorizza in file wav

Risentendo il file wav con cool edit c'è un ronzio di fondo e poi la voce non è così intellegibile

So che le info che ti sto dando non sono molto dettagliate, ma sapresti ugualmente darmi qualche suggerimento?

Ho tentato di far girare l'app Recording del TMRpcm ma su arduino UNO e su arduino nano mi da dei problemi di compilazione

Grazie in anticipo del tuo tempo.
Ciao
paolo
Title: Re: ARDUINO E VOCE
Post by: zoomx on Oct 11, 2018, 10:01 am
Il ronzio penso sia dovuto all'alimentazione di Arduino se collegato al PC via USB.
In ogni caso su Arduino ci sono diverse fonti di interferenze, potrebbe anche essere la trasmissione via wifi. Se usi UDP può anche essere che si perde qualche pacchetto ma in sostanza il succo è che per adesso non sembra che Arduino sia adatto per un compito del genere.
Esistono però delle shield audio, così come altre board, come la costosa Teensy che ha uno shield audio e dietro una persona, quello che la produce, che la supporta bene.
Title: Re: ARDUINO E VOCE
Post by: magpa on Oct 13, 2018, 07:06 am
Quello che vorrei fare è prendere un audio da un altoparlante e tramite esp8266 dopo campionamento inviarlo in wifi verso un app di un telefono che potrebbe replicarla. Sto praticamente impazzendo a trasferire questi campioni in wifi sia per lentezza di timing sia per motivi che alcune volte non capisco nemmeno. Che tu sappia ci sono schede che potrebbero fare questo?

paolo
Title: Re: ARDUINO E VOCE
Post by: zoomx on Oct 13, 2018, 10:27 am
Non ho trovato microfoni che funzionino in WiFi, solo wireless.

Su ESP8266 ho trovato alcuni link
https://perso.aquilenet.fr/~sven337/english/2016/07/14/DIY-wifi-baby-monitor.html (https://perso.aquilenet.fr/~sven337/english/2016/07/14/DIY-wifi-baby-monitor.html)
ma alla fine c'è scritto che è rumoroso
Quote
The ESP8266 is not a perfect fit for a project like that : it doesn't have a decent ADC, it doesn't have a decent DAC, and it tends to be electrically noisy in such a way that the electret pickup circuit can be affected by wifi transfers. On the other hand it's cheap, easy to use, and has plenty of processing power.
https://www.esp8266.com/viewtopic.php?f=6&t=11427 (https://www.esp8266.com/viewtopic.php?f=6&t=11427)
ma fa uso di un STM32 oltre all'esp8266
https://stackoverflow.com/questions/46951404/microphone-audio-streaming-from-esp8266-to-c-sharp-socket-server-over-wifi (https://stackoverflow.com/questions/46951404/microphone-audio-streaming-from-esp8266-to-c-sharp-socket-server-over-wifi)
ma lo sketch va modificato perché tìinefficiente.

Forse la soluzione più semplice sarebbe quella di usare un vecchio smartphone.

Title: Re: ARDUINO E VOCE
Post by: magpa on Oct 17, 2018, 12:55 pm
Qualcosa sono riuscito a fare. Ricevo sufficientemente bene ossia si capisce ma va a scatti. Utilizzo per lo speech sul telefono android AudioTrack che però non so rendere continuo. Sto cercando su Internet, ma senza successo. Eppure di streaming se ne fanno sui telefoni. POssibile che a nessuno è venuto di realizzare uno streaming in casa?

Un'altra cosa che mi capita è che l'ESP qualche volta va lentissimo nella audioclient.write(). La scrittura sul client non schioda qualche volta per 1-2 sec. Lo ricarico e qualche volta riparte ma non sempre. Potrebbe dipendere da chi riceve che essendo piuttosto lento rallenta anche il mittente?

Ti tengo aggiornato se aggiornamenti ci saranno
Ciao
paolo
Title: Re: ARDUINO E VOCE
Post by: zoomx on Oct 17, 2018, 02:38 pm
Lo streaming si fa usando il traffico UDP non TCP, come mi è sembrato di capire.
Significa che chi manda i pacchetti non si cura se arrivino o meno ma spara in continuazione.

Ho trovato degli esempi cercando Walkie Talkie invece di streaming
Questo è per Proton (Broadcom BCM43362 Wi-Fi chip+STM32F205 120Mhz ARM Cortex M )
https://www.hackster.io/middleca/wi-fi-walkie-talkies-0a38f4 (https://www.hackster.io/middleca/wi-fi-walkie-talkies-0a38f4)
Questo invece usa ESP8266 ma ha anche lui problemi
http://essentialscrap.com/esptalkie/ (http://essentialscrap.com/esptalkie/)
https://hackaday.com/2018/07/23/fail-of-the-week-esp-walkie-not-so-talkie/ (https://hackaday.com/2018/07/23/fail-of-the-week-esp-walkie-not-so-talkie/)

Tieni conto che alcuni dei problemi sono dovuti al fatto che anche come ricevitore viene usato un dispositivo analogo e l'ESP8266 non ha un DAC, però ha un'uscita I2S che è poi quella usata dai ricevitori di web radio in streaming.

Poi c'è una libreria che fa uso del chip nRF24L01 che va sui 2.4GHz ma usa un protocollo tutto suo, purtroppo.

Un RaspberryPI 3B+ potrebbe farlo ma non ha ingresso audio, devi usare una scheda audio USB, ma ha il WiFi al contrario dei precedenti modelli.
Title: Re: ARDUINO E VOCE
Post by: magpa on Oct 22, 2018, 10:47 am
Grazie dei suggerimenti ma con UDP sembra si perda il 90% dei pacchetti. Esp8266 spedisce alla grande ma il telefono ne prende uno ogni tanto. In effetti sono parecchi al secondo.
Sono ritornato al socket e ieri sera è andato alla grande mi sono sentito la radio la telefono. Grandioso.
Dopo tutte le prove che avevo fatto ho salvato subito il tutto. Inutilmente stamani l'ho ripreso e balbettava come al solito. l'ESP8266-12E fa quello che vuole oghi tanto riesce a star dietro alle spedizione altre volte rallenta e sospende proprio l'elaborazione.

Se blocco l'app sul telefono che riceve l'ESP riprende alla grande e va velocissimo.

E' la connessione socket che lo mette in crisi. Cosa si potrebbe fare per guarirlo.

Stando in debug sull'app del telefono e metto un break sulla ricezione e dopo qualche secondo lo tolgo mantiene per qualche secondo un audio perfetto e poi ricomincia a balbettare.

Ieri sera gli girava bene e non ha perso un colpo.

Tra un po' mi sa che mollo. Non ci riesco a fare una cosa stabile e ripetibile. Mi sa che dovrei mettere un mini computer più potente.

Ciao zoomx, mi dispiace no averti dati belle notizie
Title: Re: ARDUINO E VOCE
Post by: zoomx on Oct 22, 2018, 02:10 pm
Da quello che scrivi il problema potrebbe stare nell'app che non è abbastanza veloce per prendere tutti i pacchetti ed elaborarla. Però è anche vero che in rete i pochi progetti che ho visto son sembrati tutti fallimentari proprio su questo punto.


In ogni caso sappi che ho imparato un poco, nel senso che adesso sono un po' più informato.
Può essere che applicherò parte di quanto imparato per trasmettere segnali più lenti, tipo un campionamento a 200Hz o meno.
Title: Re: ARDUINO E VOCE
Post by: magpa on Nov 03, 2018, 05:46 am
Ho trovato un ESP più veloce anzi veloce il doppio e sto facendo i primi test e devo dire che catturare la voce ed inviarla su wifi è eccitante e lo fa abbastanza bene. Ora devo pensare a fare il processo inverso ma sto vedendo che è più rognoso tra le varie codifiche audio che si intrecciano tra android, le varie codifiche wav ,  ESP e circuiteria spicciola.
Staremo a vedere
Title: Re: ARDUINO E VOCE
Post by: zoomx on Nov 06, 2018, 08:54 am
Hai preso l'ESP32 oppure hai raddoppiato il clock dell'ESP8266?
Title: Re: ARDUINO E VOCE
Post by: magpa on Nov 15, 2018, 07:59 am
Ciao Zoomx ho preso l'esp32 ma devo dire che sono deluso dai risultati della trasmissione voce da e verso il telefono. Non riesco ad ottenere un suono decente. Tutti gracchii, voce che prima parte bene e poi si affievolisce e si confonde con il rumore. L'ho provate tutte o quasi ma non riesco ad ottenere quello che credevo abbastanza facile. Sai cos'è secondo me la cosa particolare che il telefono non ragiona a byte ma solo a int, mentre l'invio verso l'esp32 deve essere a byte quindi prima traduzione. L'esp ragiona a int ma spedendo (ho tanti esempi) traduzione in byte arrivato al telefono altra traduzione. Non riesco a dare un taglio preciso a tutto questo.

Forse l'unica che mi va abbastanza bene è la trasmissione dal telefono all'esp32, ma il contrario è disastroso.

hai sotto mano magari qualche esempio di trasmissione di questo tipo? magari non l'ho ancora provato.

Continuo anche se con poco entusiamo a fare qualche altra prova.

A presto
Title: Re: ARDUINO E VOCE
Post by: zoomx on Nov 15, 2018, 01:12 pm
Purtroppo non ho alcun esempio.
La storia byte e int. L'int è, di solito, 2 byte ma dipende dall'architettura della MCU per questo c'è int16_t e uint16_t che sono sicuramente 2 byte.
L'altra seccatura e l'ordine dei byte nell'int (big endian e little endian) che dipende daccapo dall'architettura della MCU e a questo punto della CPU del telefono. Ad esempio se tu mandi il valore decimale 1500 questo va in 2 byte, 05 hex in uno e DC hex nell'altro. Il problema sorge su quale byte viene prima, quindi per alcuni va scritto 05 DC per altri CD 05.
Non sono sicuro però che qui il problema sia questo.

Tieni conto che parlando di audio le sorgenti di disturbo possono essere diverse per cui mi è venuto in mente di provare a trasmettere un'onda sinusoidale sintetica a 440Hz (o altra frequenza) e vedere se dall'altro lato ti arriva la nota giusta.
L'array con i dati te lo puoi generare qui
http://www.daycounter.com/Calculators/Sine-Generator-Calculator.phtml (http://www.daycounter.com/Calculators/Sine-Generator-Calculator.phtml)
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 04, 2019, 12:19 pm
Buongiorno, spero di non essere arrivato molto tardi.
Mi accodo in quanto anch'io vorrei prelevare un suono mediante un Microfono collegato in analogico al NodeMCU, spedirlo ad un Raspberry o PC e da li gestirlo.

Attualmente acquisisco il suono e lo spedisco via UDP.

Il microfono KY-038, collegato al NodeMCU mediante pin analogico "A0".


Lo Sketch su NodeMCU:

Code: [Select]


#include <ESP8266WiFi.h> // libreria per la gestione del wifi di ESP
#include <WiFiUdp.h> // libreria per utilizzare i moduli UDP

const char* ssid = "------"; // inserisci SSID della rete wifi a cui si collegherà NodeMCU
const char* password = "------"; // password della rete wifi a cui si collegherà NodeMCU

int contconexion = 0;

WiFiUDP Udp;

void setup()
{
  Serial.begin(115200);
  Serial.println();

  pinMode(5, OUTPUT);  //D1 Led de estado
  digitalWrite(15, LOW);

  WiFi.mode(WIFI_STA); //para que no inicie el SoftAP en el modo normal
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED and contconexion <50) { //Cuenta hasta 50 si no se puede conectar lo cancela
    ++contconexion;
    delay(250);
    Serial.print(".");
    digitalWrite(5, HIGH);
    delay(250);
    digitalWrite(5, LOW);
  }
  
}

void loop()
{
  //Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
  Udp.beginPacket("---.---.---.---", 1234); // indirizzo IP della macchina su cui sta il server

  for(int i=0; i<1024;i++){
    int old=micros();

    float analog = analogRead(17);

    analog = ((analog / 1) - 385);
    if (analog > 255){
      analog = 255;
    }
    else if (analog < 0){
      analog = 0;
    }
    
    Udp.print(int(analog)); // mando i pacchetti mediante il canale UDP
    
    Serial.println(int(analog)); // visualizzo grafico audio in Plotter seriale

    while(micros()-old<124); // 90uSec = 1Sec/11111Hz - 3uSec para los otros procesos
  }
  Udp.endPacket();
  delay(5);
}





Il Server scritto in Python:

Code: [Select]


import pyaudio
import socket

UDP_IP = "---.---.---.---" # indirizzo IP della macchina su cui sta il server
UDP_PORT = 1234 # porta che rimane in ascolto

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((UDP_IP, UDP_PORT))


p = pyaudio.PyAudio()

print("pyaudio: ", p)
stream = p.open(format=32, channels=1, rate=111111, output=True)

print("stream: ", stream)

try:
    while True:
        data, addr = sock.recvfrom(1024) # buffer de 1024 bytes
        print ("data: ", data)
        print ("addr: ", addr)
        stream.write(data) # mi fa sentire l'audio negli altoparlanti
        
except KeyboardInterrupt:  #precionar Crtl + C para salir
    print("Cerrando...")
    stream.stop_stream()
    stream.close()
    p.terminate()



L'audio che riproduco dagli speaker del PC è completamente distorto e incomprensibile. Visualizzando il Plotter seriale, le oscillazioni si vedono bene.

Deduco possa essere un problema di acquisizione e spedizione pacchetti (visto che la lettura del canale analogico avviene (apparentemente) correttamente).



Title: Re: ARDUINO E VOCE
Post by: zoomx on Mar 04, 2019, 03:31 pm
Intanto stai usando un microfono un po' sordo in quanto pensato per accendere e spegnere qualcosa con un battito di mani.

Poi fai un clipping feroce qui
Code: [Select]
    analog = ((analog / 1) - 385);
    if (analog > 255){
      analog = 255;
    }
    else if (analog < 0){
      analog = 0;
    }


Dovresti prendere un microfono con un MAX, dalla Cina costa poco più di quello che stai usando.

Potrebbe essere che al prosto di UDP.print dovresti usare UDP.write perché mi sa che print te lo stampa in ascii.

Non ho capito poi questo pezzo di codice
Code: [Select]
(analog / 1)
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 04, 2019, 06:28 pm
Grazie per la risposta.

cosa intendi per Clipping feroce?

Per il microfono potrei procurare altro anche se avrei una certa fretta quindi chissà se lo riuscirò a trovare in italia. Ma ti riferisci a qualcosa simile a: MAX4466.
Io ho preso l'idea dal video youtube: Proyecto #1 ESP8266 - Micrófono Espía, Audio Streaming por UDP

https://www.youtube.com/watch?v=1dA81w7C4kg (https://www.youtube.com/watch?v=1dA81w7C4kg)

Credo utilizzi un sistema microfonico simile anche se la scheda la costruisce lui.

Come potrei impacchettare l'audio? Nel senso, dal video spedisce lo streaming, io invece vorrei campionare a 4000 hz quindi per Nyquist dovrei avere il doppio ovvero 8000 valori. Ho pensato che (1/8000)*1000=0,125 millisecondi ovvero ogni 0,125 millisecondi dovrei leggere 8000 valori, metterli in un vettore e sparare l'intero vettore in UDP. E' corretto il ragionamento?
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 05, 2019, 12:06 am
Ho testato, con:

Code: [Select]
Udp.print(int(analog));

o

Code: [Select]
Udp.write(int(analog));

la situazione a livello di audio non cambia, cambia solo l'output nel Monitor seriale che come dicevi tu giustamente, visualizza piuttosto che numeri, codici ascii.

Ho ordinato i microfoni da te consigliati (MAX) e di preciso MAX9814 e MAX4466, li ho presi entrambi anche se credo che nel mio caso dovrebbero svolgere la medesima funzione.

Nel frattempo che arrivino (ordinati in Italia per accorciare i tempi) vorrei andare avanti e magari creare i buffer e spedire i buffer via UDP piuttosto che a casaccio quello che passa passa.

NOTA. Strano che nel video passa bene l'audio, il circuito sembra uguale.
Title: Re: ARDUINO E VOCE
Post by: zoomx on Mar 05, 2019, 09:00 am
Ho visto il video.
Intanto nello sketch c'è
Code: [Select]
Udp.write(int(analog));
come dicevo io.
Poi il circuiti del microfono è diverso, non usa quella schedina rossa, l'ho usata anche io e non va bene.

Per quanto riguarda il clipping. L'ESP8266 campiona a 10 bit, quindi valori da 0 a 1023. Lo sketch divide il valore per 1, forse prima era qualcosa di diverso ma adesso dividere per 1 non serve.
Quindi sottrae un valore fisso che probabilmente corrisponde alla media dei valori che escono fuori dal convertitore se non c'è alcun segnale.
Poi, se il valore è maggiore di 255 lo tronca a 255.
Infine controlla se con la sottrazione non è andato sotto zero, se si lo porta daccapo a zero.

Il motivo per cui non usa 2 byte è dovuto al fatto che con 2 byte le cose si complicano perché dall'altra parte nel flusso quando prendi 2 byte non sai se appartengono allo stesso campione oppure a due campioni consecutivi. Devi usare un protocollo oppure trasmettere una coppia di byte ogni tanto che servono per sincronizzare i flussi (con UDP i pacchetti possono andare persi e non si ha correzione).

I microfoni che hai preso vanno bene, sono anche quelli che ho usato io. Forse prenderai un po' di rumore lo stesso perché ci sono un sacco di interferenze. Mentre il microfono con la scheda rossa ti fornisce zero se non c'è segnale questi col MAX lavorano come il circuito del video, ti forniranno un valore intorno a 512. Questo perché il convertitore funziona solo con tensioni positive mentre il microfono ne fornisce negative. Quella rossa credo che le elimini, quella con MAX invece somma una tensione positiva in moto da avere sempre valori positivi. Non so se mi son spiegato bene.

Non ho ancora ascoltato il video.
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 06, 2019, 12:48 am
Grazie
Quote
zoomx
.

Forse mi manca qualche parte, ma non capisco cosa intendi:
Quote
Il motivo per cui non usa 2 byte è dovuto al fatto che con 2 byte le cose si complicano perché dall'altra parte nel flusso quando prendi 2 byte non sai se appartengono allo stesso campione oppure a due campioni consecutivi. Devi usare un protocollo oppure trasmettere una coppia di byte ogni tanto che servono per sincronizzare i flussi (con UDP i pacchetti possono andare persi e non si ha correzione).
Per il discorso del microfono, si infatti mi sembrava strano che lo aveva costruito lui uguale a quello o che quello potesse andar bene, anche perché il codice è molto semplice figurati.

Rimane, lasciando stare il microfono che è stato spedito oggi, il problema di come dovrei passare queste tracce al pc o Raspberry. Io mi vorrei trovare sul pc o Raspberry una traccia wav ad esempio ogni 10 secondi o più di acquisizione.

Pensavo di fare due vettori, ne riempivo uno e lo sparavo, mentre lo sparavo, ne riempivo un altro, in modo ciclico. Tipo swap. Ma non saprei come fare. Penso che lavorando su wav potrei riuscire.

Come avevo scritto:
Quote
Ho pensato che (1/8000)*1000=0,125 millisecondi ovvero ogni 0,125 millisecondi dovrei leggere 8000 valori, metterli in un vettore e sparare l'intero vettore in UDP. E' corretto il ragionamento?
dovrei prendere e riempire il vettore con 8000 celle ogni 0,125 millisecondi.. ehmmm..
Title: Re: ARDUINO E VOCE
Post by: zoomx on Mar 06, 2019, 11:19 am
Il convertitore è a 10 bit per cui avrai valori tra zero e 1023. Poiché in un byte al massimo puoi avere 256 valori (0-255) il risultato del convertitore va messo in 2 byte, i primi 8 in uno e i restanti 2 nell'altro. L'altro quindi avrà solo 2 bit, valori da 0 a 3.
Ora quando trasmetti in UDP può capitare che qualche byte vada perso.
Dall'altro lato, quando ricevi un byte, non puoi sapere se questo contiene i primi 8 o i restanti 2. Diciamo che se contiene valori superiori a 3 allora si tratta dei primi 8 ma non ne puoi essere sicuro.

Puoi fare anche un'altra cosa in attesa del microfono: mandare dei dati artificiali e vedere come arrivano dall'altra parte.
Pr esempio puoi trasmettere ques'onda sinusoidale (a 8 bit!)
Code: [Select]
uint8_t  sine_wave[256] = {
  0x80, 0x83, 0x86, 0x89, 0x8C, 0x90, 0x93, 0x96,
  0x99, 0x9C, 0x9F, 0xA2, 0xA5, 0xA8, 0xAB, 0xAE,
  0xB1, 0xB3, 0xB6, 0xB9, 0xBC, 0xBF, 0xC1, 0xC4,
  0xC7, 0xC9, 0xCC, 0xCE, 0xD1, 0xD3, 0xD5, 0xD8,
  0xDA, 0xDC, 0xDE, 0xE0, 0xE2, 0xE4, 0xE6, 0xE8,
  0xEA, 0xEB, 0xED, 0xEF, 0xF0, 0xF1, 0xF3, 0xF4,
  0xF5, 0xF6, 0xF8, 0xF9, 0xFA, 0xFA, 0xFB, 0xFC,
  0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFD,
  0xFD, 0xFC, 0xFB, 0xFA, 0xFA, 0xF9, 0xF8, 0xF6,
  0xF5, 0xF4, 0xF3, 0xF1, 0xF0, 0xEF, 0xED, 0xEB,
  0xEA, 0xE8, 0xE6, 0xE4, 0xE2, 0xE0, 0xDE, 0xDC,
  0xDA, 0xD8, 0xD5, 0xD3, 0xD1, 0xCE, 0xCC, 0xC9,
  0xC7, 0xC4, 0xC1, 0xBF, 0xBC, 0xB9, 0xB6, 0xB3,
  0xB1, 0xAE, 0xAB, 0xA8, 0xA5, 0xA2, 0x9F, 0x9C,
  0x99, 0x96, 0x93, 0x90, 0x8C, 0x89, 0x86, 0x83,
  0x80, 0x7D, 0x7A, 0x77, 0x74, 0x70, 0x6D, 0x6A,
  0x67, 0x64, 0x61, 0x5E, 0x5B, 0x58, 0x55, 0x52,
  0x4F, 0x4D, 0x4A, 0x47, 0x44, 0x41, 0x3F, 0x3C,
  0x39, 0x37, 0x34, 0x32, 0x2F, 0x2D, 0x2B, 0x28,
  0x26, 0x24, 0x22, 0x20, 0x1E, 0x1C, 0x1A, 0x18,
  0x16, 0x15, 0x13, 0x11, 0x10, 0x0F, 0x0D, 0x0C,
  0x0B, 0x0A, 0x08, 0x07, 0x06, 0x06, 0x05, 0x04,
  0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01,
  0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03,
  0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x0A,
  0x0B, 0x0C, 0x0D, 0x0F, 0x10, 0x11, 0x13, 0x15,
  0x16, 0x18, 0x1A, 0x1C, 0x1E, 0x20, 0x22, 0x24,
  0x26, 0x28, 0x2B, 0x2D, 0x2F, 0x32, 0x34, 0x37,
  0x39, 0x3C, 0x3F, 0x41, 0x44, 0x47, 0x4A, 0x4D,
  0x4F, 0x52, 0x55, 0x58, 0x5B, 0x5E, 0x61, 0x64,
  0x67, 0x6A, 0x6D, 0x70, 0x74, 0x77, 0x7A, 0x7D
};


usando qualcosa del genere
Code: [Select]
 for (int i = 0; i <= 255; i++) {
    UDP.write(sine_wave[i]);
  }
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 07, 2019, 05:54 pm
Ho appena ricevuto il microfono MAX esattamente il modello:

Quote
Max4466 Amplificatore Microfono Voice module Microphone Audio Amplifier Arduino
inserzione baia:

Quote
113225058600
Ho compilato nuovamente lo sketch, avviato il server ma la situazione non cambia. Il microfono funziona in quanto: sia il Monitor Seriale che il Plotter Seriale, stampano valori e onde; come con il microfono "scheda rossa". Ho provato a ruotare il potenziometro senza alcuna emissione di segnale sonoro, solo segnale distorto come se passasse qualcosa ad intervalli irregolari tipo piezoelettrico.

Non mi resta che aspettare l'altro microfono che ho ordinato:

Quote
MAX9814 AMPLIFICATORE MICROFONO sensore suono audio ARDUINO MODULO
inserzione baia:

Quote
254004249876
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 07, 2019, 06:39 pm
Il convertitore è a 10 bit per cui avrai valori tra zero e 1023. Poiché in un byte al massimo puoi avere 256 valori (0-255) il risultato del convertitore va messo in 2 byte, i primi 8 in uno e i restanti 2 nell'altro. L'altro quindi avrà solo 2 bit, valori da 0 a 3.
Ora quando trasmetti in UDP può capitare che qualche byte vada perso.
Dall'altro lato, quando ricevi un byte, non puoi sapere se questo contiene i primi 8 o i restanti 2. Diciamo che se contiene valori superiori a 3 allora si tratta dei primi 8 ma non ne puoi essere sicuro.

Puoi fare anche un'altra cosa in attesa del microfono: mandare dei dati artificiali e vedere come arrivano dall'altra parte.
Pr esempio puoi trasmettere ques'onda sinusoidale (a 8 bit!)
Code: [Select]
uint8_t  sine_wave[256] = {
  0x80, 0x83, 0x86, 0x89, 0x8C, 0x90, 0x93, 0x96,
  0x99, 0x9C, 0x9F, 0xA2, 0xA5, 0xA8, 0xAB, 0xAE,
  0xB1, 0xB3, 0xB6, 0xB9, 0xBC, 0xBF, 0xC1, 0xC4,
  0xC7, 0xC9, 0xCC, 0xCE, 0xD1, 0xD3, 0xD5, 0xD8,
  0xDA, 0xDC, 0xDE, 0xE0, 0xE2, 0xE4, 0xE6, 0xE8,
  0xEA, 0xEB, 0xED, 0xEF, 0xF0, 0xF1, 0xF3, 0xF4,
  0xF5, 0xF6, 0xF8, 0xF9, 0xFA, 0xFA, 0xFB, 0xFC,
  0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFD,
  0xFD, 0xFC, 0xFB, 0xFA, 0xFA, 0xF9, 0xF8, 0xF6,
  0xF5, 0xF4, 0xF3, 0xF1, 0xF0, 0xEF, 0xED, 0xEB,
  0xEA, 0xE8, 0xE6, 0xE4, 0xE2, 0xE0, 0xDE, 0xDC,
  0xDA, 0xD8, 0xD5, 0xD3, 0xD1, 0xCE, 0xCC, 0xC9,
  0xC7, 0xC4, 0xC1, 0xBF, 0xBC, 0xB9, 0xB6, 0xB3,
  0xB1, 0xAE, 0xAB, 0xA8, 0xA5, 0xA2, 0x9F, 0x9C,
  0x99, 0x96, 0x93, 0x90, 0x8C, 0x89, 0x86, 0x83,
  0x80, 0x7D, 0x7A, 0x77, 0x74, 0x70, 0x6D, 0x6A,
  0x67, 0x64, 0x61, 0x5E, 0x5B, 0x58, 0x55, 0x52,
  0x4F, 0x4D, 0x4A, 0x47, 0x44, 0x41, 0x3F, 0x3C,
  0x39, 0x37, 0x34, 0x32, 0x2F, 0x2D, 0x2B, 0x28,
  0x26, 0x24, 0x22, 0x20, 0x1E, 0x1C, 0x1A, 0x18,
  0x16, 0x15, 0x13, 0x11, 0x10, 0x0F, 0x0D, 0x0C,
  0x0B, 0x0A, 0x08, 0x07, 0x06, 0x06, 0x05, 0x04,
  0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01,
  0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03,
  0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x0A,
  0x0B, 0x0C, 0x0D, 0x0F, 0x10, 0x11, 0x13, 0x15,
  0x16, 0x18, 0x1A, 0x1C, 0x1E, 0x20, 0x22, 0x24,
  0x26, 0x28, 0x2B, 0x2D, 0x2F, 0x32, 0x34, 0x37,
  0x39, 0x3C, 0x3F, 0x41, 0x44, 0x47, 0x4A, 0x4D,
  0x4F, 0x52, 0x55, 0x58, 0x5B, 0x5E, 0x61, 0x64,
  0x67, 0x6A, 0x6D, 0x70, 0x74, 0x77, 0x7A, 0x7D
};


usando qualcosa del genere
Code: [Select]
  for (int i = 0; i <= 255; i++) {
    UDP.write(sine_wave[i]);
  }

Ho fatto quello che mi hai consigliato, ho creato il codice (lato client):

Code: [Select]

#include <ESP8266WiFi.h> // Libreria per inviare e ricevere dati in WiFi con ESP8266
#include <WiFiUdp.h> // Libreria per la gestione di Client-Server UDP in WiFi

const char* ssid = "nome_rete_wifi";
const char* password = "password_rete_wifi";

int contconexion = 0;

WiFiUDP Udp;

uint8_t  sine_wave[256] = {
  0x80, 0x83, 0x86, 0x89, 0x8C, 0x90, 0x93, 0x96,
  0x99, 0x9C, 0x9F, 0xA2, 0xA5, 0xA8, 0xAB, 0xAE,
  0xB1, 0xB3, 0xB6, 0xB9, 0xBC, 0xBF, 0xC1, 0xC4,
  0xC7, 0xC9, 0xCC, 0xCE, 0xD1, 0xD3, 0xD5, 0xD8,
  0xDA, 0xDC, 0xDE, 0xE0, 0xE2, 0xE4, 0xE6, 0xE8,
  0xEA, 0xEB, 0xED, 0xEF, 0xF0, 0xF1, 0xF3, 0xF4,
  0xF5, 0xF6, 0xF8, 0xF9, 0xFA, 0xFA, 0xFB, 0xFC,
  0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFD,
  0xFD, 0xFC, 0xFB, 0xFA, 0xFA, 0xF9, 0xF8, 0xF6,
  0xF5, 0xF4, 0xF3, 0xF1, 0xF0, 0xEF, 0xED, 0xEB,
  0xEA, 0xE8, 0xE6, 0xE4, 0xE2, 0xE0, 0xDE, 0xDC,
  0xDA, 0xD8, 0xD5, 0xD3, 0xD1, 0xCE, 0xCC, 0xC9,
  0xC7, 0xC4, 0xC1, 0xBF, 0xBC, 0xB9, 0xB6, 0xB3,
  0xB1, 0xAE, 0xAB, 0xA8, 0xA5, 0xA2, 0x9F, 0x9C,
  0x99, 0x96, 0x93, 0x90, 0x8C, 0x89, 0x86, 0x83,
  0x80, 0x7D, 0x7A, 0x77, 0x74, 0x70, 0x6D, 0x6A,
  0x67, 0x64, 0x61, 0x5E, 0x5B, 0x58, 0x55, 0x52,
  0x4F, 0x4D, 0x4A, 0x47, 0x44, 0x41, 0x3F, 0x3C,
  0x39, 0x37, 0x34, 0x32, 0x2F, 0x2D, 0x2B, 0x28,
  0x26, 0x24, 0x22, 0x20, 0x1E, 0x1C, 0x1A, 0x18,
  0x16, 0x15, 0x13, 0x11, 0x10, 0x0F, 0x0D, 0x0C,
  0x0B, 0x0A, 0x08, 0x07, 0x06, 0x06, 0x05, 0x04,
  0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01,
  0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03,
  0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x0A,
  0x0B, 0x0C, 0x0D, 0x0F, 0x10, 0x11, 0x13, 0x15,
  0x16, 0x18, 0x1A, 0x1C, 0x1E, 0x20, 0x22, 0x24,
  0x26, 0x28, 0x2B, 0x2D, 0x2F, 0x32, 0x34, 0x37,
  0x39, 0x3C, 0x3F, 0x41, 0x44, 0x47, 0x4A, 0x4D,
  0x4F, 0x52, 0x55, 0x58, 0x5B, 0x5E, 0x61, 0x64,
  0x67, 0x6A, 0x6D, 0x70, 0x74, 0x77, 0x7A, 0x7D
};


void setup()
{
  Serial.begin(115200);
  Serial.println();

  pinMode(5, OUTPUT);  //D1 Led di stato
  digitalWrite(15, LOW);

  WiFi.mode(WIFI_STA); // avvio SoftAP (access point abilitato al software) in modalità normale
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED and contconexion <50) { // Conteggio fino a 50, se non riesce cancella la connessione
    ++contconexion;
    delay(250);
    Serial.print(".");
    digitalWrite(5, HIGH);
    delay(250);
    digitalWrite(5, LOW);

  } // fine while()
 
} // fine setup()

void loop()
{
  Serial.println("sono nel loop \n"); // per capire se entro nel loop - solo di test
  Udp.beginPacket("ip_rete_wifi", 1234);
  Serial.println("\nsono dentro"); // per capire se entro nel loop - solo di test

  for (int i = 0; i <= 255; i++) {
    Udp.write(sine_wave[i]);
  }

  Udp.endPacket();
  delay(2000); // secondi, 2 secondi
} // fine loop()


Ho creato il codice (lato server):

Code: [Select]

import pyaudio
import socket

UDP_IP = "ip_rete_wifi"
UDP_PORT = 1234

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((UDP_IP, UDP_PORT))

print("IP e': ", UDP_IP)
print("Porta e': ", UDP_PORT)

p = pyaudio.PyAudio()

print("Pyaudio: ", p)
stream = p.open(format=32, channels=1, rate=111111, output=True)

print("Stream: ", stream)

try:
    while True:
        data, addr = sock.recvfrom(1024) # buffer de 1024 bytes
        print ("--------------------------\n")
        print ("data: ", data)
        print ("\n")
        print ("addr: ", addr)
        print ("\n")
        stream.write(data) # mi fa sentire l'audio negli altoparlanti
       
except KeyboardInterrupt:  #precionar Crtl + C para salir
    print("Cerrando...")
    stream.stop_stream()
    stream.close()
    p.terminate()


Avvio il server dal terminale:
Quote
python nome_file_server.py
L'output è:

Quote
data:  b'\x80\x83\x86\x89\x8c\x90\x93\x96\x99\x9c\x9f\xa2\xa5\xa8\xab\xae\xb1\xb3\xb6\xb9\xbc\xbf\xc1\xc4\xc7\xc9\xcc\xce\xd1\xd3\xd5\xd8\xda\xdc\xde\xe0\xe2\xe4\xe6\xe8\xea\xeb\xed\xef\xf0\xf1\xf3\xf4\xf5\xf6\xf8\xf9\xfa\xfa\xfb\xfc\xfd\xfd\xfe\xfe\xfe\xff\xff\xff\xff\xff\xff\xff\xfe\xfe\xfe\xfd\xfd\xfc\xfb\xfa\xfa\xf9\xf8\xf6\xf5\xf4\xf3\xf1\xf0\xef\xed\xeb\xea\xe8\xe6\xe4\xe2\xe0\xde\xdc\xda\xd8\xd5\xd3\xd1\xce\xcc\xc9\xc7\xc4\xc1\xbf\xbc\xb9\xb6\xb3\xb1\xae\xab\xa8\xa5\xa2\x9f\x9c\x99\x96\x93\x90\x8c\x89\x86\x83\x80}zwtpmjgda^[XUROMJGDA?<9742/-+(&$" \x1e\x1c\x1a\x18\x16\x15\x13\x11\x10\x0f\r\x0c\x0b\n\x08\x07\x06\x06\x05\x04\x03\x03\x02\x02\x02\x01\x01\x01\x01\x01\x01\x01\x02\x02\x02\x03\x03\x04\x05\x06\x06\x07\x08\n\x0b\x0c\r\x0f\x10\x11\x13\x15\x16\x18\x1a\x1c\x1e "$&(+-/2479<?ADGJMORUX[^adgjmptwz}'
Ad ogni iterazione l'output giustamente è uguale. Testato anche con altre reti internet (velocità diverse), l'output non cambia.
Title: Re: ARDUINO E VOCE
Post by: zoomx on Mar 07, 2019, 07:10 pm
A me sembra che i valori non arrivino correttamente oppure non sono gestiti correttamente dal python
x80}zwtpmjgda^[XUROMJGDA?<9742/-+(&$"
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 08, 2019, 01:29 am
Si effettivamente se quello che mando dovrebbe arrivare con lo stesso ordine, non arrivano con lo stesso ordine. Ma le varie iterazioni, anche da connessioni diverse, quindi più o meno veloci, danno lo stesso output. Deduco che forse è il lato server che non gestisce bene quello che riceve.

Per venirne a capo, quale potrebbe essere il modo corretto per far ascoltare l'audio ambientale al microfono, spedirlo al server che applicherà la fft (o gliela faccio processare al NodeMCU) e confrontare tale audio ricevuto con i suoni presenti sul server? Confrontarli per fare un riconoscimento (stile Shazam)

Title: Re: ARDUINO E VOCE
Post by: zoomx on Mar 08, 2019, 12:09 pm
Io ancora il python non l'ho studiato, mi ha bloccato il fatto che fa la 2.x e 3.x ci siano incomprensioni profonde (già a livello di print). Ma è diventato molto di moda anche nel mondo della ricerca.

Prova magari con queta app per Win10 o qualcosa di simile per altri sistemi operativi, giusto per vedere se il problema è chi trasmette o chi riceve, c'è sempre la possibilità che sia l'ESP8266 a trasmettere male.
https://www.microsoft.com/en-us/p/udp-sender-reciever/9nblggh52bt0?activetab=pivot:overviewtab

La risposta al tuo ultimo quesito credo dipenda dalla complessità del segnale da riconoscere. PEr segnali semplici esistono persino semplici progettini per Arduino(!) di riconoscimento vocale (ancora mai provati) ma se devi andare sul complesso credo che il segnale audio debba essere di buona qualità.
Per cui io intanto partirei da un RaspberryPI con scheda audio USB e poi valuterei se fosse possibile scendere a qualcosa di meno complesso.

Edit:Accidenti volevo provare l'app ma è per telefoni!
Edit2: Sembra che vada pene anche per PC.
Edit3: forse questa è meglio https://packetsender.com/ (https://packetsender.com/)
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 08, 2019, 12:29 pm
Grazie per i consigli e sincerità
Quote
zoomx
Comunque acquisizione e salvataggio con raspberry e OS X mediante microfono usb la faccio tranquillamente..contavo di utilizzare NodeMCU per una questione di spazio e prezzo. Chissà se mai riuscirò..esempio con raspberry potrebbe essere una buona idea quella di acquisire, processare e creare un db con "mongo db". Almeno questo mi hanno consigliato. Qualcuno lo ha usato o lo usa?
Title: Re: ARDUINO E VOCE
Post by: zoomx on Mar 08, 2019, 12:45 pm
Ho fatto un test usando Packet Sender che però non riceve nulla.
Ma con Wireshark intercetto il pacchetto. Ed è sbagliato. Lo vedo identico a quello che hai stampato tu.

Code: [Select]
Frame 3: 298 bytes on wire (2384 bits), 298 bytes captured (2384 bits) on interface 0
Ethernet II, Src: Espressi_69:14:4b (5c:cf:7f:69:14:4b), Dst: D-Link_14:96:d6 (f0:7d:68:14:96:d6)
Internet Protocol Version 4, Src: 192.168.137.10, Dst: 192.168.137.1
User Datagram Protocol, Src Port: 49153, Dst Port: 1234
Data (256 bytes)
    Data: 808386898c909396999c9fa2a5a8abaeb1b3b6b9bcbfc1c4...
    [Length: 256]


...}zwtpmjgda^[XUROMJGDA?<9742/-+(&$" ..........
.
.............................
.
.......... "$&(+-/2479<?ADGJMORUX[^adgjmptwz}

Sembra che il problema risieda quindi nell'ESP8266. Solo che Wireshark mi mostra il pacchetto anche come array C



Code: [Select]
char packet_bytes[] = {
  0x80, 0x83, 0x86, 0x89, 0x8c, 0x90, 0x93, 0x96,
  0x99, 0x9c, 0x9f, 0xa2, 0xa5, 0xa8, 0xab, 0xae,
  0xb1, 0xb3, 0xb6, 0xb9, 0xbc, 0xbf, 0xc1, 0xc4,
  0xc7, 0xc9, 0xcc, 0xce, 0xd1, 0xd3, 0xd5, 0xd8,
  0xda, 0xdc, 0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8,
  0xea, 0xeb, 0xed, 0xef, 0xf0, 0xf1, 0xf3, 0xf4,
  0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfa, 0xfb, 0xfc,
  0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff,
  0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfd,
  0xfd, 0xfc, 0xfb, 0xfa, 0xfa, 0xf9, 0xf8, 0xf6,
  0xf5, 0xf4, 0xf3, 0xf1, 0xf0, 0xef, 0xed, 0xeb,
  0xea, 0xe8, 0xe6, 0xe4, 0xe2, 0xe0, 0xde, 0xdc,
  0xda, 0xd8, 0xd5, 0xd3, 0xd1, 0xce, 0xcc, 0xc9,
  0xc7, 0xc4, 0xc1, 0xbf, 0xbc, 0xb9, 0xb6, 0xb3,
  0xb1, 0xae, 0xab, 0xa8, 0xa5, 0xa2, 0x9f, 0x9c,
  0x99, 0x96, 0x93, 0x90, 0x8c, 0x89, 0x86, 0x83,
  0x80, 0x7d, 0x7a, 0x77, 0x74, 0x70, 0x6d, 0x6a,
  0x67, 0x64, 0x61, 0x5e, 0x5b, 0x58, 0x55, 0x52,
  0x4f, 0x4d, 0x4a, 0x47, 0x44, 0x41, 0x3f, 0x3c,
  0x39, 0x37, 0x34, 0x32, 0x2f, 0x2d, 0x2b, 0x28,
  0x26, 0x24, 0x22, 0x20, 0x1e, 0x1c, 0x1a, 0x18,
  0x16, 0x15, 0x13, 0x11, 0x10, 0x0f, 0x0d, 0x0c,
  0x0b, 0x0a, 0x08, 0x07, 0x06, 0x06, 0x05, 0x04,
  0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01,
  0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03,
  0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x0a,
  0x0b, 0x0c, 0x0d, 0x0f, 0x10, 0x11, 0x13, 0x15,
  0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24,
  0x26, 0x28, 0x2b, 0x2d, 0x2f, 0x32, 0x34, 0x37,
  0x39, 0x3c, 0x3f, 0x41, 0x44, 0x47, 0x4a, 0x4d,
  0x4f, 0x52, 0x55, 0x58, 0x5b, 0x5e, 0x61, 0x64,
  0x67, 0x6a, 0x6d, 0x70, 0x74, 0x77, 0x7a, 0x7d
};



E mi pare identico. Potresti provare a riprodurre la frequenza in python.

Edit: imponendo a PacketSender di usare solo IPv4 (forse perché ho parecchie schede di rete?), funziona, ricevo i pacchetti correttamente.

"$&(+-/2479<?ADGJMORUX[^adgjmptwz} dovrebbe essere la rappresentazione ASCII di un gruppo dei valori del pacchetto.

Per cui la palla ritorna al Pyton.

Edit2:
Progetto simile, utile per trasmettere usando buffer
https://perso.aquilenet.fr/~sven337/english/2016/07/14/DIY-wifi-baby-monitor.html (https://perso.aquilenet.fr/~sven337/english/2016/07/14/DIY-wifi-baby-monitor.html)
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 10, 2019, 01:03 pm
Grazie per le prove

Quote
zoomx
si il problema sarà nel ESP. Comunque il progetto del Baby Monitor lo avevo visto ma il codice per me è incomprensibile..non ho le conoscenze per capirlo.

Penso proprio di passare direttamente a gestire il lavoro mediante più macchine virtuali, a cui collegherò il microfono USB. L'acqusizione da microfono USB so che funziona in quanto l'ho già provata e poi vedrò di utilizzare qualche DB, ad esempio mi consigliavano: MongoDB. Successivamente potrei interfacciare le macchine mediante Kubernets o Swarm.

Chissà quello che ne verrà fuori
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 10, 2019, 02:09 pm
Anche perché, nel GitHub vedo che non c'è un solo file ".ino" ma ce ne sono diversi. Non saprei come caricarli su NodeMCU.
Title: Re: ARDUINO E VOCE
Post by: zoomx on Mar 10, 2019, 07:19 pm
Vanno caricati quelli della cartella Xmit (trasmettitore), basta metterli nella stessa cartella e l'Ide li aprirà assieme.
wifi_params.h  contiene i parametri per la connessione wifi, che vanno modificati.
Ho notato che nel codice della trasmittente sembrano esserci anche i pezzi del convertitore DAC.
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 11, 2019, 12:10 am
Se ho capito bene, dovrei scaricare i file e metterli nella stessa cartella: "wifi_params.h" e "xmit.ino", modificare i settari del wifi e gli IP in modo da adeguarli alla mia rete.
Fatto questo dovrei effettuare l'upload dello sketch "xmit.ino" sul mio NodeMCU. Ma il microfono vedo che lui lo collega al pin "D8"
Code: [Select]
const int scePin = D8; //15;    // SCE - Chip select
quindi dovrei collegare il pin OUT del microfono al pin "D8" del NodeMCU?

Una volta fatto questo dovrei avere il lato client. Il lato server lo dovrei prendere dalla directory "recv" se utilizzo un altro NodeMCU e invece "udpserver" se utilizzo un pc?

In un commento ho letto che se utilizzo il pc dovrò utilizzare i file nelle directory: "udpserver" e "udpclient", ed invece "recv" e "xmit" se utilizzo NodeMCU?
Title: Re: ARDUINO E VOCE
Post by: zoomx on Mar 11, 2019, 09:48 am
Non avevo letto con attenzione il progetto.
Non usa l'ADC del nodeMCU ma un ADC esterno, MCP3201, che comunica in SPI ed è a 12 bit invece dei 10, il pin D8 è quello che seleziona il dispositivo con cui si vuole comunicare perché l'SPI è un bus condiviso.

A questo punto non mi sembra più tanto utile come pensavo.
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 11, 2019, 11:45 am
Buongiorno, il microfono MAX9814 è arrivato. Ho provato e come gli altri da lo stesso risultato. Ulteriore conferma che mi perdo una gran serie di pacchetti in giro per strada.
Sto sbagliando qualcosa a livello Server? Sto sbagliando qualcosa a livello Cliente? Boh.

C'è da dire che è un po brutto che in una discussione di un forum risponda solo una persona, apprezzo tantissimo la tua disponibilità

Quote
zoomx
ma così è difficilissimo risolvere il mio problema.

Quote
gpb01
tu o chi per te non sapreste darci aiuto in merito?
Title: Re: ARDUINO E VOCE
Post by: gpb01 on Mar 11, 2019, 11:49 am
tu o chi per te non sapreste darci aiuto in merito?
Secondo te, se qualcuno avesse già affrontato la cosa o conoscesse la soluzione, non sarebbe già intervenuto ? ? ? :o

Evidentemente è argomento che non ha molti "accoliti" in questa sezione del forum ... ::)

Prova a cercare nella parte internazionale la GIUSTA sezione e poni li la domanda (rigorosamente in lingua Inglese) ... magari hai maggiore fortuna.

Guglielmo
Title: Re: ARDUINO E VOCE
Post by: alessandro87gatto on Mar 12, 2019, 12:58 am
Va bene, ci proverò. Grazie