Визуализатор спектра

Дополнил константы в namespace ADC_module .

Добавил функцию ожидания сэмпла с подсчётом числа циклов ожидания. Если циклов 0, то нельзя гарантировать, что сэмпл не был пропущен.
Добавил контроль пропуска сэмпов. Он скорее для отладки. Иногда в процесс сэмплирования вклинивается прерывание и циклы ожидания сокращаются. При делителе частоты 1/32 запас достаточно большой. При 1/16 иногда пропускает сэмплы.

Вывод гистограммы в логарифмической шкале.

 

скинь скетч, а для матрицы 8*8 не делал? и я так понял он для нано не подойдет?

 

nano, это ATmega328 . В этом МК меньше битов в управляющих регистрах реализовано. Вход A0 это ADC0. Нет режима

• Bit 7 – ADHSM: ADC High Speed Mode
Writing this bit to one enables the ADC High Speed mode. This mode enables higher conversion rate at the
expense of higher power consumption.

Просто комментируй строчки, которые ошибку вызывают.

И тут

AD::analog_channel( AD::A0);// пин A0 на Leonardo/micro

замени на

AD::analog_channel( AD::ADC0);// пин A0 на UNO/nano

До матрицы еще не добрался.

 

Привет, не разбирался с матрицей?) или с ргб лентой?)

 

Вчера матрица пришла. Поиграл с ней. На днях прикручу её к анализатору спектра.

 

ок понял, а я пока нашел где взять леонардо, буду ждать вестей))))

 

Афигеть, четко)))) круто получилось)))) Я так понимаю ты доделал программу?)

 

Код (C++):

// Dump_A0
// Arduino/Genuino Leonardo, micro FREE RUN MODE Analog Digital Conversion (ADC) 38461.5 sps
// Fix fast Fourier transform 128 samples 18930 Hz Nyquist frequency. 300.45 Hz step.
// LED_BUILTIN - индикатор перегрузки
// A0 - Analog in с делителя напряжения 5 В, сигнал через конденсатор  10мкФ
// 8,9,10 -> clk,cs(load),data in - LED матрица 8х8 с драйвером MAX7219

#define prog_int8_t int8_t

#include "fix_fft.h"
// #include "Timer.ino.cpp"

#define BITS (7)

// Для релиза строчку закоментировать
// #define DBG

#ifdef DBG
  #define SER(oper) oper
#else
  #define SER(oper)
#endif

#define ASIZE (1<<BITS)

#define dataPin 10
#define csPin 9
#define clockPin 8

const size_t buket_sz[9] = { 1, 1, 2, 2, 4, 6, 10, 14, 20 }; // компоновка частот по столбикам. 0Hz игнорируем 300, 600 - 900, 1200 - 1500,
const char   height[8]   = { 3, 4, 6, 8, 11, 15, 21, 30 };  // порог амплитуды для высоты столбика. логарифмическая шкала 41/1.39

 

 

Код (C++):

// File_1

