// Set up potentiometer pin
#define POT_PIN A3

// Set up clock out pin
#define CLC_OUT 9

// Set up free pin (для ловли наводок)
#define FREE_PIN A1

// Set up random out pin (выход данных)
#define RANDOM_OUT 10

// Set up MFM out pin (выход МЧМ)
#define MFM_OUT 2

 int RND = 0;    // текущий бит данных
 int RND_OLD = 0; // предыдущий бит данных
 unsigned int POT = 20;     // полпериода в микросекундах
 int MFM = 0;   // текущий бит МЧМ

 unsigned int arr[100];  // массив случайных чисел
 int i=0;
 int j=0;

 unsigned long time;


 void setup() {
  // put your setup code here, to run once:

// Set ADC mode
  // Регистр настройки мультиплексора
     ADMUX  = 0b01000011; // 0B0100011 - опорное Uпит (первые 01), 10 bit (3-й 0), A3 (последние 0011)
  // Регистр статуса и контроля
     ADCSRA = 0b11110011; // CLK/8 - ускоряем АЦП - в 8 раз ниже частоты процессора (32/8=4МГц)

// Set up pins as input
  pinMode(POT_PIN, INPUT);
  pinMode(FREE_PIN, INPUT);

// Set up pins as outputs
  pinMode(CLC_OUT, OUTPUT);
  pinMode(RANDOM_OUT, OUTPUT);
  pinMode(MFM_OUT, OUTPUT);

  digitalWrite(MFM_OUT, MFM);

  randomSeed(analogRead(FREE_PIN));

  // для пинов 9 и 10 (таймер1) - для 10 кГц вроде не обязательно
  // TCCR1A = 0b00000001;  // 8bit
  // TCCR1B = 0b00001001;  // x1 fast pwm - 62.5 кГц - для UNO и 125 кГц - для LGT8F328P

  time = micros();
 
}


  // Main loop - put your main code here, to run repeatedly:

  void loop() {  // до 30 кГц без задержек на random и ускорением чтения потенциометра

  for(i = 0; i < 100; i++){ // в массиве будет 100 элементов    //
  arr[i] = random(65536); // заполним массив случайными числами   // Чтобы потом в цикле не вносить задержек
  }
 
  while(true){   // бесконечный цикл для основной программы


     while(micros()-time < POT+10){
     }
    time = micros();

  digitalWrite(CLC_OUT, HIGH);  // переключаем СLC на HIGH - тактовая частота, желателен меандр

  RND = bitRead(arr[i], j);             // чтение битов массива

    digitalWrite(RANDOM_OUT, RND);          // вывод случайных данных на 10-й пин

  if (RND < 1 && RND_OLD < 1) digitalWrite(MFM_OUT, !digitalRead(MFM_OUT)); // смена логического уровня МФМ в начале 
                                                                           // бита данных, если второй 0 подряд
                   
   j=j+1;           //
   if(j > 15) {     // последовательное чтение
   j = 0;           // битов из массива
   i=i+1;           // (быстрее, чем random (2))
   }                 //     
   if(i > 99) i = 0;

   // POT = analogRead(POT_PIN);        // чтение потенциометра
   // POT = map(POT, 20, 1000, 1, 512); // масштабируем до диапазона 1 ... 512
   // POT = constrain(POT, 1, 512);     // ограничиваем диапазон, чтобы исключить выбросы

       while(micros()-time < POT+10){
     }
    time = micros();

  digitalWrite(CLC_OUT, LOW); // переключаем СLC на LOW - тактовая частота, желателен меандр

  if (RND > 0) digitalWrite(MFM_OUT, !digitalRead(MFM_OUT));  // переход уровня МФМ при 1 данных по спаду CLC -
                   // в середине бита, т.е. CLC должен быть меандром
    RND_OLD = RND;
   
    //  POT = analogRead(POT_PIN);   //
    // POT = map(POT, 20, 1000, 1, 512);  // 25 мкс
    // POT = constrain(POT, 1, 512);    // поэтому пока отключил

   } // закрыли while

} // закрыли loop

