Arduino.ru

Спасибо, разобрался. Подключил АКБ к А0 через делитель (2 резистора по 10кОм) и все заработало.

float Vcc = 4.64; // Напряжение на 5V pin ( замер мультиметром )
float Bat_Volt = 0.0;  // Напряжение батареи
float Battery =0;

void readVcc() 
{
for(int i=0;i< 100;i++)
  {
   Battery=Battery+analogRead(Bat_Pin); //чтение значения на А0
   delay (2);
  }
  Battery=Battery/100; 
  Bat_Volt = 2* Battery *Vcc/ 1.024; 
  Voltage = int(Bat_Volt);
  Voltage = map(Voltage, 3200, 8400, 0, 100);
  Voltage = constrain(Voltage, 0, 100);

Запустил версию 1.7. Сделал- экран не отключается. Почему то не запускается авто поиск. Что можно посмотреть?

З.Ы. Конечно можно станции прописать в скетче, но хотелось бы что бы все функции работали.

Видать ветка заглохла! Сменил на версию 1.6- автопоиск не работает. Как и в версии 1.7 настройки путаются. На дисплее горит "канал"- регулируется громкость и т.д. 

Где-то есть ошибка у тебя, все работает, я уже под себя многое изменил, но сток работает как 1.7, так и 1.6. Единственное у меня EEprom не сохраняет станцию. В скетче ставлю на 2 станцию и частоту 102.2, а при запуске пишет 9 станцию и соответствующую частоту.

Была бы ошибка- не заливался бы скетч! Если не жалко выложите, пожалуйста, Ваш отредактированный скетч.

У меня там много изменений для личного проекта робота Wall-e. Я заменил отключение экрана на смену нового экрана с отображением уровня заряда батареи. Исходник 1.7 проверил и работает исправно

решил повторить. но прикрутить вместо кнопок Энкодер. 

как с кнопками так и с энкодером выявился баг.

после автопоиска при переходе на переключения каналов - получаем как бы ненастроенный канал.

-частота вроде верная а звук пробивается через шипенье.

при подключении через монитор порта и включения режима отладки было выяснено что после автопоиска сбрасывается флаг tuned при этом частота настройки верная сигнал моно и уровень низкий.

так же после автопоиска глючит ручной поиск. при движении вверх может показывать частоту выше на 0.2 чем настроена станция если начать двигать вниз то всё встаёт нормально.

как с этим бороться --не занимался. похоже -это косяк библиотеки.

в общем если не пользоваться автопоиском. то всё работает нормально.

А так - код с Энкодером вместо кнопок ниже. Да и  дисплей я использовал 1.3" с другим контроллером SH1106 нужный можно выбрать.

//FM Radio OLED Copyright by GhostLion v1.7 GOLD

#include <EEPROM.h>
#include <radio.h>    \\ пробовал исходную библиотеку и вот эту https://github.com/mathertel/Radio
#include <RDA5807M.h> \\


#include "U8glib.h"
#include "rus6x10.h"
#include "MyDigitsHelveticaBold24.h"
//Назначаем кнопки
// **********************************************************
// **********************************************************
//#define Pin_DOWN 4   // левая кнопка 
//#define Pin_UP 2     // правая кнопка 
//#define Pin_SET 3    // центральная кнопка
// **********************************************************
// **********************************************************
// раскомментировать нужное ненужное закомментировать
// **********************************************************
// **********************************************************
// Или Энкодер - подробнее тут: https://alexgyver.ru/encoder/
#include "GyverEncoder.h" // Для работы с энкодером
#define CLK 2  // Назначаем
#define DT 3   // конткты
#define SW 4   // Энкодера
Encoder enc1(CLK, DT, SW);  // инициируем энкодер
// установим - кнопки не нажаты
boolean SET=HIGH;
boolean UP=HIGH;
boolean DOWN=HIGH;
// закончим  настройку энкодера
// **********************************************************
// **********************************************************

#define FIX_BAND 1

const uint8_t Radio [] U8G_PROGMEM = {0x3F, 0xFF, 0xFF, 0xFF, 0xFC, 0x40, 0x00, 0x00, 0x00, 0x02, 0x80, 0x00, 0x00, 0xC0, 0x01, 0x80,0x00, 0x00, 0xC0, 0x01, 0x8E, 0x88, 0x00, 0xC0, 0x01, 0x88, 0xD8, 0x00, 
0xC0, 0x01, 0x88, 0xA8,0x00, 0xC0, 0x01, 0x8C, 0xA8, 0x00, 0xC0, 0x01, 0x88, 0xA8, 0x00, 0xC0, 0x01, 0x80, 0x00, 0x00,0xC0, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x81, 0x04, 0x10, 0x41, 0x05, 0x81, 0x04, 0x10, 
0x41,0x05, 0x95, 0x55, 0x55, 0x55, 0x55, 0x95, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x80,0x00, 0x00, 
0xF8, 0x01, 0x80, 0x00, 0x03, 0xFE, 0x01, 0x80, 0x00, 0x07, 0x03, 0x01, 0x80, 0x00,0x0C, 0x01, 0x81, 0x80, 0x60, 0x18, 0x00, 0xC1, 0x81, 0xF8, 0x18, 0x00, 0x41, 0x83, 0x9C, 0x10,0x00, 0x61, 0x83, 0x0C, 0x30, 
0x00, 0x61, 0x83, 0x0C, 0x30, 0x00, 0x61, 0x83, 0x0C, 0x30, 0x00,0x61, 0x83, 0x9C, 0x10, 0x00, 0x61, 0x81, 0xF8, 0x18, 0x00, 0x41, 0x80, 0x60, 0x18, 0x00, 0xC1,0x80, 0x00, 0x0C, 0x01, 0x81, 0x80, 0x00, 0x07, 
0x03, 0x01, 0x80, 0x00, 0x03, 0xFE, 0x01, 0x80,0x00, 0x00, 0xF8, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00,0x00, 0x00, 0x02, 0x3F, 0xFF, 0xFF, 0xFF, 0xFC};

const uint8_t Bass[] U8G_PROGMEM = {0x7F, 0xFE, 0x80, 0x01, 0x9B, 0x8D, 0xA2, 0x51, 0xA3, 0x91, 0x9A, 0x4D, 0x8A, 0x45, 0xB3, 0x99,0x80, 0x01, 0x7F, 0xFE};
const uint8_t Stereo[] U8G_PROGMEM = {0x7F, 0xFE, 0x80, 0x01, 0x9B, 0xB9, 0xA1, 0x25, 0xA1, 0x39, 0x99, 0x31, 0x89, 0x29, 0xB1, 0x25,0x80, 0x01, 0x7F, 0xFE};
const uint8_t SM[] U8G_PROGMEM = {0x7F, 0xFE, 0x80, 0x01, 0x8C, 0x51, 0x90, 0xA9, 0x90, 0xA9, 0x8C, 0xA9, 0x84, 0xA9, 0x98, 0x89,0x80, 0x01, 0x7F, 0xFE};

const uint8_t Bat1[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat2[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat3[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat4[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat5[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat6[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat7[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0xA9, 0xAA, 0xAD, 0xAA, 0xAD, 0xAA, 0xAD, 0xAA, 0xAD, 0xAA, 0xA9,0x80, 0x02, 0x7F, 0xFC};

const uint8_t Vol1[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,0x60, 0x00, 0x60, 0x00};
const uint8_t Vol2[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x0C, 0x00,0x6C, 0x00, 0x6C, 0x00};
const uint8_t Vol3[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x01, 0x80, 0x0D, 0x80, 0x0D, 0x80,0x6D, 0x80, 0x6D, 0x80};
const uint8_t Vol4[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x01, 0xB0, 0x01, 0xB0, 0x0D, 0xB0, 0x0D, 0xB0,0x6D, 0xB0, 0x6D, 0xB0};
const uint8_t Vol5[] U8G_PROGMEM = {0x00, 0x06, 0x00, 0x06, 0x00, 0x36, 0x00, 0x36, 0x01, 0xB6, 0x01, 0xB6, 0x0D, 0xB6, 0x0D, 0xB6,0x6D, 0xB6, 0x6D, 0xB6};

const uint8_t L1 [] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18};
const uint8_t L2 [] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x18};
const uint8_t L3 [] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x18, 0x00, 0x18, 0x18};
const uint8_t L4 [] U8G_PROGMEM = {0x00, 0x00, 0x7E, 0x00, 0x3C, 0x00, 0x18, 0x00, 0x18, 0x18};
const uint8_t L5 [] U8G_PROGMEM = {0xFF, 0x00, 0x7E, 0x00, 0x3C, 0x00, 0x18, 0x00, 0x18, 0x18};
// зададим частоты станций Новосибирск
const unsigned int Station[] = {9380,10320,10390,10520,9420,9910,10260,9540,9280,9700,9870,10200,10140,10670,10770,10620,9620,9500,9660,10070,10000,9580,9740,9950,9830,9780,10460,10570,9460};
byte NK = 29; // количество каналов = количеству станций
byte v,k,m,rs, flag1=1,flag2=0,flag3=0;
int Voltage;
unsigned int s,s2;
boolean b,ms,sm,flag=1,MODE=1;
long TimeOut;
//Выберем свой дисплей
// **********************************************************
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);// Олед 0,96"
//U8GLIB_SSD1309_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);   // Олед 1,3"
// **********************************************************
RDA5807M radio;
// ******************************** 
RADIO_INFO ri; // в этой библиотеке нужно для получения уровня сигнала станции с исходной библиотекой ненужна
// ********************************
void setup()
{
  
// **********************************************************
// **********************************************************
 enc1.setType(TYPE2);  // Тип Энкодера 
// **********************************************************
// **********************************************************
Inicial();
}

void loop()
{
  // при использовании кнопок закомментитьэтот блок
// **********************************************************
// ********************************************************** 
// это для работы с энкодером
  enc1.tick();// обязательная функция отработки энкодера. Должна постоянно опрашиваться
   if (enc1.isTurn()== false ) {     // если не был совершён поворот (индикатор поворота в любую сторону)
// типа отжимаем кнопки
    UP = HIGH;
    DOWN = HIGH;
    SET = HIGH;
// **********************************************************
// **********************************************************    
  }
  
Parsing();
Menu();
Energy();  
}
//==============================================
void Inicial()
{
 u8g.firstPage();  
do {
  u8g.drawBitmapP (5, 16, 5, 40, Radio);
  u8g.setFont(rus6x10);
  u8g.setPrintPos(40,11);u8g.print(F("FM РАДИО"));
  u8g.setPrintPos(55,45);u8g.print(F("v 1.7 GOLD"));
  u8g.setPrintPos(55,55);u8g.print(F("By GhostLion"));  
   }
while( u8g.nextPage() );

delay(1500);
if (EEPROM[0]!=1)
    {
     EEPROM[0]=1;
     EEPROM[1]=5;
     EEPROM[2]=1; // здесь установить номер текущего канала (моя частота 98.30 "Mayak") (или 0)
     EEPROM[3]=1;
     EEPROM[4]=1;
     EEPROM[5]=0;
     EEPROM[6]=98;  // частота текущей радиостанции
     EEPROM[7]=30;  // "Маяк"
     EEPROM[8]=1;
    }
v  = EEPROM[1];               // громкость
k  = EEPROM[2];               // текущий канал
m  = EEPROM[3];               // текущее меню
b  = EEPROM[4];               // супербасс
ms = EEPROM[5];               // моно/стерео
s  = EEPROM[6]*100+EEPROM[7]; // текущая частота
sm = EEPROM[8];               // softmute
s2=s;
radio.init();
radio.setMute(true);
radio.setVolume(v);
radio.setMono(ms);
radio.setMute(false);
radio.setBassBoost(b);
radio.setSoftMute(sm);  
radio.setBandFrequency(FIX_BAND, s);

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Serial.print("Radio:"); 
  radio.debugRadioInfo();
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  
readVcc();
}
//================================================
void Parsing()
{
  // использование кнопок
// **********************************************************
// **********************************************************  
//boolean SET=digitalRead(Pin_SET);
//boolean UP=digitalRead(Pin_UP);
//boolean DOWN=digitalRead(Pin_DOWN);
// **********************************************************
// **********************************************************
//
//
      // Имитируем нажате кнопок энкодером
// **********************************************************
// **********************************************************
  if (enc1.isRight())    UP = LOW;        // если был поворот
  if (enc1.isLeft())   DOWN = LOW;
  if (enc1.isClick())   SET = LOW;
// **********************************************************
// **********************************************************

if(SET==HIGH && flag1==0)
  {
    flag1=1;
  }
if(SET==LOW && flag1==1)
  {
    flag1=0;
    TimeOut=millis();
    if(MODE==1) {m++; flag=1; if(m>7) m=1;}
  }
  
 if(UP==LOW && flag2==1)
  {
    flag2=0;
  }
   if(UP==HIGH && flag2==0)
   {
    if(MODE==1)
    {
    switch(m)
      {
        case 1:{ (v==15?0:v++); radio.setVolume(v); break; }
        case 2:{ b = 1; radio.setBassBoost(b); radio.setBandFrequency(FIX_BAND,s); break; }
        case 3:{ ms = 0; radio.setMono(ms); radio.setBandFrequency(FIX_BAND,s); break; }
        case 4:{sm = 1; radio.setSoftMute(true);radio.setBandFrequency(FIX_BAND,s); break;}
        case 5:{ radio.seekUp(true); delay(2000); s = radio.getFrequency(); Kanal(); break; }
        case 6:{ s=s+10; if (s > 10800) s = 8700; delay(100); radio.setBandFrequency(FIX_BAND,s);Kanal(); break; }
        case 7:{ k++;if (k>NK) k=1;s = Station[k-1];radio.setBandFrequency(FIX_BAND,s);  break;}
      }
   flag=1;
   TimeOut=millis();
    }
   else {(v==15?0:v++);radio.setVolume(v);}
   flag2=1;
   }
   if(DOWN==LOW && flag3==1)
  {
    flag3=0;
  }
   if(DOWN==HIGH && flag3==0)
   {
    if(MODE==1)
    {
    switch(m)
      {
        case 1:{ (v==0?15:v--); radio.setVolume(v); break; }
        case 2:{ b = 0; radio.setBassBoost(b); radio.setBandFrequency(FIX_BAND,s); break; }
        case 3:{ ms = 1; radio.setMono(ms); radio.setBandFrequency(FIX_BAND,s); break; }
        case 4:{sm = 0; radio.setSoftMute(false);radio.setBandFrequency(FIX_BAND,s); break;}
        case 5:{ radio.seekDown(true); delay(2000); s=radio.getFrequency(); Kanal(); break; }
        case 6:{ s=s-10; if (s<8700) s=10800; delay(100); radio.setBandFrequency(FIX_BAND,s); Kanal(); break; }
        case 7:{ k--;if (k<1) k=NK;s = Station[k-1];radio.setBandFrequency(FIX_BAND,s);     break;}
      }
   flag=1;
   TimeOut=millis();
   }
   else {(v==0?15:v--);radio.setVolume(v);}
   flag3=1;
  }
}
//================================================
void Menu()
{
float ch;
if(flag==1 && MODE==1)
{
//************************************
//rs = radio.getRSSI(); // получаем уровень сигнала для родной библиотеки
//************************************
//
//************************************    
radio.getRadioInfo(&ri); // уровень сигнала для другой библиотеки
rs=ri.rssi;              // которую использовал я https://github.com/mathertel/Radio
//************************************  
ch=float(s)/100; 
u8g.firstPage();  
do {
u8g.setDefaultForegroundColor();
if(Voltage>85) u8g.drawBitmapP (110, 0, 2, 10, Bat7);
  else if(Voltage>70) u8g.drawBitmapP (110, 0, 2, 10, Bat6);
  else if(Voltage>55) u8g.drawBitmapP (110, 0, 2, 10, Bat5);
  else if(Voltage>40) u8g.drawBitmapP (110, 0, 2, 10, Bat4);
  else if(Voltage>25) u8g.drawBitmapP (110, 0, 2, 10, Bat3);
  else if(Voltage>10) u8g.drawBitmapP (110, 0, 2, 10, Bat2);
  else u8g.drawBitmapP (110, 0, 2, 10, Bat1);
if(v<3) u8g.drawBitmapP (13, 0, 2, 10, Vol1);
  else if(v<7) u8g.drawBitmapP (13, 0, 2, 10, Vol2);
  else if(v<10) u8g.drawBitmapP (13, 0, 2, 10, Vol3);
  else if(v<13) u8g.drawBitmapP (13, 0, 2, 10, Vol4);
  else u8g.drawBitmapP (13, 0, 2, 10, Vol5);
if(ms==0) u8g.drawBitmapP (55, 0, 2, 10, Stereo);
if(b==1) u8g.drawBitmapP (75, 0, 2, 10, Bass);
if(sm==1) u8g.drawBitmapP (35, 0, 2, 10, SM);

u8g.setFont(MyDigitsHelveticaBold24);
if(ch<100) u8g.setPrintPos(30,43); else u8g.setPrintPos(23,43);
u8g.print(ch,1);
u8g.setFont(rus6x10);
u8g.print(" MHz");
if (rs>50) u8g.drawBitmapP (0, 0, 1, 10, L5);
  else if(rs>40)  u8g.drawBitmapP (0, 0, 1, 10, L4);
  else if(rs>30)  u8g.drawBitmapP (0, 0, 1, 10, L3);
  else if(rs>20)  u8g.drawBitmapP (0, 0, 1, 10, L2);
  else u8g.drawBitmapP (0, 0, 1, 10, L1);
if(k!=0){
    u8g.drawRFrame (0,32,18,13,2);
    u8g.setPrintPos(3,42);
    if(k<10) u8g.print("0");
    u8g.print(k);
        }
u8g.drawRFrame (0,51,127,12,3);
u8g.setPrintPos(13,61);
 switch(m)
 {
  case 1: {u8g.print(F("- < ГРОМКОСТЬ > +"));break;}
  case 2: {u8g.print(F(" НЕТ < БАСС > ДА"));break;}
  case 3: {u8g.print(F("НЕТ < СТЕРЕО > ДА"));break;}
  case 4: {u8g.print(F("НЕТ < S.MUTE > ДА"));break;}
  case 5: {u8g.print(F(" <  АВТОПОИСК  >"));break;}
  case 6: {u8g.print(F("<  РУЧ. ПОИСК  >"));break;}
  case 7: {u8g.print(F("  <  КАНАЛЫ  >"));break;}
 
 }


}
while( u8g.nextPage() );     
  flag=0;    
}
}
//================================================
void Energy()
{
 //if(MODE==1 && millis()-TimeOut>2000) flag=1;
 if(MODE==1 && millis()-TimeOut>8000)
  {
    u8g.sleepOn(); 
    MODE=0;
    if(v!= EEPROM[1]) EEPROM[1] = v;
    if(k!= EEPROM[2]) EEPROM[2] = k;
    if(m!= EEPROM[3]) EEPROM[3] = m;
    if(b!= EEPROM[4]) EEPROM[4] = b;
    if(ms!=EEPROM[5]) EEPROM[5] = ms;
    if(s2!=s){s2=s;   EEPROM[6] = int(s/100); 
                      EEPROM[7] = s%100;
             }
    if(sm!=EEPROM[8]) EEPROM[8] = sm;         
  }
  if(MODE==0 && millis()-TimeOut<500)
  {
    u8g.sleepOff(); 
    readVcc();
    MODE = 1; 
    flag = 1; 
    m = 7;
  }
}
//===================================================
void readVcc() 
{
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#else
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#endif
  delay(2); // Wait for Vref to settle
  ADCSRA |= _BV(ADSC); // Start conversion
  while (bit_is_set(ADCSRA, ADSC)); // measuring
  uint8_t low  = ADCL; // must read ADCL first - it then locks ADCH
  uint8_t high = ADCH; // unlocks both
  long result = (high << 8) | low;

  result = 1.080 * 1023 * 1000 / result; // расчёт реального VCC
  Voltage = int(result);
  Voltage = map(Voltage, 3200, 4200, 0, 100);
  Voltage = constrain(Voltage, 0, 100);
}
//=======================================================
void Kanal()
{
  k = 0;
  for(int x = 0; x < NK; x ++)
    {
      if(s == Station[x]) {k = (x+1); break;}
    }   
}

модифицировал версию 1.7 от GhostLion

и так выкладываю модифицированную версию 1.7.2 

//FM Radio OLED Copyright by GhostLion v1.7.2 GOLD
// Modified by Rylov
#include <EEPROM.h>
#include <radio.h>    \\  библиотекa  https://github.com/mathertel/Radio
#include <RDA5807M.h> \\


#include "U8glib.h"
#include "rus6x10.h"
#include "MyDigitsHelveticaBold24.h"
#define RDA5807M_FLG_TUNE word(0x0010) // флаг настройка - после автопоиска нужно установить
//Назначаем кнопки
// **********************************************************
// **********************************************************
//#define Pin_DOWN 4   // левая кнопка 
//#define Pin_UP 2     // правая кнопка 
//#define Pin_SET 3    // центральная кнопка
// **********************************************************
// **********************************************************
// раскомментировать нужное ненужное закомментировать
// **********************************************************
// **********************************************************
// Или Энкодер - подробнее тут: https://alexgyver.ru/encoder/
#include "GyverEncoder.h" // Для работы с энкодером
#define CLK 2  // Назначаем
#define DT 3   // конткты
#define SW 4   // Энкодера
Encoder enc1(CLK, DT, SW);  // инициируем энкодер
// установим - кнопки не нажаты
boolean SET=HIGH;
boolean UP=HIGH;
boolean DOWN=HIGH;
// закончим  настройку энкодера
// **********************************************************
// **********************************************************

#define FIX_BAND 1

const uint8_t Radio [] U8G_PROGMEM = {0x3F, 0xFF, 0xFF, 0xFF, 0xFC, 0x40, 0x00, 0x00, 0x00, 0x02, 0x80, 0x00, 0x00, 0xC0, 0x01, 0x80,0x00, 0x00, 0xC0, 0x01, 0x8E, 0x88, 0x00, 0xC0, 0x01, 0x88, 0xD8, 0x00, 
0xC0, 0x01, 0x88, 0xA8,0x00, 0xC0, 0x01, 0x8C, 0xA8, 0x00, 0xC0, 0x01, 0x88, 0xA8, 0x00, 0xC0, 0x01, 0x80, 0x00, 0x00,0xC0, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x81, 0x04, 0x10, 0x41, 0x05, 0x81, 0x04, 0x10, 
0x41,0x05, 0x95, 0x55, 0x55, 0x55, 0x55, 0x95, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x80,0x00, 0x00, 
0xF8, 0x01, 0x80, 0x00, 0x03, 0xFE, 0x01, 0x80, 0x00, 0x07, 0x03, 0x01, 0x80, 0x00,0x0C, 0x01, 0x81, 0x80, 0x60, 0x18, 0x00, 0xC1, 0x81, 0xF8, 0x18, 0x00, 0x41, 0x83, 0x9C, 0x10,0x00, 0x61, 0x83, 0x0C, 0x30, 
0x00, 0x61, 0x83, 0x0C, 0x30, 0x00, 0x61, 0x83, 0x0C, 0x30, 0x00,0x61, 0x83, 0x9C, 0x10, 0x00, 0x61, 0x81, 0xF8, 0x18, 0x00, 0x41, 0x80, 0x60, 0x18, 0x00, 0xC1,0x80, 0x00, 0x0C, 0x01, 0x81, 0x80, 0x00, 0x07, 
0x03, 0x01, 0x80, 0x00, 0x03, 0xFE, 0x01, 0x80,0x00, 0x00, 0xF8, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00,0x00, 0x00, 0x02, 0x3F, 0xFF, 0xFF, 0xFF, 0xFC};

const uint8_t Bass[] U8G_PROGMEM = {0x7F, 0xFE, 0x80, 0x01, 0x9B, 0x8D, 0xA2, 0x51, 0xA3, 0x91, 0x9A, 0x4D, 0x8A, 0x45, 0xB3, 0x99,0x80, 0x01, 0x7F, 0xFE};
const uint8_t Stereo[] U8G_PROGMEM = {0x7F, 0xFE, 0x80, 0x01, 0x9B, 0xB9, 0xA1, 0x25, 0xA1, 0x39, 0x99, 0x31, 0x89, 0x29, 0xB1, 0x25,0x80, 0x01, 0x7F, 0xFE};
const uint8_t SM[] U8G_PROGMEM = {0x7F, 0xFE, 0x80, 0x01, 0x8C, 0x51, 0x90, 0xA9, 0x90, 0xA9, 0x8C, 0xA9, 0x84, 0xA9, 0x98, 0x89,0x80, 0x01, 0x7F, 0xFE};

const uint8_t Bat1[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat2[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat3[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat4[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat5[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat6[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat7[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0xA9, 0xAA, 0xAD, 0xAA, 0xAD, 0xAA, 0xAD, 0xAA, 0xAD, 0xAA, 0xA9,0x80, 0x02, 0x7F, 0xFC};

const uint8_t Vol1[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,0x60, 0x00, 0x60, 0x00};
const uint8_t Vol2[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x0C, 0x00,0x6C, 0x00, 0x6C, 0x00};
const uint8_t Vol3[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x01, 0x80, 0x0D, 0x80, 0x0D, 0x80,0x6D, 0x80, 0x6D, 0x80};
const uint8_t Vol4[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x01, 0xB0, 0x01, 0xB0, 0x0D, 0xB0, 0x0D, 0xB0,0x6D, 0xB0, 0x6D, 0xB0};
const uint8_t Vol5[] U8G_PROGMEM = {0x00, 0x06, 0x00, 0x06, 0x00, 0x36, 0x00, 0x36, 0x01, 0xB6, 0x01, 0xB6, 0x0D, 0xB6, 0x0D, 0xB6,0x6D, 0xB6, 0x6D, 0xB6};

const uint8_t L1 [] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18};
const uint8_t L2 [] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x18};
const uint8_t L3 [] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x18, 0x00, 0x18, 0x18};
const uint8_t L4 [] U8G_PROGMEM = {0x00, 0x00, 0x7E, 0x00, 0x3C, 0x00, 0x18, 0x00, 0x18, 0x18};
const uint8_t L5 [] U8G_PROGMEM = {0xFF, 0x00, 0x7E, 0x00, 0x3C, 0x00, 0x18, 0x00, 0x18, 0x18};
// зададим частоты станций Новосибирск
const unsigned int Station[] = {9380,10320,10390,10520,9420,9910,10260,9540,9280,9700,9870,10200,10140,10670,10770,10620,9620,9500,9660,10070,10000,9580,9740,9950,9830,9780,10460,10570,9460};
byte NK = 29; // количество каналов = количеству станций
byte v,k,m,rs, flag1=1,flag2=0,flag3=0;
int Voltage;
unsigned int s,s2;
boolean b,ms,sm,flag=1,MODE=1;
long TimeOut;
unsigned long startSeek; // after 300 msec must be tuned. after 500 msec must have RDS.
//Выберем свой дисплей
// **********************************************************
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);// Олед 0,96"
//U8GLIB_SSD1309_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);   // Олед 1,3"
// **********************************************************
RDA5807M radio;
// ******************************** 
RADIO_INFO ri; //  нужно для получения уровня сигнала станции  и других настроек
// ********************************
void setup()
{
  
// **********************************************************
// **********************************************************
 enc1.setType(TYPE2);  // Тип Энкодера 
// **********************************************************
// **********************************************************
Inicial();
}

void loop()
{
  // при использовании кнопок закомментит ьэтот блок
// **********************************************************
// ********************************************************** 
// это для работы с энкодером
  enc1.tick();// обязательная функция отработки энкодера. Должна постоянно опрашиваться
   if (enc1.isTurn()== false ) {     // если не был совершён поворот (индикатор поворота в любую сторону)
// типа  кнопки не нажаты
    UP = HIGH;
    DOWN = HIGH;
    SET = HIGH;
// **********************************************************
// **********************************************************    
  }
  
Parsing();
Menu();
Energy();  
}
//==============================================
void Inicial()
{
 u8g.firstPage();  
do {
  u8g.drawBitmapP (5, 16, 5, 40, Radio);
  u8g.setFont(rus6x10);
  u8g.setPrintPos(40,11);u8g.print(F("FM РАДИО"));
  u8g.setPrintPos(55,25);u8g.print(F("v 1.7.2 GOLD"));
  u8g.setPrintPos(55,35);u8g.print(F("By GhostLion"));
  u8g.setPrintPos(55,45);u8g.print(F("modified by"));
  u8g.setPrintPos(55,55);u8g.print(F("   Rylov"));    
   }
while( u8g.nextPage() );

delay(1500);
if (EEPROM[0]!=1)
    {
     EEPROM[0]=1;
     EEPROM[1]=5;
     EEPROM[2]=1; // здесь установить номер текущего канала (моя частота 98.30 "Mayak") 
     EEPROM[3]=1;
     EEPROM[4]=1;
     EEPROM[5]=0;
     EEPROM[6]=98;  // частота текущей радиостанции
     EEPROM[7]=30;  // "Маяк"
     EEPROM[8]=1;
    }
v  = EEPROM[1];               // громкость
k  = EEPROM[2];               // текущий канал
m  = EEPROM[3];               // текущее меню
b  = EEPROM[4];               // супербасс
ms = EEPROM[5];               // моно/стерео
s  = EEPROM[6]*100+EEPROM[7]; // текущая частота
sm = EEPROM[8];               // softmute
s2=s;
radio.init();
radio.setMute(true);
radio.setVolume(v);
radio.setMono(ms);
radio.setMute(false);
radio.setBassBoost(b);
radio.setSoftMute(sm);  
radio.setBandFrequency(FIX_BAND, s);
  
readVcc();
}
//================================================
void Parsing()
{
  // использование кнопок
// **********************************************************
// **********************************************************  
//boolean SET=digitalRead(Pin_SET);
//boolean UP=digitalRead(Pin_UP);
//boolean DOWN=digitalRead(Pin_DOWN);
// **********************************************************
// **********************************************************
//
//
      // Имитируем нажате кнопок энкодером
// **********************************************************
// **********************************************************
  if (enc1.isRight())    UP = LOW;        // если был поворот
  if (enc1.isLeft())   DOWN = LOW;
  if (enc1.isClick())   SET = LOW;
// **********************************************************
// **********************************************************

if(SET==HIGH && flag1==0)
  {
    flag1=1;
  }
if(SET==LOW && flag1==1)
  {
    flag1=0;
    TimeOut=millis();
    if(MODE==1) {m++; flag=1; if(m>7) m=1;}
  }
  
 if(UP==LOW && flag2==1)
  {
    flag2=0;
  }
   if(UP==HIGH && flag2==0)
   {
    if(MODE==1)
    {
    switch(m)
      {
        case 1:{ (v==15?0:v++); radio.setVolume(v); break; }
        case 2:{ b = 1; radio.setBassBoost(b); radio.setBandFrequency(FIX_BAND,s); break; }
        case 3:{ ms = 0; radio.setMono(ms); radio.setBandFrequency(FIX_BAND,s); break; }
        case 4:{sm = 1; radio.setSoftMute(true);radio.setBandFrequency(FIX_BAND,s); break;}
        case 5:{ radio.seekUp(true);delay(100); startSeek = millis();
        // wait for seek complete
      do {
        radio.getRadioInfo(&ri);
      } while ((!ri.tuned) && (startSeek + 350 > millis()));
      //tune();
         s = radio.getFrequency(); Kanal(); break; }
        case 6:{ s=s+10; if (s > 10800) s = 8700; delay(100); radio.setBandFrequency(FIX_BAND,s);Kanal(); break; }
        case 7:{ k++;if (k>NK) k=1;s = Station[k-1];radio.setBandFrequency(FIX_BAND,s);  break;}
      }
   flag=1;
   TimeOut=millis();
    }
   else {(v==15?0:v++);radio.setVolume(v);}
   flag2=1;
   }
   if(DOWN==LOW && flag3==1)
  {
    flag3=0;
  }
   if(DOWN==HIGH && flag3==0)
   {
    if(MODE==1)
    {
    switch(m)
      {
        case 1:{ (v==0?15:v--); radio.setVolume(v); break; }
        case 2:{ b = 0; radio.setBassBoost(b); radio.setBandFrequency(FIX_BAND,s); break; }
        case 3:{ ms = 1; radio.setMono(ms); radio.setBandFrequency(FIX_BAND,s); break; }
        case 4:{sm = 0; radio.setSoftMute(false);radio.setBandFrequency(FIX_BAND,s); break;}
        case 5:{ radio.seekDown(true); delay(100); startSeek = millis();
        // wait for seek complete
      do {
        radio.getRadioInfo(&ri);
      } while ((!ri.tuned) && (startSeek + 350 > millis()));
      //tune();
      s=radio.getFrequency(); Kanal(); break; }
        case 6:{ s=s-10; if (s<8700) s=10800; delay(100); radio.setBandFrequency(FIX_BAND,s); Kanal(); break; }
        case 7:{k=constrain(k,1,NK); k--;if (k<1) k=NK;s = Station[k-1];radio.setBandFrequency(FIX_BAND,s);     break;}
      }
   flag=1;
   TimeOut=millis();
   }
   else {(v==0?15:v--);radio.setVolume(v);}
   flag3=1;
  }
}
//================================================
void Menu()
{
float ch;
if(flag==1 && MODE==1)
{

//
//************************************    
radio.getRadioInfo(&ri); // уровень сигнала 
rs=ri.rssi;              // 
//************************************  
ch=float(s)/100; 
u8g.firstPage();  
do {
u8g.setDefaultForegroundColor();
if(Voltage>85) u8g.drawBitmapP (110, 0, 2, 10, Bat7);
  else if(Voltage>70) u8g.drawBitmapP (110, 0, 2, 10, Bat6);
  else if(Voltage>55) u8g.drawBitmapP (110, 0, 2, 10, Bat5);
  else if(Voltage>40) u8g.drawBitmapP (110, 0, 2, 10, Bat4);
  else if(Voltage>25) u8g.drawBitmapP (110, 0, 2, 10, Bat3);
  else if(Voltage>10) u8g.drawBitmapP (110, 0, 2, 10, Bat2);
  else u8g.drawBitmapP (110, 0, 2, 10, Bat1);
if(v<3) u8g.drawBitmapP (13, 0, 2, 10, Vol1);
  else if(v<7) u8g.drawBitmapP (13, 0, 2, 10, Vol2);
  else if(v<10) u8g.drawBitmapP (13, 0, 2, 10, Vol3);
  else if(v<13) u8g.drawBitmapP (13, 0, 2, 10, Vol4);
  else u8g.drawBitmapP (13, 0, 2, 10, Vol5);
if(ms==0) u8g.drawBitmapP (55, 0, 2, 10, Stereo);
if(b==1) u8g.drawBitmapP (75, 0, 2, 10, Bass);
if(sm==1) u8g.drawBitmapP (35, 0, 2, 10, SM);

u8g.setFont(MyDigitsHelveticaBold24);
if(ch<100) u8g.setPrintPos(30,43); else u8g.setPrintPos(23,43);
u8g.print(ch,1);
u8g.setFont(rus6x10);
u8g.print(" MHz");
if (rs>50) u8g.drawBitmapP (0, 0, 1, 10, L5);
  else if(rs>40)  u8g.drawBitmapP (0, 0, 1, 10, L4);
  else if(rs>30)  u8g.drawBitmapP (0, 0, 1, 10, L3);
  else if(rs>20)  u8g.drawBitmapP (0, 0, 1, 10, L2);
  else u8g.drawBitmapP (0, 0, 1, 10, L1);
if(k!=0){
    u8g.drawRFrame (0,32,18,13,2);
    u8g.setPrintPos(3,42);
    if(k<10) u8g.print("0");
    u8g.print(k);
        }
u8g.drawRFrame (0,51,127,12,3);
u8g.setPrintPos(13,61);
 switch(m)
 {
  case 1: {u8g.print(F("- < ГРОМКОСТЬ > +"));break;}
  case 2: {u8g.print(F(" НЕТ < БАСС > ДА"));break;}
  case 3: {u8g.print(F("НЕТ < СТЕРЕО > ДА"));break;}
  case 4: {u8g.print(F("НЕТ < S.MUTE > ДА"));break;}
  case 5: {u8g.print(F(" <  АВТОПОИСК  >"));break;}
  case 6: {u8g.print(F("<  РУЧ. ПОИСК  >"));break;}
  case 7: {u8g.print(F("  <  КАНАЛЫ  >"));break;}
 
 }


}
while( u8g.nextPage() );     
  flag=0;    
}
}
//================================================
void Energy()
{
 //if(MODE==1 && millis()-TimeOut>2000) flag=1;
 if(MODE==1 && millis()-TimeOut>8000)
  {
    u8g.sleepOn(); 
    MODE=0;
    if(v!= EEPROM[1]) EEPROM[1] = v;
    if(k!= EEPROM[2]) EEPROM[2] = k;
    if(m!= EEPROM[3]) EEPROM[3] = m;
    if(b!= EEPROM[4]) EEPROM[4] = b;
    if(ms!=EEPROM[5]) EEPROM[5] = ms;
    if(s2!=s){s2=s;   EEPROM[6] = int(s/100); 
                      EEPROM[7] = s%100;
             }
    if(sm!=EEPROM[8]) EEPROM[8] = sm;         
  }
  if(MODE==0 && millis()-TimeOut<500)
  {
    u8g.sleepOff(); 
    readVcc();
    MODE = 1; 
    flag = 1; 
    m = 7;
  }
}
//===================================================
void readVcc() 
{
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#else
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#endif
  delay(2); // Wait for Vref to settle
  ADCSRA |= _BV(ADSC); // Start conversion
  while (bit_is_set(ADCSRA, ADSC)); // measuring
  uint8_t low  = ADCL; // must read ADCL first - it then locks ADCH
  uint8_t high = ADCH; // unlocks both
  long result = (high << 8) | low;

  result = 1.080 * 1023 * 1000 / result; // расчёт реального VCC
  Voltage = int(result);
  Voltage = map(Voltage, 3200, 4200, 0, 100);
  Voltage = constrain(Voltage, 0, 100);
}
//=======================================================
void Kanal()
{
  k = 0;
  for(int x = 0; x < NK; x ++)
    {
      if(s == Station[x]) {k = (x+1); break;}
    }   
}
/*
void tune() {
   uint16_t Reg03h = getRegister(0x03); // Считываем текущее значение
   setRegister(0x03, Reg03h | RDA5807M_FLG_TUNE);
}

void setRegister(uint8_t reg, const uint16_t value) {
  Wire.beginTransmission(0x11);
  Wire.write(reg);
  Wire.write(highByte(value));
  Wire.write(lowByte(value));
  Wire.endTransmission(true);
}

uint16_t getRegister(uint8_t reg) {
  uint16_t result;
  Wire.beginTransmission(0x11);
  Wire.write(reg);
  Wire.endTransmission(false);
  Wire.requestFrom(0x11, 2, true);
  result = (uint16_t)Wire.read() << 8;
  result |= Wire.read();
  return result;
}
*/

Что добавлено и изменено.

Версия заточена под  Энкодер с возможностью возврата кнопок (раскомментить нужное – ненужное закомментировать)

Дисплей я использовал 1,3” на другом контроллере SH1106 , для использования другого дисплея выберите нужный из трёх .

Использовал другую библиотеку (https://github.com/mathertel/Radio ) с ней всё работало кроме получения уровня сигнала –переписал эту строчку под новую библиотеку (radio.getRadioInfo(&ri); rs=ri.rssi;) , используя (radio.getRadioInfo(&ri);) можно получать и другую информацию о состоянии.

Так же мне не понравилось, что при автопоиске имелась задержка на 3 сек. Просто вместо (Delay 3000;)  проверяем состояние и ждём когда будет настроено на станцию, это происходит намного быстрее и нет ощущения тормознутости. Работает с новой библиотекой.

Ещё был исправлен небольшой баг. Если при автонастройке,  произошла настройка на станцию которой нет в фиксированных или на пустую частоту, то после перехода на выбор каналов и попытке переключиться на другой канал вниз, выскакиваем на леший канал (255) и если листать дальше вниз будет 254 и т.д  частоты могут быть типа 255 или 2,5 MHz. Если листнуть вверх то сразу всё встаёт на место.

И ещё, если у вас будет чехарда с настройками каналов после автопоиска  и глюки с ручным поиском (см. пост выше). Попробуйте раскомментировать  две строчки содержащие tune(); и блок кода в конце скётча.

Rylov! А есть возможность прикрутить к Вашему скетчу дисплей Нокия 5110? 

прикрутить то можно надо просто выбрать свой дисплей,

U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8

правильно его подключить и перерисовать весь интерфейс под более низкое разрешение. 84х48. интерфейс я не рисовал это не мой скетч, меня больше интерисовала работа с тюнером в рамках будущего проекта так же меня интерисует  RDS. А так я только исправил  баги которые нашёл. проще подобрать дисплей под этот скетч - я ставил такой . можно как у автора проэкта такой.

С дисплеем,как у автора, проект я повторял и выше писал с какими бяками в версиях 1.6 и 1.7 я столкнулся при повторении. Ваш скетч пока не пробовал. У меня есть корпус старого приемника с уже с вмонтированным дисплеем 5110. Отсюда и возник вопрос. А самостоятельно править скет я не в состоянии.

возможно что то было не так. когда нажимаешь меню - переключается на каналы, если экран погас то режим громкость. а с автопоиском там было не очень - ощущение как будто не работает, но оно работало, это задержка в 3 сек давала такое ощущение. ну и мой скетч заточен под энкодер - как подключать смотри тут я брал голую крутилку (type2) и цеплял по схеме с резисторами и кондёрами.

если нужны кнопки то надо править.  раскомментировать строки 15,16,17,172,173,174 и закомментировать строки 24-32,93,105-110,113,182-184.

можно еще добавить возле пункта софт мют и функцию шумоподавления? что можно было регулировать уровень шумодава помех

Пытаюсь залить версию 1.7.2  с кнопками, дисплей 0.96". Вроде все исправления внес, но получаю вот такую ошибку

Arduino: 1.8.19 (Windows 10), Плата:"Arduino Nano, ATmega328P"


C:\Users\Nestor\Documents\Arduino\Radio_OLED\Radio_OLED.ino: In function 'void setup()':
Radio_OLED:96:1: error: 'Inicial' was not declared in this scope
 Inicial();
 ^~~~~~~
C:\Users\Nestor\Documents\Arduino\Radio_OLED\Radio_OLED.ino: At global scope:
Radio_OLED:115:10: error: expected constructor, destructor, or type conversion before ';' token
 Parsing();
          ^
Radio_OLED:116:7: error: expected constructor, destructor, or type conversion before ';' token
 Menu();
       ^
Radio_OLED:117:9: error: expected constructor, destructor, or type conversion before ';' token
 Energy();
         ^
Radio_OLED:118:1: error: expected declaration before '}' token
 }
 ^
exit status 1
'Inicial' was not declared in this scope


Этот отчёт будет иметь больше информации с
включенной опцией Файл -> Настройки ->
"Показать подробный вывод во время компиляции"

Что можно посмотреть? Спасибо!

посмотри 113 строку   '}' закомментируй ее. я в описании пропустил однако.

Сейчас выдает вот 

Arduino: 1.8.19 (Windows 10), Плата:"Arduino Nano, ATmega328P"


libraries\U8glib\clib\u8g_font_data.c.o (symbol from plugin): In function `u8g_font_rus4x6':
(.text+0x0): multiple definition of `rus6x10'
sketch\Radio_OLED.ino.cpp.o (symbol from plugin):(.text+0x0): first defined here
collect2.exe: error: ld returned 1 exit status
exit status 1
Ошибка компиляции для платы Arduino Nano.


Этот отчёт будет иметь больше информации с
включенной опцией Файл -> Настройки ->
"Показать подробный вывод во время компиляции"

похоже конфликт библиотек U8glib возможно в папке со скетчем и в папке IDE

Если возможно поделитесь, пожалуйста, ссылкой на правильную библиотеку. Спасибо!

З.Ы. Не могу ни где найти MyDigitsHelveticaBold24.h

 я пользуюсь этой - https://disk.yandex.ru/d/pl7Yw76GGAy2PQ

у вас возможно библиотека лежит в двух местах - в папке со скетчем и в папке с IDE

ДЕЛ!

Нашел все, залилось! Спасибо!

Собрал на макете, при включении появляется начальная заставка и на этом все. Далее радио не запускается. на кнопки не реагирует. Что можно посмотреть?

З.Ы. Сопли и соединения проверил.

т.е. меню не появляется. проходит инициализация и всё.

проблемы могут быть как железные так и программные. 

может код который заливаете сюда выложите.

Попробовал залить Ваш код с энкодером-  запускается только заставка и все. 

З.Ы. Залил тестовый скетч Starting_with_Arduino_OLED - все работает. Так что пока Х.З.!

странно. 

надо пробовать вставлять вывод текста прохождения конкретных мест проги.  в терминал 

т.е. в 90 строке вставить Serial.begin(9600);

А далее в проге в нужных местах вставить типа Serial.println(" -001- ");

для начала бы вставил на 133 строке (001), и после 155 (002)

затем на 114 (003) и после 115.(004) далее открываем монитор порта и запускаем радио смотрим где стопорнулось.

Наверное тямы не хватает у меня- любая попытка внести изменения выдается ошибка. Вот одна из них

пробуй сперва вставить только Serial.begin(9600); в 90 строку

и ";" не забудь на конце строки вставить

код будетвыглядеть так

void setup()
{
 Serial.begin(9600);   
// **********************************************************
// **********************************************************
//enc1.setType(TYPE2);  // Тип Энкодера
// **********************************************************
// **********************************************************
Inicial();
}

вот тебе код "энкодер" с отладочными вставками.

//FM Radio OLED Copyright by GhostLion v1.7.2 GOLD
// Modified by Rylov
#include <EEPROM.h>
#include <radio.h>    \\  библиотекa  https://github.com/mathertel/Radio
#include <RDA5807M.h> \\


#include "U8glib.h"
#include "rus6x10.h"
#include "MyDigitsHelveticaBold24.h"
#define RDA5807M_FLG_TUNE word(0x0010) // флаг настройка - после автопоиска нужно установить
//Назначаем кнопки
// **********************************************************
// **********************************************************
//#define Pin_DOWN 4   // левая кнопка 
//#define Pin_UP 2     // правая кнопка 
//#define Pin_SET 3    // центральная кнопка
// **********************************************************
// **********************************************************
// раскомментировать нужное ненужное закомментировать
// **********************************************************
// **********************************************************
// Или Энкодер - подробнее тут: https://alexgyver.ru/encoder/
#include "GyverEncoder.h" // Для работы с энкодером
#define CLK 2  // Назначаем
#define DT 3   // конткты
#define SW 4   // Энкодера
Encoder enc1(CLK, DT, SW);  // инициируем энкодер
// установим - кнопки не нажаты
boolean SET=HIGH;
boolean UP=HIGH;
boolean DOWN=HIGH;
// закончим  настройку энкодера
// **********************************************************
// **********************************************************

#define FIX_BAND 1

const uint8_t Radio [] U8G_PROGMEM = {0x3F, 0xFF, 0xFF, 0xFF, 0xFC, 0x40, 0x00, 0x00, 0x00, 0x02, 0x80, 0x00, 0x00, 0xC0, 0x01, 0x80,0x00, 0x00, 0xC0, 0x01, 0x8E, 0x88, 0x00, 0xC0, 0x01, 0x88, 0xD8, 0x00, 
0xC0, 0x01, 0x88, 0xA8,0x00, 0xC0, 0x01, 0x8C, 0xA8, 0x00, 0xC0, 0x01, 0x88, 0xA8, 0x00, 0xC0, 0x01, 0x80, 0x00, 0x00,0xC0, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x81, 0x04, 0x10, 0x41, 0x05, 0x81, 0x04, 0x10, 
0x41,0x05, 0x95, 0x55, 0x55, 0x55, 0x55, 0x95, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x80,0x00, 0x00, 
0xF8, 0x01, 0x80, 0x00, 0x03, 0xFE, 0x01, 0x80, 0x00, 0x07, 0x03, 0x01, 0x80, 0x00,0x0C, 0x01, 0x81, 0x80, 0x60, 0x18, 0x00, 0xC1, 0x81, 0xF8, 0x18, 0x00, 0x41, 0x83, 0x9C, 0x10,0x00, 0x61, 0x83, 0x0C, 0x30, 
0x00, 0x61, 0x83, 0x0C, 0x30, 0x00, 0x61, 0x83, 0x0C, 0x30, 0x00,0x61, 0x83, 0x9C, 0x10, 0x00, 0x61, 0x81, 0xF8, 0x18, 0x00, 0x41, 0x80, 0x60, 0x18, 0x00, 0xC1,0x80, 0x00, 0x0C, 0x01, 0x81, 0x80, 0x00, 0x07, 
0x03, 0x01, 0x80, 0x00, 0x03, 0xFE, 0x01, 0x80,0x00, 0x00, 0xF8, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00,0x00, 0x00, 0x02, 0x3F, 0xFF, 0xFF, 0xFF, 0xFC};

const uint8_t Bass[] U8G_PROGMEM = {0x7F, 0xFE, 0x80, 0x01, 0x9B, 0x8D, 0xA2, 0x51, 0xA3, 0x91, 0x9A, 0x4D, 0x8A, 0x45, 0xB3, 0x99,0x80, 0x01, 0x7F, 0xFE};
const uint8_t Stereo[] U8G_PROGMEM = {0x7F, 0xFE, 0x80, 0x01, 0x9B, 0xB9, 0xA1, 0x25, 0xA1, 0x39, 0x99, 0x31, 0x89, 0x29, 0xB1, 0x25,0x80, 0x01, 0x7F, 0xFE};
const uint8_t SM[] U8G_PROGMEM = {0x7F, 0xFE, 0x80, 0x01, 0x8C, 0x51, 0x90, 0xA9, 0x90, 0xA9, 0x8C, 0xA9, 0x84, 0xA9, 0x98, 0x89,0x80, 0x01, 0x7F, 0xFE};

const uint8_t Bat1[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat2[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01, 0xA0, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat3[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01, 0xA8, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat4[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01, 0xAA, 0x01,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat5[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81, 0xAA, 0x81,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat6[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1, 0xAA, 0xA1,0x80, 0x02, 0x7F, 0xFC};
const uint8_t Bat7[] U8G_PROGMEM = {0x7F, 0xFC, 0x80, 0x02, 0xAA, 0xA9, 0xAA, 0xAD, 0xAA, 0xAD, 0xAA, 0xAD, 0xAA, 0xAD, 0xAA, 0xA9,0x80, 0x02, 0x7F, 0xFC};

const uint8_t Vol1[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,0x60, 0x00, 0x60, 0x00};
const uint8_t Vol2[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x0C, 0x00,0x6C, 0x00, 0x6C, 0x00};
const uint8_t Vol3[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x01, 0x80, 0x0D, 0x80, 0x0D, 0x80,0x6D, 0x80, 0x6D, 0x80};
const uint8_t Vol4[] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x01, 0xB0, 0x01, 0xB0, 0x0D, 0xB0, 0x0D, 0xB0,0x6D, 0xB0, 0x6D, 0xB0};
const uint8_t Vol5[] U8G_PROGMEM = {0x00, 0x06, 0x00, 0x06, 0x00, 0x36, 0x00, 0x36, 0x01, 0xB6, 0x01, 0xB6, 0x0D, 0xB6, 0x0D, 0xB6,0x6D, 0xB6, 0x6D, 0xB6};

const uint8_t L1 [] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18};
const uint8_t L2 [] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x18};
const uint8_t L3 [] U8G_PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x18, 0x00, 0x18, 0x18};
const uint8_t L4 [] U8G_PROGMEM = {0x00, 0x00, 0x7E, 0x00, 0x3C, 0x00, 0x18, 0x00, 0x18, 0x18};
const uint8_t L5 [] U8G_PROGMEM = {0xFF, 0x00, 0x7E, 0x00, 0x3C, 0x00, 0x18, 0x00, 0x18, 0x18};
// зададим частоты станций Новосибирск
const unsigned int Station[] = {9380,10320,10390,10520,9420,9910,10260,9540,9280,9700,9870,10200,10140,10670,10770,10620,9620,9500,9660,10070,10000,9580,9740,9950,9830,9780,10460,10570,9460};
byte NK = 29; // количество каналов = количеству станций
byte v,k,m,rs, flag1=1,flag2=0,flag3=0;
int Voltage;
unsigned int s,s2;
boolean b,ms,sm,flag=1,MODE=1;
long TimeOut;
unsigned long startSeek; // after 300 msec must be tuned. after 500 msec must have RDS.
//Выберем свой дисплей
// **********************************************************
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);// Олед 0,96"
//U8GLIB_SSD1309_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);   // Олед 1,3"
// **********************************************************
RDA5807M radio;
// ******************************** 
RADIO_INFO ri; //  нужно для получения уровня сигнала станции  и других настроек
// ********************************
void setup()
{
  Serial.begin(9600);
// **********************************************************
// **********************************************************
 enc1.setType(TYPE2);  // Тип Энкодера 
// **********************************************************
// **********************************************************
Inicial();
}

void loop()
{
  // при использовании кнопок закомментит ьэтот блок
// **********************************************************
// ********************************************************** 
// это для работы с энкодером
  enc1.tick();// обязательная функция отработки энкодера. Должна постоянно опрашиваться
   if (enc1.isTurn()== false ) {     // если не был совершён поворот (индикатор поворота в любую сторону)
// типа  кнопки не нажаты
    UP = HIGH;
    DOWN = HIGH;
    SET = HIGH;
// **********************************************************
// **********************************************************    
  }
Serial.println(" -003- ");  
Parsing();
Serial.println(" -004- ");
Menu();
Energy();  
}
//==============================================
void Inicial()
{
 u8g.firstPage();  
do {
  u8g.drawBitmapP (5, 16, 5, 40, Radio);
  u8g.setFont(rus6x10);
  u8g.setPrintPos(40,11);u8g.print(F("FM РАДИО"));
  u8g.setPrintPos(55,25);u8g.print(F("v 1.7.2 GOLD"));
  u8g.setPrintPos(55,35);u8g.print(F("By GhostLion"));
  u8g.setPrintPos(55,45);u8g.print(F("modified by"));
  u8g.setPrintPos(55,55);u8g.print(F("   Rylov"));    
   }
while( u8g.nextPage() );
Serial.println(" -001- ");
delay(1500);
if (EEPROM[0]!=1)
    {
     EEPROM[0]=1;
     EEPROM[1]=5;
     EEPROM[2]=1; // здесь установить номер текущего канала (моя частота 98.30 "Mayak") 
     EEPROM[3]=1;
     EEPROM[4]=1;
     EEPROM[5]=0;
     EEPROM[6]=98;  // частота текущей радиостанции
     EEPROM[7]=30;  // "Маяк"
     EEPROM[8]=1;
    }
v  = EEPROM[1];               // громкость
k  = EEPROM[2];               // текущий канал
m  = EEPROM[3];               // текущее меню
b  = EEPROM[4];               // супербасс
ms = EEPROM[5];               // моно/стерео
s  = EEPROM[6]*100+EEPROM[7]; // текущая частота
sm = EEPROM[8];               // softmute
s2=s;
radio.init();
Serial.println(" -002- ");
radio.setMute(true);
radio.setVolume(v);
radio.setMono(ms);
radio.setMute(false);
radio.setBassBoost(b);
radio.setSoftMute(sm);  
radio.setBandFrequency(FIX_BAND, s);
  
readVcc();
}
//================================================
void Parsing()
{
  // использование кнопок
// **********************************************************
// **********************************************************  
//boolean SET=digitalRead(Pin_SET);
//boolean UP=digitalRead(Pin_UP);
//boolean DOWN=digitalRead(Pin_DOWN);
// **********************************************************
// **********************************************************
//
//
      // Имитируем нажате кнопок энкодером
// **********************************************************
// **********************************************************
  if (enc1.isRight())    UP = LOW;        // если был поворот
  if (enc1.isLeft())   DOWN = LOW;
  if (enc1.isClick())   SET = LOW;
// **********************************************************
// **********************************************************

if(SET==HIGH && flag1==0)
  {
    flag1=1;
  }
if(SET==LOW && flag1==1)
  {
    flag1=0;
    TimeOut=millis();
    if(MODE==1) {m++; flag=1; if(m>7) m=1;}
  }
  
 if(UP==LOW && flag2==1)
  {
    flag2=0;
  }
   if(UP==HIGH && flag2==0)
   {
    if(MODE==1)
    {
    switch(m)
      {
        case 1:{ (v==15?0:v++); radio.setVolume(v); break; }
        case 2:{ b = 1; radio.setBassBoost(b); radio.setBandFrequency(FIX_BAND,s); break; }
        case 3:{ ms = 0; radio.setMono(ms); radio.setBandFrequency(FIX_BAND,s); break; }
        case 4:{sm = 1; radio.setSoftMute(true);radio.setBandFrequency(FIX_BAND,s); break;}
        case 5:{ radio.seekUp(true);delay(100); startSeek = millis();
        // wait for seek complete
      do {
        radio.getRadioInfo(&ri);
      } while ((!ri.tuned) && (startSeek + 350 > millis()));
      //tune();
         s = radio.getFrequency(); Kanal(); break; }
        case 6:{ s=s+10; if (s > 10800) s = 8700; delay(100); radio.setBandFrequency(FIX_BAND,s);Kanal(); break; }
        case 7:{ k++;if (k>NK) k=1;s = Station[k-1];radio.setBandFrequency(FIX_BAND,s);  break;}
      }
   flag=1;
   TimeOut=millis();
    }
   else {(v==15?0:v++);radio.setVolume(v);}
   flag2=1;
   }
   if(DOWN==LOW && flag3==1)
  {
    flag3=0;
  }
   if(DOWN==HIGH && flag3==0)
   {
    if(MODE==1)
    {
    switch(m)
      {
        case 1:{ (v==0?15:v--); radio.setVolume(v); break; }
        case 2:{ b = 0; radio.setBassBoost(b); radio.setBandFrequency(FIX_BAND,s); break; }
        case 3:{ ms = 1; radio.setMono(ms); radio.setBandFrequency(FIX_BAND,s); break; }
        case 4:{sm = 0; radio.setSoftMute(false);radio.setBandFrequency(FIX_BAND,s); break;}
        case 5:{ radio.seekDown(true); delay(100); startSeek = millis();
        // wait for seek complete
      do {
        radio.getRadioInfo(&ri);
      } while ((!ri.tuned) && (startSeek + 350 > millis()));
      //tune();
      s=radio.getFrequency(); Kanal(); break; }
        case 6:{ s=s-10; if (s<8700) s=10800; delay(100); radio.setBandFrequency(FIX_BAND,s); Kanal(); break; }
        case 7:{k=constrain(k,1,NK); k--;if (k<1) k=NK;s = Station[k-1];radio.setBandFrequency(FIX_BAND,s);     break;}
      }
   flag=1;
   TimeOut=millis();
   }
   else {(v==0?15:v--);radio.setVolume(v);}
   flag3=1;
  }
}
//================================================
void Menu()
{
float ch;
if(flag==1 && MODE==1)
{

//
//************************************    
radio.getRadioInfo(&ri); // уровень сигнала 
rs=ri.rssi;              // 
//************************************  
ch=float(s)/100; 
u8g.firstPage();  
do {
u8g.setDefaultForegroundColor();
if(Voltage>85) u8g.drawBitmapP (110, 0, 2, 10, Bat7);
  else if(Voltage>70) u8g.drawBitmapP (110, 0, 2, 10, Bat6);
  else if(Voltage>55) u8g.drawBitmapP (110, 0, 2, 10, Bat5);
  else if(Voltage>40) u8g.drawBitmapP (110, 0, 2, 10, Bat4);
  else if(Voltage>25) u8g.drawBitmapP (110, 0, 2, 10, Bat3);
  else if(Voltage>10) u8g.drawBitmapP (110, 0, 2, 10, Bat2);
  else u8g.drawBitmapP (110, 0, 2, 10, Bat1);
if(v<3) u8g.drawBitmapP (13, 0, 2, 10, Vol1);
  else if(v<7) u8g.drawBitmapP (13, 0, 2, 10, Vol2);
  else if(v<10) u8g.drawBitmapP (13, 0, 2, 10, Vol3);
  else if(v<13) u8g.drawBitmapP (13, 0, 2, 10, Vol4);
  else u8g.drawBitmapP (13, 0, 2, 10, Vol5);
if(ms==0) u8g.drawBitmapP (55, 0, 2, 10, Stereo);
if(b==1) u8g.drawBitmapP (75, 0, 2, 10, Bass);
if(sm==1) u8g.drawBitmapP (35, 0, 2, 10, SM);

u8g.setFont(MyDigitsHelveticaBold24);
if(ch<100) u8g.setPrintPos(30,43); else u8g.setPrintPos(23,43);
u8g.print(ch,1);
u8g.setFont(rus6x10);
u8g.print(" MHz");
if (rs>50) u8g.drawBitmapP (0, 0, 1, 10, L5);
  else if(rs>40)  u8g.drawBitmapP (0, 0, 1, 10, L4);
  else if(rs>30)  u8g.drawBitmapP (0, 0, 1, 10, L3);
  else if(rs>20)  u8g.drawBitmapP (0, 0, 1, 10, L2);
  else u8g.drawBitmapP (0, 0, 1, 10, L1);
if(k!=0){
    u8g.drawRFrame (0,32,18,13,2);
    u8g.setPrintPos(3,42);
    if(k<10) u8g.print("0");
    u8g.print(k);
        }
u8g.drawRFrame (0,51,127,12,3);
u8g.setPrintPos(13,61);
 switch(m)
 {
  case 1: {u8g.print(F("- < ГРОМКОСТЬ > +"));break;}
  case 2: {u8g.print(F(" НЕТ < БАСС > ДА"));break;}
  case 3: {u8g.print(F("НЕТ < СТЕРЕО > ДА"));break;}
  case 4: {u8g.print(F("НЕТ < S.MUTE > ДА"));break;}
  case 5: {u8g.print(F(" <  АВТОПОИСК  >"));break;}
  case 6: {u8g.print(F("<  РУЧ. ПОИСК  >"));break;}
  case 7: {u8g.print(F("  <  КАНАЛЫ  >"));break;}
 
 }


}
while( u8g.nextPage() );     
  flag=0;    
}
}
//================================================
void Energy()
{
 //if(MODE==1 && millis()-TimeOut>2000) flag=1;
 if(MODE==1 && millis()-TimeOut>8000)
  {
    u8g.sleepOn(); 
    MODE=0;
    if(v!= EEPROM[1]) EEPROM[1] = v;
    if(k!= EEPROM[2]) EEPROM[2] = k;
    if(m!= EEPROM[3]) EEPROM[3] = m;
    if(b!= EEPROM[4]) EEPROM[4] = b;
    if(ms!=EEPROM[5]) EEPROM[5] = ms;
    if(s2!=s){s2=s;   EEPROM[6] = int(s/100); 
                      EEPROM[7] = s%100;
             }
    if(sm!=EEPROM[8]) EEPROM[8] = sm;         
  }
  if(MODE==0 && millis()-TimeOut<500)
  {
    u8g.sleepOff(); 
    readVcc();
    MODE = 1; 
    flag = 1; 
    m = 7;
  }
}
//===================================================
void readVcc() 
{
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#else
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#endif
  delay(2); // Wait for Vref to settle
  ADCSRA |= _BV(ADSC); // Start conversion
  while (bit_is_set(ADCSRA, ADSC)); // measuring
  uint8_t low  = ADCL; // must read ADCL first - it then locks ADCH
  uint8_t high = ADCH; // unlocks both
  long result = (high << 8) | low;

  result = 1.080 * 1023 * 1000 / result; // расчёт реального VCC
  Voltage = int(result);
  Voltage = map(Voltage, 3200, 4200, 0, 100);
  Voltage = constrain(Voltage, 0, 100);
}
//=======================================================
void Kanal()
{
  k = 0;
  for(int x = 0; x < NK; x ++)
    {
      if(s == Station[x]) {k = (x+1); break;}
    }   
}
/*
void tune() {
   uint16_t Reg03h = getRegister(0x03); // Считываем текущее значение
   setRegister(0x03, Reg03h | RDA5807M_FLG_TUNE);
}

void setRegister(uint8_t reg, const uint16_t value) {
  Wire.beginTransmission(0x11);
  Wire.write(reg);
  Wire.write(highByte(value));
  Wire.write(lowByte(value));
  Wire.endTransmission(true);
}

uint16_t getRegister(uint8_t reg) {
  uint16_t result;
  Wire.beginTransmission(0x11);
  Wire.write(reg);
  Wire.endTransmission(false);
  Wire.requestFrom(0x11, 2, true);
  result = (uint16_t)Wire.read() << 8;
  result |= Wire.read();
  return result;
}
*/

Не запускается под энкодер. В мониторе

13:24:00.987 ->  -001- 
13:24:02.753 ->  -001- 
13:24:04.488 ->  -001- 
13:24:06.222 ->  -001- 
13:24:07.956 ->  -001- 
13:24:09.738 ->  -001- 
13:24:11.472 ->  -001- 
13:24:13.206 ->  -001- 
13:24:14.941 ->  -001- 
13:24:16.675 ->  -001- 
13:24:18.409 ->  -001- 
13:24:20.190 ->  -001- 
13:24:21.925 ->  -001- 
13:24:23.659 ->  -001- 

А здесь выдает ошибку

Смотри -002- стоит после инициализации тюнера

radio.init();
Serial.println(" -002- ");

попробуй переставить    Serial.println(" -002- ");  перед    radio.init(); если появится в мониторе -002- то дело в тюнере и его подключении.

это место будет выглядеть так

s2=s;
Serial.println(" -002- ");
radio.init();
radio.setMute(true);

Теперь выдает вот.   -002- не появляется

 пробуй поставить Serial.println(" -002- "); перед if (EEPROM[0]!=1) после delay(1500);

если появится то пробуй после } перед v  = EEPROM[1];               // громкость

есть такое ощущение что  после delay(1500);  происходит ресет  возможно при обращении к еепром.

Вот с другим модулем ФМ 

Вот переставил

Вот перед перед v  = EEPROM[1];               // громкость

получается что у тебя происходит сброс ардуинки при выполнении этого участка кода.

delay(1500);
if (EEPROM[0]!=1
    {
     EEPROM[0]=1;
     EEPROM[1]=5;
     EEPROM[2]=1; // здесь установить номер текущего канала (моя частота 98.30 "Mayak")
     EEPROM[3]=1;
     EEPROM[4]=1;
     EEPROM[5]=0;
     EEPROM[6]=98;  // частота текущей радиостанции
     EEPROM[7]=30;  // "Маяк"
     EEPROM[8]=1;
    }
 

нужно после delay(1500); вставить и следом еще один delay(500); поставить. и посмотреть что будет.

delay(1500);
Serial.println(" -002- ");
delay(500);

Получилось вот 

Похоже операция с еепром в ардуинке вызывает сброс. Пробуй менять ардуинку или смотри ее питание.

Поменял- ничего не поменялось. Питание подаю через разъем на ардуинке с USB компьютера.

[/quote] Похоже питание.[/quote]

Пробовал и от отдельного- не помогает!  Переделал все на TEA5767, залил скетч со стр. 1-  все работает. Останусь пока так. Вам отдельное спасибо!

З.Ы.Почему не хочет работать РДА- Х.З.! Оба модуля были исправны.

З.Ы.1 Что надо исправить в скетче что бы не отключался экран?

найди это u8g.sleepOn(); и закомментируй.

Отлично! И крайний вопрос. В скетче для 5767 не нашел регулировку начальной громкости. Я правильно понял из комментариев, что этот параметр не регулируется? Спасибо!

З.Ы. И все таки жаль, что на РДА не заработала!

я 5767 не занимался. скорее всего нету этого параметра.

Проверил вот этим скетчем https://github.com/lucsmall/Arduino-RDA5807M . Оба модуля, что у меня есть, рабочие. Почему в этом радио не работают- Х.З. Питание не менял.