namespace ADC_module
{
  // Free Running Conversion
// ADHSM bit in ADCSRB allows an increased ADC clock frequency
// prescaling is set by the ADPS bits in ADCSRA
//  prescaler keeps running for as long as the ADEN bit is set
//  left adjusted by setting the ADLAR bit in ADMUX
// no more than 8-bit precision is required, it is sufficient to read ADCH
// ADCL must be read first, then ADCH

// e ADC Start Conversion bit, ADSC
// Auto Triggering is enabled by setting the ADC Auto Trigger Enable bit, ADATE in ADCSRA.
// trigger source is selected by setting the ADC Trigger Select bits, ADTS in ADCSRB
// ADC Interrupt Flag as a trigger source makes the ADC start a new conversion as soon as the ongoing
// conversion has finished. The ADC then operates in Free Running mode
//  ADSC can also be used to determine if a conversion is in progress.

#define GB( mask, pos, bit )  ( _BV(bit) * ( ( 0b##mask >> pos ) & 1) )

enum PS : uint8_t
{
#define bits( m ) ( GB(m, 2, ADPS2) | GB(m, 1, ADPS1) | GB(m, 0, ADPS0) )
  PS2_  = bits(000),
  PS2   = bits(001),
  PS4   = bits(010),
  PS8   = bits(011),
  PS16  = bits(100),
  PS32  = bits(101),
  PS64  = bits(110),
  PS128 = bits(111),
  ADCSRA_PS1 = bits(111),
#undef bits
};


void clock_source ( PS cs_ )
{
  ADCSRA = ADCSRA & ~ADCSRA_PS1 | cs_;
}

void no_interrupt () //  ADC Interrupt Disable
{
  ADCSRA &= ~_BV(ADIE);
}

inline uint8_t conversion_complete () // ADC Interrupt Flag
{
    return ADCSRA & _BV(ADIF);
}

inline uint8_t wait_conversion () // ADC Interrupt Flag
{
  uint8_t res(0);
  while( !( ADCSRA & _BV(ADIF) ) ) { if( !(++res) ) { res = 255; } };
  ADCSRA |= _BV(ADIF);
  return res;
}

enum ACHNL : uint8_t {

#define bits( m ) ( GB(m, 5, MUX5) | GB(m, 4, MUX4) | GB(m, 3, MUX3) | GB(m, 2, MUX2) | GB(m, 1, MUX1) | GB(m, 0, MUX0) )
//                 543210
  ADC0      = bits(000000),
  ADC1      = bits(000001),
  ADC4      = bits(000100),
  ADC5      = bits(000101),
  ADC6      = bits(000110),
  ADC7      = bits(000111),
  ADC8      = bits(100000),
  ADC9      = bits(100001),
  ADC10     = bits(100010), //  ADC10
  ADC11     = bits(100011), //  ADC11
  ADC12     = bits(100100), //  ADC12
  ADC13     = bits(100101), //  ADC13
  TSENSR    = bits(100111), // Temperature Sensor
// //////////
  ACD41x1   = bits(010100), //   ADC4 ADC1 1x
  ACD51x1   = bits(010101), //   ADC5 ADC1 1x
  ACD61x1   = bits(010110), //   ADC6 ADC1 1x
  ACD71x1   = bits(010111), //   ADC7 ADC1 1x
  ACD40x10  = bits(101000), //  ADC4 ADC0 10x
  ACD50x10  = bits(101001), //  ADC5 ADC0 10x
  ACD60x10  = bits(101010), //  ADC6 ADC0 10x
  ACD70x10  = bits(101011), //  ADC7 ADC0 10x
  ACD41x10  = bits(101100), //  ADC4 ADC1 10x
  ACD51x10  = bits(101101), //  ADC5 ADC1 10x
  ACD61x10  = bits(101110), //  ADC6 ADC1 10x
  ACD71x10  = bits(101111), //  ADC7 ADC1 10x
  ACD40x40  = bits(110000), //  ADC4 ADC0 40x
  ACD50x40  = bits(110001), //  ADC5 ADC0 40x
  ACD60x40  = bits(110010), //  ADC6 ADC0 40x
  ACD70x40  = bits(110011), //  ADC7 ADC0 40x
  ACD41x40  = bits(110100), //  ADC4 ADC1 40x
  ACD51x40  = bits(110101), //  ADC5 ADC1 40x
  ACD61x40  = bits(110110), //  ADC6 ADC1 40x
  ACD71x40  = bits(110111), //  ADC7 ADC1 40x
  ACD40x200 = bits(111000), //  ADC4 ADC0 200x
  ACD50x200 = bits(111001), //  ADC5 ADC0 200x
  ACD60x200 = bits(111010), //  ADC6 ADC0 200x
  ACD70x200 = bits(111011), //  ADC7 ADC0 200x
  ACD41x200 = bits(111100), //  ADC4 ADC1 200x
  ACD51x200 = bits(111101), //  ADC5 ADC1 200x
  ACD61x200 = bits(111110), //  ADC6 ADC1 200x
  ACD71x200 = bits(111111), //  ADC7 ADC1 200x
// /////////
  ACD10x1   = bits(001000),
  ACD10x10  = bits(001001),
  ACD10x40  = bits(100110), // ADC1 ADC0 40x
  ACD10x200 = bits(001011),
  V1_1      = bits(011110), // 1.1V (VBand Gap)
  V0        = bits(011111), // 0V (GND)
  GND       = bits(011111),
  ADMUX_MUX1= bits(011111),
  ADCSRB_MUX1=bits(100000),
  A0      =  ADC7,
  A1      =  ADC6,
  A2      =  ADC5,
  A3      =  ADC4,
  A4      =  ADC1,
  A5      =  ADC0,
  A4_5x1  = ACD10x1,
  A4_5x10 = ACD10x10,
  A4_5x40 = ACD10x40,
  A4_5x200= ACD10x200,
};

void analog_channel ( ACHNL chnl_ ) // set input channel configuration
{
    ADMUX  = ADMUX  & ~ADMUX_MUX1  | chnl_ & ADMUX_MUX1;
    ADCSRB = ADCSRB & ~ADCSRB_MUX1 | chnl_ & ADCSRB_MUX1;
}

enum REFS : uint8_t
{
#define bits( m ) ( GB(m, 1, REFS1) | GB(m, 0, REFS0) )
  EXT_AREF     = bits(00), // 0 0 AREF, Internal VREF turned off
  AVCC         = bits(01), // 0 1 AVCC with external capacitor on AREF pin
  INTERNAL_256 = bits(11), // 1 1 Internal 2.56V Voltage Reference with external capacitor on AREF pin
  ADMUX_REFS1  = bits(11)
#undef bits
};

void reference ( REFS rf_ )
{
    ADMUX = ADMUX & ~ADMUX_REFS1 | rf_ ; // Vcc
}

void enable () // ADC Enable
{
    ADCSRA |= _BV(ADEN);
}

void start() // ADC Start Conversion
{
    ADCSRA |= _BV(ADSC);
}

bool in_progress () // A conversion is in progress
{
    return ADCSRA & _BV(ADSC);
}

void auto_trigger () // ADC Auto Trigger Enable
{
    ADCSRA |= _BV(ADATE);
}

enum ATSRC : uint8_t // ADC Auto Trigger Source
{
#define bits( m ) ( GB(m, 3, ADTS3) | GB(m, 2, ADTS2) | GB(m, 1, ADTS1) | GB(m, 0, ADTS0) )
  FREE_RUN     = bits(0000), //  Free Running mode
  COMPARATOR   = bits(0001), //  Analog Comparator
  EXT_IRQ0     = bits(0010), //  External Interrupt Request 0
  TIMER0_A     = bits(0011), //  Timer/Counter0 Compare Match A
  TIMER0_OVF   = bits(0100), //  Timer/Counter0 Overflow
  TIMER1_B     = bits(0101), //  Timer/Counter1 Compare Match B
  TIMER1_OVF   = bits(0110), //  Timer/Counter1 Overflow
  TIMER1_CAP   = bits(0111), //  Timer/Counter1 Capture Event
  TIMER4_OVF   = bits(1000), //  Timer/Counter4 Overflow
  TIMER4_A     = bits(1001), //  Timer/Counter4 Compare Match A
  TIMER4_B     = bits(1010), //  Timer/Counter4 Compare Match B
  TIMER4_D     = bits(1011), //  Timer/Counter4 Compare Match D
  ADCSRB_ADTS1 = bits(1111)
#undef bits
};

void auto_trigger_src ( ATSRC src_ ) // ADC Auto Trigger Source
{
    ADCSRB = ADCSRB & ~ADCSRB_ADTS1 | src_;
}

void high_speed () //  : ADC High Speed Mode
{
    ADCSRB |= _BV(ADHSM);
}

template <class T> void value_type();
template <class T> inline T value(); // ADC conversion is complete, the result is found in these two registers

template <> void value_type<uint8_t>() // ADC Left Adjust Result
{
    ADMUX |= _BV(ADLAR);
}

template<> inline uint8_t value<uint8_t> () //  ADC Left Adjust Result 8 bit
{
  return ADCH; // ignore 2 bis from ADCL
}

template <> void value_type<uint16_t>() // ADC Right Adjust Result
{
  ADMUX &= ~_BV(ADLAR);
}

template<> inline uint16_t value<uint16_t> () //  ADC Right Adjust Result 10 bit
{
  return ADC;
}


};
 

 

