FREQUENCIMETRO FALANTE
 Ele fala a frequencia lida em kilohertz

veja video no youtube :frequencimetro falante 2

e pre testes : frequencimetro falante 1


Foto : Frequencimetro falante montado na caixa de som do PC

Este medidor foi elaborado pensando em radioamadores com deficiencia visual, conhecidos em nosso meio como "bengala branca".
O interessante é que baseado neste aplicativo muitos outros aparelhos para estas pessoas podem ser construidos, como medidores de tensão e corrente, medidores de ondas estacionarias alem de outros que podem ajudar na vida cotidiana como por exemplo uma trena eletronica que fala a distancia de objetos a frente. As aplicações são muitas basta ligar a imaginação.

O inicio deste projeto com Arduino Nano foi quando estudamos as possibilidades de tratativas de um sinal de audio com arduino e encontramos como ouvir arquivos do tipo .wav, foi baseado neste site :
http://www.instructables.com/id/Playing-Wave-file-using-arduino/

a biblioteca pode ser baixada deste
site :
https://github.com/TMRh20/TMRpcm

Foi necessario incluir um algoritmo que separava de uma leitura numerica em kilohertz, a dezena do milhar, a unidade do milhar, a centea, adezena e por fim a unidade, e ainda reproduzisse as palavras. Fizemos o algoritmo e gravamos as falas nos eguinte link :
http://www.oddcast.com/home/demos/tts/tts_example.php

Colocamos em portugues, e usamos um software (da Creative) "Gravador Inteligente", onde é gravado o que se ouve, assim gravamos o som de UM, DOIS ...DEZ, ONZE, VINTE, VINTE E, assim por diante ... depois com o software "WAVE STUDIO" (tambem da Creative) editamos cada arquivo retirando as partes não necessarias e aumentamos o volume quando fosse preciso. Assim ao ler a frequencia de 7158kHz ... teriamos 7 sete (7.wav), mil (mil.wav), 1 cento e (100e.wav), 5 cincoenta e (50e.wav), 8 oito (8.wav), kilohertz (khz.wav) .
Desta forma a frequencia que é lida é reproduzida em audio.

Para leitura da frequencia usamos outra biblioteca :
Biblioteca do frequencimetro

No desenvolvimeto do sketch notamos que a biblioteca de reprodução do som, ocupava muito espaço e fomos obrigados a retirar a biblioteca do LCD, que estava inclusa no sketch. assim ficamos apenas coma visualização via PC e pela IDE onde podemos verificar o que acontece via o Monitor Serial .

Hardware
 
Esquema :


Para leitura de frequencia, o arduino lê até 6,5MHz, para ler uma frequencia maior adicionamos um prescaler como integrado 74HC4017 que divide o sinal de entrada por 10, o frequencimetro apesar de ler até 65MHz, funcionou muito bem até 32MHz, atendendo a nossa espectativa.

Para reprodução do som usamos um LM386 com um préamplificador de audio com um 2N2222.
Para armazenamento dos arquivos wave usamos um SDcard de 8Gb mas poderia ser um de 4Gb ou 16Gb. Para leitura do SDcard usamos um SDcard reader.
Para alimentação usamos um 7805.


Problemas encontrados
Um problema foi o ruido que aparecia quando não havia reprodução de som, para resover incluimos um transistor que emudece o LM386, que coloca o pino 7 a terra via um resistor de 10k.
Outro problema foi a falha na leitura do SDcard quando usamos 5V externos, com a alimentação via USB tudo ocorria bem, incluimos um diodo 1N4001 em serie com os 5V resolvendo este problema.

Montagem :
Montamos em uma caixa de som de PC de sucata, usamos uma placa padrão para montar o soquete para o arduino nano e para o amplificador de audio, o circuito  emudecedor e para o prescaler.
Na montagem é necessario ter cuidado para ter acesso a porta USB do arduino, para isso fizemos um rasgo na caixa.
  


Fotos da montagem


fotos do rasgo para leitura da USB

Arquivo .RAR dos arquivos tipo .wav

Sketch do programa :

// links para bibliotecas especias outras fazem parte da IDE do arduino:
// FreqCounter http://interface.khm.de/index.php/lab/interfaces-advanced/arduino-frequency-counter-library/
//TMRpcm https://github.com/TMRh20/TMRpcm


#include <FreqCounter.h> //bibliotecas usadas
#include <SPI.h>
#include <SD.h>
#include <TMRpcm.h>
TMRpcm tmrpcm;
#define SD_ChipSelectPin 10
float ax ;
const int mudopin = 6;
const int bPin = 3;
int bestado = 1;
int  dm, um, c, d, u, milhar, dezmilhar, unimilhar, dezena, centena, unidade ;
float  frq;
float  frq1;
float ajuste= 1.000174;
//ajuste setar para 1 ler a frequencia de 30MHz na porta serial PC ...
// calcule o ajuste dividindo a frequencia lida por 30000
//altere o valor e confira

