Guia para Desenvolvimento do Software

Os programas serão os seguintes:
1 - Programa base, com inicialização do processador e efeitos diversos
- Deverá conter as opções de menu para selecionar as funções da bobina,
- Deverá acionar leds RGB na bobina mudando a cor conforme o estado da bobina, sendo verde (seguro) sem tensão, amarelo com baixa tensão, vermelho em modo de alta tensão
- Efeitos visuais usando os leds RGB para quando em standby, efeitos visuais ritmicos conforme sons de entrada
- Para sinalizar toques de teclas e energizqação da bobina usar o buzzer para gerar sinais sonoros
2 - Programa de varredura da frequencia, com objetivo de determinar a frequencia de ressonancia.
- Oscilador variando a frequencia de 5KHz até 1 MHz, ou proximo disso, para isso basta incrementar e decrementar o delayMicroseconds
- Colocar no display as informações de frequencia e tensão de saída
- Fonte de consulta https://pt.wikipedia.org/wiki/Frequ%C3%AAncia_de_resson%C3%A2ncia
3 - Programa para mudar a frequencia usando trimpot
- Diferente do programa anterior que fica varrendo as frequencias automaticamente esse será alterado manualmente ajustando o trimpot
4 - Medir a tensão de saida deduzindo a tensão com base nos metodos de medição a capacitor
- Informar no display as reatancias capacitivas, frequencia e valor da tensão de saida
- Fonte de referencia https://pt.wikipedia.org/wiki/Reat%C3%A2ncia_capacitiva
5 - Gerador de midi e tocar as musicas pré configuradas
- Montar o programa com as frenquencias das notas musicais
- Montar as sequencias de notas e tempos para gerar os sons no formato midi
6 - Utilizar o amplificador para gerar sinais de microfone ou entrada de audio
- Elaborar o programa que coleta a amostra de entrada e converte em pulsos PWM para a bobina

Professor tem algum exercicio que podemos usar uma base dele pra ir programando conforme o resto?

Publiquei aqui as orientações

https://roboticalivre.forumeiros.com/t2867-ideias-para-o-projeto

/*
* CURSO DE ROBOTICA 2021
*
* Exercicio: 3.20
* Tema: menu selecionavel
* Atividade: criar um menu onde posa selecionar uma opçao
* Descrição: usar a funçao switch para criar um menu e usar uma tecla para selecionar uma das opçoes
* Hardware: Ligar da seguinte forma: RS=>pino D12; EN=>pino D13; D4=>pino D4; D5=>pino D5; D6=>pino D6; D7=>pino D7, as teclas serão ligados em pinos digitais
* Comandos: LiquidCrystal, Serial.begin, switch,  case, if,digitalRead,etc.
* Dica1: Programas utilizado 3.11, 3.12, 3.13 e 3.14
* Dica2: Instrumentos: ldr, ntc, buzzer.
* Dica3: Jogos: menu
* Dica4: Entretenimento: caracter

*/

#define teclaUp 8 //tecla que desloca display para cima
#define teclaDown 9 //tecla que desloca display para baixo
#define teclaselect 10
#define buzzer 11
#define ntc A0 //o pino A0 vai se chamar ntc
#define ldr A1 //o pino A1 vai se chamar ldr
#include


//DECLARAcAO DE VARIAVEIS GLOBAIS
long valorntc;//cria a variavel valorntc para guardar o valor de ntc
long valorldr;//cria a variavel valorldr para guardar o valor de ldr
LiquidCrystal lcd(12,13,4,5,6,7);
byte emoji[] = {
B00001, //o bit que for colocado em 1 vai acender no display
B00011,
B00111,
B01110,
B11110,
B11111,
B11111,
B11111};
byte emoji1[] = {
B11111, //o bit que for colocado em 1 vai acender no display
B11111,
B11111,
B01110,
B01110,
B11111,
B11111,
B11111};
byte emoji2[] = {
B10000, //o bit que for colocado em 1 vai acender no display
B11000,
B11100,
B01110,
B01111,
B11111,
B11111,
B11111};
byte emoji3[] = {
B11011, //o bit que for colocado em 1 vai acender no display
B11000,
B11100,
B11110,
B01111,
B00111,
B00011,
B0001};
byte emoji4[] = {
B11111, //o bit que for colocado em 1 vai acender no display
B00000,
B00000,
B00000,
B00000,
B11111,
B11111,
B11111};
byte emoji5[] = {
B11011, //o bit que for colocado em 1 vai acender no display
B00011,
B00111,
B01111,
B11110,
B11100,
B11000,
B10000};

