В различных проектах часто бывает необходимо следить за множеством параметров, которые представлены аналоговыми величинами. Конечно, часто хватает микроконтроллера, но иногда алгоритм обработки слишком сложен для него и требуется использование полноценного компьютера. К тому же на нём гораздо проще организовывать сохранение логов и красивую визуализацию данных. В таком случае либо берётся готовое промышленное решение (которое, разумеется, стоит дорого, но часто является избыточным), либо делается что-то самодельное. В самом банальном случае это может быть плата Arduino с бесконечным циклом из analogRead и serial.write. Если входных данных много (больше, чем аналоговых входов), то потребуется несколько плат, придумывать как их правильно опрашивать с компьютера и т. д. Во многих случаях подойдёт разработанное мною решение (возможно, я не первый придумал именно такую реализацию, не особо интересовался этим вопросом), которое позволит сэкономить время на отладку и сделать относительную простую и понятную архитектуру системы.
Чтобы понять, подойдёт ли это решение вам, предлагаю ознакомится с его характеристиками:
Максимальное число каналов: 44;
Частота дискретизации: 1000 Герц;
Разрешение: 8 бит.
Характеристики достаточно посредственные, однако для многих задач могут подойти. Это ведь не осциллограф, а система опроса датчиков. К тому же на её примере можно познакомится с использованием USART не совсем по назначению.
Система состоит из отдельных модулей АЦП на базе микроконтроллера ATMEGA8 (можно применить другой МК семейства AVR с АЦП и аппаратным модулем USART, если немного изменить прошивку). Модулей может быть один или несколько, каждый предоставляет 6 или 8 АЦП в зависимости от корпуса микроконтроллера (выводная версия имеет 6 АЦП, а для поверхностного монтажа 8), только суммарное количество каналов не должно превышать 44. Главная особенность в том, что вне зависимости от количества модулей требуется лишь один USART со стороны компьютера (это может быть USB-переходник или аппаратный COM-порт). Это достигается засчёт того, что USART'ы всех микроконтроллеров соединяются последовательно (RX одного к TX другого), а RX и TX пины крайних в цепочке уже подсоединяются к компьютеру.
Тут надо заметить то, что разрядность моего АЦП не совсем 8 бит — возможно лишь 255 градаций вместо 256. Значение 0xFF зарезервировано для особой цели. Если микроконтроллер получает его, то начинает выдавать каждый раз значение с очередного канала своего АЦП, а когда они кончаются ретранслирует 0xFF дальше по цепочке. Если же на вход USART приходит значение отличное от 0xFF, то микросхема просто пересылает байт далее. Таким образом передав одно произвольное значение и 44 0xFF можно получить значения со всех каналов всех АЦП (если АЦП меньше, то лишние каналы будут равны 0xFF). Произвольное значение нужно для того, чтобы все модули сбросили указатель на текущий канал АЦП, который надо передавать при получении 0xFF. В реальности удобнее передавать 45 0xFF, чтобы надёжно определять окончание приёма (если получили 0xFF, значит каналы закончились).
Программа для AVR выглядит предельно просто и занимает чуть меньше 300 байт памяти:
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <util/delay.h>
// Firmware options
#define USART_BAUDRATE 460800
#define LED_PIN 1
#define ADC_COUNT 6
#define STARTUP_DELAY 1000
// Calculated UBRR value
#define UBRR (F_CPU / (16 * (uint32_t)USART_BAUDRATE) - 1)
// Global variables
uint8_t adc[ADC_COUNT]; // Buffer
uint8_t cur_in_adc; // Input byte index
uint8_t cur_out_adc; // Output byte index
// USART interrupt handler
ISR(USART_RXC_vect) {
// Read data from USART
uint8_t buffer = UDR;
if (buffer == 0xFF) {
if (cur_out_adc < ADC_COUNT) {
// Return data byte from buffer
UDR = adc[cur_out_adc];
cur_out_adc++;
// Activate led
PORTB |= _BV(LED_PIN);
} else {
// Chain 0xFF
UDR = 0xFF;
// Deactivate led
PORTB &= ~_BV(LED_PIN);
}
} else {
// Chain data byte
UDR = buffer;
// Reset byte counter
cur_out_adc = 0;
// Deactivate led
PORTB &= ~_BV(LED_PIN);
}
}
// Main function
void main() {
// Setup watchdog timer
wdt_enable(WDTO_15MS);
// Setup pin for led
DDRB |= _BV(LED_PIN);
// Blink led
PORTB |= _BV(LED_PIN);
for (uint8_t i = 0; i < STARTUP_DELAY / 5; i++) {
_delay_ms(5);
wdt_reset();
}
PORTB &= ~_BV(LED_PIN);
// Setup ADC
ADMUX = _BV(REFS1) | _BV(REFS0) | _BV(ADLAR);
ADCSRA = _BV(ADEN) | _BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0);
// Setup USART
UBRRL = UBRR & 0xFF;
UBRRH = UBRR >> 8;
UCSRA = 0;
UCSRB = _BV(RXCIE) | _BV(RXEN) | _BV(TXEN);
UCSRC = _BV(URSEL) | _BV(UCSZ1) | _BV(UCSZ0);
// Enable interrupts
sei();
// Main loop
while (1) {
// Reset watchdog timer
wdt_reset();
// Select ADC channel
ADMUX = _BV(REFS1) | _BV(REFS0) | _BV(ADLAR) | cur_in_adc;
// Start conversion and wait until it performed
ADCSRA |= _BV(ADIF) | _BV(ADSC);
while (ADCSRA & _BV(ADSC));
// Put value from ADC to buffer
uint8_t value = ADCH;
adc[cur_in_adc] = (value != 0xFF) ? value : 0xFE;
// Switch to next channel
cur_in_adc++;
if (cur_in_adc >= ADC_COUNT) {
cur_in_adc = 0;
}
}
}
А вот простой пример программы для компьютера. Она принимает в качестве параметра имя последовательного порта и начинает выдавать на stdout данные в формате CSV, а на stderr статистику (байт передано, получено и сколько замеров произведено за секунду). Можно просто перенаправить её вывод в файл, а потом открыть его в Excel, Calc или более подходящей программе, а можно легко использовать её в качестве бэкэнда в своём приложении, перехватив её вывод. Приложение изначально написано под Linux, но в теории может быть собрано с использованием Cygwin для ОС семейства Windows.
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <time.h>
#include <signal.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/select.h>
// Settings
#define DEFAULT_BAUDRATE 460800
#define MAX_CHANNEL_COUNT 44
#define READ_BUFFER_SIZE 256
// Global variables
volatile sig_atomic_t write_buffer_offset = INT_MAX;
volatile sig_atomic_t remaining_writes = 0;
volatile sig_atomic_t write_counter = 0;
volatile sig_atomic_t read_counter = 0;
volatile sig_atomic_t sample_counter = 0;
int adc_data[MAX_CHANNEL_COUNT];
int adc_count = 0;
int cur_adc = -1;
uint8_t command[(MAX_CHANNEL_COUNT + 2) * 1000];
// Print usage information
void print_usage(char *program_name) {
fprintf(stderr, "Usage: %s devicen", program_name);
fprintf(stderr, "tdevice - path to serial device (e.g. /dev/ttyS0 or /dev/ttyUSB0)n");
fprintf(stderr, "n");
}
// Open serial port
int open_serial_device(char *path) {
// Open device
int fd = open(path, O_RDWR | O_NONBLOCK);
if (fd == -1) return -1;
// Get current options
struct termios options;
tcgetattr(fd, &options);
// Set baudrate
cfsetspeed(&options, DEFAULT_BAUDRATE);
// Set mode (8N1)
options.c_cflag &= ~PARENB;
options.c_cflag &= ~CSTOPB;
options.c_cflag &= ~CSIZE;
options.c_cflag |= CS8;
// Disable hardware flow control (if available)
#ifdef CNEW_RTSCTS
options.c_cflag &= ~CNEW_RTSCTS;
#elifdef CRTSCTS
options.c_cflag &= ~CRTSCTS;
#endif
// Set new options
tcsetattr(fd, TCSANOW, &options);
// Return handle
return fd;
}
// Alarm handler
void alarm_handler(int sig) {
// Check for timeout
static int first_run = 1;
if (first_run) {
first_run = 0;
} else if (!sample_counter) {
fprintf(stderr, "Timeoutn");
exit(-2);
}
// Send next command
if (write_buffer_offset >= sizeof(command)) {
write_buffer_offset = 0;
} else {
remaining_writes++;
}
// Display debug info
fprintf(stderr, "Writing %i bps, reading %i bps, %i samples per secondn", write_counter, read_counter, sample_counter);
// Reset performance counter
read_counter = 0;
write_counter = 0;
sample_counter = 0;
}
// Print ADC data
void print_adc_data() {
int i;
for (i = 0; i < adc_count; i++) {
if (i) {
printf(",%i", adc_data[i]);
} else {
printf("%i", adc_data[i]);
}
}
printf("n");
}
// Main function
int main(int argc, char **argv) {
if (argc < 2) {
print_usage(argv[0]);
} else {
// Open serial port
char *device = argv[1];
int device_fd = open_serial_device(device);
if (device_fd == -1) {
fprintf(stderr, "Failed to open %s: %sn", device, strerror(errno));
return -1;
}
// Setup alarm signal handler
{
struct sigaction sig;
sig.sa_handler = alarm_handler;
sigemptyset(&sig.sa_mask);
sig.sa_flags = SA_RESTART;
sigaction(SIGALRM, &sig, NULL);
}
// Setup timer
timer_t timer;
if (timer_create(CLOCK_MONOTONIC, NULL, &timer)) {
perror("timer_create() failedn");
close(device_fd);
return -1;
}
{
struct itimerspec timer_spec;
timer_spec.it_interval.tv_sec = 1;
timer_spec.it_interval.tv_nsec = 0;
timer_spec.it_value.tv_sec = 0;
timer_spec.it_value.tv_nsec = 1;
if (timer_settime(timer, 0, &timer_spec, NULL) < 0) {
perror("timer_settime() failed");
close(device_fd);
return -1;
}
}
// Generate USART command
{
int i;
memset(command, 0xFF, sizeof(command));
for (i = 0; i < sizeof(command); i += MAX_CHANNEL_COUNT + 2) {
command[i] = 0;
}
}
// Main loop
while (1) {
// Wait device ready for reading or writing
fd_set fds_r, fds_w;
FD_ZERO(&fds_r);
FD_ZERO(&fds_w);
FD_SET(device_fd, &fds_r);
FD_SET(device_fd, &fds_w);
int retval = select(FD_SETSIZE, &fds_r, &fds_w, NULL, NULL);
// Check for errors
if (retval < 0) {
if (errno == EINTR) continue;
perror("select() failed");
timer_delete(timer);
close(device_fd);
return -1;
}
// Read data
if (FD_ISSET(device_fd, &fds_r)) {
uint8_t buffer[READ_BUFFER_SIZE];
int bytes_count;
while ((bytes_count = read(device_fd, buffer, sizeof(buffer))) > 0) {
read_counter += bytes_count;
int i;
for (i = 0; i < bytes_count; i++) {
if (buffer[i] == 0xFF) {
if (adc_count) {
print_adc_data();
sample_counter++;
adc_count = 0;
}
cur_adc = -1;
} else {
if ((cur_adc > -1) && (cur_adc < MAX_CHANNEL_COUNT)) {
if (buffer[i] != 0xFF) {
adc_data[cur_adc] = buffer[i];
adc_count++;
}
}
cur_adc++;
}
}
}
}
// Write data
if (FD_ISSET(device_fd, &fds_w) && (write_buffer_offset < sizeof(command))) {
int bytes_count;
while ((bytes_count = write(device_fd, command + write_buffer_offset, sizeof(command) - write_buffer_offset)) > 0) {
write_counter += bytes_count;
write_buffer_offset += bytes_count;
}
if ((write_buffer_offset >= sizeof(command)) && remaining_writes) {
write_buffer_offset = 0;
remaining_writes--;
}
}
}
// Cleanup
timer_delete(timer);
close(device_fd);
}
return 0;
}
Удобно, что последовательный порт используется практически на пределе своих возможностей, поэтому не требуется заботится о синхронизации данных (я просто отправляю каждую секунду сразу 1000 команд на чтение АЦП) — если мы передаём 46 килобайт данных каждую секунду со скоростью 460800 бит в секунду, то можно быть полностью уверенным, что блоки из 46 байт данных (один замер) будут приходить каждую миллисекунду (хотя буферизация ядром ОС и USB-переходником, конечно, внесёт задержку, но замеры всегда будут производится с нужной частотой).
Печатная плата была спроектирована в KiCad:
Все платы соединяются в цепочку, у последней платы RX и TX соединяются джампером.
Качество работы АЦП можно оценить по этому изображению пилы на 10 Гц:
Для сравнения изображение с осциллографа DS203 (он же и выступает генератором):
К сожалению, у меня нет более качественного источника сигнала, но для низкочастотных сигналов моя система должна подойти.
Надо отметить, что не каждый преобразователь USART-USB обеспечивает скорость 460800 бит/сек при полной загрузке канала. Преобразователь на базе CP2102 заставил меня долго искать ошибку в собственном коде, пока я не попробовал FT232. Также наблюдается потеря порядка 0.17% данных (в программе для компьютера приняты меры, чтобы не терялась синхронизация данных). Скорее всего это вызвано плохой линией USART, либо недоработкой в программе. В общем, для 90% применений не должно быть критично, но ставить на АЭС скорее всего не стоит.
Ну и напоследок скажу, что себестоимость одного модуля получается около 50-60 рублей, если заказывать все детали из Китая, так что решение должно быть достаточно привлекательным.
Автор: KivApple
