Получение данных по USART

[Fangir]

Я передаю данные по 1 байту, как другому МК распознать команду?
Допустим, в команде "led_off" - 7 байт

Я передал её с помощью функции

// Передача строки
void usart0_put(char *str) {
	while(*str != '\0') {
		while(!(UCSRA & (1 ‹‹ UDRE))); // Ожидаем, когда очистится буфер
		UDR = *str; // Помещаем данные в буфер
		str++;
	}
}

Хотел записывать все принятые данные в стек, а после обрабатывать их, как-то так

// Прерывание по окончанию приема данных
unsigned char usart0_stack[100], usart0_counter = 0;
interrupt[USART0_RXC] void usart0_rx_isr(void) {
	// Записываем символ
	if(usart0_counter ‹= 100) {
		usart0_stack[usart0_counter++] = UDR;
	}
}

Но застопорился и не знаю как дальше развить идею

И да, я использую RTOS, так что процесс, который мог бы обработать данные, может очухаться примерно через 5-20ms после начала приема
Он не сможет обработать данные сразу же

[_Артём_]

Я передаю данные по 1 байту, как другому МК распознать команду?
Допустим, в команде "led_off" - 7 байт

Зависит от формата команд. Можно в каждой команде передавать её длину. Или заканчивать команду каким-либо зарезервированным символом (переводом строки например) и при приёме этого символа можно начинать разбор команды.

Хотел записывать все принятые данные в стек, а после обрабатывать их, как-то так

Буфер - это правильно.

И да, я использую RTOS, так что процесс, который мог бы обработать данные, может очухаться примерно через 5-20ms после начала приема
Он не сможет обработать данные сразу же

Что-то долго у вас процесс очухивается...На 8 МГц тактовой процесс может за 40-50 мкс среагировать. Что за RTOS у вас?

Он не сможет обработать данные сразу же

Используйте семафоры или события для запуска обработки.

[NewWriter]

А может для начала команды использовать некий зарезервированный код, который будет содержать данные о начале и длине команды. Например, как м MIDI-сообщениях. Команды разделены по типам и у каждого типа - своя длина в байтах. Тип команды зашифрован в первом байте.
Может, за основу взять протокол MIDI? Тогда и придумывать ничего не придется.

[Easyrider83]

Элементарно. Каждый входящий байт вызывает прерывание, правильно. Но еще он обнуляет таймер, который переполняется через время, за которое приходит полтора байта. Иными словами, если байт не пришел, вызывается прерывание таймера, в котором вы поднимаете флаг о том, что стек заполнен, пора обрабатывать.

[Fangir]

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

// Передача символа
void usart0_putChar(char с) {
	while(!(UCSRA & (1 ‹‹ UDRE))); // Ожидаем, когда очистится буфер
	UDR = с; // Помещаем данные в буфер
}


// Передача строки
void usart0_putStr(char *str) {
	while(*str != '\0') {
		usart0_putChar(*str); // Отсылаем символ
		str++;
	}
	usart0_putChar('#'); // Символ конца команды
}


//##################################################  #############################################
//##################################################  #############################################



#define usart0_MAX 20     // Максимальная длина команды
#define usart0_STACK 100  // Длина стека


// Прием данных
unsigned char usart0_get(void) {
	unsigned char data[usart0_MAX];

	// Пока счетчик не равен нулю
	while(usart0_counter) {
		// хз как реализовать выборку из стека
		// И попутно уменьшение счетчика
		// Надо делать как-то с конца но я щас слишком сонный
		// Буду благодарен, если кто поможет
		// data[] = usart0_stack[usart0_counter--]
	}
	// return data;
}



// Прерывание по окончанию приема данных
unsigned char usart0_stack[usart0_STACK];   // Стек
unsigned char usart0_counter = 0;  // Счетчик стека
unsigned char usart0_max_len = 0;  // Счетчик длины команды
interrupt[USART0_RXC] void usart0_rx_isr(void) {
	unsigned char data = UDR;

	// Если стек переполнился то просто игнорируем прием данных
	if(usart0_counter ‹= usart0_STACK) {
		usart0_stack[usart0_counter++] = data; // Записываем в стек символ 

		// Конец команды!
		if(data == '#') {
			usart0_max_len = 0; // Сбрасываем счетчик 
		}

		// Счетчик дошел до предела, команда слишком большая
		if(usart0_max_len++ == usart0_MAX) { 
			usart0_max_len = usart0_MAX;      // Сбрасываем
			usart0_counter -= usart0_MAX + 1; // Откатываем назад
		}
	}
}

[akegor]

UDR = с; // Помещаем данные в буфер

