Как разделить высокую входную частоту на 1,25, как в старой TTL-логике Arduino?

oscillator-clock

В современном хронометрировании существует опорная частота 10 МГц (или любая степень 10). Цифровые часы принимают только частоту 32768 Гц (или другую возможную степень двойки).

Проблема в том, как правильно преобразовать степень 10 в степень 2. Это делается серией делителей 1,25 (каждые 5 входов выводят 4) и 2,5 (каждые 5 входов выводят 2).

Мне интересно, как это можно сделать с помощью Arduino. У меня высокая входная частота, скажем, 1 МГц, поэтому мне приходится использовать регистры напрямую. Тогда у меня есть выходная частота 1/2 (счетчик 2) входной и 1/4 входной частоты, и я хотел бы иметь выходную частоту 4/5 входной (деление на счетчик 1,25). Итак, нужны ли мне 3 выходных контакта: 1 для счета двоек, один для четверок и один для пятерок? Или это можно как-то сделать, используя 1 входной контакт и 1 выходной контакт с входной частотой 4/5?

Я пытался изменить код, но не могу сказать, как пропустить каждый пятый цикл. Допустим, в цепочке этих счетчиков я могу получить частоту от 1 000 000 Гц: 1000000 Гц - 800000 Гц - 640000 Гц - 512000 Гц - 409600 Гц - 327680 Гц - 2262144 Гц поэтому вход = степень десяти, затем выход = степень двойки Мой вопрос: насколько высокой может быть максимальная входная частота для этого кода? и можете ли вы помочь мне изменить этот код?

/*
 * From one square wave generate 3 waves 1/2, 1/4 and 4/5 of the original frequency.
 *
 * Original sketch tried to be modified from here:
 *
 * https://arduino.stackexchange.com/questions/63202
 *                               _   _   _   _   _   _   _   _   _   _
 *  input:  digital 13 = PB7    / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/  1 000 000 Hz
 *                              R1F0R1F0R1F0R1F0R1F0R1F0R1F0R1F0R1F0R1F0R
 *                               ___     ___     ___     ___     ___
 *  output: digital 10 = PB4    /   \___/   \___/   \___/   \___/   \___/    500 000 Hz
 *                              R 1 F 0 R 1 F 0 R 1 F 0 R 1 F 0 R 1 F 0 R  
 *                               _______         _______         _______
 *  output: digital 11 = PB5    /       \_______/       \_______/       \    250 000 Hz
 *                              R   1   F   0   R   1   F   0   R   1   F
 *                               _   _   _   _       _   _   _   _   
 *  output: digital 12 = PB6    / \_/ \_/ \_/ \_____/ \_/ \_/ \_/ \_____/    800 000 Hz
 *                              R1F0R1F0R1F0R1F00000R1F0R1F0R1F0R1F00000R
 */

int main(void)
{
    DDRB = _BV(PB4) | _BV(PB5) | _BV(PB6) | ~_BV(PB7);  // PB4 PB5 PB6 как выходы и PB7 как вход
    for (;;) {
        loop_until_bit_is_clear(PINB, PB7);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB7);
        PORTB |= _BV(PB4);                              // поднимаем PB4

        loop_until_bit_is_clear(PINB, PB4);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB4);
        PORTB |= _BV(PB5);                              // повышение PB5

        loop_until_bit_is_clear(PINB, PB5);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB5);
        PORTB |= _BV(PB6);                              // повышение PB6

        loop_until_bit_is_clear(PINB, PB7);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB7);
        PORTB &= ~_BV(PB4);                             // падение PB4

        loop_until_bit_is_clear(PINB, PB7);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB7);
        PORTB |= _BV(PB4);                              // поднимаем PB4

        loop_until_bit_is_clear(PINB, PB4);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB4);
        PORTB |= ~_BV(PB5);                             // падение PB5

        loop_until_bit_is_clear(PINB, PB7);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB7);
        PORTB &= ~_BV(PB4);                             // падение PB4

        loop_until_bit_is_clear(PINB, PB7);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB7);
        PORTB |= _BV(PB4);                              // поднимаем PB4

        loop_until_bit_is_clear(PINB, PB4);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB4);
        PORTB |= _BV(PB5);                              // повышение PB5

        loop_until_bit_is_clear(PINB, PB5);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB5);
        PORTB |= ~_BV(PB6);                             // падение PB6

        loop_until_bit_is_clear(PINB, PB7);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB7);
        PORTB &= ~_BV(PB4);                             // падение PB4

        loop_until_bit_is_clear(PINB, PB7);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB7);
        PORTB |= _BV(PB4);                              // поднимаем PB4

        loop_until_bit_is_clear(PINB, PB4);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB4);
        PORTB |= ~_BV(PB5);                             // падение PB5

        loop_until_bit_is_clear(PINB, PB7);             // ждем увеличения входных данных
        loop_until_bit_is_set(PINB, PB7);
        PORTB &= ~_BV(PB4);                             // падение PB4
    }
}