Код (C++):

// File_2

void mtxWrite(uint8_t reg, uint8_t data)
{
   digitalWrite(csPin, LOW);
   shiftOut(dataPin, clockPin, MSBFIRST, reg);
   shiftOut(dataPin, clockPin, MSBFIRST, data);
   digitalWrite(csPin, HIGH);
}
 

 

а схема подключения какая?

 

Код (C++):

// File_9

namespace AD = ADC_module;

typedef uint16_t val_t;

void setup() {
  // put your setup code here, to run once:
SER( Serial.begin(250000); )
SER( while(!Serial){  } )
SER( Serial.println(F("Starting... ")); )
    pinMode(LED_BUILTIN, OUTPUT); // Overload indicator
    pinMode(dataPin, OUTPUT);
    pinMode(clockPin, OUTPUT);
    pinMode(csPin, OUTPUT);
    mtxWrite(0xB, 0x7); // 8 лиеек
    mtxWrite(0xC, 0x1); // включили драйвер
// режим проверки матрицы
    mtxWrite(0xF, 0x1);
    delay(1000);
    mtxWrite(0xF, 0x0);
    AD::reference(AD::AVCC);
    AD::value_type<val_t>(); // тип значения - 8 / 10 бит
    AD::auto_trigger_src( AD::FREE_RUN ); // источник автоматического пускателя
    AD::auto_trigger();  // автоматический запуск ADC
    AD::analog_channel( AD::A0 ); // пин

    AD::high_speed();  //  дополнительное питание для повышения разрядности
    AD::clock_source( AD::PS32 ); // делитель частоты 16000000 МГц / 32. Нормальная частота сэмплирования  16000000 МГц / 32 / 13 = 38461 Гц. Столбик 300.48077 Гц.

    AD::no_interrupt(); // без прерываний от ADC.
    AD::enable();    // включаем ADC
    AD::start();     // запускаем замеры
}

