Arduino.ru

на время прошивки можно к имеющемуся припаяному кварцу 27Мгц прислонить кварц на 16 Мгц и дуина будет тактироваться от меньшего кварца и будет можно прошить, здесь это уже обсуждалось

Зачем такой изврат, когда есть нормальный оптибут? И места чутка высвободится и работать все будет в штатном режиме.

есть у меня доктор,вылечил,залил по новой фузы и загрузчик (слизал с ардуино нано,пишлось немного азобать http://arduino.ru/forum/proekty/virtos-samyi-prostoi-dvukhluchevoi-ostsillograf-ostsillograf-na-arduino?page=8#comment-243215)

частотомер все равно попробую добавить(сам),памяти еще почти половина

Сташевский68-скетч брал здесь http://arduino.ru/forum/proekty/pultoskop-na-arduino-27mgts?page=12#comment-176022

всем спасибо за помощь!

Допилил под себя генератор ШИМ . может кому пригодится.

1. увеличил кол-во коэфициентов до х 100000  (для ускоренной установки)

2 . ограничил счетчик 8 Мгц

//=================================================================== Функция Генератор PWM() ================================================================
void Generator() {
  display.clearDisplay();                                       // очистить дисплей 
  //------------------------ изменение частоты  -------------------------------------------------------------------------------------------------------
  if (flag==0) {                                                // флаг выборов режима настройки ШИМ или Частоты
    if(digitalRead(key_down)){                                  // если нажата кнопка  вниз
      freq-=stepFreq;                                           // шаг изменения частоты
      if(freq<0) freq=0;                                        // проверка на выход  за 0 
      bool success = SetPinFrequencySafe(led, freq);            // установить частоту  freq  на указанном пине led   
      delay(100);                                               // задержка от дребезга 
    }
    if(digitalRead(key_up)){                                    // если нажата кнопка вверх        
      freq+=stepFreq;                                           // прирощение частоты
      if (freq >8000000)freq=8000000 ;                          // если частота > 8 MHz  то всегда 8 MHz   
      bool success = SetPinFrequencySafe(led, freq);            // установить частоту  freq  на указанном пине led 
      delay(100);                                               // задержка от дребезга 
    }  
  }
  //---------------------------  изменение PWM    ------------------------------------------------------------------------------------------------------
  if (flag==1) {                                                // флаг выборов режима настройки ШИМ или Частоты
    if(digitalRead(key_down)){                                  // если нажата кнопка вниз  
      PWM=PWM-1;                                                // уменьшение на 1 %
      if(PWM<0) PWM=100;                                        // проверка на достижение 0%
      delay(100);                                               // задержка от дребезга
    }
    if(digitalRead(key_up)){                                    // если нажата кнопка вверх  
      PWM=PWM+1;                                                // увеличим на  1%
      if(PWM>100) PWM=0;                                        // проверка превышения 100%
      delay(100);                                               // защита от дребезга 
    }  
  }      
  //------------------------- изменение разряда для редактирования  частоты   --------------------------------------------------------------------------
  if(digitalRead(key_ok)) {                                    // нажата кнопка "ok" переключение разряда выбора частоты 
    delay(100);                                                // защита от дребезга
    hag++;                                                     // прирощение hag
    if(hag>=7) hag=0;                                          // проверка на превышение диаппазона
  } 
  
  long freqX=freq*(overclock/16.0);                            // расчет частоты  при частоте кварца  отличном от 16 мГц 
  
  // выводим уровень ШИМ -------------------------------------------------------------------------------------------------------------------------------        
  display.setTextSize(1);                                     // отображение % PWM (скважности) вверху между полосками 
  display.setCursor(21,5);                                    //
  display.print("PWM=");                                      //
  display.print(PWM);                                         //
  display.print("%");                                         //
  // рисуем полосочки уровня ШИМ------------------------------------------------------------------------------------------------------------------------
  display.drawLine(41-(41*PWM/100.0),  0, 42+(41*PWM/100.0),  0, BLACK);
  display.drawLine(42-(41*PWM/100.0),  1, 41+(41*PWM/100.0),  1, BLACK);
  display.drawLine(43-(41*PWM/100.0),  2, 40+(41*PWM/100.0),  2, BLACK);
  display.drawLine(41-(41*PWM/100.0), 16, 42+(41*PWM/100.0), 16, BLACK);
  display.drawLine(42-(41*PWM/100.0), 15, 41+(41*PWM/100.0), 15, BLACK);
  display.drawLine(43-(41*PWM/100.0), 14, 40+(41*PWM/100.0), 14, BLACK);
  // готовимся для вывода частоты    ------------------------------------------------------------------------------------------------------------------
 
  // рисуем частоту------------------------------------------------------------------------------------------------------------------------------------ 
    display.setTextSize(2); display.setCursor(4, 20);  
  if(freqX<1000)  {display.setCursor(18, 20); display.print(freqX);}    // выводим частоту    999  Hz 
  if(freqX>=1000 && freqX<10000)  { display.print(freqX/1000.0, 3);}    //                  1-10   kHz 
  if(freqX>=10000&&freqX<100000)  { display.print(freqX/1000.0, 2);}    //                 10-100  kHz 
  if(freqX>=100000&&freqX<1000000){ display.print(freqX/1000.0, 1);}    //                100-1000 kHz   
  if(freqX>=1000000)              {display.print(freqX/1000000.0, 3);}  //                >   1    mHz
     
  if(freqX >=1000 && freqX<1000000 ) {  display.setTextSize(1); display.setCursor(70, 20); display.print("K") ; } // выводим еденицу измерения
  if(freqX >=1000000 )               {  display.setTextSize(1); display.setCursor(70, 20); display.print("M") ; } // 
                                        display.setTextSize(1); display.setCursor(70, 28); display.print("Hz");   //
 //----------------------------------------------     строка множетеля    ----------------------------------------------------------------------------- 
  // выводим строку статуса (режима)                           
  display.setCursor(0,40);                                     //  установка курсора
  display.setTextSize(1);                                      //  выбор размера шрифта
  display.print(">>");                                         // 
  display.setTextColor(WHITE, BLACK);                          //  установка инверсии для
  display.print(" ");                                          //
  if(hag<6) display.print("x");                                // 
  
  if(hag==0) {                                                // выбор множителя частоты х1,0        
    display.print(1*(overclock/16.0),1); 
    stepFreq=1; flag=0; }
  if(hag==1){                                                 //выбор множителя частоты х10
    display.print(10*(overclock/16.0),0); 
    stepFreq=10; }
  if(hag==2){                                                 //выбор множителя частоты х100
    display.print(100*(overclock/16.0),0); 
    stepFreq=100; }
  if(hag==3){                                                 //выбор множителя частоты х1000
    display.print(1000*(overclock/16.0),0); 
    stepFreq=1000;}  
  if(hag==4){                                                 //выбор множителя частоты х10000
    display.print(10000*(overclock/16.0),0); 
    stepFreq=10000;   } 
  if(hag==5){                                                 //выбор множителя частоты х100000
    display.print(100000*(overclock/16.0),0); 
    stepFreq=100000;   } 
  
  if(hag==6){                                                 //выбор  PWM
    display.print("PWM "); display.print(PWM); display.print("%"); 
    flag=1;
  } 
  
  display.print(" ");
  display.setTextColor(BLACK);
  display.setCursor(70,40);
  display.print("<<");
  //--------------------------------------------------------   конец строки  множетеля   ---------------------------------------------------------------------------------------
  // выставили ШИМ
  pwmWrite(led, PWM*2.55);                                      // расчет множителя коэфициента заполнения и вывод через пин led
  delay(200);                                                   // ожидание
  display.display();                                            // вывод на экран
}
//==========================================================     конец функции Generator()     =================================================================================

Спасибо за "материал к размышлению", Stashevskiy68! :)