int emoje(){
lcd.setCursor(3,0); //posiciona o cursor onde havera a animação
lcd.write(byte(1)); //Escreve no display o caractere
lcd.setCursor(4,0);
lcd.write(byte(2));
lcd.setCursor(5,0);
lcd.write(byte(3));
lcd.setCursor(3,1); //posiciona o cursor onde havera a animação
lcd.write(byte(4)); //Escreve no display o caractere
lcd.setCursor(4,1);
lcd.write(byte(5));
lcd.setCursor(5,1);
lcd.write(byte(6));
}
byte menu = 1; //variavel que guarda a posição do menu que será apresentada
int timer; //variável que guarda o temporizador

//INICIALIZAÇÃO DO HARDWARE
void setup() {
 Serial.begin(9600);
Serial.print("Use as teclas Down e Up para escoler uma opcao, e a tecla select para selecionar ou sair da opcao escolida");
lcd.begin(16, 2);
lcd.createChar(1, emoji);
lcd.createChar(2, emoji1);
lcd.createChar(3, emoji2);
lcd.createChar(4, emoji3);
lcd.createChar(5, emoji4);
lcd.createChar(6, emoji5);
lcd.clear(); //limpa o display e posiciona o cursor na primeira linha e primeira coluna
pinMode(teclaUp, INPUT_PULLUP); //programa a tecla como entrada pull up
pinMode(teclaDown, INPUT_PULLUP); //programa a tecla como entrada pull up
pinMode(teclaselect, INPUT_PULLUP);
pinMode(buzzer, OUTPUT);
}


//PROGRAMA PRINCIPAL
void loop() {
 if(!digitalRead(teclaUp)){
menu ++;
if(menu == 6) menu = 5;
while(!digitalRead(teclaUp)){
delay(20);
}
}

if(!digitalRead(teclaDown)){
menu --;
if(menu == 0) menu = 1;
while(!digitalRead(teclaDown)){
delay(20);
}
}
valorntc = analogRead(ntc);
valorldr = analogRead(ldr);


switch(menu){
case(1):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">1 - Menu1");
lcd.setCursor(0,1);
lcd.print("2 - Menu2");
if(!digitalRead(teclaselect)){
 lcd.clear();
tone(buzzer,1500,500);
delay(1000);
while(!digitalRead(teclaselect)){
delay(300);
break;
}
}
break;


case(2):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">2 - Menu2");
lcd.setCursor(0,1);
lcd.print("3 - Menu3");
if(!digitalRead(teclaselect)){
lcd.clear();
 lcd.setCursor(0,0);
lcd.print("valorntc = ");
lcd.println(valorntc);
delay(1000);
while(!digitalRead(teclaselect)){
delay(300);
break;
}
}
break;



case(3):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">3 - Menu3");
lcd.setCursor(0,1);
lcd.print("4 - Menu4");
if(!digitalRead(teclaselect)){
 lcd.clear();
lcd.setCursor(0,0);
lcd.print("valorldr = ");
lcd.println(valorldr);
delay(1000);
while(!digitalRead(teclaselect)){
delay(300);
break;
}
}
break;



case(4):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">4 - Menu4");
lcd.setCursor(0,1);
lcd.print("5 - Menu5");
if(!digitalRead(teclaselect)){
 lcd.clear();
emoje();
delay(1000);
while(!digitalRead(teclaselect)){
delay(300);
break;
}
}
break;