void loop() {
    char re[ASIZE]; //
    char im[ASIZE]; // мнимая часть
    char disp[8];   // дисплей
    uint8_t overload(0);  // Пиковый уровень сигнала для детектора перегрузки;
    uint8_t overtime(255);  // Минимальное время ожидания готовности.
    char *pre = re;
    char *pim = im;
    AD::wait_conversion();  // тут фактически только сброс флага готовности, но очередной сэмпл может быть на подходе
    AD::wait_conversion();  // для рассчёта overtime дождёмся начала сэмпла
    for ( uint8_t j = ASIZE ; --j ; )
    {
      uint8_t wait(
          AD::wait_conversion()
        );
      char v = (AD::value<val_t>() - 511)>>1;
      *(pre++) = v;
      *(pim++) = 0;
      v = abs(v);
      overload = max( overload, v ); // детектор перегрузки
      overtime = min( overtime, wait );
    }
    if ( 120 < overload )
    { // что то делаем в случае перегрузки. если 127 <= overload FFT может выдавать искаженный результат.
      digitalWrite(LED_BUILTIN, HIGH);
SER(    Serial.print(" OLD"); )
    } else {
      digitalWrite(LED_BUILTIN, LOW);    
    }
SER( Serial.print('\t'); )
SER( Serial.print((int)overload); )
    if ( 0 == overtime )
    { // что то делаем в случае недостаточной скорости чтения сэмплов
SER(    Serial.print(" OTM"); )
    }
SER( Serial.print('\t'); )
SER( Serial.println((int)overtime); )
/*
    pim = im;
    for ( uint8_t j = ASIZE ; --j ; )
    {
      Serial.print('\t');
      Serial.print((int)*(pim++));
    }
    Serial.print('\n');
   
    memset ( im, 0, ASIZE);
*/
    fix_fft(re, im, BITS, 0);
    for ( size_t i = 0 ; i < ASIZE / 2 ; ++i )
    {
      re[i] = sqrt(re[i] * re[i] + im[i] * im[i]); // Расчет амплитуды комплексного ряда.
    }
SER(
    Serial.print("Hz:");
    for ( size_t i = 0 ; i < ASIZE / 2 ; ++i )
    {
      Serial.print('\t');
      Serial.print(16000000L / 32 / 13 * i / 128);
     }
     Serial.println("");
     for ( size_t i = 0 ; i < ASIZE / 2 ; ++i )
     {
       Serial.print('\t');
       Serial.print((int)re[i]);
     }
    Serial.println("");
)
    size_t *bp = buket_sz;
    size_t k = *(bp++);
    for( uint8_t i = 0; i < 8 ; ++i, ++bp )
    {
      unsigned long datum = 0;
      for ( uint8_t j = 0 ; j < *bp; ++j, ++k )
      {
//        datum += re[k];
          datum = max(datum, re[k]); // для тестовых сигналов лучше пиковое значение
      }
      disp[i] = datum; //  / buket_sz[i];
SER(   Serial.print('\t'); )
SER(   Serial.print((int)disp[i]); )
    }
SER( Serial.println(F("\n\t@@@@@@\t@@@@@@\t@@@@@@\t@@@@@@\t@@@@@@\t@@@@@@\t@@@@@@\t@@@@@@")); )
    for ( uint8_t j = 0 ; j < 8 ; ++j ) // заполняем матрицу
    {
      uint8_t line(0);
      for ( uint8_t i = 0 ; i < 8 ; ++i )
      {
        line <<= 1;
        if ( height[j] <= disp[i] )
        {
           line |= 1;
SER(        Serial.print(F("\t@@@@@@")); ) // включаем ячейку
        } else {
SER(        Serial.print(F("\t")); ) // выключаем ячейку
        }
      }
      mtxWrite(j+1, line);
SER(   Serial.println(F("\t-")); )
    }
SER( delay(500); ) // Задержка чтобы монитор порта не перегружать
}
 