Это буфер в аппаратном, а не в программном смысле. В программном один байт - огромаднейший буфер!
Я путчаром загоняю всю посылку в буфер, а содержимое буфера передается по прерываниям.
При приеме жду ожидаемое количество байтов в буфере и проверяю первый байт (признак начала сообщения) - если байт правильный, провожу разбор посылки, если нет - жду дальше.
Обмен в ASCII, Все, кроме заголовка, шестнадцатиричное. Заголовок - любой знак, кроме 0...F и 0x0A, 0x0D, 0x00 0xFF. Пока не встречалось необходимости в своих интерфейсах применять другой подход. В случае приема чужих посылок ситуация посложнее.

[_Артём_]

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

А что её тестировать, если она работающая?
Или тут такой принцип - компилируется значит работает?

Код:

#define usart0_MAX 20 // Максимальная длина команды #define usart0_STACK 100 // Длина стека // Прием данных unsigned char usart0_get(void) { unsigned char data[usart0_MAX]; // Пока счетчик не равен нулю while(usart0_counter) { // хз как реализовать выборку из стека // И попутно уменьшение счетчика // Буду благодарен, если кто поможет // data[] = usart0_stack[usart0_counter--] } // return data; }

// хз как реализовать выборку из стека

Неудивительно что ХЗ - неправильно делаете вот и не знаете. Стек - это LIFO (last in — first out, «последним пришёл — первым вышел»). Для вашего случая больше подойдёт FIFO(кольцевой буфер, или циклический буфер): в прерывании приёма делается инкремент индекса последнего принятого символа,
в основной программе - инкремент индекса самого раннего символа (до тех пор пока индексы не станут равны).

P.S. Почему переменные usart0_stack и usart0_counter не volatile?

[jump]

еще он обнуляет таймер, который переполняется через время, за которое приходит полтора байта

вах, адын палавынка МОДБАС!
тогда уж и втарой палавынка вазми дарагой - 3.5 длительности байта.
и назначение согласно стандарта МОДБАС (для таймера) - 1.5 длительности байта (разрыв посылки, уничтожение пакета) и 3.5 длительности байта (окончание пакета, начало обработки), прерывание от USART складывает байты в буфер и обнуляет таймер

[rafik65]

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

[kosmos440o]

while(*str != '\0')

а если "\0" вдруг чего-то не придёт?
Функция void usart0_put(char *str) 7 мсек - не много?


Надо контроль ошибок сделать.
Начало сообщения обозначить может быть.
вообще понадёжнее как-то.
Читайте про Модбас, там вроде минималка для нормального обмена.
Стандартная библиотека USART чем не нравится? Там получше обработка будет.

#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7

#define FRAMING_ERROR (1‹‹FE)
#define PARITY_ERROR (1‹‹UPE)
#define DATA_OVERRUN (1‹‹OVR)
#define DATA_REGISTER_EMPTY (1‹‹UDRE)
#define RX_COMPLETE (1‹‹RXC)

// USART0 Receiver buffer
#define RX_BUFFER_SIZE0 16
char rx_buffer0[RX_BUFFER_SIZE0];

#if RX_BUFFER_SIZE0‹256
unsigned char rx_wr_index0,rx_rd_index0,rx_counter0;
#else
unsigned int rx_wr_index0,rx_rd_index0,rx_counter0;
#endif

// This flag is set on USART0 Receiver buffer overflow
bit rx_buffer_overflow0;
char rx_errors=0;
// USART0 Receiver interrupt service routine
interrupt [USART0_RXC] void usart0_rx_isr(void)
{
char status,data;
status=UCSR0A;
data=UDR0;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
{
rx_buffer0[rx_wr_index0]=data;
if (++rx_wr_index0 == RX_BUFFER_SIZE0) rx_wr_index0=0;
if (++rx_counter0 == RX_BUFFER_SIZE0)
{
rx_counter0=0;
rx_buffer_overflow0=1;
};
}else {rx_errors++;};
}

#ifndef _DEBUG_TERMINAL_IO_
// Get a character from the USART0 Receiver buffer
#define _ALTERNATE_GETCHAR_
#pragma used+
char getchar(void)
{
char data;
while (rx_counter0==0);
data=rx_buffer0[rx_rd_index0];
if (++rx_rd_index0 == RX_BUFFER_SIZE0) rx_rd_index0=0;
#asm("cli")
--rx_counter0;
#asm("sei")
return data;
}
#pragma used-
#endif

// USART1 Transmitter buffer
#define TX_BUFFER_SIZE1 255
unsigned char tx_message [TX_BUFFER_SIZE1];
unsigned char tx_counter1=0;
unsigned char tx_len=0;

// USART1 Transmitter interrupt service routine
//перед этим первый байт отправить вручную и tx_len длину сообщения определить.
interrupt [USART1_TXC] void usart1_tx_isr(void)
{
tx_counter1++;
while ((UCSR1A & DATA_REGISTER_EMPTY)==0){};
if (tx_counter1‹tx_len)
{
UDR1=tx_message [tx_counter1];
}
}