case(5):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">5 - Menu5");
if(!digitalRead(teclaselect)){
 lcd.clear();
lcd.print("Like");
delay(1000);
while(!digitalRead(teclaselect)){
delay(300);
break;
}
}
break;

}
delay(100);
}/*minha maior dificuldade foi na parte em que s aparecia menu 5
esqueci que tinha que por break no final de cada case
*/

Lucca, voce viu o circuito que coloquei no simulador? Então precisa fazer o setup conforme a pinagem do simulador.
A estratégia do switch case ta de boa, mas falta fazer as funções que vao rodar os programas da bobina, são aqueles que estou publicando
Tem uma função que vai precisar para os leds RGB sinalizarem o status da bobina (pode ter animação, verde em setup, amarelo antes de energizar, vermelho quendo ligada)
Pode ter buzzer sinalizando que será ativada a bobina
Vamos precisar também das funções que fazem as leituras dos sensores e informam sobre as medidas no display
No setup precisa configurar o registro para frequencia de 31250Hz no PWM , fiz já o exemplo de como deve funcionar
No programa que detecta a frequencia de ressonancia tem que varrer a frequencia entre 10k e 50kHz, dai fazer a leitura da tensão e apresentar no display
O programa de varredura manual usa o trimpot para alterar a mesma faixa de frequencia e testar as tensões de saída
Tem outro programa pronto que é o do microfone, também ja publiquei esse,
Os demais ainda falta desenvolver

Uma boa também pode ser o desenvolvimento do fluxograma para ajudar no desenvolvimento do software.
Separa o programa em funções para facilitar o desenvolvimento

Tem bastante trabalho ainda no programa da bobina, mas faz por partes.

/*
* Projeto Bobina de tesla - PUCPR
* Tema: Bobina de tesla
* Atividade: criar uma bobina de tesla utilizando o arduino
* Descrição: usar a funçao switch para criar um menu e usar uma tecla para selecionar uma das opçoes
* Hardware: Ligar da seguinte forma: RS=>pino D12; EN=>pino D13; D4=>pino D4; D5=>pino D5; D6=>pino D6; D7=>pino D7, as teclas serão ligados em pinos digitais
* Comandos: LiquidCrystal, Serial.begin, switch, case, if,digitalRead,etc.
* Dica1: Programas utilizado 3.11, 3.12, 3.13 e 3.14
* Dica2: Instrumentos: ldr, ntc, buzzer.
* Dica3: Jogos: menu
* Dica4: Entretenimento: caracter

*/
#include
#define teclaUp 8 //tecla que desloca display para cima
#define teclaDown 10 //tecla que desloca display para baixo
#define teclaSelect 11
#define bobina 9
#define tecla1 12
#define tecla2 13
#define buzzer 14
#define Vsec A2
#define Out A3
#define ntc A4 //o pino A0 vai se chamar ntc
#define ldr A5 //o pino A1 vai se chamar ldr
#define trimpot A6
#define mic A7

//DECLARAcAO DE VARIAVEIS GLOBAIS
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);
int cont = 0;
int tempo = analogRead(trimpot);
int volt = analogRead(Vsec);
int Iout = analogRead(Out);

Funçoes
void Sweep() {
while(){
for(tempo = 0; tempo < 50; tempo ++){
for(cont = 0; cont < 10000; cont ++){
digitalWrite(bobina, LOW);
delayMicroseconds(tempo); // pausa por 50 microssegundos
digitalWrite(bobina, HIGH);
delayMicroseconds(tempo); // pausa por 50 microssegundos
Serial.print("Valor do volt = ");
Serial.println(analogRead(volt));
Serial.print("Valor do tempo = ");
Serial.println(tempo);
Serial.print("Valor do Iout = ");
Serial.println(Iout);
}
}
}
}
void fManu() {
while(digitalRead(teclaselect)){
for(cont = 0; cont < 1000; cont ++){
digitalWrite(bobina, LOW);
delayMicroseconds(tempo); // pausa por 50 microssegundos
digitalWrite(bobina, HIGH);
delayMicroseconds(tempo); // pausa por 50 microssegundos
}
tempo = map(tempo, 0, 1024, 1, 50);
volt = map(volt, 0, 1024, 1000, 100000);
Iout = map(Iout, 0, 1024, 0, 5);
lcd.setCursor(0, 5);
lcd.print(volt);
lcd.setCursor(1, 5);
lcd.print(out);
lcd.setCursor(1, 14);
lcd.print(tempo);
}
return;
}