// Set up clock out pin
 #define CLC_OUT 8   // PORTB нулевой бит PBO

 unsigned long time;

 void setup() {

// Set up pins as outputs
  pinMode(CLC_OUT, OUTPUT);

  time = micros();

}

  void loop() {

   label:

   PORTB |= (1 << 0);

   while(micros()-time < 20){
   }

   time = micros();

   PORTB &= ~(1 << 0);

   while(micros()-time < 20){
   }

   time = micros();

   goto label;

} // закрыли loop

// Получение последовательности псевдослучайных данных с регулируемой внешним потенциометром
// стабильной частотой (без джиттера) от 900 Гц до 20 кГц.

// Set up potentiometer pin
 #define POT_PIN A3

// Set up clock out pin
 #define CLC_OUT 9      // PORTB первый бит PB1

// Set up random out pin (выход данных)
 #define RANDOM_OUT 10  // PORTB второй бит PB2

 byte RND = 0;          // текущий бит данных

 int GEN=650;
 bool XOR=1;

 unsigned int POT = 10;
 // unsigned int m=30; // считал, что 20 мкс - это 160 тактов при частоте 8 МГц, но получилось 30 (?)
 // unsigned int POT_PLUS = POT + m; // добавка для выравнивания меандра

 unsigned int l=0;

 void setup() {

// Set up pins as input
  pinMode(POT_PIN, INPUT);

// Set up pins as outputs
  pinMode(CLC_OUT, OUTPUT);
  pinMode(RANDOM_OUT, OUTPUT);

 }

   void loop() {

   noInterrupts();

   label:               // до метки заполнялся массив случайных данных, пришлось убрать

   XOR=bitRead(GEN, 14)^bitRead(GEN, 13);  //
   GEN=GEN<<1;               // псевдослучайная последовательность на переменной GEN (аналог LFSR)
   bitWrite(GEN, 0, XOR);         // более стабильная, чем random (фронты CLC не дрожат)

   RND=bitRead(GEN, 15);         // "случайные" биты данных

   // RND = analogRead(A1)&0b1;            // 23-24 мкс, тоже без джиттера, но нужен шум на А1

   PORTB |= (1 << 1);                      // фронт CLC

   // Вывод данных

   // digitalWrite(RANDOM_OUT, RND);       // вывод данных на 10-й пин - около 3 мкс, сильный джиттер

   if (RND < 1) PORTB &= ~(1 << 2); // установить 0 в бите 2 (10-й пин), всего за пару микросекунд
   else PORTB |= (1 << 2);          // установить 1 в бите 2 (10-й пин)


   POT = analogRead(POT_PIN);              // "чтение" потенциометра - 23-24 мкс

   POT=POT/4*3;               // уменьшил, чтобы приблизить мин. частоту к 1 кГц

   for (l = 0; l < POT; l++) {             // задержка, определяемая потенциометром
   asm ("nop");
   }

   PORTB &= ~(1 << 1);                     // спад CLC

   for (l = 0; l < POT+30; l++) {          // добавка +30, чтобы приблизить CLC к меандру (не обязательно)
   asm ("nop");
   }

   goto label;

   interrupts();

} // закрыли loop

 
.
.
.
 PORTD |= (1 << 2);                  // фронт CLC

   if (RND < 1) PORTB &= ~(1 << 2); // установить 0 в бите PB2 (10-й пин) // вывод "случайных" данных
   else PORTB |= (1 << 2);               // установить 1 в бите PB2 (10-й пин) // пара микросекунд

    // int dat = (PINB & (1 << 3));      // не удлиняет период

    int dat = digitalRead(RANDOM_IN);  // плюс ещё пара микросекунд - чуть удлиняет период

   if (dat < 1) PORTD &= ~(1 << 5);   // установить 0 в бите PD5 (5-й пин) - трансляция c 3-го бита PB
   else PORTD |= (1 << 5);                // установить 1 в бите PD5 (5-й пин)