---

Лично Ник Гамон: Я видел тебя здесь много раз. какая честь. Мне нужны исходные часы для многопланетных часов, без дробей. Наименьшее общее кратное для периодов секунды для: Земли, Марса, Титана.

Если я буду точно сохранять соотношение между планетами, то даже если земные часы, использующие резонатор Arduino, будут смещаться на несколько десятков секунд в день, часы Марса и часы Титана будут смещаться на такое же количество времени.

Для меня это не имеет значения, потому что, если я остановлю часы и подожду, все три планеты снова выровняются. Но если бы я не сохранял точное соотношение между планетами, например, Земля будет дрейфовать 30 секунд в день, Марс будет дрейфовать 31 секунду в день, а Титан будет дрейфовать 29 секунд в день - это зависит от того, насколько точное приближение я возьму. Таким образом, если остановить часы на 30 секунд, чтобы установить их правильно, Земля вернется к 0 секундам, но Титан будет отставать на 1 секунду, а Марс будет на 1 секунду раньше. Я бы не стал исправлять все три, просто остановив часы. Мне пришлось бы останавливать часы 3 раза индивидуально (по одному разу для каждой планеты, иначе ошибка для 2-х оставшихся планет со временем накопилась бы, даже если поправить Землю) И поверьте мне, вычислить марсианское время непросто (хорошо, потому что приложение НАСА уже существует), но время Титана у меня есть только в Excel, и его мне приходится пересчитывать при установке часов.

Периоды для Земли: 1 с, Марса 1,027 491 251 7 с, Титана 0,998 068 437 5 с,

Очевидно, что математика Arduino не точна максимум до 10 десятичных знаков. 32 байта, что составляет 0,000 000 000 2 и что-то... это от 2 до -32-й степени.

Параметры наименьшего общего кратного:
Земля:Марс = 291/299, Земля:Титан = 3624/3617
Земля:Марс:Титан = целое число:целое:1 054 584 (то есть 291 x 3624)

Итак, первый вариант - генерировать 1 054 584 Гц (я называю это золотым мегагерцем), что немного больше, чем 15 тактовых циклов Arduino =, если быть точным, 15 и 16 циклов должны чередоваться с некоторым правилом скачкообразного цикла (аналогично наше правило високосного года), чтобы получить эту частоту.

Найдите другую десятичную частоту, немного отличающуюся.

Вариант 1:
Земля:Марс = 812993/800000, а Титан может быть на 1/4 цикла меньше, поэтому 800 кГц

Вариант 2:
Земля:Марс:Титан = целое число:целое:3200000, поэтому 3,2 МГц (5 тактовых циклов) и Марс, Титан и Земля лучше совмещены,

Вариант 3: Частота 9600000 Гц (точно 5 тактов на Arduino Zero 48 МГц или 10 циклов на разогнанном Arduino Due 96 МГц) и идеальное выравнивание планет.

Эти параметры должны иметь 24-битный счетчик, до 16777216, а не только 16 байт. Если я не буду точно соблюдать соотношение, часы будут двигаться с разной скоростью, и поправить часы, чтобы остановить все три часа одновременно, будет недостаточно.

Каждый из них придется исправлять индивидуально (хотя на Земле будет самая большая ошибка из-за резонатора Arduino, некоторые остаточные ошибки из-за неточных соотношений будут накапливаться с течением времени, и время от времени придется останавливать дополнительные 2 тактовых генератора). и устанавливается индивидуально)

---