void voz() {
while(){
analogRead(mic);
analogWrite(bobina, mic);
}
return;
}
/*
void voz() {
if(!digitalRead(teclaUp) && (!digitalRead(teclaDown))){
(!digitalRead(teclaUp)) = tone(buzzer, 265, 100);
(!digitalRead(teclaDown)) = tone(buzzer, 297, 100);
(!digitalRead(teclaselect)) = tone(buzzer, 330, 100);
}
}

loop
//PROGRAMA PRINCIPAL
void loop() {
if(!digitalRead(teclaUp)){
menu ++;
if(menu == 6) menu = 5;
while(!digitalRead(teclaUp)){
delay(20);
}
}

if(!digitalRead(teclaDown)){
menu --;
if(menu == 0) menu = 1;
while(!digitalRead(teclaDown)){
delay(20);
}
}
switch(menu){
case(1):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">1 - Menu1");
lcd.setCursor(0,1);
lcd.print("2 - Menu2");
if(!digitalRead(teclaSlect)){
lcd.clear();
fManu();
delay(1000);
while(!digitalRead(teclaSlect)){
delay(300);
break;
}
}
break;
case(2):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">2 - Menu2");
lcd.setCursor(0,1);
lcd.print("3 - Menu3");
if(!digitalRead(teclaSlect)){
lcd.clear();
lcd.setCursor(0,0);
voz();
delay(1000);
while(!digitalRead(teclaSlect)){
delay(300);
break;
}
}
break;
case(3):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">3 - Menu3");
lcd.setCursor(0,1);
lcd.print("4 - Menu4");
if(!digitalRead(teclaSlect)){
lcd.clear();
lcd.setCursor(0,0);
lcd.print("valorldr = ");
delay(1000);
while(!digitalRead(teclaSlect)){
delay(300);
break;
}
}
break;
case(4):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">4 - Menu4");
lcd.setCursor(0,1);
lcd.print("5 - Menu5");
if(!digitalRead(teclaSlect)){
lcd.clear();
emoje();
delay(1000);
while(!digitalRead(teclaSlect)){
delay(300);
break;
}
}
break;
case(5):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">5 - Menu5");
if(!digitalRead(teclaSlect)){
lcd.clear();
lcd.print("Like");
delay(1000);
while(!digitalRead(teclaSlect)){
delay(300);
break;
}
}
break;

}
setup
//INICIALIZAÇÃO DO HARDWARE
void setup() {
Serial.begin(9600);
lcd.begin(16, 2);
pinMode(teclaUp, INPUT_PULLUP); //programa a tecla como entrada pull up
pinMode(teclaDown, INPUT_PULLUP); //programa a tecla como entrada pull up
pinMode(teclaselect, INPUT_PULLUP);
pinMode(tecla1, INPUT_PULLUP); //programa a tecla como entrada pull up
pinMode(tecla2, INPUT_PULLUP); //programa a tecla como entrada pull up
pinMode(buzzer, OUTPUT);

}

Testei Prof so que quero entender onde esta o erro.

Tem erros saindo pela culatra, A Monica pelo visto copiou do jeito que coloquei no papel, aquilo não era o código, mas sim um roteiro. Precisa entender como funciona para programar, mas vamos lá.
- O setup não é ali que coloca
- O display precisa configurar e inicializar, conforme descrito no capitulo 3
- essa função abaixo não entendo, favor descrever
void voz() {
if(!digitalRead(teclaUp) && (!digitalRead(teclaDown))){
(!digitalRead(teclaUp)) = tone(buzzer, 265, 100);
(!digitalRead(teclaDown)) = tone(buzzer, 297, 100);
(!digitalRead(teclaselect)) = tone(buzzer, 330, 100);
}
}
- No switch/case descrever (fazer os comentários) cada um dos cases, que função vai chamar e o que vai fazer, e colocar a função lá dentro, não invocou nenhuma função
- No trecho abaixo precisa formatar melhor o display

tempo = map(tempo, 0, 1024, 1, 50);
volt = map(volt, 0, 1024, 1000, 100000);
Iout = map(Iout, 0, 1024, 0, 5);
lcd.setCursor(0, 5);
lcd.print(volt);
lcd.setCursor(1, 5);
lcd.print(out);
lcd.setCursor(1, 14);
lcd.print(tempo);
}
return;
}

- Nesse trecho quando ler um pino analógico precisa guardar o valor numa variável ou aplicar direto numa estrutura
void voz() {
while(){
analogRead(mic);
analogWrite(bobina, mic);
}
return;
}

- Falta as funções que fazem o calculo da saída da bobina

/*
* Projeto Bobina de tesla - PUCPR
* Tema: Bobina de tesla
* Atividade: criar uma bobina de tesla utilizando o ESP32
* Descrição: usar a funçao switch para criar um menu e usar uma tecla para selecionar uma das opçoes e conforme a opção selecionada a bobina efetuara um funcao
* Hardware: Ligar os pinos do display
* Comandos: LiquidCrystal, Serial.begin, switch, case, if, digitalRead, etc.
*/
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DEFINIÇÕES INICIAIS
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* Inicializa o display e faz as definições
*/