.
.
.

   PORTD |= (1 << 2);                  // фронт CLC

   if (RND < 1) PORTB &= ~(1 << 2);    // установить 0 в бите PB2 (10-й пин) // вывод "случайных" данных
   else PORTB |= (1 << 2);                   // установить 1 в бите PB2 (10-й пин) // пара микросекунд

     for (int k = 0; k < 5; k++) {     // задержка перед считыванием данных (надёжность записи)
     asm ("nop");                           // нужна для срабатывания int dat = (PINB & (1 << 3));
     }                                           //

     int dat = (PINB & (1 << 3));

   // int dat = digitalRead(RANDOM_IN);    // работает нормально, не требует задержки, +2 мкс

   if (dat < 1) PORTD &= ~(1 << 5);         // установить 0 в бите PD5 (5-й пин) - трансляция c 3-го бита PB
   else PORTD |= (1 << 5);                      // установить 1 в бите PD5 (5-й пин)

const byte pinCoarse = A0;
const int32_t CoarseStep = 200ul;
const byte pinFine = A1;
const byte MaxCount = 16;
const uint32_t FreqMax = 140000ul;


void inline setWave(uint32_t fr) {
  //собствеенно включение генератора. комментировать нечего
  if (fr > 1000) {
    uint16_t ht = 8000000L / fr; //тиков на полпериода
    TCCR1A = 0b10001110;//COM1A1:COM1A0:COM1B1:COM1B0:X:X:WGM11:WGM10
    TCCR1B = 0b00011001;//X:X:X:WGM13:WGM12:CS12:CS11:CS10
    // ИТОГО канал только А, режим 14 (FastPWM TOP=ICR1), нон инвертинг, частота 16МГц /64 =250КГц
    ICR1 = (uint16_t) (ht << 1);
    OCR1A = (uint16_t)(ht);
  }
  else {
    uint16_t ht = 1000000L / fr;
    TCCR1A = 0b10001110;//COM1A1:COM1A0:COM1B1:COM1B0:X:X:WGM11:WGM10
    TCCR1B = 0b00011010;//X:X:X:WGM13:WGM12:CS12:CS11:CS10
    // ИТОГО канал только А, режим 14 (FastPWM TOP=ICR1), нон инвертинг, частота 16МГц /8 =2 МГц
    ICR1 = (uint16_t) (ht << 1);
    OCR1A = (uint16_t)(ht);
  }

}

