Работа с UART в пакетном режиме и ОС Опции

[Pavel V.]

Как правильно организовать работу с пакетным протоколом (что-то наподобие WAKE в собственной реализации) в условиях использования операционки?

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

Ответный пакет формируется в функции обработки команды и запускается отправка по прерыванию.

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

В этом случае возникает необходимость использования чего-то вроде кольцевого буфера для предотвращения потери данных.

Как правильно реализовать такую схему при наличии операционки?

Пока видится только такая схема работы:
1. Процесс, который занимается отправкой данных в порт, занят только тем, что висит в вечном channel.pop() из кольцевого буфера и в случае появления данных выполняет отправку байта в порт.
2. Процесс, который обрабатывает асинхронные события. Например, нажали кнопку. Процесс в этом случае вызывает некую функцию SendInputAsync() в которой формируется пакет и делается необходимое количество channel.push(). Затем процесс уходит в Sleep() на заданное настройками время.

Возможно, необходимо сделать процесс на каждое асинхронное событие?

Смущает передача управления для отправки каждого байта. Можно, конечно, вызывать channel.pop() с таймаутом и воспользоваться дополнительным событием, которое будет устанавливаться только по добавлению в канал полного пакета. Но как-то громоздко получается.

Прошу помощи у более опытных товарищей

[Сергей Борщ]

1. Процесс, который занимается отправкой данных в порт, занят только тем, что висит в вечном channel.pop() из кольцевого буфера и в случае появления данных выполняет отправку байта в порт.

А почему бы не повесить кольцевой буфер на UART (и опустошать его в прерывании), а сам процесс отправки пакета не обрамить мутексом? Тогда любой процесс сможет оправлять пакеты асинхронно. Что-то типа такого (не wake, но подобный протокол):

CODE

class bus_frame
{
public:
typedef uint16_t address_t;
protected:
enum
{
STA = 0xC0,
STO = 0xC1,
CTL = 0x7F,
TRANSPARENCY = 0x20,
};
typedef crc::ccitt crc_t;
};

class frame : public bus_frame
{
public:
frame(iodevice & uart);
frame(iodevice & uart, address_t address);
~frame();

void send(void const * buffer, size_t size);
void send(uint8_t data); // calculate CRC and send transparently

protected:
void send_transparently(uint8_t data);
static OS::TMutex Mutex;
iodevice & Uart;
crc_t CRC;
};


frame::frame(iodevice & uart, address_t address)
: Uart(uart)
{
Mutex.Lock();
Uart.send(STA);
send(address >> 0);
send(address >> 8);
}

frame::frame(iodevice & uart)
: Uart(uart)
{
Mutex.Lock();
Uart.send(STA);
}

frame::~frame()
{
send_transparently(~CRC >> 0);
send_transparently(~CRC >> 8);
Uart.send(STO);
Mutex.Unlock();
}

void frame::send(uint8_t data)
{
CRC.calculate(data);
send_transparently(data);
}

void frame::send_transparently(uint8_t data)
{
if((data == CTL) || (data == STA) || (data == STO))
{
Uart.send(CTL);
data ^= TRANSPARENCY;
}
Uart.send(data);
}

void frame::send(void const * buffer, size_t size)
{
uint8_t const * pSrc = (uint8_t const *)buffer;
while(size--)
send(*pSrc++);
}

void Test(bus_frame::address_t destination)
{
frame Frame(Uplink, destination);
Frame.send("Tipa test", sizeof("Tipa test"));
}