395 lines
22 KiB
Arduino
395 lines
22 KiB
Arduino
/*
|
||
* DDS-генератор сигналов для лабораторных работ
|
||
* Платформа: RP2040 (Raspberry Pi Pico)
|
||
*
|
||
* Работает в ОБОИХ Arduino-ядрах:
|
||
* - earlephilhower (arduino-pico) — штатный ШИМ analogWriteFreq/analogWriteRange
|
||
* и таймер add_repeating_timer_us (pico-sdk);
|
||
* - официальное ядро "Raspberry Pi Pico/RP2040" (Arduino Mbed OS) — в пользовательском
|
||
* коде НЕТ ни analogWriteFreq, ни pico-sdk-заголовков (hardware/pwm.h, hardware/timer.h),
|
||
* поэтому здесь используется только mbed API, который является частью самого ядра:
|
||
* mbed::PwmOut (ШИМ) + mbed::Ticker (тактовый генератор выборок 62,5 кГц).
|
||
* Ветка выбирается автоматически по макросу ARDUINO_ARCH_MBED.
|
||
*
|
||
* ЧЕРНОВИК (AI-сгенерировано, 2026-10-26). Требует проверки преподавателем
|
||
* на реальном стенде: номиналы RC-фильтра, диапазоны частот, точность ADC.
|
||
*
|
||
* Возможности:
|
||
* - прямоугольник : аппаратный ШИМ (точная частота, независимая скважность);
|
||
* ниже 20 Гц — «программный» прямоугольник в таймерном ISR
|
||
* (аппаратный ШИМ RP2040 не опускается ниже ~7,5 Гц);
|
||
* - синус : таблица 256 точек + аккумулятор фазы (DDS) в таймерном
|
||
* ISR -> ШИМ (несущая = SAMPLE_HZ = 62,5 кГц) -> внешний
|
||
* ФНЧ (схема ниже); амплитуда — командой M;
|
||
* - свип : логарифмический (f0..f1, N точек) с синхроимпульсом
|
||
* на отдельном пине — для осциллографа/хост-скрипта;
|
||
* - измерение : ADC0 (размах за окно) — амплитуда на выходе
|
||
* исследуемой цепи (DUT) для автоматической АЧХ.
|
||
*
|
||
* ─── СХЕМА СИНУСА (обязательна: ШИМ даёт меандр, а не синус) ───
|
||
*
|
||
* GP15 ──[R1]──┬──[R2]──┬──────► OUT (вход DUT)
|
||
* │ │
|
||
* [C1] [C2]
|
||
* │ │
|
||
* GND GND
|
||
*
|
||
* Пассивный ФНЧ 2-го порядка. При несущей 62,5 кГц:
|
||
* R1 = R2 = 1 кОм, C1 = C2 = 47 нФ -> f_c ≈ 3,4 кГц
|
||
* подавление несущей ≈ (62,5/3,4)^2 ≈ 50 дБ -> пульсации ~10 мВ
|
||
* Номиналы для другой несущей: f_c и постоянную RC смотреть в README.
|
||
*
|
||
* ВНИМАНИЕ (важно): выходное сопротивление фильтра ~1 кОм. Вход
|
||
* интегратора — R1 = 10 кОм, получается делитель 10/11 (просадка ~9 %).
|
||
* Если это критично — поставить буфер-повторитель на ОУ (Sallen-Key):
|
||
* тот же фильтр 2-го порядка + низкое выходное сопротивление.
|
||
*
|
||
* Постоянная составляющая: при скважности 50 % среднее = 1,65 В, синус
|
||
* смещён на Uпит/2. Где смещение недопустимо — разделительный C = 1 мкФ
|
||
* последовательно + R = 47 кОм на землю (ФВЧ ≈ 3,4 Гц), либо уменьшить
|
||
* амплитуду командой M.
|
||
*
|
||
* Протокол команд (Serial, 115200, строка + \n):
|
||
* F <Гц> — установить частоту (1..500000)
|
||
* SF <Гц> — частота синусоиды (1..SAMPLE_HZ/2, защита от алиасинга)
|
||
* W Q | W S — режим: Q — прямоугольник, S — синус
|
||
* D <0..255> — скважность прямоугольника (128 = 50 %)
|
||
* M <0..127> — амплитуда синуса (127 = максимум)
|
||
* A — однократно измерить амплитуду на ADC0
|
||
* -> ответ "A <мВ размах>"
|
||
* SWEEP <f0> <f1> <n> <dwell_ms>
|
||
* — логарифмический свип; на каждой точке выдаёт
|
||
* "P <Гц> <мВ>" и импульс синхро на PIN_TRIG
|
||
* STOP — прервать свип
|
||
*/
|
||
|
||
#include <Arduino.h>
|
||
#include <math.h>
|
||
|
||
// ───────────────── выбор бэкенда ─────────────────
|
||
// Официальное mbed-ядро: нет analogWriteFreq, нет pico-sdk в пользовательском
|
||
// коде -> только mbed API (PwmOut + Ticker). earlephilhower: analogWrite* +
|
||
// add_repeating_timer_us.
|
||
#if defined(ARDUINO_ARCH_MBED)
|
||
#define USE_MBED_API 1
|
||
#include "mbed.h"
|
||
#else
|
||
#define USE_MBED_API 0
|
||
#include "hardware/timer.h" // add_repeating_timer_us, repeating_timer_t
|
||
#endif
|
||
|
||
// ─────────────────────────── пины ───────────────────────────
|
||
#define PIN_OUT 15 // выход сигнала (прямоугольник — прямо; синус — через RC)
|
||
#define PIN_TRIG 16 // синхроимпульс (для осциллографа)
|
||
// ВАЖНО: не GP14 — он попадает в диапазон PIO в
|
||
// варианте 04-dds-pio-rp2040.py; для единой разводки
|
||
// стенда синхро держим на GP16 во всех вариантах
|
||
#define PIN_ADC 26 // ADC0 = A0 — вход измерения (выход DUT через делитель!)
|
||
|
||
// ─────────────────────── параметры DDS ──────────────────────
|
||
// ВАЖНО: несущая ШИМ и частота обновления выборок должны СОВПАДАТЬ.
|
||
// Значение скважности применяется один раз за период ШИМ; если обновлять
|
||
// выборки с другой частотой, появляется джиттер и биения на выходе фильтра.
|
||
// При 16 мкс период ISR занимает ~3 % CPU RP2040; при перегрузке —
|
||
// снизить до 31250 (тогда f_c фильтра пересчитать вниз пропорционально).
|
||
#define CARRIER_HZ 62500UL // несущая ШИМ для синуса (= частота выборок)
|
||
#define SAMPLE_HZ 62500UL // частота обновления выборок синуса
|
||
#define PWM_RANGE 255 // 8-бит (для синуса); прямоугольнику хватает
|
||
#define AMP_MAX 127 // максимальная амплитуда выборки (единиц duty)
|
||
|
||
// Прямоугольник ниже этой частоты генерится в ISR: аппаратный ШИМ RP2040
|
||
// (div 8.4 + wrap 16 бит) физически не опускается ниже ~7,5 Гц.
|
||
#define SW_SQ_MIN_HZ 20UL
|
||
|
||
// ───────────────────────── состояние ────────────────────────
|
||
enum WaveMode : uint8_t { MODE_SQUARE = 0, MODE_SINE = 1 };
|
||
|
||
static volatile uint32_t g_freq = 1000; // текущая частота, Гц
|
||
static volatile uint8_t g_duty = 128; // 0..255 (прямоугольник)
|
||
static volatile uint8_t g_amp = AMP_MAX;// амплитуда синуса, 0..AMP_MAX
|
||
static volatile WaveMode g_mode = MODE_SQUARE;
|
||
static volatile uint32_t g_phase = 0; // аккумулятор фазы (32 бит)
|
||
static volatile bool g_sweep = false; // флаг активного свипа
|
||
static int8_t g_lut[256]; // sin: -127..127
|
||
|
||
// ─────────────── универсальный слой ШИМ ───────────────
|
||
// pwmStart() — включить ШИМ на PIN_OUT (idempotent)
|
||
// pwmConfig(f, range) — настроить частоту несущей
|
||
// pwmDuty(d) — установить скважность (0..255, масштабируется на текущий wrap)
|
||
|
||
#if USE_MBED_API
|
||
// официальное mbed-ядро: PwmOut (16-бит размах внутри ядра)
|
||
static mbed::PwmOut g_pwm(digitalPinToPinName(PIN_OUT));
|
||
|
||
static void pwmStart() { /* PwmOut активен сразу */ }
|
||
static void pwmConfig(uint32_t freq_hz, uint32_t range) {
|
||
(void)range;
|
||
if (freq_hz < 1) freq_hz = 1;
|
||
g_pwm.period_us(1000000UL / freq_hz); // период в мкс (для 62,5 кГц = 16 мкс)
|
||
}
|
||
static void pwmDuty(uint32_t duty) {
|
||
if (duty > PWM_RANGE) duty = PWM_RANGE;
|
||
g_pwm.write((float)duty / (float)PWM_RANGE);
|
||
}
|
||
|
||
#else
|
||
// earlephilhower arduino-pico
|
||
static void pwmStart() { /* analogWrite сам включает ШИМ */ }
|
||
static void pwmConfig(uint32_t freq_hz, uint32_t range) {
|
||
analogWriteFreq(freq_hz);
|
||
analogWriteRange(range);
|
||
}
|
||
static void pwmDuty(uint32_t duty) {
|
||
analogWrite(PIN_OUT, duty);
|
||
}
|
||
#endif // USE_MBED_API
|
||
|
||
// ─────────────────────── таблица синуса ─────────────────────
|
||
static void buildLut() {
|
||
for (int i = 0; i < 256; ++i) {
|
||
g_lut[i] = (int8_t)lroundf(127.0f * sinf(2.0f * (float)M_PI * i / 256.0f));
|
||
}
|
||
}
|
||
|
||
// ─────────────── тело ISR: обновление выборок ────────────────
|
||
// В режиме SINE — DDS-шаг фазы и новая скважность каждые 16 мкс;
|
||
// в режиме SQUARE с f < SW_SQ_MIN_HZ — программный прямоугольник
|
||
// (тот же ШИМ, только скважность 255 или 0 по фазе);
|
||
// в режиме SQUARE с f >= SW_SQ_MIN_HZ ШИМ работает аппаратно, ISR молчит.
|
||
static void sampleIsrBody() {
|
||
if (g_mode == MODE_SINE) {
|
||
// шаг фазы = f * 2^32 / Fs (64-бит, чтобы не переполнить)
|
||
uint32_t step =
|
||
(uint32_t)((uint64_t)g_freq * (1ULL << 32) / SAMPLE_HZ);
|
||
g_phase += step;
|
||
uint8_t idx = (uint8_t)(g_phase >> 24);
|
||
// центрируем на 128 и масштабируем амплитудой (g_amp 0..127)
|
||
int32_t s = ((int32_t)g_lut[idx] * g_amp) / 127;
|
||
pwmDuty((uint8_t)(128 + s));
|
||
} else if (g_freq < SW_SQ_MIN_HZ) {
|
||
uint32_t step =
|
||
(uint32_t)((uint64_t)g_freq * (1ULL << 32) / SAMPLE_HZ);
|
||
g_phase += step;
|
||
pwmDuty(((g_phase >> 24) < g_duty) ? PWM_RANGE : 0);
|
||
}
|
||
}
|
||
|
||
#if USE_MBED_API
|
||
static void sampleTick() { sampleIsrBody(); }
|
||
static mbed::Ticker g_tick;
|
||
static void startSampleClock() {
|
||
// 16 мкс -> 62,5 кГц; Ticker — аппаратный таймер mbed
|
||
g_tick.attach_us(&sampleTick, 1000000L / SAMPLE_HZ);
|
||
}
|
||
#else
|
||
static bool onSample(repeating_timer_t *) {
|
||
sampleIsrBody();
|
||
return true;
|
||
}
|
||
static repeating_timer_t g_timer;
|
||
static void startSampleClock() {
|
||
add_repeating_timer_us(-(1000000L / SAMPLE_HZ), onSample, nullptr, &g_timer);
|
||
}
|
||
#endif
|
||
|
||
// ─────────────────── применить режим/частоту ────────────────
|
||
static void applySquare() {
|
||
if (g_freq < SW_SQ_MIN_HZ) {
|
||
// программный прямоугольник (ISR): несущая = SAMPLE_HZ
|
||
pwmStart();
|
||
pwmConfig(SAMPLE_HZ, PWM_RANGE);
|
||
pwmDuty(g_duty > 0 ? PWM_RANGE : 0);
|
||
} else {
|
||
pwmStart();
|
||
pwmConfig(g_freq, PWM_RANGE);
|
||
pwmDuty(g_duty);
|
||
}
|
||
}
|
||
|
||
static void applySine() {
|
||
// частота ШИМ = SAMPLE_HZ (совпадает с ISR), размах — 8 бит
|
||
pwmStart();
|
||
pwmConfig(SAMPLE_HZ, PWM_RANGE);
|
||
// уровень выборок обновляет ISR
|
||
}
|
||
|
||
static void setFrequency(uint32_t hz) {
|
||
if (hz < 1) hz = 1;
|
||
if (hz > 500000) hz = 500000;
|
||
g_freq = hz;
|
||
if (g_mode == MODE_SQUARE) applySquare();
|
||
}
|
||
|
||
static void setMode(WaveMode m) {
|
||
g_mode = m;
|
||
if (m == MODE_SQUARE) applySquare();
|
||
else applySine();
|
||
}
|
||
|
||
// ─────────────────── измерение амплитуды (ADC) ──────────────
|
||
// Возвращает размах (пик-пик) в милливольтах за окно window_ms.
|
||
// TODO (студенту): заменить окно по времени на окно по числу периодов
|
||
// измеряемой частоты, чтобы размах считался по целому числу периодов.
|
||
static uint32_t measureAmplitudeMv(uint32_t window_ms = 50) {
|
||
uint16_t vmin = 4095, vmax = 0;
|
||
uint32_t t0 = millis();
|
||
while ((millis() - t0) < window_ms) {
|
||
uint16_t v = analogRead(PIN_ADC);
|
||
if (v < vmin) vmin = v;
|
||
if (v > vmax) vmax = v;
|
||
}
|
||
// ADC 12 бит, Vref = 3,3 В
|
||
return (uint32_t)((uint32_t)(vmax - vmin) * 3300UL / 4095UL);
|
||
}
|
||
|
||
// ───────────────────────── свип ─────────────────────────────
|
||
static void triggerPulse() {
|
||
digitalWrite(PIN_TRIG, HIGH);
|
||
delayMicroseconds(50);
|
||
digitalWrite(PIN_TRIG, LOW);
|
||
}
|
||
|
||
static void runSweep(float f0, float f1, int n, uint32_t dwell_ms) {
|
||
if (n < 2) n = 2;
|
||
if (f0 < 1) f0 = 1;
|
||
if (f1 <= f0) f1 = f0 * 10.0f;
|
||
g_sweep = true;
|
||
|
||
const float ratio = powf(f1 / f0, 1.0f / (float)(n - 1));
|
||
float f = f0;
|
||
for (int i = 0; i < n && g_sweep; ++i) {
|
||
setFrequency((uint32_t)lroundf(f));
|
||
triggerPulse(); // метка точки для осциллографа
|
||
delay(dwell_ms); // дать DUT/фильтру устояться
|
||
uint32_t mv = measureAmplitudeMv();
|
||
Serial.print("P "); // точка АЧХ: частота + размах
|
||
Serial.print((uint32_t)lroundf(f));
|
||
Serial.print(' ');
|
||
Serial.println(mv);
|
||
f *= ratio;
|
||
}
|
||
Serial.println("DONE");
|
||
setFrequency((uint32_t)f0); // вернуться к началу
|
||
}
|
||
|
||
// ─────────────────────── подробный хелп ──────────────────────
|
||
static void printHelp() {
|
||
Serial.println(F("# ─────────── DDS-генератор: команды ───────────"));
|
||
Serial.println(F("# Обозначения: <..> — обязательный аргумент."));
|
||
Serial.println(F("# Все команды вводятся строкой, Enter — конец строки."));
|
||
Serial.println(F("#"));
|
||
Serial.println(F("# РЕЖИМ И ЧАСТОТА"));
|
||
Serial.println(F("# W Q — режим прямоугольника (аппаратный ШИМ)"));
|
||
Serial.println(F("# W S — режим синуса (DDS -> ШИМ -> внешний ФНЧ)"));
|
||
Serial.println(F("# F <Гц> — частота выхода, 1..500000"));
|
||
Serial.println(F("# в режиме Q — частота прямоугольника;"));
|
||
Serial.println(F("# в режиме S — то же (для совместимости)"));
|
||
Serial.println(F("# пример: F 1000"));
|
||
Serial.println(F("# SF <Гц> — частота синуса с защитой от алиасинга"));
|
||
Serial.println(F("# ограничена SAMPLE_HZ/2 (см. шапку файла)"));
|
||
Serial.println(F("# пример: SF 25"));
|
||
Serial.println(F("#"));
|
||
Serial.println(F("# ФОРМА СИГНАЛА"));
|
||
Serial.println(F("# D <0..255> — скважность прямоугольника (128 = 50 %)"));
|
||
Serial.println(F("# пример: D 64 (25 % включено)"));
|
||
Serial.println(F("# M <0..127> — амплитуда синуса (127 = максимум)"));
|
||
Serial.println(F("# пример: M 32 (четверть шкалы)"));
|
||
Serial.println(F("#"));
|
||
Serial.println(F("# ИЗМЕРЕНИЕ И СВИП"));
|
||
Serial.println(F("# A — размах на ADC0 (GP26), мВ -> ответ 'A <мВ>'"));
|
||
Serial.println(F("# SWEEP <f0> <f1> <n> <dwell_ms>"));
|
||
Serial.println(F("# логарифмический свип от f0 до f1 за n точек,"));
|
||
Serial.println(F("# пауза dwell_ms на точку; на точку печатает"));
|
||
Serial.println(F("# 'P <Гц> <мВ>', в конце 'DONE'"));
|
||
Serial.println(F("# пример: SWEEP 10 100000 25 150"));
|
||
Serial.println(F("# STOP — прервать свип"));
|
||
Serial.println(F("#"));
|
||
Serial.println(F("# СПРАВКА"));
|
||
Serial.println(F("# HELP | ? — этот текст"));
|
||
Serial.println(F("#"));
|
||
Serial.println(F("# ─── СХЕМА (синус: ШИМ даёт меандр, нужен ФНЧ) ───"));
|
||
Serial.println(F("# GP15 --[R1]--+--[R2]--+--> во вход схемы"));
|
||
Serial.println(F("# | |"));
|
||
Serial.println(F("# [C1] [C2] R1=R2=1к, C1=C2=47н"));
|
||
Serial.println(F("# | | (f_c ~ 3.4 кГц)"));
|
||
Serial.println(F("# GND GND"));
|
||
Serial.println(F("# Постоянная составляющая при 50% = Uпит/2: нужен разделительный"));
|
||
Serial.println(F("# конденсатор, если смещение мешает. ADC0 — до 3.3 В (делитель!)."));
|
||
Serial.println(F("# ─────────────────────────────────────────────"));
|
||
}
|
||
|
||
// ─────────────────────── разбор команд ──────────────────────
|
||
static void handleLine(char *line) {
|
||
char *cmd = strtok(line, " \t");
|
||
if (!cmd) return;
|
||
|
||
if (!strcasecmp(cmd, "HELP") || !strcmp(cmd, "?")) {
|
||
printHelp();
|
||
} else if (!strcasecmp(cmd, "F")) {
|
||
char *a = strtok(nullptr, " \t");
|
||
if (a) setFrequency((uint32_t)strtoul(a, nullptr, 10));
|
||
Serial.print("OK F "); Serial.println(g_freq);
|
||
} else if (!strcasecmp(cmd, "SF")) {
|
||
// частота синусоиды: с защитой от алиасинга (f <= SAMPLE_HZ/2)
|
||
char *a = strtok(nullptr, " \t");
|
||
uint32_t hz = a ? (uint32_t)strtoul(a, nullptr, 10) : g_freq;
|
||
if (hz < 1) hz = 1;
|
||
if (hz > SAMPLE_HZ / 2) hz = SAMPLE_HZ / 2;
|
||
setFrequency(hz);
|
||
Serial.print("OK SF "); Serial.println(g_freq);
|
||
} else if (!strcasecmp(cmd, "W")) {
|
||
char *a = strtok(nullptr, " \t");
|
||
if (a) setMode((!strcasecmp(a, "S")) ? MODE_SINE : MODE_SQUARE);
|
||
Serial.print("OK W "); Serial.println(g_mode == MODE_SINE ? "S" : "Q");
|
||
} else if (!strcasecmp(cmd, "D")) {
|
||
char *a = strtok(nullptr, " \t");
|
||
if (a) { g_duty = (uint8_t)constrain(atoi(a), 0, 255); applySquare(); }
|
||
Serial.print("OK D "); Serial.println(g_duty);
|
||
} else if (!strcasecmp(cmd, "M")) {
|
||
char *a = strtok(nullptr, " \t");
|
||
if (a) g_amp = (uint8_t)constrain(atoi(a), 0, AMP_MAX);
|
||
Serial.print("OK M "); Serial.println(g_amp);
|
||
} else if (!strcasecmp(cmd, "A")) {
|
||
Serial.print("A "); Serial.println(measureAmplitudeMv());
|
||
} else if (!strcasecmp(cmd, "SWEEP")) {
|
||
char *a0 = strtok(nullptr, " \t");
|
||
char *a1 = strtok(nullptr, " \t");
|
||
char *a2 = strtok(nullptr, " \t");
|
||
char *a3 = strtok(nullptr, " \t");
|
||
if (a0 && a1 && a2 && a3) {
|
||
runSweep(atof(a0), atof(a1), atoi(a2), strtoul(a3, nullptr, 10));
|
||
}
|
||
} else if (!strcasecmp(cmd, "STOP")) {
|
||
g_sweep = false;
|
||
}
|
||
}
|
||
|
||
// ────────────────────────── setup/loop ──────────────────────
|
||
void setup() {
|
||
Serial.begin(115200);
|
||
buildLut();
|
||
pinMode(PIN_TRIG, OUTPUT);
|
||
digitalWrite(PIN_TRIG, LOW);
|
||
analogReadResolution(12); // ADC0 — 12 бит
|
||
startSampleClock();
|
||
setMode(MODE_SQUARE);
|
||
setFrequency(1000);
|
||
Serial.println("# DDS generator ready (RP2040). Подробный хелп: HELP или ?");
|
||
printHelp();
|
||
}
|
||
|
||
void loop() {
|
||
static char buf[96];
|
||
static size_t len = 0;
|
||
while (Serial.available()) {
|
||
char c = (char)Serial.read();
|
||
if (c == '\n' || c == '\r') {
|
||
buf[len] = '\0';
|
||
if (len) handleLine(buf);
|
||
len = 0;
|
||
} else if (len < sizeof(buf) - 1) {
|
||
buf[len++] = c;
|
||
}
|
||
}
|
||
}
|