#include
#define teclaUp 8
#define bobina 9
#define teclaDown 10
#define teclaSelect 11
#define MIC A1
#define trimpot A2


// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DEFINIÇÕES E VARIAVEIS GLOBAL
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* Pinagem do display e declaração de variaveis
*/
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);
byte tempo = 23;
byte THIGH, TLOW = 0;
byte tempoAnt = 0;
int cont = 0;
byte volt = 0;
byte Iout = 0;


// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// INICIALIZAÇÃO DO HARDWARE
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void setup() {
/*
* Faz as inicializações do display e da porta serial
*/
Serial.begin(9600);
lcd.begin(16, 2);
ledcAttachPin(DRV1, 0);
pinMode(bobina, OUTPUT);
TCCR1B = TCCR1B & B11111000 | B00000001;
pinMode(teclaUp, INPUT_PULLUP);
pinMode(teclaDown, INPUT_PULLUP);
pinMode(teclaSelect, INPUT_PULLUP);
analogSetWidth(10);
}

// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DEFINIÇÕES E VARIAVEIS GLOBAL
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
*
*/
void Sweep() {
for(tempo = 0; tempo < 50; tempo ++){
for(cont = 0; cont < 10000; cont ++){
digitalWrite(bobina, LOW);
delayMicroseconds(tempo); // pausa por 50 microssegundos
digitalWrite(bobina, HIGH);
delayMicroseconds(tempo); // pausa por 50 microssegundos
lcd.setCursor(0, 0);
lcd.print("Volt ");
lcd.setCursor(5, 0);
lcd.print(analogRead(volt));
lcd.setCursor(0, 1);
lcd.print("Out ");
lcd.setCursor(4, 1);
lcd.print(Iout);
lcd.setCursor(7, 1);
lcd.print("Tp");
lcd.setCursor(11, 1);
lcd.print(tempo);
}
}
}


// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DEFINIÇÕES E VARIAVEIS GLOBAL
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
*
*/
void fManu() {
for(cont = 0; cont < 1000; cont ++){
digitalWrite(bobina, HIGH);
delayMicroseconds(tempo); // pausa por 50 microssegundos
digitalWrite(bobina, LOW);
delayMicroseconds(tempo); // pausa por 50 microssegundos
}
lcd.setCursor(0, 0);
lcd.print("Volt ");
lcd.setCursor(5, 0);
lcd.print(analogRead(volt));
lcd.setCursor(0, 1);
lcd.print("Out ");
lcd.setCursor(4, 1);
lcd.print(Iout);
lcd.setCursor(7, 1);
lcd.print("Tp");
lcd.setCursor(11, 1);
lcd.print(tempo);
return;
}

// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Função de Voz
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* modulação da voz
*/
void voz() {
tempo = map(analogRead(MIC), 300, 1024, 30, 220);
ledcWrite(0, tempo);
return;
}

// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Função de ajuste
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* Apenas pra fazer o ajuste da centelha
*/
void variaAjuste() {
tempo = map(analogRead(trimpot), 0, 1024, 25000, 60000);
if(tempo != tempoAnt){
tempoAnt = tempo;
ledcSetup(0, tempo, ;
ledcWrite(0, 127);
Serial.print(tempo);
}
}

// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PROGRAMA PRINCIPAL
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
byte menu = 0;
if(!digitalRead(teclaUp)){
menu ++;
if(menu == 6) menu = 5;
while(!digitalRead(teclaUp)){
delay(20);
}
}

if(!digitalRead(teclaDown)){
menu --;
if(menu == 0) menu = 1;
while(!digitalRead(teclaDown)){
delay(20);
}
}
switch(menu){
case(1):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">1 - Menu1");
lcd.setCursor(0,1);
lcd.print("2 - Menu2");
if(!digitalRead(teclaSelect)){
lcd.clear();
fManu();
delay(1000);
while(!digitalRead(teclaSelect)){
delay(300);
break;
}
}
break;
case(2):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">2 - Menu2");
lcd.setCursor(0,1);
lcd.print("3 - Menu3");
if(!digitalRead(teclaSelect)){
lcd.clear();
lcd.setCursor(0,0);
voz();
delay(1000);
while(!digitalRead(teclaSelect)){
delay(300);
break;
}
}
break;
case(3):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">3 - Menu3");
lcd.setCursor(0,1);
lcd.print("4 - Menu4");
if(!digitalRead(teclaSelect)){
lcd.clear();
lcd.setCursor(0,0);
Sweep();
delay(1000);
while(!digitalRead(teclaSelect)){
delay(300);
break;
}
}
break;
case(4):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">4 - Menu4");
lcd.setCursor(0,1);
lcd.print("5 - Menu5");
if(!digitalRead(teclaSelect)){
lcd.clear();
variaAjuste();
delay(1000);
while(!digitalRead(teclaSelect)){
delay(300);
break;
}
}
break;
case(5):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">5 - Menu5");
if(!digitalRead(teclaSelect)){
lcd.clear();



delay(1000);
while(!digitalRead(teclaSelect)){
delay(300);
break;
}
}
break;
}
}

Formatei o código do Lucca

#include
#define bobina 2
#define teclaUp 13
#define teclaDown 12
#define teclaselect 14
#define buzzer 27
#define ntc 25
#define MIC 26
#define Vi 15