void setup() {
  Serial.begin(9600);
  tmrpcm.speakerPin = 9;
  pinMode(bPin, INPUT);
  if (!SD.begin(SD_ChipSelectPin)) {  // see if the card is present and can be initialized:
    Serial.println("Falha no SDcard");
    return;
  }
  digitalWrite(mudopin, LOW);
  delay(1000);
  //tmrpcm.setVolume(0);
  tmrpcm.play("py2ohh1.WAV");
  delay(5000);
  digitalWrite(mudopin, HIGH);
}

void loop() {
  frequencimetro();
 // delay(1000);
  if (frq1 > 100) {
      Serial.println(frq);
    Serial.println(frq1);
    ax = abs(frq);
    Serial.println(ax);
    bestado = digitalRead(bPin);
    if (bestado == LOW) {
      Serial.println(ax); //4
      Serial.println();
      debulhando();
      digitalWrite(mudopin, LOW);
      falando();
      digitalWrite(mudopin, HIGH);
      delay(1000);
    }
  }
}


void frequencimetro() {
  FreqCounter::f_comp = 0; // Cal Value / Calibrate with professional Freq Counter
  delay (100) ;
  FreqCounter::start(1000);  // values of 10, 100 or 1000 ms are practicable for a resolution of 100, 10 and 1 Hz
  while (FreqCounter::f_ready == 0) {
    frq = (FreqCounter::f_freq);
    frq = (((1 * frq) / 100) / ajuste);
  }
  FreqCounter::f_comp = 0;
  delay (100) ;
  FreqCounter::start(1000);  // values of 10, 100 or 1000 ms are practicable for a resolution of 100, 10 and 1 Hz
  while (FreqCounter::f_ready == 0) {
    frq1 = (FreqCounter::f_freq);
    frq1 = (((10 * frq1) / 1000) / ajuste) ;
  }
}