сегодня на работе тестировал генератор. максимум что он выдал - 2 МHz  . до  2,9 KHz шаг 1 гц,  5 Кгц - 3 гц   ... и  далее   шаг увеличивается. короче попробую пройтись по всему диаппазону  и  перписать код так чтобы не зависимо от введенного значения  возвращал значения ближайшей достоверно выводимой частоты.

Я собрал пультоскоп на ардуино нано. Он запускается но зависает если я выбираю генератор в главном меню, а в DDS генераторе при выборе любого из пунктов ничего не происходит, при этом зависает всего на пару секунд. Подключил всё вроде правильно, по схеме с сайта автора и скетч оттуда же. Что может быть не так?

В DDS-генераторе ничего и не должно происходить, кроме изменени формы сигнала, т.е. навел курсор на пункт "Пила", на выходе - пила, навел на синус - синус...

Даже не знаю, что и предположить. Попробуйте залить мой скейтч с сайта автора. По железу все совместимо.

И обязательно используйте ардуино ИДЕ с сайта автора!

У меня работает с кнопками как на землю, так и как у автора - на питание с резистивной подтяжкой. Написан автодетект в самом начале скейтча. Ничего менять не надо - должно само все заработать.

Загрузил твой скетч Electronik83 , и нечего кроме этого не увидел:Видимо теперь зависает при самом старте. к слову у меня ардуино нано, изначально не виделась компютером. Я шью её через другую ардуину нано.

UPD: сделал как ты собственно и просил прошил через arduino IDE с сайта автора. запускается, только как будто с зажатой средней кнопкой, запускается осцилограф и начинают переключатся по очереди режимы

Значит проблема с подключением кнопок, видимо...

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

Может че то где то не припаялось или припаялось не так. Кароче ищи проблему в пайке/сборке.

И версию автора тоже надо лить через ардуино ИДЕ с сайта автора, чтобы было меньше глюков.

И эту звездочку от адафрут (или от чего там) я ни разу не видел на своем дисплее...

И я этот автодетект кнопок двести раз проверял - все было нормально.

UPD: Я не просил - я рекомендовал.... Так как ардиуно ИДЕ ардуине ИДЕ рознь....

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

Или могла изоляция провода проплавиться в процессе пайки и коротнуть куда нибудь...

для svj3ist. залей  мой код для генератора он для кнопок на +5. код из поста  #2456.  он рабочий 100%. и компилятор возьми с сайта автора 1.6.5.  . у меня только с него заливается без глюков.

А он разве полный? не компилируется.

для svj3ist. и рекомендую продолжать на коде от Electronik83 у него  нормальный оптимизированный код  . видно что  не первый день программирует. меню конечно можно было  через массив реализовать (чтоб при увеличении пунктов можно было прокрутку сделать и сделать отдкльно универсальной функцией) но всеравно лучше чем у автора проекта (прошу автора не обижаться - мы здесь для того чтобы друг у друга  учиться).

Проблема в пайке/сборке. Не может многократно проверенный код вести себя неадекватно. Пролей авторскую прошиву через ИДЕ с сайта автора. Разбирайся...

P.S. программирую со времен спектрумов. Много че не доделал, как надо в пультоскопе этом....

нет. не полный только генератор. могу залить полный, рабочий. только там я еще работаю над генератором.но в принципе рабочий.

давай

лови

//Страница проэкта  http://srukami.inf.ua/pultoscop_v25110.html
// ---------------------------------------------------------------
// От Electronik83:
// 1. Причесал код: немного оптимизировал, без ухода от алгоритмов автора
// 2. Вырезал кнопку питания - проще тумблер поставить (имхо).
// 3. Причесал код: поменял имена некоторых переменных и дефайнов
// 4. Поменял алгоритм работы кнопок - просто подключаем кнопки к земле и без всяких резисторов!
// 5. Изменил навигацию в главном меню (можно вниз и вверх ездить стало)
// 6. Слегка приукрасил менюху главную и DDS-генератора
// 7. DDS-генератор переключается (меняет форму сигнала) от любой кнопки теперь
// 8. В режиме генератора PWM в процентах в целых числах (без дробей), изменил полосочки
// 9. В генераторе пофиксил/оптимизировал вывод частоты (1000 герц не показывало)
// 10. В генераторе поменял отрисовку (отцентровал некоторые элементы)
// 11. В генераторе изменил задержку для дребезга и общую задержку - кнопки стали лучше реагировать
// 12. В генераторе стало точнее видно частоту (вместо трех разрядов - четыре)