LiquidCrystal lcd(21, 22, 5, 18, 23, 19);
byte menu = 1;
byte tempo = 23;
byte tempoAnt = 0;
byte cont = 0;
void setup() {
Serial.begin(9600);
lcd.begin(16, 2);
ledcAttachPin(bobina, 0);//Atribuimos o pino 2 ao canal 0.
ledcSetup(0, 1000, 10);//Atribuimos ao canal 0 a frequencia de 1000Hz com resolucao de 10bits.
pinMode(teclaUp, INPUT_PULLUP ); // configura GIOP21 como pino de entrada e habilita o resistor pull-up interno
pinMode(teclaDown, INPUT_PULLUP ); // configura GIOP21 como pino de entrada e habilita o resistor pull-up interno
pinMode(teclaselect, INPUT_PULLUP ); // configura GIOP21 como pino de entrada e habilita o resistor pull-up interno
pinMode(buzzer, OUTPUT);
pinMode(MIC, OUTPUT);
analogSetWidth(10);
}
void voz() {
tempo = map(analogRead(MIC), 300, 1024, 30, 220);
ledcWrite(0, tempo);
return;
}
void variaAjuste() {
// tempo = map(analogRead(trimpot), 0, 1024, 25000, 60000);
if(tempo != tempoAnt){
tempoAnt = tempo;
ledcSetup(0, tempo, 0);
ledcWrite(0, 127);
Serial.print(tempo);
}
}
/*
void fManu() {
while(digitalRead(teclaselect)){
for(cont = 0; cont < 1000; cont ++){
digitalWrite(bobina, LOW);
delayMicroseconds(tempo); // pausa por 50 microssegundos
digitalWrite(bobina, HIGH);
delayMicroseconds(tempo); // pausa por 50 microssegundos
}

lcd.setCursor(0, 0);
lcd.print("Vi ");
lcd.setCursor(5, 0);
lcd.print("12,5V");
lcd.setCursor(0, 1);
lcd.print("Ii ");
lcd.setCursor(4, 1);
lcd.print("3,4A");
lcd.setCursor(7, 1);
lcd.print("Pt");
lcd.setCursor(11, 1);
lcd.print("60W");
}
return;
}
*/

void loop() {
if(!digitalRead(teclaUp)){
menu ++;
if(menu == 6) menu = 5;
while(!digitalRead(teclaUp)){
delay(20);
}
}

if(!digitalRead(teclaDown)){
menu --;
if(menu == 0) menu = 1;
while(!digitalRead(teclaDown)){
delay(20);
}
}

switch(menu){
case(1):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">1 - Menu1");
lcd.setCursor(0,1);
lcd.print("2 - Menu2");
if(!digitalRead(teclaselect)){
lcd.clear();
tone(buzzer,1500,500);
delay(1000);
while(!digitalRead(teclaselect)){
delay(300);
break;
}
}
break;
case(2):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">2 - Menu2");
lcd.setCursor(0,1);
lcd.print("3 - Menu3");
if(!digitalRead(teclaselect)){
lcd.clear();
lcd.setCursor(0,0);
lcd.print("valorntc = ");
delay(1000);
while(!digitalRead(teclaselect)){
delay(300);
break;
}
}
break;
case(3):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">3 - Menu3");
lcd.setCursor(0,1);
lcd.print("4 - Menu4");
if(!digitalRead(teclaselect)){
lcd.clear();
lcd.setCursor(0,0);
lcd.print("valorldr = ");
delay(1000);
while(!digitalRead(teclaselect)){
delay(300);
break;
}
}
break;
case(4):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">4 - Menu4");
lcd.setCursor(0,1);
lcd.print("5 - Menu5");
if(!digitalRead(teclaselect)){
lcd.clear();
voz();
delay(1000);
while(!digitalRead(teclaselect)){
delay(300);
break;
}
}
break;
case(5):
lcd.clear();
lcd.setCursor(0,0);
lcd.print(">5 - Menu5");
if(!digitalRead(teclaselect)){
lcd.clear();
lcd.print("Like");
delay(1000);
while(!digitalRead(teclaselect)){
delay(300);
break;
}
}
break;
}
delay(100);
}

Oi Alvaro, hj a parte eletronica da bobina foi para a escola, pode usar para testar os seus programas.
No grupo do whatsapp enviei o programa que usei para fazer os testes, nele está o setup, menu, calibrei os sensores, tem uma função para apresentação do display.
Deixei sem o código de controle da bobina, se quiser pode usar partes dele para compor o seu.. Na verdade não vi a parte de controle da bobina no seu código também.
Outro detalhe, não coloquei trimpot no hardware, pensei melhor e se tem as teclas só colocar o ajuste usando as teclas up e down para mudar a frequencia.

Minha sugestão é colocar na bancada e fazer só o codigo de controle da bobina, põem para rodar o ajuste da frequencia somente,
Depois desenvolve a busca automatica
Depois desenvolve o microfone

Daí pega esses pedaços e coloca no programa de seleção.