void undde() {
  if (unidade == 1) {
    tmrpcm.play("1.WAV");
    delay(1000);
  }
  else if (unidade == 2) {
    tmrpcm.play("2.WAV");
    delay(1000);
  }
  else if (unidade == 3) {
    tmrpcm.play("3.WAV");
    delay(1000);
  }
  else if (unidade == 4) {
    tmrpcm.play("4.WAV");
    delay(1000);
  }
  else if (unidade == 5) {
    tmrpcm.play("5.WAV");
    delay(1000);
  }
  else if (unidade == 6) {
    tmrpcm.play("6.WAV");
    delay(1000);
  }
  else if (unidade == 7) {
    tmrpcm.play("7.WAV");
    delay(1000);
  }
  else if (unidade == 8) {
    tmrpcm.play("8.WAV");
    delay(1000);
  }
  else if (unidade == 9) {
    tmrpcm.play("9.WAV");
    delay(1000);
  }
}
void dzn() {
  if (dezena == 10) {
    tmrpcm.play("10.WAV");
    delay(1000);
  }
  else if (dezena == 11) {
    tmrpcm.play("11.WAV");
    delay(1000);
  }
  else if (dezena == 12) {
    tmrpcm.play("12.WAV");
    delay(1000);
  }
  else if (dezena == 13) {
    tmrpcm.play("13.WAV");
    delay(1000);
  }
  else if (dezena == 14) {
    tmrpcm.play("14.WAV");
    delay(1000);
  }
  else if (dezena == 15) {
    tmrpcm.play("15.WAV");
    delay(1000);
  }
  else if (dezena == 16) {
    tmrpcm.play("16.WAV");
    delay(1000);
  }
  else if (dezena == 17) {
    tmrpcm.play("17.WAV");
    delay(1000);
  }
  else if (dezena == 18) {
    tmrpcm.play("18.WAV");
    delay(1000);
  }
  else if (dezena == 19) {
    tmrpcm.play("19.WAV");
    delay(1000);
  }
  if ( (dezena < 10 ) ) {
    undde();
  }
  if (dezena == 20) {
    tmrpcm.play("20.WAV");
    delay(1000);
  }
  if ((dezena > 20) && (dezena < 30 ) ) {
    tmrpcm.play("20e.WAV");
    delay(1000);
    undde();
  }
  if (dezena == 30) {
    tmrpcm.play("30.WAV");
    delay(1000);
  }
  if ((dezena > 30) && (dezena < 40 ) ) {
    tmrpcm.play("30e.WAV");
    delay(1000);
    undde();
  }
  if (dezena == 40) {
    tmrpcm.play("40.WAV");
    delay(1000);
  }
  if ((dezena > 40) && (dezena < 50 ) ) {
    tmrpcm.play("40e.WAV");
    delay(1000);
    undde();
  }
  if (dezena == 50) {
    tmrpcm.play("50.WAV");
    delay(1000);
  }
  if ((dezena > 50) && (dezena < 60 ) ) {
    tmrpcm.play("50e.WAV");
    delay(1000);
    undde();
  }
  if (dezena == 60) {
    tmrpcm.play("60.WAV");
    delay(1000);
  }
  if ((dezena > 60) && (dezena < 70 ) ) {
    tmrpcm.play("60e.WAV");
    delay(1000);
    undde();
  }
  if (dezena == 70) {
    tmrpcm.play("70.WAV");
    delay(1000);
  }
  if ((dezena > 70) && (dezena < 80 ) ) {
    tmrpcm.play("70e.WAV");
    delay(1000);
    undde();
  }
  if (dezena == 80) {
    tmrpcm.play("80.WAV");
    delay(1000);
  }
  if ((dezena > 80) && (dezena < 90 ) ) {
    tmrpcm.play("80e.WAV");
    delay(1000);
    undde();
  }
  if (dezena == 90) {
    tmrpcm.play("90.WAV");
    delay(1000);
  }
  if ((dezena > 90)  ) {
    tmrpcm.play("90e.WAV");
    delay(1000);
    undde();
  }
}
void cntn() {
  if ((centena == 1) && (dezena == 0) && (unidade == 0)) {
    tmrpcm.play("100.WAV");
    delay(1000);
  }
  else if (centena == 1)  {
    tmrpcm.play("100e.WAV");
    delay(1000);
  }
  if ((centena == 2) && (dezena == 0) && (unidade == 0)) {
    tmrpcm.play("200.WAV");
    delay(1000);
  }
  else if (centena == 2)  {
    tmrpcm.play("200e.WAV");
    delay(1000);
  }
  if ((centena == 3) && (dezena == 0) && (unidade == 0)) {
    tmrpcm.play("300.WAV");
    delay(1000);
  }
  else if (centena == 3)  { //dizer trezentos e
    tmrpcm.play("300e.WAV");
    delay(1000);
  }
  if ((centena == 4) && (dezena == 0) && (unidade == 0)) {
    tmrpcm.play("400.WAV");
    delay(1000);
  }
  else if (centena == 4)  {
    tmrpcm.play("400e.WAV");
    delay(1000);
  }
  if ((centena == 5) && (dezena == 0) && (unidade == 0)) {
    tmrpcm.play("500.WAV");
    delay(1000);
  }
  else if (centena == 5)  {
    tmrpcm.play("500e.WAV");
    delay(1000);
  }
  if ((centena == 6) && (dezena == 0) && (unidade == 0)) {
    tmrpcm.play("600.WAV");
    delay(1000);
  }
  else if (centena == 6)  {
    tmrpcm.play("600e.WAV");
    delay(1000);
  }
  if ((centena == 7) && (dezena == 0) && (unidade == 0)) {
    tmrpcm.play("700.WAV");
    delay(1000);
  }
  else if (centena == 7)  {
    tmrpcm.play("700e.WAV");
    delay(1000);
  }
  if ((centena == 8) && (dezena == 0) && (unidade == 0)) {
    tmrpcm.play("800.WAV");
    delay(1000);
  }
  else if (centena == 8)  {
    tmrpcm.play("800e.WAV");
    delay(1000);
  }
  if ((centena == 9) && (dezena == 0) && (unidade == 0)) {
    tmrpcm.play("900.WAV");
    delay(1000);
  }
  else if (centena == 9)  {
    tmrpcm.play("900e.WAV");
    delay(1000);
  }
}
void falando() {
  dezmilhar = ((10 * dm) + um);

  if (dezmilhar != 0)  {
    dezena = dezmilhar;
    unidade = um;
    if (dezena < 10) {
      undde();
    }
    else {
      dzn ();
      if (dezena > 20) {
      }
    }

    if (c != 0)  {
      tmrpcm.play("1000.WAV");
      delay(1000);
    }
    if (c == 0) {
      tmrpcm.play("1000e.WAV");
      delay(1000);
    }
  }

  unidade = u;
  if (c == 0) {
  }
  else {
    centena = c;
    cntn();
  }
  if (d != 0) {
    dezena = (10 * d + u);
    dzn();
  }
  if ((d == 0) ) {
    unidade = u;
    undde();
  }
  tmrpcm.play("khz.WAV");
  delay(3000);
}

void debulhando() {
  dm = (ax / 10000);
  // Serial.println(dm); //1
  // Serial.println();
  um = ((ax - (dm * 10000)) / 1000);
  //  Serial.println(um); //4
  //  Serial.println();
  c = ((ax - ((dm * 10000) + (um * 1000))) / 100);
  //Serial.println(c);//3
  //  Serial.println();
  d = (((ax - (((dm * 10000) + (um * 1000)) + (c * 100))) / 10));
  //  Serial.println(d);//0
  //  Serial.println();
  u = (ax - (((dm * 10000) + (um * 1000)) + (c * 100) + (d * 10)));
  // Serial.println(u);
  // Serial.println();
}


73 e boa montagem de py2ohh miguel