В этой статье, мы расскажем о том, как разработали собственный простой формат пакетов для передачи данных и почему мы это сделали, а также покажем несколько реализаций структуры данных под разработанный формат.
О собственном формате пакетов данных мы задумались после создания ряда программно-аппаратных решений, которые в основном носили демонстрационный характер, но могли бы использоваться и в реальных проектах. Речь идет о двух проектах — спектроанализаторе и уловителе сигналов. В обоих случаях мы использовали внешнюю плату, данные с которой пересылались через COM-порт, и это в принципе работало. Проблема заключается в том, что использованная в реализации идея с разбиением одного крупного значения на байты будет работать только в идеальных условиях. И вот почему: разделенное на байты число не имеет четких признаков своего начала или конца, а потому при приеме может быть неверно интерпретировано принимающей стороной. Но это не единственная проблема — помимо отсутствия маркеров или разметки данных, довольно высока вероятность того, что даже при удачном стечении обстоятельств их приемник будет не в состоянии опознать поврежденные данные.
Со всем этим мы столкнулись почти сразу, но не придав этому значения и посчитав два проекта слишком учебными, решение проблемы мы обошли стороной. Но потом, одному из авторов данной статьи пришлось столкнуться с реальной проблемой — спектроанализатор принимал не те данные… И вот тогда мы задумались о собственном бинарном формате пакетов, достаточно простом, чтобы поместиться в микроконтроллер, и достаточно узнаваемым как человеком, так и компьютером. Формат пакетов был придуман достаточно быстро и получил название SF6 (Send Frame with 6 fields — SF6) и о нем мы расскажем далее.
Наш формат пакетов достаточно прост по своей структуре и является бинарным, но при этом он содержит хорошо узнаваемые данные (в форме байтов). Эти данные представляют собой последовательности байтов, в которых закодированы некоторые связные цепочки символов ASCII. Эти цепочки служат маркерами, за которые цепляется распознающий пакет код, и между этими цепочками нет никаких разделителей: ни новой строки, ни пробелов, ни символов табуляции. Такая структура делает формат менее избыточным, а в совокупности с его фиксированным размером в байтах, позволяет организовать очень простой и быстрый кодер/энкодер пакетов.
Пакет данных в формате SF6 представляет собой последовательность байтов размером в 292 байта и содержит в себе следующие поля: «магическое число», идентификаторы служебных секций, уникальный идентификатор пакета, «особый» идентификатор, заголовок начала секции данных, данные в байтовом виде и заголовок конца секции данных.
«Магическое число» — это сигнатура формата, опознавательный маркер пакета, который одновременно служит признаком начала очередной порции данных, т.е. фрейма данных. В нашем случае «магическое число» является комбинацией байтов, которую можно интерпретировать как строку из ASCII символов следующего вида: «SF6!». За сигнатурой идет первый маркер, который указывает на служебную информацию, и представляет собой последовательной байтов соответствующих ASCII строке вида «SF6_». Сразу за этим маркером идет поле, которое представляет собой уникальный идентификатор пакета, записанный последовательностью данных в обратном порядке. К примеру, идентификатор 0x01abcdef будет представлен последовательностью байтов [0xef, 0xcd, 0xab, 0x01]. Уникальный идентификатор пакета всегда имеет фиксированный размер в байтах,
и он равен 4.
После уникального идентификатора идет второй маркер, который является точно таким же, как и первый, и представляет собой ту же ASCII строку «SF6_». За вторым маркером идет «особый» идентификатор, который имеет фиксированный размер равный 4 байтам. Он также записывается в обратном порядке, и в изначальном варианте представлял собой 32-битный хэш от последовательности байтов внутри секции данных.
После всех служебных пометок идет заголовок секции данных, который представляет собой ASCII последовательность вида «SF6_@BDF» (BDF — Begin of Data Frame). За заголовком секции данных идут сами данные в байтовом виде и данные представлены в виде последовательности байтов размером ровно 256 байт. Размер секции фиксированный и не содержит в себе никаких разделителей между байтами — в этой секции они представлены непрерывным потоком. Завершает пакет заголовок конца секции данных, который является также ASCII строкой вида «SF6_@EDF» (EDF — End of Data Frame).
Структура простая и легко разбирается даже на слабых устройствах с ограниченным функционалом. Отметим также, что идентификатор пакета (id — identifier) и «особый» идентификатор (qn — qualified number) не регламентированы по использованию и могут быть использованы самым разным образом для передачи нужных служебных данных. Это позволяет использовать данные поля по усмотрению программиста и именно он придает им конкретный смысл, несмотря на то, что наличие id и qn обязательно во фрейме данных.
Реализован SF6 в виде структуры данных на D, которая хранит внутреннее содержание пакета в нескольких полях: id, qn, data и packet. К ним прилагаются сеттеры/геттеры позволяющие изменять/считывать содержимое пакета, при этом сеттеры принимают на вход массивы беззнаковых байтов (но, есть перегруженные варианты сеттеров для полей id и qn, принимающие на вход 32-битное значение), а геттеры возвращают такие же массивы.
Идеология работы со структурой данных SF6_Packet проста: c помощью сеттера setPacket в структуру вносятся байты, полученные из некоторого источника, затем запускается процедура decode, которая разбирает пакет на секции, и извлекаются байты данных с помощью геттера getData. Помимо такой работы со структурой возможно не только считывание пакета, но и его формирование, для чего предусмотрено использование сеттеров, устанавливающих отдельные компоненты пакета в нужные значения с последующим его созданием с помощью процедуры encode и извлечением полученного пакета с помощью геттера getPacket.
Структура SF6_Packet реализована в следующем коде на D:
import std.conv;
template addProperty(T, string propertyName, string defaultValue = T.init.to!string)
{
import std.string : format, toLower;
const char[] addProperty = format(
`
private %2$s %1$s = %4$s;
void set%3$s(%2$s %1$s)
{
this.%1$s = %1$s;
}
%2$s get%3$s()
{
return %1$s;
}
`,
"_" ~ propertyName.toLower,
T.stringof,
propertyName,
defaultValue
);
}
/+
+ Simple Frame protocol with 6 fields (SF6)
+
+ Protocol structure:
+ magic number: "SF6!"
+ system information marker: "SF6_"
+ id: 4 byte value
+ system information marker: "SF6_"
+ qn: 4 byte value
+ begin data frame (BDF): "SF6_@BDF"
+ data: 256 bytes
+ end data frame (EDF): "SF6_@EDF"
+
+ id is identifier of packet (no reglament)
+ qn is another identifier for packet (no reglament)
+/
class SF6_Packet
{
private
{
// magic number is "SF6!"
enum ubyte[4] MAGIC_NUMBER = [0x53, 0x46, 0x36, 0x21];
// system fields is "SF6_"
enum ubyte[4] SF = [0x53, 0x46, 0x36, 0x5f];
// data begin marker is "SF6_@BDF"
enum ubyte[8] BDF = [0x53, 0x46, 0x36, 0x5f, 0x40, 0x42, 0x44, 0x46];
// data end marker is "SF6_@EDF"
enum ubyte[8] EDF = [0x53, 0x46, 0x36, 0x5f, 0x40, 0x45, 0x44, 0x46];
// data portion size (in bytes)
enum DATA_LENGTH = 256;
// packet size
enum PACKET_SIZE = MAGIC_NUMBER.length + (2 * SF.length) + (2 * SF.length) + BDF.length + DATA_LENGTH + EDF.length;
}
mixin(addProperty!(ubyte[4], "ID"));
mixin(addProperty!(ubyte[4], "QN"));
mixin(addProperty!(ubyte[256], "Data"));
mixin(addProperty!(ubyte[], "Packet"));
private
{
// encode value
auto fromUnsignedInteger(uint value)
{
ubyte[4] data;
data[0] = (value & 0xff);
data[1] = (value & (0xff << 8)) >> 8;
data[2] = (value & (0xff << 16)) >> 16;
data[3] = (value & (0xff << 24)) >> 24;
return data;
}
}
this()
{
}
void setID(uint id)
{
_id = fromUnsignedInteger(id);
}
void setQN(uint qn)
{
_qn = fromUnsignedInteger(qn);
}
auto encode()
{
_packet ~= MAGIC_NUMBER;
_packet ~= SF;
_packet ~= _id;
_packet ~= SF;
_packet ~= _qn;
_packet ~= BDF;
_packet ~= _data;
_packet ~= EDF;
}
auto decode()
{
if (_packet.length == PACKET_SIZE)
{
auto magicNumber = _packet[0..MAGIC_NUMBER.length];
auto edfNumber = _packet[$-EDF.length..$];
if ((magicNumber == MAGIC_NUMBER) && (edfNumber == EDF))
{
auto idPosition = MAGIC_NUMBER.length + SF.length;
auto qnPosition = idPosition + SF.length + 4;
auto dataPosition = qnPosition + 4 + BDF.length;
_id = _packet[idPosition..idPosition+SF.length];
_qn = _packet[qnPosition..qnPosition+4];
_data = _packet[dataPosition..dataPosition+DATA_LENGTH];
}
}
}
bool isValid()
{
return ((_packet[0..4] == MAGIC_NUMBER) &&
(_packet[4..8] == SF) &&
(_packet[12..16] == SF) &&
(_packet[20..28] == BDF) &&
(_packet[284..292] == EDF));
}
}Кроме этого, мы создали реализацию передатчика SF6 пакетов для Arduino (использовали Arduino MKR Zero). В этом случае плата получает данные от встроенного АЦП разрядностью 12 бит, разбивает полученные значения на два байта, упаковывает их в SF6 пакет и передает пакет по UART, который не задействован для общения платы с компьютером. Реализация выглядит так:
// send data via UART
void sendData(byte *data, unsigned int length)
{
for (unsigned int i = 0; i < length; i++)
{
Serial1.write(data[i]);
}
}
// encode unsigned long (is analog to D's uint) as array of bytes
void encodeUnsignedLong(byte *data, unsigned long value)
{
data[0] = (value & 0xff);
data[1] = (value & (0xff << 8)) >> 8;
data[2] = (value & (0xff << 16)) >> 16;
data[3] = (value & (0xff << 24)) >> 24;
}
// send SF6 data packet: data - array of bytes, id - identifier of packet, hash - data hash);
void send_SF6Packet(byte *data, unsigned int id, unsigned int hash)
{
byte MAGIC_NUMBER[4] = {0x53, 0x46, 0x36, 0x21};
// system fields is "SF6_"
byte SF[4] = {0x53, 0x46, 0x36, 0x5f};
// data begin marker is "SF6_@BDF"
byte BDF[8] = {0x53, 0x46, 0x36, 0x5f, 0x40, 0x42, 0x44, 0x46};
// data end marker is "SF6_@EDF"
byte EDF[8] = {0x53, 0x46, 0x36, 0x5f, 0x40, 0x45, 0x44, 0x46};
byte ID[4], HASH[4];
encodeUnsignedLong(ID, id);
encodeUnsignedLong(HASH, hash);
sendData(MAGIC_NUMBER, 4);
sendData(SF, 4);
sendData(ID, 4);
sendData(SF, 4);
sendData(HASH, 4);
sendData(BDF, 8);
sendData(data, 256);
sendData(EDF, 8);
}
// simple hashing (R.Pike, B.Kernigan "Practice of programming")
unsigned int simpleHash(byte *data, unsigned int length)
{
unsigned int MULTIPLIER = 31;
unsigned int h;
for (unsigned int i = 0; i < length; i++)
{
h = h * MULTIPLIER + data[i];
}
return h % length;
}
int id = 0;
void setup() {
Serial1.begin(230400);
}
void loop() {
byte data[256];
analogReadResolution(12);
for (unsigned long i = 0; i < 256; i += 2)
{
unsigned int d = analogRead(A1);
data[i] = (byte) (d & 0x00ff);
data[i+1] = (byte) ((d & 0xff00) >> 8);
}
unsigned int hash = simpleHash(data, 256);
send_SF6Packet(data, id, hash);
id++;
}Для испытания концепции формата помимо платы Arduino MKR Zero была использована плата Sipeed Maix Bit на базе процессора архитектуры RISC-V (RV64IMAFDC) с прошитым в нее MaixPy (интерпретатор Python 3 на базе Micropython). Под эту плату был
написан код, который реализует прием пакетов SF6 от Arduino MKR Zero, разбор пакетов, выполнение быстрого преобразования Фурье для поступивших данных и вывод результата на миниатюрный LCD-экран размером 320×240. Код для платы Maix Bit:
class SF6_Packet:
# signature
MAGIC_NUMBER = bytes([0x53, 0x46, 0x36, 0x21])
# system info marker
SF = bytes([0x53, 0x46, 0x36, 0x5f])
# begin data frame
BDF = bytes([0x53, 0x46, 0x36, 0x5f, 0x40, 0x42, 0x44, 0x46])
# end data frame
EDF = bytes([0x53, 0x46, 0x36, 0x5f, 0x40, 0x45, 0x44, 0x46])
# data frame size (in bytes)
DATA_LENGTH = 256;
# packet length (in bytes)
PACKET_LENGTH = 292;
def fromUnsignedInt(self, value):
data = []
data.append(value & 0xff)
data.append((value & (0xff << 8)) >> 8)
data.append((value & (0xff << 16)) >> 16)
data.append((value & (0xff << 24)) >> 24)
return bytes(data)
def __init__(self):
self._id = []
self._qn = []
self._data = []
self._packet = []
def encode(self):
self._packet.extend(self.MAGIC_NUMBER)
self._packet.extend(self.SF)
self._packet.extend(self._id)
self._packet.extend(self.SF)
self._packet.extend(self._qn)
self._packet.extend(self.BDF)
self._packet.extend(self._data)
self._packet.extend(self.EDF)
def decode(self):
if (len(self._packet) == self.PACKET_LENGTH):
magicNumber = self._packet[:len(self.MAGIC_NUMBER)]
edfNumber = self._packet[len(self._packet) - len(self.EDF):]
if ((magicNumber == self.MAGIC_NUMBER) and (edfNumber == self.EDF)):
idPosition = len(self.MAGIC_NUMBER) + len(self.SF)
qnPosition = idPosition + len(self.SF) + 4;
dataPosition = qnPosition + 4 + len(self.BDF)
self._id = self._packet[idPosition:idPosition+len(self.SF)];
self._qn = self._packet[qnPosition:qnPosition+4];
self._data = self._packet[dataPosition:dataPosition+self.DATA_LENGTH];
from fpioa_manager import fm, board_info
from machine import UART
from Maix import FFT
import image
import lcd
# Pin 15 - TX
fm.register (board_info.PIN15, fm.fpioa.UART1_TX)
# Pin 17 - RX
fm.register (board_info.PIN17, fm.fpioa.UART1_RX)
# UART: 230 400 baud
uart = UART(UART.UART1, 230400, timeout=1000)
# init packet class
sf6 = SF6_Packet()
data = []
lcd.init()
img = image.Image()
sample_points = 1024
FFT_points = 512
lcd_width = 320
lcd_height = 240
hist_num = FFT_points
if hist_num > 320:
hist_num = 320
hist_width = int(320 / hist_num) #changeable
x_shift = 0
while True:
while len(data) < sample_points:
d = uart.read(292)
if not (d is None):
sf6._packet = d
sf6.decode()
p = sf6._data
data.extend(p)
FFT_res = FFT.run(bytearray(data), FFT_points)
FFT_amp = FFT.amplitude(FFT_res)
img = img.clear()
x_shift = 0
for i in range(hist_num):
if FFT_amp[i] > 240:
hist_height = 240
else:
hist_height = FFT_amp[i]
img = img.draw_rectangle((x_shift,240-hist_height,hist_width,hist_height),[255,255,255],2,True)
x_shift = x_shift + hist_width
lcd.display(img)
data = []Выглядит это впечатляюще:
Но и на этом наша команда не остановилась: мы создали приемник пакетов SF6 и для компьютера, воспользовавшись D и его библиотекой из реестра dub под названием serialport. Для этого мы написали простую демонстрацию, в которой использована старая версия SF6, отличающаяся только наименованием служебного поля qn (в старой версии оно называется hash), и которая выглядит следующим образом:
#!/usr/bin/env dub
/+ dub.sdl:
name "packets"
dependency "serialport" version="~>2.2.3"
+/
import serialport;
import std.algorithm;
import std.format;
import std.range;
import std.stdio;
import std.string;
import std.conv;
template addProperty(T, string propertyName, string defaultValue = T.init.to!string)
{
import std.string : format, toLower;
const char[] addProperty = format(
`
private %2$s %1$s = %4$s;
void set%3$s(%2$s %1$s)
{
this.%1$s = %1$s;
}
%2$s get%3$s()
{
return %1$s;
}
`,
"_" ~ propertyName.toLower,
T.stringof,
propertyName,
defaultValue
);
}
class SF6_Packet
{
private
{
// magic number is "SF6!"
enum ubyte[4] MAGIC_NUMBER = [0x53, 0x46, 0x36, 0x21];
// system fields is "SF6_"
enum ubyte[4] SF = [0x53, 0x46, 0x36, 0x5f];
// data begin marker is "SF6_@BDF"
enum ubyte[8] BDF = [0x53, 0x46, 0x36, 0x5f, 0x40, 0x42, 0x44, 0x46];
// data end marker is "SF6_@EDF"
enum ubyte[8] EDF = [0x53, 0x46, 0x36, 0x5f, 0x40, 0x45, 0x44, 0x46];
// data portion size (in bytes)
enum DATA_LENGTH = 256;
// packet size
enum PACKET_SIZE = MAGIC_NUMBER.length + (2 * SF.length) + (2 * SF.length) + BDF.length + DATA_LENGTH + EDF.length;
}
private
{
mixin(addProperty!(ubyte[4], "ID"));
mixin(addProperty!(ubyte[4], "Hash"));
mixin(addProperty!(ubyte[256], "Data"));
mixin(addProperty!(ubyte[], "Packet"));
// encode value
auto fromUnsignedInteger(uint value)
{
ubyte[4] data;
data[0] = (value & 0xff);
data[1] = (value & (0xff << 8)) >> 8;
data[2] = (value & (0xff << 16)) >> 16;
data[3] = (value & (0xff << 24)) >> 24;
return data;
}
}
this()
{
}
void setID(uint id)
{
_id = fromUnsignedInteger(id);
}
void setHash(uint hash)
{
_hash = fromUnsignedInteger(hash);
}
auto encode()
{
_packet ~= MAGIC_NUMBER;
_packet ~= SF;
_packet ~= _id;
_packet ~= SF;
_packet ~= _hash;
_packet ~= BDF;
_packet ~= _data;
_packet ~= EDF;
}
auto decode()
{
if (_packet.length == PACKET_SIZE)
{
auto magicNumber = _packet[0..MAGIC_NUMBER.length];
auto edfNumber = _packet[$-EDF.length..$];
if ((magicNumber == MAGIC_NUMBER) && (edfNumber == EDF))
{
auto idPosition = MAGIC_NUMBER.length + SF.length;
auto hashPosition = idPosition + SF.length + 4;
auto dataPosition = hashPosition + 4 + BDF.length;
_id = _packet[idPosition..idPosition+SF.length];
_hash = _packet[hashPosition..hashPosition+4];
_data = _packet[dataPosition..dataPosition+256];
}
}
}
bool isValid()
{
return ((_packet[0..4] == MAGIC_NUMBER) &&
(_packet[4..8] == SF) &&
(_packet[12..16] == SF) &&
(_packet[20..28] == BDF) &&
(_packet[284..292] == EDF));
}
}
void main()
{
enum PORT_SPEED = 230_400;
SerialPortBlk device = new SerialPortBlk("/dev/ttyACM0", PORT_SPEED);
device.config = SPConfig(PORT_SPEED, DataBits.data8, Parity.none, StopBits.one);
ubyte[292] buffer;
device.read(buffer);
auto p = new SF6_Packet;
p.setPacket(buffer);
p.decode;
p.getID.writeln;
p.getHash.writeln;
p.getData.writeln;
p.getPacket.writeln;
p.isValid.writeln;
float[] data;
auto tmp = p.getData;
for (int i = 0; i < 256; i += 2)
{
uint value;
value |= tmp[i];
value |= (tmp[i+1] << 8);
data ~= value;
data ~= (value / 1024.0) * 3.3;
}
data.writeln;
}Запускается демонстрация командой:dub run --single packets2.d
Реализация пакетов SF6 оказалась очень простой и доступной, что позволило нам использовать её для своих проектов. Описанная выше проблема со спектроанализатором была решена в тот же день, когда была написана первая версия формата SF6, и потребовала незначительной модификации кода с добавлением файла sf6.d. Это событие нас очень порадовало и поэтому мы решили рассказать о собственном формате пакетов, который пусть и является экспериментальным, но все же может быть использован и вами, уважаемые читатели…