Кроме того, мне хотелось бы иметь что-то вроде календаря для каждой планеты. Какой самый быстрый и короткий способ его настроить? Земля: 365,2425 дней, Марс 668,592 дней и Титан 673,54388 дней. Для Земли у нас есть 365 плюс каждый 4-й прыжок, но не каждый 100-й прыжок, а каждый 400-й прыжок. Дни в месяце 31,28/29,31,30,31,30,31,31,30,31,30,31. Для Марса мы бы имели: 56,56,55,56,56,55,56,56,55,56,56,55/56, а также каждый нечетный и каждый 10-й прыжок (это 0,6), но не каждые 100 (это 0,59), но каждые 500 прыжков (это 0,592). Високосным месяцем будет 12-й месяц. Для Титана у нас будет 56,56,56,56,56,57,56,56,56,56,56,56/57, а также каждый нечетный и каждый 20-й прыжок (это 0,55), но не каждый 160-й прыжок ( это 0,54388). Кроме того, упомянутая продолжительность составляет не 1 день Титана, а 1/16 дня Титана, да, день Титана длится почти 16 дней. Итак, я хотел бы иметь что-то вроде «дней в сутках»; = 8-дневная неделя из 24 часов 60 минут 60 секунд из 0,98 вышеупомянутых земных секунд, а также неделя до полудня и после полудня. Восьмой день будет называться «День Земли и будет проходить между воскресеньем и понедельником». На Марсе у нас было бы 7 дней в неделе, как на Земле, и аналогичным образом: понедельник 1-го, вторник 2-го.... Но для Титана у нас было бы 16 раз 1-го числа: утро понедельника 1-го, утро вторника 1-го... утра. 1-го воскресенья, 1-го дня Земли, 1-го дня понедельника, 1-го понедельника, 1-го вечера вторника, ... 1-го вечера воскресенья, 1-го дня Земли, а затем 16 раз 2-го, ... снова с утра понедельника до полудня земного дня. Так мы можем разделить ужасно длинные 16-дневные сутки на недели и дни. есть ли у нас какая-нибудь разумная функция, такая как RTC, где я ввожу/вывожу (год, месяц, день, неделю, день недели, час, минуту, секунду), когда я ввожу/вывожу "unix-время" для Земли, Марса и Титана на основе разной длины секунд? У нас будут Unix Earth, Unix Mars и Unix Titan. Очевидно, что для Земли и Марса день недели и дата будут меняться одновременно, и нам не нужна «неделя». для Земли и Марса (это было бы отключено), а для Титана есть 8 дней недели, затем 2 недели, а затем 1 титановый день (длиной 2 недели), так что да, 16 дней в день и 673,54 из них, это почти 30 лет в году. формулы между Землей, Марсом и Титаном Unix-времени еще должны быть готовы, но как разбить это беззнаковое длинное Unix-время для каждой планеты на компоненты и еще один (недельный) компонент для Титана, день титана ужасно длинный, сделайте будний день (и неделя) здесь время, не день, а день в дне, и неделя в дне.

---

Ник Гамон, не хочу показаться неуважительным, это мой самый первый вопрос после нескольких лет чтения этих форумов.

В Arduino Uno r4 действительно существует возможность напрямую генерировать прерывания длительностью 1/256 секунды, поскольку для этого существует специальная библиотека, использующая встроенные часы RTC, которые уже являются частью этого Arduino.

К сожалению, хороший круглый кратный для Земли, Марса и Титана будет равен 3,2 миллиона Гц. Поскольку Arduino 4 представляет собой 32-битный процессор с частотой 48 МГц, он выполняет математические операции до 32 бит за один или два тактовых цикла. и 3,2 миллиона Гц будут ровно 15 тактовыми циклами, однако для прерывания это не так уж много циклов. Но 256 Гц — это вполне достаточно для 32-битного процессора с частотой 48 МГц, верно? Я не уверен, насколько точны эти часы RTC, нужно выяснить, как только я их получу. Этот Arduino uno R4 появился в магазине всего несколько дней назад и он совершенно новый и необычный. (32 бит, 48 МГц)

1/256 секунды — это 12500/3200000 секунды. так что, слава богу, 3,2 миллиона делятся на 256 без дроби.

Прилагаю пример документации Arduino r4:

https://docs.arduino.cc/tutorials/uno-r4-wifi/rtc #unix

#include "RTC.h"

const int LED_ON_INTERRUPT  = 22;

void setup(){
  RTC.begin();
  if (!RTC.setPeriodicCallback(periodic_cbk, Period::ONCE_EVERY_2_SEC)) {
    Serial.println("ERROR: periodic callback not set");
  }
}

void loop() {
}

void periodic_cbk() {
  static bool clb_st = false;
  if(clb_st) {
    digitalWrite(LED_ON_INTERRUPT,HIGH);
  }
  else {
    digitalWrite(LED_ON_INTERRUPT,LOW);
  }
  clb_st = !clb_st;
 
  Serial.println("PERIODIC INTERRUPT");
}

Период можно указать с помощью следующих перечислений:

ONCE_EVERY_2_SEC
ONCE_EVERY_1_SEC
N2_TIMES_EVERY_SEC
N4_TIMES_EVERY_SEC
N8_TIMES_EVERY_SEC
N16_TIMES_EVERY_SEC
N32_TIMES_EVERY_SEC
N64_TIMES_EVERY_SEC
N128_TIMES_EVERY_SEC
N256_TIMES_EVERY_SEC

---