void setup() {
  pinMode(9, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  static byte count = 0;
  static uint16_t valueCoarse = 0;
  static uint16_t valueFine = 0;

  int32_t fr = 100;

  valueCoarse += analogRead(pinCoarse); //Усредняем ЦАП за MaxCount измерений
  valueFine   += analogRead(pinFine  ); //Усредняем ЦАП за MaxCount измерений
  count++;

  if (count == MaxCount) {
    //вычисляем частоту грубый режим по 200 Гц, начиная со 100, точный - по одному
    fr = CoarseStep * map(valueCoarse / MaxCount, 0, 1023, 1, FreqMax / CoarseStep) +
         map(valueFine / MaxCount, 0, 1023, -CoarseStep / 2, CoarseStep / 2);

    setWave(fr);
   
    //просто вывод значений, желающие переделывают на экранчик ;))
    Serial.print(" Freq=");
    Serial.print(fr);
    Serial.println();

    valueCoarse = 0;
    valueFine = 0;
    count = 0;
  }
  delay(10);
}

 

.
.
.

if (DAT < 1 && DAT_OLD < 1) {
      PORTD = PORTD^0b01000000;         // в начале бита данных, если второй 0 подряд

      MFM = PIND & (1 << 6);

      if (MFM < 1) PORTB = PORTB & 0b11111100; // 0 - в PB0 и PB1 (операция И меняет 2 младших бита)
      else {
       if (SIDE < 1) PORTB |= (1 << 0);                // 1 в PB0 (на левой стороне)
       if (SIDE > 0) PORTB |= (1 << 1);                // 1 в PB1 (на правой стороне)
       SIDE = 1.3 - SIDE;            // округление до целого числа (меняем сторону)
      }
   }

.
.
.

   if (DAT > 0) {
    PORTD = PORTD^0b01000000;           // в середине бита, т.е. CLC должен быть меандром

     MFM = PIND & (1 << 6);
   
      if (MFM < 1) PORTB = PORTB & 0b11111100; // 0 - в PB0 и PB1 (операция И меняет 2 младших бита)
      else {
       if (SIDE < 1) PORTB |= (1 << 0);                // 1 в PB0 (на левой стороне)
       if (SIDE > 0) PORTB |= (1 << 1);                // 1 в PB1 (на правой стороне)
       SIDE = 1.3 - SIDE;            // округление до целого числа (меняем сторону)
      }
   }
.
.
.

#include <avr/interrupt.h> // обслуживание прерываний

#define outdat 8 // вместо D8 ставим соотвествующий (любой из возможных) номер вывода адуринки
#define outclock 10 // OC1A = D9/PB1, OC1B = D10/PB2 возможные варианты вывода
                 // сигнала Clc (OC1A при ICR=периоду, OC1B при OC1A=периоду)
volatile unsigned int tmpClc; // РВХ данных периода
volatile unsigned int tmpPwm; // РВХ данных активной части Clc (ШИМ)
// volatile byte tmpOut; // буфер данных для вывода на линию данных
volatile byte FqClc; // флаг запроса смены параметров тактового сигнала
            // активный уровень = 1
volatile byte FqRnd; // флаг запроса обработчика для очередного вывода данных
            // в tmpOut (на линию outdat в следующих циклах Clc)

volatile byte cnt = 0; // for test

#define hasm0 1
#define hasm2 0b01000000

void rndmod();

union {
 uint64_t bigdat;
 struct {
  byte vdat0;
  byte vdat1;
  byte vdat2;
  byte vdat3;
  byte vdat4;
  byte vdat5;
  byte vdat6;
  byte vdat7; }lowdat;
} recodum;

//----------

void setup() {
   // put your setup code here, to run once:
 pinMode(outdat, OUTPUT); digitalWrite(outdat, LOW);
 pinMode(outclock, OUTPUT); digitalWrite(outclock, LOW);
 // настройки таймера Т1 для работы
 // период задан по OCR1A, ШИМ 50% определен в OCR1B
 // для вывода Clc задан OC1B = D10/PB2
 // для outdat может выбираться любой из свободных  цифровых
 cli();
 TCCR1A = (1<<COM1B0) | (1<<COM1B1) | (1<<WGM10);
 TCCR1B = 1<<WGM13; // только режим! таймер остановлен
          // 1<<CS10 = пуск таймера с  clkI/O/1 (No prescaling)
          // 1<<CS11 = пуск таймера с clkI/O/8 (From prescaler)
 TIMSK1 = (1<<OCIE1A) | (1<<TOIE1);
 // загрузка начального нижнего значения (20000 единиц clkI/O/8 на 1 период) частоты в РВХ
 tmpClc = 20000/2; tmpPwm = tmpClc>>1; FqClc = 1;
 rndmod(); // загрузка данных в recodum.lowdat.vdat0 (tmpOut)
 sei();
 TCCR1B = TCCR1B | 1<<CS11; // пуск таймера Т1 0.000000062*8=0.0000005
}

//----------

void loop() {
   // put your main code here, to run repeatedly:

   if(FqRnd){
    rndmod(); cnt++;
    if(cnt == 10){
       tmpClc = tmpClc - cnt; cnt = 0;
       if(tmpClc <= 150){ tmpClc = 20000/2; }
       tmpPwm = tmpClc>>1;
       FqClc = 1;
      }
    FqRnd = 0;
   }
}

//----------

ISR(TIMER1_COMPA_vect){
   if(FqClc){OCR1A = tmpClc; OCR1B = tmpPwm; FqClc = 0;}
}

ISR(TIMER1_OVF_vect){
   digitalWrite(outdat, bitRead(recodum.lowdat.vdat0, 0));
   if(!FqRnd){   FqRnd = 1;}
}

void rndmod()
{
 byte tmpa, tmpb;
 if(recodum.bigdat == 0){recodum.bigdat = UINT64_MAX;}
 tmpa = recodum.lowdat.vdat0 & hasm0;
 if(tmpa){tmpa = 0xFF;}
 tmpb = recodum.lowdat.vdat2 & hasm2;
 if(tmpb){tmpb = 0xFF;}
 tmpa = tmpa ^ tmpb;
 recodum.bigdat = recodum.bigdat >> 1;
 if(tmpa){bitWrite(recodum.lowdat.vdat7, 7, 1);}
  else {bitWrite(recodum.lowdat.vdat7, 7, 0);}
}

//----------**********************----------

//---------- файла/end of file---------------------