ARDUINO E VOCE

Ho testato, con:

 Udp.print(int(analog));

o

 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.

Ho visto il video.
Intanto nello sketch c'è

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.

Grazie

zoomx

.

Forse mi manca qualche parte, ma non capisco cosa intendi:

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:

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..

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!)

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

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

Ho appena ricevuto il microfono MAX esattamente il modello:

Max4466 Amplificatore Microfono Voice module Microphone Audio Amplifier Arduino

inserzione baia:

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:

MAX9814 AMPLIFICATORE MICROFONO sensore suono audio ARDUINO MODULO

inserzione baia:

254004249876

zoomx:
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!)

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


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):

#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):

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:

python nome_file_server.py

L'output è:

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.

A me sembra che i valori non arrivino correttamente oppure non sono gestiti correttamente dal python
x80}zwtpmjgda^[XUROMJGDA?<9742/-+(&$"

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)

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.

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/

Grazie per i consigli e sincerità

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?

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.

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

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

Grazie per le prove

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

Anche perché, nel GitHub vedo che non c'è un solo file ".ino" ma ce ne sono diversi. Non saprei come caricarli su NodeMCU.

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.

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"

 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?

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.

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à

zoomx

ma così è difficilissimo risolvere il mio problema.

gpb01

tu o chi per te non sapreste darci aiuto in merito?

alessandro87gatto:
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 ... ::slight_smile:

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

Guglielmo

Va bene, ci proverò. Grazie