#include <Adafruit_GFX.h>    // библиотек для работы с дисплеем
#include <Adafruit_PCD8544.h>// библиотек для работы с дисплеем
#include <FreqCount.h>       // библиотек для работы с подсчетом частоты на входе
#include <PWM.h>             // библиотек для работы с  ШИМ
#include <CyberLib.h>        // библиотек для работы с ???
#include <EEPROM.h>          // библиотек для работы с  енергонезависимой памятью
#define led  9               // пин для генератора сигналов (не менять)
#define dds  10              // пин для генератора dds (не менять)
#define key_down 13          // кнопка минус (можно любой пин)
#define key_ok   12          // кнопка ОК (можно любой пин)
#define key_up   11          // кнопка плюс (можно любой пин)
#define akb A5               // любой свободный аналоговый пин для измерения напряжения АКБ 
#define overclock 16         // частота на которой работает Ардуино
                                        // (clk(scl), din(sda), dc, ce, rst)       
Adafruit_PCD8544 display = Adafruit_PCD8544(7       , 6       ,  4,  3,   2); // пины к которым у вас подключен дисплей         
byte contrast=30;    // контрастность дисплея
byte SinU=30;        // уровень синхронизации 0 до 255 
int PWM = 50;        // стартовое значение ШИМ от 0 до 100        
//int32_t freq = 1000; //стартовое значение частоты в Гц
float freq = 1000;   //стартовое значение частоты в Гц
float VCC=5.0;       //напряжение питания, меряем мультиметром
//###########################################################
int d=0;
byte sinM[32]={1,6,15,29,48,69,92,117,143,168,191,212,229,243,251,255,254,248,237,222,203,181,156,131,106,81,59,39,22,10,3,1};
byte pilaM[32]={1,9,17,25,33,41,49,57,65,73,81,89,97,105,113,121,129,137,145,153,161,169,177,185,193,201,209,217,225,235,245,255};
byte RpilaM[32]={250,246,238,230,222,214,206,198,190,182,174,166,158,150,142,134,126,118,110,102,94,86,78,70,62,54,41,33,25,17,9,1};
byte trianglM[32]={1,18,35,52,69,86,103,120,137,154,171,188,205,222,239,255,239,223,207,191,175,159,143,127,111,95,79,63,47,31,15,1};
byte hag=0;
long stepFreq=0;
boolean flag=0;
byte mass[701];
byte x=0; 
byte ddsMenu=0;   // меню dds-генератора 
byte oscMenu=0;   // меню осциллоскопа 
bool opornoe=1;   // флаг опорного напряжения
bool pause=0;     // флаг режима паузы
byte mode=0;      // режим работы прибора 
byte razv=0;      // развертка по умолчанию
unsigned long count=0;
byte sinX=30; 
byte meaX=83;
int Vmax=0;       // максимальное напряжение 
byte sinhMASS=0;
long countX=0;
int xUART=3;      // адрес в масиме скоростей терминала по умолчанию  "9600"
int  prokr=0;