Код (C++):

// File_9

namespace AD = ADC_module;

typedef uint16_t val_t;

void setup() {
  // put your setup code here, to run once:
SER( Serial.begin(250000); )
SER( while(!Serial){  } )
SER( Serial.println(F("Starting... ")); )
    pinMode(LED_BUILTIN, OUTPUT); // Overload indicator
    pinMode(dataPin, OUTPUT);
    pinMode(clockPin, OUTPUT);
    pinMode(csPin, OUTPUT);
    mtxWrite(0xB, 0x7); // 8 лиеек
    mtxWrite(0xC, 0x1); // включили драйвер
// режим проверки матрицы
    mtxWrite(0xF, 0x1);
    delay(1000);
    mtxWrite(0xF, 0x0);
    AD::reference(AD::AVCC);
    AD::value_type<val_t>(); // тип значения - 8 / 10 бит
    AD::auto_trigger_src( AD::FREE_RUN ); // источник автоматического пускателя
    AD::auto_trigger();  // автоматический запуск ADC
    AD::analog_channel( AD::A0 ); // пин

    AD::high_speed();  //  дополнительное питание для повышения разрядности
    AD::clock_source( AD::PS32 ); // делитель частоты 16000000 МГц / 32. Нормальная частота сэмплирования  16000000 МГц / 32 / 13 = 38461 Гц. Столбик 300.48077 Гц.

    AD::no_interrupt(); // без прерываний от ADC.
    AD::enable();    // включаем ADC
    AD::start();     // запускаем замеры
}