Сейчас я также бьюсь над тем, как включить этот календарь из времени Unix, чтобы разбить его на отдельные компоненты для Земли, Марса и Титана. Время un ix началось 01.01.1970 00:00:00, unix Mars началось 01.01.192 00:00:00, а Titan Unix началось 01.01.13 в понедельник 00:00:00, но я бы хотел, чтобы первые годы можно было регулировать, потому что. В конечном итоге он выйдет за пределы диапазона через 136 земных лет, 72 марсианских года и примерно 4,6 лет Титана, поэтому мы могли бы повторно использовать его, сдвинув начальный год, и, кроме того, я хотел бы, чтобы он был действительным по крайней мере до 2323 года, поэтому только с разрешением 4 секунды, поскольку 300 лет имеют менее 2-х 32-х 4-секундных интервалов. Но от этого календаря у меня болит голова. Я видел библиотеку RTC, но не могу просто изменить числа, чтобы получить календарь Марса и Титана.

Причина, по которой я хотел бы это сделать, заключается в том, что в какой-то момент в будущем начнется человеческая колонизация Марса, а в более отдаленном будущем начнется человеческая колонизация Титана (спутника Сатурна) (уже есть Вертолет с ядерным двигателем, который будет работать в атмосфере Титана с высокой плотностью, низкой гравитацией и очень холодной средой, в 2034 году (дата уже одобрена НАСА, он взлетит в 2027 году, но, как вы можете предположить, полет займет 7 лет, чтобы охватить один миллиард миль, или 1,6 миллиарда километров до Сатурна), и план атомной подводной лодки, которая будет плавать в морях жидкого метана, не знаю когда, но концепция уже существует, ее температура близка к температуре жидкого азота, жидкий метан имеет температуру минус 180 градусов по Цельсию или около минус 300 градусов по Фаренгейту, поэтому отопление и изоляция должны быть идеальными) и для каждой планеты нам нужен другой календарь

---

Если бы мне нужно было построить ФАПЧ (фазовую автоподстройку частоты), то мне нужно было бы перейти от 32768 Гц ровно до 3,2 МГц (точно так же, как и кристалл с частотой 32768 Гц), на 5 раз умножив его на 2,5 то есть (умножить на 5 и разделить на 2). Лол, я не мог 5 раз умножить на пять, потому что я получил бы 102,4 МГц (а затем разделил бы их 5 раз на 2), и даже Arduino не была достаточно быстрой, чтобы поймать это прерывание. Но чистая логика TTL способна это сделать (при условии, что она может умножать на дроби, то есть 2,5 в 5-й степени)

---

Привет, ребята, ЖК-клавиатура Shield 1602 A совместима с какой библиотекой и какой Arduino? как должны быть установлены пины? Я просто не могу заставить это работать

// Подсчет секунд, прошедших на каждой планете.
volatile uint32_t earth_secs, mars_secs, titan_secs;

// Выполняется каждые 1024 мкс по прерыванию таймера.
ISR(TIMER0_COMPA_vect) {
    static uint16_t earth_ticks, mars_ticks, titan_ticks;
    earth_ticks += 16;
    if (earth_ticks >= 15625) {
        earth_ticks -= 15625;
        earth_secs++;
    }
    mars_ticks += 22;
    if (mars_ticks >= 22075) {
        mars_ticks -= 22075;
        mars_secs++;
    }
    titan_ticks += 34;
    if (titan_ticks >= 33139) {
        titan_ticks -= 33139;
        titan_secs++;
    }
}

uint32_t earth_seconds, mars_seconds, titan_seconds;

void update_planet_times() {
    // Вычисляем количество миллисекунд, прошедших с момента последнего обновления.
    static uint32_t last_update;
    uint32_t now = millis();
    uint32_t elapsed_millis = now - last_update;
    last_update = now;

    // Обновляем земное время. 1 земная секунда = 1000/1 мс.
    static uint32_t earth_ticks;
    earth_ticks += elapsed_millis * 1;
    uint32_t elapsed_earth_seconds = elapsed_earth_ticks / 1000;
    earth_ticks -= elapsed_earth_seconds * 1000;
    earth_seconds += elapsed_earth_seconds;

    // Обновляем марсианское время. 1 марсианская секунда = 763426/743 мс.
    static uint32_t mars_ticks;
    mars_ticks += elapsed_millis * 743;
    uint32_t elapsed_mars_seconds = elapsed_mars_ticks / 763426;
    mars_ticks -= elapsed_mars_seconds * 763426;
    mars_seconds += elapsed_mars_seconds;

    // Обновляем время Титана. 1 Титановая секунда = 3193819/3200 мс.
    static uint32_t titan_ticks;
    titan_ticks += elapsed_millis * 3200;
    uint32_t elapsed_titan_seconds = elapsed_titan_ticks / 3193819;
    titan_ticks -= elapsed_titan_seconds * 3193819;
    titan_seconds += elapsed_titan_seconds;
}