void setup() {
  
  digitalWrite(key_up,LOW); digitalWrite(key_ok,LOW); digitalWrite(key_down,LOW);     // подтянули кнопки к "-"
  display.begin();                                                                    // инициализация дисплея
  display.setContrast(contrast);                                                      // установить контрастность экрана 

// ----------------------------    Заставка  ----------------------------------------------------------------------------------------------------------------------

/*
// Battery
  display.drawRect(40, 39, 4, 5, BLACK);               // пипка
  display.drawRect(23, 37, 18, 9, BLACK);              // батарея
  display.fillRect(25, 39, 4, 5, BLACK);               //уровень1
  display.fillRect(30, 39, 4, 5, BLACK);               //уровень2
  display.fillRect(35, 39, 4, 5, BLACK);               //уровень3

 display.setCursor(50,38); display.print(analogRead(akb)*VCC/1024) ;  display.print("в");  
//display.print("Stashevskiy68"); 

display.display();                                      // вывести на дисплей 
delay(2000);                                            //время демонстрации
*/
//------------------------------------------------------------------- Главное МЕНЮ  --------------------------------------------------------------------------------    
  while(!digitalRead(key_ok))  {                                                      // выводим меню, пока не выбран режим работы прибора  
    display.clearDisplay();                                                           // очистка дисплея
    if (mode == 0) display.setTextColor(WHITE, BLACK); else display.setTextColor(BLACK);
        display.setCursor(3 , 0); display.println(" Осциллоскоп ");
    if (mode == 1) display.setTextColor(WHITE, BLACK); else display.setTextColor(BLACK);
        display.setCursor(3 ,10); display.println("Генератор PWM");
    if (mode == 2) {display.setTextColor(WHITE, BLACK); display.setCursor( 0, 20); display.println(" "); display.setCursor(77, 20); display.println(" "); } else display.setTextColor(BLACK);
       display.setCursor(3 ,20); display.println( "Генератор DDS");
    if (mode == 3) display.setTextColor(WHITE, BLACK); else display.setTextColor(BLACK);
       display.setCursor(3,30); display.println("Терминал UART");
       
       //display.setTextColor(BLACK);
       //display.setCursor(12,40); display.print("Vbat="); display.print(analogRead(akb)*VCC/1024); display.print("V"); // индикация напряжения
    
    
    // перемещаемся по меню  
    if (!digitalRead(key_up)  ) { mode++; delay(100); }            // если нажата кнопка вверх
    if (!digitalRead(key_down)) { mode--; delay(100); }            //                    вниз 
    if (mode == 0xFF) mode = 3;                                    //
    if (mode>3) mode=0;                                            //  
    delay(50);                                                     // ожидание (дребезг контактов) 
    display.display();                                             // выводим все на экран
  }
  // выбран режим работы...
  if (mode==0) FreqCount.begin(1000);                              // считаем частоту
  if (mode==1) { InitTimersSafe(); bool success = SetPinFrequencySafe(led, freq); }
  if (mode==2) { InitTimersSafe(); bool success = SetPinFrequencySafe(led,200000);     }
  delay(200);
}
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------
//void loop(){ }
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------
// читаем с АЦП данные и помещаем их в буфер...   
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------
void Zamer() {
  if (razv>=6) ADCSRA = 0b11100010; //delitel 4      // делитель  в зависимости от развертки 
  if (razv==5) ADCSRA = 0b11100011; //delitel 8
  if (razv==4) ADCSRA = 0b11100100; //delitel 16
  if (razv==3) ADCSRA = 0b11100101; //delitel 32
  if (razv==2) ADCSRA = 0b11100110; //delitel 64
  if (razv<2)  ADCSRA = 0b11100111; //delitel 128
  if (razv==0) {
    for(int i=0; i<700; i++) { 
      while ((ADCSRA & 0x10)==0);
      ADCSRA|=0x10;
      delayMicroseconds(500);               // задержка 0.5 сек
      mass[i]=ADCH;                         // выбираем из масива
    }
  } else {                                  // (rezv>0)
    for(int i=0; i<700; i++) { 
      while ((ADCSRA & 0x10)==0);
      ADCSRA|=0x10;
      mass[i]=ADCH;
    }
  }
}
//------------------------------------- конец функции ZAMER () -----------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------------------------
// безконечный цикл
void loop() {
  if(mode==0) { // если режим осциллоскопа, то..  
    if(opornoe) ADMUX = 0b01100011; // выбор внешнего опорного
           else ADMUX = 0b11100011; // выбор внутреннего опорного 1,1В
    delay(5);
    if(pause==0) Zamer();
    // определение точки синхронизации
    bool flagSINHRO=0;
    bool flagSINHRnull=0;
    for(int y=1; y<255 ;y++){
      if(flagSINHRO==0){if(mass[y]<SinU){flagSINHRnull=1;}}
      if(flagSINHRO==0){if(flagSINHRnull==1){if(mass[y]>SinU){flagSINHRO=1;sinhMASS=y;}}}}
    // считаем максимальное значение сигнала (для вывода на экран)
    Vmax=0; 
    for(int y=1; y<255; y++) if(Vmax<mass[y]) Vmax=mass[y];
    
    // отрисовка графика 
    display.clearDisplay();
    if(pause) {                                                                            // если в режиме паузы, то рисуем с прокруткой...
      display.drawLine(prokr/8,8,prokr/8+6,8, BLACK);                                      //шкала прокрутки
      display.drawLine(prokr/8,9,prokr/8+6,9, BLACK);                                      //шкала прокрутки
      x=3;
      for(int y=prokr; y<prokr+80; y++) {                                                  // рисуем форму сигнала
        if(razv<7)  x++;
        if(razv==7) x+=2;
        if(razv==8) x+=3; 
        display.drawLine(x, 47-mass[y]/7, x+1, 47-mass[y+1]/7, BLACK);                     // Отрисовка осцилограммы 1 линия
       // display.drawLine(x+1, 47-mass[y]/7+1, x+2, 47-mass[y+1]/7+1, BLACK);             // отрисовка осцилограммы 2 линия (для утолщения)
      }
    } else {                                                                               // если паузы нет, то рисуем немного по другому))..
      display.fillCircle(80,47-SinU/7, 2, BLACK);                                          //рисуем уровень синхронизации    
      x=3;
      for(int y=sinhMASS; y<sinhMASS+80; y++) {                                            // рисуем форму сигнала
        if(razv<7)  x++; 
        if(razv==7) x+=2;
        if(razv==8) x+=3; 
        display.drawLine(x, 47-mass[y]/7, x+1, 47-mass[y+1]/7, BLACK);
       // display.drawLine(x+1, 47-mass[y]/7+1, x+2, 47-mass[y+1]/7+1, BLACK);        
      }
      sinhMASS=0;
    }
    // отрисовка сетки
    for(byte i=47;i>5;i=i-7) { display.drawPixel(0, i, BLACK); display.drawPixel(1, i, BLACK); display.drawPixel(2, i, BLACK); }
    for(byte i=47;i>5;i=i-3) { display.drawPixel(21,i, BLACK); display.drawPixel(42,i, BLACK); display.drawPixel(63,i, BLACK); }
    for(byte i=3;i<84;i=i+3) { display.drawPixel(i,33, BLACK); display.drawPixel(i,19, BLACK); }
    // отрисовка menu    
    display.setCursor(0,0);
    if(oscMenu==0) {
      display.setTextColor(WHITE,BLACK);
      if(opornoe) display.print(VCC,1); else display.print("1.1");
      display.setTextColor(BLACK); 
      display.print(" "); display.print(razv);
      display.print(" P");
      if(digitalRead(key_down) || digitalRead(key_up)) { opornoe=!opornoe; }
    }
    if(oscMenu==1) {
      if(opornoe) display.print(VCC,1); else display.print("1.1");
      display.setTextColor(WHITE, BLACK); 
      display.print(" "); display.print(razv);
      display.setTextColor(BLACK);
      display.print(" P");
      if(digitalRead(key_down)) { razv=razv-1; if(razv==255) razv=0; }
      if(digitalRead(key_up)  ) { razv=razv+1; if(razv==9)   razv=8; }
    }
    if(oscMenu==2) {
      if(opornoe) display.print(VCC,1); else display.print("1.1");
      display.print(" "); display.print(razv);
      display.setTextColor(WHITE, BLACK);
      display.print(" P");
      display.setTextColor(BLACK);
      pause=1;
      if(digitalRead(key_down)) { prokr=prokr-10; if(prokr<0)   prokr=0;   }
      if(digitalRead(key_up)  ) { prokr=prokr+10; if(prokr>620) prokr=620; }    
    }
    if(oscMenu==3) {
      prokr=0;
      pause=0;
      if(opornoe) display.print(VCC,1); else display.print("1.1");
      display.print(" "); display.print(razv);
      display.print(" P");
      if(digitalRead(key_down)) { SinU=SinU-20; if(SinU<20)  SinU=20;  }
      if(digitalRead(key_up)  ) { SinU=SinU+20; if(SinU>230) SinU=230; }   
      display.fillCircle(80,47-SinU/7, 2, BLACK);
      display.fillCircle(80,47-SinU/7, 1, WHITE); 
    }
    if (digitalRead(key_ok)) { oscMenu++; if(oscMenu==4) { oscMenu=0; pause=0; }}  //перебор меню
    if (FreqCount.available()) count = FreqCount.read();                           //вывод частоты по готовности счетчика
    
    // считаем частоту сигнала
    byte Frec1=0;                                                                  // 
    long Frec=0;                                                                   //
    bool flagFrec1=0;                                                              // 
    bool flagFrec2=0;                                                              //
    bool flagFrec3=0;                                                              //
    
    for(int y=1; y<255; y++) {                    
      if(flagFrec1==0 && mass[y]<SinU) flagFrec2=1;
      if(flagFrec1==0 && flagFrec2==1 && mass[y]>SinU) { flagFrec1=1; Frec1=y; }
      if(flagFrec1==1 && mass[y]<SinU) flagFrec3=1;
      if(flagFrec3==1 && mass[y]>SinU) {
        if (razv>=6) Frec=1000000/((y-Frec1-1)*3.27);  //delitel 4
        if (razv==5) Frec=1000000/((y-Frec1)*3.27)/2;  //delitel 8
        if (razv==4) Frec=1000000/((y-Frec1)*3.27)/4;  //delitel 16
        if (razv==3) Frec=1000000/((y-Frec1)*3.27)/8;  //delitel 32
        if (razv==2) Frec=1000000/((y-Frec1)*3.27)/16; //delitel 64
        if (razv==2) Frec=1000000/((y-Frec1)*3.27)/32; //delitel 128
        if (razv==1) Frec=1000000/((y-Frec1)*3.27)/32; //delitel 128
        if (razv==0) Frec=1000000/((y-Frec1)*500);     //delitel 128
        flagFrec1=0; flagFrec3=0;
      }
    }
    // отрисовка частоты сигнала
    if(opornoe==1) {
      if((Vmax*VCC/255)>2.5) countX=count*(overclock/16.0); 
      if((Vmax*VCC/255)<2.5) countX=Frec*(overclock/16.0);
    } else countX=Frec*(overclock/16.0);
    if(countX<1000) { display.print(" "); display.print(countX); display.print("Hz"); }
    if(countX>1000) { float countXK=countX/1000.0; display.print(countXK,1); display.print("KHz"); }
    // отрисовка максимального напряжения сигнала
    display.setCursor(0,40); 
    if(opornoe) display.print(Vmax*VCC/255,1); else display.print(Vmax*1.1/255,1);
    display.print("V");
    delay(200);  
    display.display();        // вываливаем все на экран
  }
  if(mode==1) Generator();    // "выпадаем" в генератор 
  if(mode==2) DDSGenerator(); // "выпадаем" в DDS генератор
  if(mode==3) TTL();          // "выпадаем" в USART приемник
}
//------------------------------------------------------------------------------------------------------------------------------------------------------------
//=================================================================== Функция Генератор PWM() ================================================================
void Generator() {
  float a =0;
  int b =0;
  float c =0;
  display.clearDisplay();                                       // очистить дисплей 
  //------------------------ изменение частоты  -------------------------------------------------------------------------------------------------------
  if (flag==0) {                                                // флаг выборов режима настройки ШИМ или Частоты
    if(digitalRead(key_down)){                                  // если нажата кнопка  вниз
      freq-=stepFreq;                                           // шаг изменения частоты
      if(freq<0) freq=0;                                        // проверка на выход  за 0 
      bool success = SetPinFrequencySafe(led, freq);            // установить частоту  freq  на указанном пине led   
      delay(100);                                               // задержка от дребезга 
    }
    if(digitalRead(key_up)){                                    // если нажата кнопка вверх        
      freq+=stepFreq;                                           // прирощение частоты
      if (freq >8000000)freq=8000000 ;                          // если частота > 8 MHz  то всегда 8 MHz   
      bool success = SetPinFrequencySafe(led, freq);            // установить частоту  freq  на указанном пине led 
      delay(100);                                               // задержка от дребезга 
    }  
  }
  //---------------------------  изменение PWM    ------------------------------------------------------------------------------------------------------
  if (flag==1) {                                                // флаг выборов режима настройки ШИМ или Частоты
    if(digitalRead(key_down)){                                  // если нажата кнопка вниз  
      PWM=PWM-1;                                                // уменьшение на 1 %
      if(PWM<0) PWM=100;                                        // проверка на достижение 0%
      delay(100);                                               // задержка от дребезга
    }
    if(digitalRead(key_up)){                                    // если нажата кнопка вверх  
      PWM=PWM+1;                                                // увеличим на  1%
      if(PWM>100) PWM=0;                                        // проверка превышения 100%
      delay(100);                                               // защита от дребезга 
    }  
  }      
  //------------------------- изменение разряда для редактирования  частоты   --------------------------------------------------------------------------
  if(digitalRead(key_ok)) {                                    // нажата кнопка "ok" переключение разряда выбора частоты 
    delay(100);                                                // защита от дребезга
    hag++;                                                     // прирощение hag
    if(hag>=7) hag=0;                                          // проверка на превышение диаппазона
  } 
  
  long freqX=freq*(overclock/16.0);                            // расчет частоты  при частоте кварца  отличном от 16 мГц 
  
  // выводим уровень ШИМ -------------------------------------------------------------------------------------------------------------------------------        
  display.setTextSize(1);                                     // отображение % PWM (скважности) вверху между полосками 
  display.setCursor(21,5);                                    //
  display.print("PWM=");                                      //
  display.print(PWM);                                         //
  display.print("%");                                         //

  // рисуем полосочки уровня ШИМ------------------------------------------------------------------------------------------------------------------------
  display.drawLine(41-(41*PWM/100.0),  0, 42+(41*PWM/100.0),  0, BLACK);
  display.drawLine(42-(41*PWM/100.0),  1, 41+(41*PWM/100.0),  1, BLACK);
  display.drawLine(43-(41*PWM/100.0),  2, 40+(41*PWM/100.0),  2, BLACK);
  display.drawLine(41-(41*PWM/100.0), 16, 42+(41*PWM/100.0), 16, BLACK);
  display.drawLine(42-(41*PWM/100.0), 15, 41+(41*PWM/100.0), 15, BLACK);
  display.drawLine(43-(41*PWM/100.0), 14, 40+(41*PWM/100.0), 14, BLACK);
  // готовимся для вывода частоты    ------------------------------------------------------------------------------------------------------------------
 
  // рисуем частоту------------------------------------------------------------------------------------------------------------------------------------ 
    display.setTextSize(2); display.setCursor(4, 20);  
  if(freqX<1000)  {display.setCursor(18, 20); display.print(freqX);}    // выводим частоту    999  Hz 
  if(freqX>=1000 && freqX<10000)  { display.print(freqX/1000.0,   3);}  //                  1-10   kHz 
  if(freqX>=10000&&freqX<100000)  { display.print(freqX/1000.0,   2);}  //                 10-100  kHz 
  if(freqX>=100000&&freqX<1000000){ display.print(freqX/1000.0,   1);}  //                100-1000 kHz   
  if(freqX>=1000000)              { display.print(freqX/1000000.0,3);}  //                >   1    mHz
 
  if(freqX <10000 )                   { display.setTextSize(1); display.setCursor(64, 20); display.print("   ") ;}                               // очищаем место
  if(freqX >=10000 && freqX <100000)  { display.setTextSize(1); display.setCursor(64, 20); a=freq/10  ; b=a; c=(a-b)*10   ;display.print(c,0);}  // выводим 1хх герцы
  if(freqX >=100000 && freqX <1000000){ display.setTextSize(1); display.setCursor(64, 20); a=freq/100 ; b=a; c=(a-b)*100  ;display.print(c,0);}  // выводим 11х герцы
  if(freqX >=1000000)                 { display.setTextSize(1); display.setCursor(64, 20); a=freq/1000; b=a; c=(a-b)*1000 ;display.print(c,0);}  // выводим 111 герцы
 
  if(freqX >=1000 && freqX<1000000 )  { display.setTextSize(1); display.setCursor(64, 28); display.print("K") ; } // выводим еденицу измерения
  if(freqX >=1000000 )                { display.setTextSize(1); display.setCursor(64, 28); display.print("M") ; } // 
                                        display.setTextSize(1); display.setCursor(70, 28); display.print("Hz");   //
 //----------------------------------------------     строка множетеля    ----------------------------------------------------------------------------- 
  // выводим строку статуса (режима)                           
  display.setCursor(0,40);                                     //  установка курсора
  display.setTextSize(1);                                      //  выбор размера шрифта
  display.print(">>");                                         // 
  display.setTextColor(WHITE, BLACK);                          //  установка инверсии для
  display.print(" ");                                          //
  if(hag<6) display.print("x");                                // 
  
  if(hag==0) {                                                 // выбор множителя частоты х1,0        
    display.print(1*(overclock/16.0),1); 
    stepFreq=1; flag=0; }
  if(hag==1){                                                  //выбор множителя частоты х10
    display.print(10*(overclock/16.0),0); 
    stepFreq=10; }
  if(hag==2){                                                  //выбор множителя частоты х100
    display.print(100*(overclock/16.0),0); 
    stepFreq=100; }
  if(hag==3){                                                 //выбор множителя частоты х1000
    display.print(1000*(overclock/16.0),0); 
    stepFreq=1000;}  
  if(hag==4){                                                 //выбор множителя частоты х10000
    display.print(10000*(overclock/16.0),0); 
    stepFreq=10000;   } 
  if(hag==5){                                                 //выбор множителя частоты х100000
    display.print(100000*(overclock/16.0),0); 
    stepFreq=100000;   } 
  
  if(hag==6){                                                 //выбор  PWM
    display.print("PWM "); display.print(PWM); display.print("%"); 
    flag=1;
  } 
  
  display.print(" ");
  display.setTextColor(BLACK);
  display.setCursor(70,40);
  display.print("<<");
  //--------------------------------------------------------   конец строки  множетеля   ---------------------------------------------------------------------------------------
  // выставили ШИМ
  pwmWrite(led, PWM*2.55);                                      // расчет множителя коэфициента заполнения и вывод через пин led
  delay(200);                                                   // ожидание
  display.display();                                            // вывод на экран
}
//==========================================================     конец функции Generator()     =================================================================================
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Рисуем меню DDS-генератора
void DDSGeneratorMenu() { // я думаю, что эта функция не нужна, разберусь позже.... [Electronik83]
  display.clearDisplay(); 
  if (ddsMenu==0) display.setTextColor(WHITE, BLACK); else display.setTextColor(BLACK);
      display.setCursor(21, 0); display.println(" Синус ");
  if (ddsMenu==1) display.setTextColor(WHITE, BLACK); else display.setTextColor(BLACK);
      display.setCursor( 3,10); display.println(" Треугольник ");
  if (ddsMenu==2) display.setTextColor(WHITE, BLACK); else display.setTextColor(BLACK);
      display.setCursor(24,20); display.println(" Пила ");
  if (ddsMenu==3) display.setTextColor(WHITE, BLACK); else display.setTextColor(BLACK);
      display.setCursor(12,30); display.println(" АнтиПила ");
      display.setTextColor(BLACK);
      display.display();
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// DDS генератор
void DDSGenerator(){
  if(ddsMenu==0) {
    DDSGeneratorMenu();    // вывод  меню
    while(!digitalRead(key_up) && !digitalRead(key_down) && !digitalRead(key_ok)) {
      PWM=sinM[d];
      pwmWrite(dds,PWM);
      d++;
      if(d==32) d=0;
    }
    ddsMenu++;
    delay(200);
  }
  if(ddsMenu==1) {
    DDSGeneratorMenu();    // вывод  меню
    while(!digitalRead(key_up) && !digitalRead(key_down) && !digitalRead(key_ok)) {
      PWM=trianglM[d];
      pwmWrite(dds,PWM);
      d++;
      if(d==32) d=0;
    }
    ddsMenu++;
    delay(200);
  }
  if(ddsMenu==2){
    DDSGeneratorMenu();    // вывод  меню
    while(!digitalRead(key_up) && !digitalRead(key_down) && !digitalRead(key_ok)) {
      PWM=pilaM[d];
      pwmWrite(dds,PWM);
      d++;
      if(d==32) d=0; 
    }
    ddsMenu++;
    delay(200);
  }
  if(ddsMenu==3){
    DDSGeneratorMenu();    // вывод  меню
    while(!digitalRead(key_up) && !digitalRead(key_down) && !digitalRead(key_ok)) {
      PWM = RpilaM[d];
      pwmWrite(dds,PWM);
      d++;
      if(d==32) d=0; 
    }
    ddsMenu=0;
    delay(200);
  }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/*
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
#define int_on() PCMSK1=(1<<PCINT9)|(1<<PCINT10)|(1<<PCINT11); PCICR=(1<<PCIE1);
//включить прерывание PCINT1, выбор пинов прерывания A1,A2,A3
#define int_off() PCMSK1=0; PCICR=0; //отключить PCINT1

void volt_meter() {
ADCSRA=(1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0);
ADCSRB=0; DIDR0=48; int_on();
float ain,vcc;  String ainstr,vccstr;
lcd.clrScr(); lcd.setFont(SmallFont);
lcd.print("Volt meter",LEFT, 0);
while(1){
ADMUX = (1<<REFS0)|(1<<MUX3)|(1<<MUX2)|(1<<MUX1); //Vcc measure
delay(1); vcc=(float)(1.1*65472) / analog_func();
vccstr=String("Vcc= "+String(vcc,3)+" v  ");
lcd.print(vccstr,LEFT, 40);
ADMUX = (1<<REFS0)|(1<<MUX2); //A4 measure
delay(1); ain= analog_func()*vcc /65472 ; 
ainstr=String("Ain4= "+String(ain,3)+" v  ");
lcd.print(ainstr,LEFT, 16);
ADMUX = (1<<REFS0)|(1<<MUX2)|(1<<MUX0); //A5 measure
delay(1); ain= analog_func() *vcc /65472 ; 
ainstr=String("Ain5= "+String(ain,3)+" v  ");
lcd.print(ainstr,LEFT, 24);
  };//end while
}//end volt meter

uint32_t analog_func(){
uint32_t adc_buff=0;
for (int n=0; n<=4095; n++ ) {
    ADCSRA |= (1<<ADSC);  
    while (bit_is_set(ADCSRA,ADSC));
    adc_buff += ADC;
   } return adc_buff>>=6;
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------

ISR (TIMER1_OVF_vect){ int_tic++; } // прерывание частотомера

void freq_meter(){
   lcd.clrScr();
   lcd.setFont(RusFont);
   lcd.print("Xfcnjnjvth",LEFT, 0);
  int_on();//включить прерывание PCINT1
  TIMSK1 = 1<<TOIE1;// подключить прерывание
  uint32_t freqm=0;// Переменная измерения частоты
  int_tic=0; TCNT1=0; TIFR1=0;//всё обнулить
while(1){
   TCCR1B=7;//тактировани от входа Т1
   delay(2000); TCCR1B=0;
   freqm= (((uint32_t)int_tic<<16) | TCNT1)/2; //сложить что натикало
   int_tic=0; TCNT1 = 0; 
   lcd.clrScr(); lcd.setFont(RusFont);
   lcd.print("Xfcnjnjvth",LEFT, 0);
   lcd.setFont(MediumNumbers);
   if (freqm <10000) { lcd.printNumI(freqm, CENTER, 8); lcd.setFont(RusFont); lcd.print("Uw",CENTER, 32 ); }
   if (freqm >=10000u && freqm < 1000000ul ) { lcd.printNumF( ((float)freqm/1000),3 ,CENTER, 8);lcd.setFont(RusFont);  lcd.print("rUw",CENTER, 32 ); }
   if (freqm >=1000000ul ) { lcd.printNumF( ((float)freqm/1000000ul),3 ,CENTER, 8); lcd.setFont(RusFont); lcd.print("vUw",CENTER, 32 ); }    
   }  
 }
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
// UART приемник   ----------------------------------------------------------------------------------------------------------------------------------------------------------
void TTL() {
  long SpeedUART[8]={1200,2400,4800,9600,19200,38400,57600,115200}; //массив со скоростями UART
  long speedTTL=SpeedUART[xUART];                              // установка скорости при входе в функцию (по умолчанию)
  display.clearDisplay();                                      // формирование экрана Терминала  
  display.setTextColor(WHITE, BLACK);                          //
  display.setCursor(0,0); display.println(" Терминал UART");   //
  display.setTextColor(BLACK);                                 // 
  display.setCursor(15,10); display.println("Скорость:");      //
  display.setTextColor(WHITE, BLACK);                          //
  display.setCursor(10,20); display.print("-");                // 
  display.setTextColor(BLACK);                                 //
  display.println(" "); display.print(speedTTL);display.println(" ");
  display.setTextColor(WHITE, BLACK);                          //  
  display.setCursor(69, 20);  display.println("+");            //
  display.setTextColor(BLACK);                                 //
  display.setCursor(9,40); display.println("ОК - запуск");     //
  //------------------------------- организация выбора скорости из массива скоростей  --------------------------------------- 
   if(digitalRead(key_up))   {xUART++;delay(100);}              //  если нажат +
   if(digitalRead(key_down)) {xUART--;delay(100);}              //  если нажат - 
  
   if(xUART<0) xUART=0;                                         // проверки на пределы массива      
   if(xUART>7) xUART=7;                                         //
   speedTTL=SpeedUART[xUART];                                   // из массива в переменную
  
    if(digitalRead(key_ok)) {                                   // если нажата "OK"
    Serial.begin(speedTTL*(16/overclock));                      // установить скорость UART
  //-------------------------------------------------------------------------------------------------------------------------
    display.clearDisplay();                                     // очистка экрана
    delay(100);                                                 // ожидание
    display.display();                                          // вывод на дисплей  
    int x=0;                                                    // объявляем локальную переменную 
    int y=0;                                                    // объявляем локальную переменную 
   
    while(1){                                                   // выполняем в цикле  
      char incomingBytes;                                       // объявляем локальную переменную 
      if (Serial.available() > 0){                              // Если в буфере есть данные
        incomingBytes=Serial.read();                            // Считывание байта в переменную incomeByte
        display.setCursor(x,y);                                 // установить курсор
        display.print(incomingBytes);                           // Печать строки в буффер дисплея
        display.display(); x=x+6;                               // вывести на экран, сместить по X
        if(x==84){x=0;y=y+8;}                                   // проверка на предел по горизонтали
        if(y==48) {                                             // проверка на предел по вертикали
          x=0;y=0;                                              // при достижении предела обнуляем 
          display.clearDisplay();                               // очистка дисплея
          delay(100);                                           // ожидание
          display.display();                                    // выводим на дисплей
        }
      }         
    }
  } 
  delay(100);  
  display.display();  
}// --------------- конец TTL  ----------------------------------------------------------------------------------------------------------------------------------------------------
 /*
  //При 1-м включении запомнить в EEPROM длину разверстки
    mode = EEPROM.read(0);    // читаем режим из еепром
    if (mode =! 1) {          // закомментировать если не программируется
    mode = 1;                 // проверяем значение в еепром
     EEPROM.write(1, razv);
     EEPROM.write(2, SinU);
     EEPROM.write(3, menu);
     EEPROM.write(4, s_mno);
     EEPROM.write(5, lcd);
     EEPROM.write(0, mode);              // пишим его в еепром
    }         
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//  функция чтения установок из EEPROM
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    void reads(){
    razv = EEPROM.read(1);    // читаем длину разверстки из еепром
    SinU = EEPROM.read(2);    // читаем режим разверстки из еепром
    menu = EEPROM.read(3);    // читаем menu из еепром
    s_mno = EEPROM.read(4);
    lcd = EEPROM.read(5);     // читаем режим подсветки из еепром
    }
 */ 
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 а я собрал 2 спектрума. запустил  и через 2 недели купил себе   P486 dx100 ( 1996 г. я тогда писал на клиппере )

to Stashevskiy68 и всем всем всем :)

Помоги разобраться, цикл чтения АЦП:

     while ((ADCSRA & 0x10)==0); // ждем готовность АЦП
     ADCSRA|=0x10;               // сбрасываем бит готовности результата АЦП

в этом коде я давно уже удалил sinX и meaX, они тут не нужны

А про спектрумы - в другой может ветке...

Блин, и это ваще какая то старая версия моего кода. я ж просил автора обновить...

Чёт просто белый экран. Ладно не буду вас больше мучить, всем спасибо! буду разбиратся, по ходу чёт не так с ардуинкой.

проверь в инициализации дисплея  порядок  ног для дисплея. строка 31. укажи  свое подключени.

                                          // (clk(scl), din(sda), dc, ce, rst)      

да так же как и в скетче автора

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

Если есть какая то картинка на экране и не тормозит - с кварцем проблем нет.

А так кварц можно проверить, загрузив в ардуинку пример blink.

только-что залил свой подправленный код -работает.

Если это мне - то и у меня все работает. Только не понимаю, почему в датащите написано одно, а по факту выходит по-другому. Как будто бит ADIF инвертирован получается...

P.S. Хочу с нуля переписать код, во всем разобраться, вплоть до бита и FFT (анализатор спектра) еще реализовать.. Будет ваще клёвая игрушка для электронщиков...

про  АЦП  это не ко мне. я только начал разбираться с ардуиной. а анализатор АЧХ это нужная вещь. я пока интерфейсом занимаюсь и прикручиваю разные, нужные мне для работы функции  и пытаюсь адаптировать под другие дисплеи.  у моего коллеги полно сименсовских с55. да и цветных пара десятков но он больше "по железу".  

для Electronik83.  по низкому уровню ты к dimax обратись. посмотри его форум (на этом сайте)по генератору с энкодером.

Спасибо за ответ и советы. Буду сам значит разбираться.

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

Но есть ещё свежее.. Если интересно кому, могу сюда бросить...

Electronik83    Интересно!!! Да же очень.

Привет.

Извини я тогда php c Деневером работал, бросил свежую прошивку на него вместо хостинга!)