void loop() {
    char re[ASIZE]; //
    char im[ASIZE]; // мнимая часть
    char disp[8];   // дисплей
    uint8_t overload(0);  // Пиковый уровень сигнала для детектора перегрузки;
    uint8_t overtime(255);  // Минимальное время ожидания готовности.
    char *pre = re;
    char *pim = im;
    AD::wait_conversion();  // тут фактически только сброс флага готовности, но очередной сэмпл может быть на подходе
    AD::wait_conversion();  // для рассчёта overtime дождёмся начала сэмпла
    for ( uint8_t j = ASIZE ; --j ; )
    {
      uint8_t wait(
          AD::wait_conversion()
        );
      char v = (AD::value<val_t>() - 511)>>1;
      *(pre++) = v;
      *(pim++) = 0;
      v = abs(v);
      overload = max( overload, v ); // детектор перегрузки
      overtime = min( overtime, wait );
    }
    if ( 120 < overload )
    { // что то делаем в случае перегрузки. если 127 <= overload FFT может выдавать искаженный результат.
      digitalWrite(LED_BUILTIN, HIGH);
SER(    Serial.print(" OLD"); )
    } else {
      digitalWrite(LED_BUILTIN, LOW);    
    }
SER( Serial.print('\t'); )
SER( Serial.print((int)overload); )
    if ( 0 == overtime )
    { // что то делаем в случае недостаточной скорости чтения сэмплов
SER(    Serial.print(" OTM"); )
    }
SER( Serial.print('\t'); )
SER( Serial.println((int)overtime); )
/*
    pim = im;
    for ( uint8_t j = ASIZE ; --j ; )
    {
      Serial.print('\t');
      Serial.print((int)*(pim++));
    }
    Serial.print('\n');
   
    memset ( im, 0, ASIZE);
*/
    fix_fft(re, im, BITS, 0);
    for ( size_t i = 0 ; i < ASIZE / 2 ; ++i )
    {
      re[i] = sqrt(re[i] * re[i] + im[i] * im[i]); // Расчет амплитуды комплексного ряда.
    }
SER(
    Serial.print("Hz:");
    for ( size_t i = 0 ; i < ASIZE / 2 ; ++i )
    {
      Serial.print('\t');
      Serial.print(16000000L / 32 / 13 * i / 128);
     }
     Serial.println("");
     for ( size_t i = 0 ; i < ASIZE / 2 ; ++i )
     {
       Serial.print('\t');
       Serial.print((int)re[i]);
     }
    Serial.println("");
)
    size_t *bp = buket_sz;
    size_t k = *(bp++);
    for( uint8_t i = 0; i < 8 ; ++i, ++bp )
    {
      unsigned long datum = 0;
      for ( uint8_t j = 0 ; j < *bp; ++j, ++k )
      {
//        datum += re[k];
          datum = max(datum, re[k]); // для тестовых сигналов лучше пиковое значение
      }
      disp[i] = datum; //  / buket_sz[i];
SER(   Serial.print('\t'); )
SER(   Serial.print((int)disp[i]); )
    }
SER( Serial.println(F("\n\t@@@@@@\t@@@@@@\t@@@@@@\t@@@@@@\t@@@@@@\t@@@@@@\t@@@@@@\t@@@@@@")); )
    for ( uint8_t j = 0 ; j < 8 ; ++j ) // заполняем матрицу
    {
      uint8_t line(0);
      for ( uint8_t i = 0 ; i < 8 ; ++i )
      {
        line <<= 1;
        if ( height[j] <= disp[i] )
        {
           line |= 1;
SER(        Serial.print(F("\t@@@@@@")); ) // включаем ячейку
        } else {
SER(        Serial.print(F("\t")); ) // выключаем ячейку
        }
      }
      mtxWrite(j+1, line);
SER(   Serial.println(F("\t-")); )
    }
SER( delay(500); ) // Задержка чтобы монитор порта не перегружать
}
 

 

а что за 2 файла? я просто с леонардо не разбирался

 

Скетч на файлы порезал. На форум не влезает один большой и вообще удобнее.

 

а можешь на яндекс диск скинуть пожалуйста, а то я запутаюсь что куда вставлять

 

В Arduino IDE в окне скетча справа вверху есть кнопка со стрелочной. Там меню - добавить вкладку.

Имя файла File_1, File_2, File_9. Без расширений .

 

Первая вкладка называется как скетч. У меня это Dump_A0. В общем файл Dump_A0 в первую вкладку надо скопировать.

 

Vcc - 5 Вольт
GND - 0
Clk - 8
Cs - 9
Din - 10

 

Подключение A0 не изменилось.


signal in к источнику
ADC input - на пин A0
питание 5 В.
общий 0 В


Если сигнал слишком громкий, будет мигать диод на плате Arduino ( пин 13).