But I want to play this value in a speaker using any GPIO Pin
You can only do this with a PWM capable pin.
First you need to choose what pin you want and then set the PWM frequency to something above the highest audio frequency, around about 40KHz is best. See this for how ESP32 PWM Example | Circuits4you.com
Then simply do an analogWrite to this pin using the value read from the analogRead, shifted over to the right by two places.
void loop(){
int val_analog = analogRead(sound_pin);
analogWrite( 9, val_analog >> 2 ); // if you have set up pin 9 for the fast PWM
// Serial.print(val_analog); never print it slows things down too much.
}
However I have no idea why you want to do this as it will be rubbish. The sampling rate will not be high enough. Why not just connect a wire from your analogue input to where you want the pin to go to?
Someone told me to get the value in a byte array and send it to the speaker.
Someone don't understand what you were asking him / her or they don't know themselves.
/*
Video: https://www.youtube.com/watch?v=oCMOYS71NIU
Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleNotify.cpp
Ported to Arduino ESP32 by Evandro Copercini
Create a BLE server that, once we receive a connection, will send periodic notifications.
The service advertises itself as: 6E400001-B5A3-F393-E0A9-E50E24DCCA9E
Has a characteristic of: 6E400002-B5A3-F393-E0A9-E50E24DCCA9E - used for receiving data with "WRITE"
Has a characteristic of: 6E400003-B5A3-F393-E0A9-E50E24DCCA9E - used to send data with "NOTIFY"
The design of creating the BLE server is:
1. Create a BLE Server
2. Create a BLE Service
3. Create a BLE Characteristic on the Service
4. Create a BLE Descriptor on the characteristic
5. Start the service.
6. Start advertising.
In this example rxValue is the data received (only accessible inside that function).
And txValue is the data to be sent, in this example just a byte incremented every second.
*/
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
float AnalogValue;
BLEServer *pServer = NULL;
BLECharacteristic * pTxCharacteristic;
BLECharacteristic * pTEMPCharacteristic;
bool deviceConnected = false;
bool oldDeviceConnected = false;
uint16_t txValue;
uint16_t TEMPValue;
static String Received_Char;
// See the following for generating UUIDs:
// https://www.uuidgenerator.net/
#define SERVICE_UUID "6E400001-B5A3-F393-E0A9-E50E24DCCA9E" // UART service UUID
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TEMP "6E400004-B5A3-F393-E0A9-E50E24DCCA9E"
class MyServerCallbacks: public BLEServerCallbacks {
void onConnect(BLEServer* pServer) {
deviceConnected = true;
};
void onDisconnect(BLEServer* pServer) {
deviceConnected = false;
}
};
class MyCallbacks: public BLECharacteristicCallbacks {
void onWrite(BLECharacteristic *pCharacteristic) {
std::string rxValue = pCharacteristic->getValue();
if (rxValue.length() > 0) {
Serial.println("*********");
Serial.print("Received Value: ");
for (int i = 0; i < rxValue.length(); i++)
{
Serial.print(rxValue[i]);
Received_Char=rxValue[i];
}
Serial.println();
Serial.println("*********");
}
Serial.println(Received_Char);
}
};
void setup() {
Serial.begin(115200);
// Create the BLE Device
BLEDevice::init("Lungs Monitoring");
// Create the BLE Server
pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());
// Create the BLE Service
BLEService *pService = pServer->createService(SERVICE_UUID);
// Create a BLE Characteristic
pTxCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID_TX,
BLECharacteristic::PROPERTY_NOTIFY
);
pTxCharacteristic->addDescriptor(new BLE2902());
pTEMPCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID_TEMP,
BLECharacteristic::PROPERTY_NOTIFY
);
pTEMPCharacteristic->addDescriptor(new BLE2902());
BLECharacteristic * pRxCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID_RX,
BLECharacteristic::PROPERTY_WRITE
);
pRxCharacteristic->setCallbacks(new MyCallbacks());
// Start the service
pService->start();
// Start advertising
pServer->getAdvertising()->start();
Serial.println("Waiting a client connection to notify...");
}
void loop() {
if (deviceConnected) {
if(Received_Char=="S"){
txValue = analogRead(A0);//=AnalogValue.toInt();
pTxCharacteristic->setValue(txValue);
pTxCharacteristic->notify();
//txValue++;
Serial.println(txValue);
delay(10); // bluetooth stack will go into congestion, if too many packets are sent
}
else if(Received_Char=="T");
}
// disconnecting
if (!deviceConnected && oldDeviceConnected) {
delay(500); // give the bluetooth stack the chance to get things ready
pServer->startAdvertising(); // restart advertising
Serial.println("start advertising");
oldDeviceConnected = deviceConnected;
}
// connecting
if (deviceConnected && !oldDeviceConnected) {
// do stuff here on connecting
oldDeviceConnected = deviceConnected;
}
}
But the data is transferring at a very high speed and the app is not able to get it properly.
Can anyone help me with how to take samples of the audio sensor and store them in a byte array and send it to the app?
When you store the data first you are limited to how long the sound can last by the amount of memory you have in the Arduino. It also means that data will not be contiguous, that is there wil be gaps between the data in one set of samples and the next.
What is the resolution of the samples? If it is more than 8 bits you can not use a byte array, it will have to be a float or int array.