Все исправил теперь на сайте прошивка с автодетектом.

Привет, обид нет я смотрю на многие работы которые писал раньше и стыд берет.

Но это не проблема, скилл не стоит на месте.

Это и придает еще больше интереса процессу когда стараешься не просто написать а сделать это лаконично и масштабировано.

Это как я от китайцев корпус для пултоскопа!)

Заказал на свою голову несколько металлических коробок с таким треком который только по Китаю отслеживается.

В том году еще, хотел новый классный корпус, под него и прошивочку.

А то получается что у меня самый убогий по внешнему виду.

bodriy2014, привет! Зато самый функциональный)) Думаю, это важнее!

Где то на форумах читал, что типа oled ssd1306 мелкий и на нем ниче не видно, по сравнению с диплеем от нокии. Да нефига подобного!
Вдоволь наигравшись с олед дисплеем, я достал пультоскоп на нокиевском дисплее. И блин. Небо и земля. Олед дисплей гараздо лучше. Хоть он и мелкий, и зрение у меня не очень - на нем все видно лучше.

Олед лучше и больше инфы влазит.

Но они жрут 50% оперативки(((

Можно на лету инфу выводить, без буфера экрана. И быстрее обновление экрана получается.

Осталось написать библиотеку.!)

Да тут библиотеку толком не напишешь. Тут работа с байтами / битами в основном.

Один хороший человек заморочился и написал

OzOLED.h Без буфера и жрет мало оперативки.

Жаль что она давно не поддерживается, и по сугубо моим наблюдениям работает не стабильно.

для Electronik83. болел не подходил к компьютеру. в последней "бета" прошивке которую Вы мне на почту кидали входы на каких пинах ? осцилограф не реагирует на сигнал по А3.