Logarithmic sound for an Arduino metal detector (Atmeg328P).

[Teleno]

In this post I described an analog circuit to produce a frequency that's proportional to the logarithm of the target signal.

I have now written a C version of the same principle that can be added to any Arduino based metal detector.

The sound signal is a square wave with the frequency given as follows:



In this case the minimum frequency is 100 Hz, the maximum 1000Hz and the maximum input voltage is 4096 (expressed in binary form as read from the ADC, eventually oversampled).
If 5V is used as the ADC reference then each bit of input voltage is approximately 1.2 mV, if the 1.1V internal reference is used instead then it's 0.27 mV



For the tests (as you can see in the code and hear in the video) I've included four synthetic target signals in the main() function:

1. A 10ms duration sawtooth with peak at 10 (repeated 3x in the video).
2. A 10ms duration sawtooth with peak at 200.
3. A 10ms duration sawtooth with peak at 1000.
4. A 10ms duration sawtooth with peak at 4000.
5. Sound in the absence of a target, with only the background noise as an input.

A background noise of 3.5 bits pp. has been added to all the targets (using the rand() function.
With a 5V ADC reference, the targets would be 12mV, 240mV, 1.2V and 4.8V respectivly with a 4.2 mVpp noise level.
The noise is audible for target 1 above but still the target beep is discernible.

Listen to the sounds:

The code:

/* ==================================================  ======================== *//*                                                                            */
/*   Filename.c                                                               */
/*   (c) 2012 Author                                                          */
/*                                                                            */
/*   Description                                                              */
/*                                                                            */
/* ==================================================  ======================== */


#include <stdbool.h>


#define F_CPU 16000000L


//gcc 7.4.0


#include <avr/io.h>
#include <stdio.h>
#include <stdint.h>


#include <errno.h>
#include <stddef.h>
#include <math.h>
#include <stdlib.h>


#include <util/delay.h>


#define PRECISION 8




int32_t log2fix (uint32_t x, size_t precision)
{
    int32_t b = 1U << (precision - 1);
    int32_t y = 0;




    if (x == 0) {
        return 0; // represents negative infinity
    }


    while (x < 1U << precision) {
        x <<= 1;
        y -= 1U << precision;
    }


    while (x >= 2U << precision) {
        x >>= 1;
        y += 1U << precision;
    }


    uint64_t z = x;


    for (size_t i = 0; i < precision; i++) {
        z = z * z >> precision;
        if (z >= 2U << (uint64_t)precision) {
            z >>= 1;
            y += b;
        }
        b >>= 1;
    }


    return y;
}






uint32_t CLOCK = 16000000;
uint16_t get_OCRX_and_prescaler(uint16_t freq);
uint16_t getFreq (uint32_t adc);


unsigned char data[] = "Hello from ATmega328p        \n";


void init(){
 
  // WGM22/WGM21/WGM20 all set -> Mode 7, fast PWM, TOP = OCR2A
  TCCR2A = (1<<COM2A0) | (1<<WGM21); // Toggle OC2A at compare match, clear on compare CTC
  DDRB |= (1 << PB3); // PB3 = OC2A = Arduino Pin 11
  
  /* Set Baudrate to 9600 bps */
  // write to lower byte
  UBRR0L = (uint8_t)(2 & 0xFF);


  // write to higher byte
  UBRR0H = (uint8_t)(2 >> 8);


  UCSR0C = 0x06;       /* Set frame format: 8data, 1stop bit  */
  UCSR0B = (1<<TXEN0); /* Enable  transmitter */
}


void transmit(unsigned char data[]){
  
    unsigned char i = 0;
    while(data[i] != 0) 
    {
      while (!( UCSR0A & (1<<UDRE0))); /* Wait for empty transmit buffer*/
      UDR0 = data[i];            /* Put data into buffer, sends the data */
      i++;                             /* increment counter           */
    }
}


void setFreq(uint8_t ocr2a, uint16_t prescaler){
 
  OCR2A = ocr2a;
 
  if (prescaler == 1) TCCR2B = (1<<CS20) | (1<<WGM22); // prescaler = 1; 


  else if (prescaler == 8) TCCR2B = (1<<CS21) | (1<<WGM22); // prescaler = 8; 


  else if (prescaler == 32) TCCR2B = (1<<CS21) | (1<<CS20) | (1<<WGM22); // prescaler = 32; 


  else if (prescaler == 64) TCCR2B = (1<<CS22) | (1<<WGM22); // prescaler = 64; 


  else if (prescaler == 128) TCCR2B = (1<<CS22) | (1<<CS20) | (1<<WGM22); // prescaler = 128; 


  else if (prescaler == 256) TCCR2B = (1<<CS22) | (1<<CS21) | (1<<WGM22); // prescaler = 256; 


  else if (prescaler == 1024) TCCR2B = (1<<CS22) | (1<<CS21) | (1<<CS20) | (1<<WGM22); // prescaler = 1024; 


 /*
  uint8_t pre = TCCR2B & 0x07;
  uint8_t oc = OCR2A & 0xFF;
  sprintf(data, "TCCR2B: %u OCR2A:%u\n", pre, oc);
  transmit(data);
  */
}


void stopTimer2(){
  
  TCCR2B = 0;
}


int main()
{
    init();


    uint32_t F;
    for (char j = 1; j < 4; j++){
      for (uint32_t adc = 1; adc < 10; adc++) {
          F = get_OCRX_and_prescaler(getFreq(adc + (uint32_t) (rand() & 0x7)));
          _delay_ms(5); 
      } 
      for (uint32_t adc = 10; adc > 0; adc--) {
          F = get_OCRX_and_prescaler(getFreq(adc + (uint32_t) (rand() & 0x7)));
          _delay_ms(5); 
      }
      stopTimer2();
      _delay_ms(500);
    }
    for (uint32_t adc = 1; adc < 200; adc+=5) {
        F = get_OCRX_and_prescaler(getFreq(adc + (uint32_t) (rand() & 0x7)));
        _delay_ms(2); 
    }
    for (uint32_t adc = 200; adc > 0; adc-=5) {
        F = get_OCRX_and_prescaler(getFreq(adc + (uint32_t) (rand() & 0x7)));
        _delay_ms(2); 
    }
    stopTimer2();
    _delay_ms(500);
    for (uint32_t adc = 1; adc < 1000; adc+= 25) {
        F = get_OCRX_and_prescaler(getFreq(adc + (uint32_t) (rand() & 0x7)));
        _delay_ms(2); 
    }
    for (uint32_t adc = 1000; adc > 0; adc-= 25) {
        F = get_OCRX_and_prescaler(getFreq(adc + (uint32_t) (rand() & 0x7)));
        _delay_ms(2); 
    }
    stopTimer2();
    _delay_ms(500);
    for (uint32_t adc = 1; adc < 4000; adc+= 50) {
        F = get_OCRX_and_prescaler(getFreq(adc + (uint32_t) (rand() & 0x7)));
        _delay_ms(1); 
    }
    for (uint32_t adc = 4000; adc > 0; adc-= 50) {
        F = get_OCRX_and_prescaler(getFreq(adc + (uint32_t) (rand() & 0x7)));
        _delay_ms(1); 
    }
    stopTimer2();
    while(1){
      uint32_t noise = (uint32_t) (rand() & 0x3);
      F = get_OCRX_and_prescaler(getFreq(noise));
      _delay_ms(1);
    }
}


uint16_t get_OCRX_and_prescaler(uint16_t freq) {


    uint32_t prescaler[7] = {1, 8, 32, 64, 128, 256, 1024};
    uint32_t OCRX;
    for (int i = 0; i < 7; i++){
        OCRX = (CLOCK >> 1) / ( ((uint32_t) (freq << 1) ) * prescaler[i]) -1;
        if(OCRX < 255) {
            setFreq( (uint8_t) OCRX, (uint16_t) prescaler[i]);
            /*
            sprintf(data, "freq: %u presc:%lu ocr2a:%u\n", freq, prescaler[i], OCRX);
            transmit(data);
            */
            
            break;  // the value with the smallest prescaler is the most accurate
        }
    }
    return freq;
}


uint16_t getFreq(uint32_t adc) {
    
    uint32_t freq =  (((uint32_t) 31) << PRECISION) + 75 * log2fix(adc << PRECISION, PRECISION);
    return (uint16_t) (freq >> PRECISION);
    
}

The code contains a nice, accurate and fast fixed point logarithm routine log2fix and some UART code (commented out) for debugging in the serial console.

The tone generator uses Timer2 in CTC mode (Clear timer on compare). Function getFreq(adc) calculates the frequency for a given input value. Function get_OCRX_and_prescaler() calculates the values of the prescaler and the OCR2A register that most closely match the desired frequency.

In the Arduino IDE:
create a new sketch.
Erase all the text in the *.ino file.
Add a new tab to the sketch, name it "somename.c" and put the above code in there.
Compile and upload.

The sound is availale on pin 11 (Arduino Duemillanove) which is the OC2A output.

[MartinB]

Hi
How would I add this function to the Arduino Nano PI?

[Qiaozhi]

Hi
How would I add this function to the Arduino Nano PI?

In the ANPI, the Nano is used to generate all the timing signals required plus the audio chopper signal.
However, the target detection is done using an analog method, and the Nano does not read the output of the channel filters. Since the Nano has no way of knowing when detection has taken place, it cannot alter the tone of the audio output accordingly.

Personally I think there is nothing to be gained anyway from using a VCO output as opposed to the current system.
Please read the first paragraph on page 7 of the book.

[MartinB]

In the ANPI, the Nano is used to generate all the timing signals required plus the audio chopper signal.
However, the target detection is done using an analog method, and the Nano does not read the output of the channel filters. Since the Nano has no way of knowing when detection has taken place, it cannot alter the tone of the audio output accordingly.

Personally I think there is nothing to be gained anyway from using a VCO output as opposed to the current system.
Please read the first paragraph on page 7 of the book.

Thanks Qiaozhi
I am still learning, so your input is greatly appreciated.

[bernte_one]

@Teleno
where is the input pin defined at the beginning at the source code?