AVR Freaks

DMX512 for lighting entertainments.
Streaming 512 of 1byte packets 250kbps
Simple Format
No checksum
1 master broadcasts data over bus, several slaves.
Twisted pair shielded cable required, D+/D-/COM
documented as ANSI E1-11
.
also RDM light control, sensor read
More complicated packet format, 250kbps, with checksum
Polling bus, 1 master, several slaves
Twisted pair shielded cable required, D+/D-/COM
Documented as ANSI E1-20
.
There is also DALI for Lighting control, sensor read
Complicated packet format 1.2 kbps
İsolated physical layer, robust bus, plain 2x wire with no polarity
I think it is patented document.

What's wrong with SANDU protocoll? (Something Awneil dreamed up)

Google Protocol Buffers are a good choice for data encoding (as also mentioned by clawson) since there is such wide support for them. On the microcontroller side of things I've had good experiences using the nanopb implementation so long as variable length fields are avoided or have established maximum sizes.

 

One thing to note about Protocol Buffers though is that they define the structure of serialized data, not how messages are framed. Prefixing messages with a varint message size is common (nanopb and Google C++ implementation support this, others probably do too). nanopb also supports null terminating messages but this is non-standard. Another option would be using SLIP for framing.

When I've used protobufs it's been the "real thing" as I've been using it on "big iron". Not sure about micro implementations.

 

EDIT: and as I typed that I realised I did have an interaction with a "small system" so it looks like it was "nanoPB" that was used.

 

EDIT2: so that would mean this:  https://github.com/nanopb/nanopb - even there it looks (on the surface) "heavy" so might still be for things more like ARMs than AVRs (it would have been ARM where we used it).

 

Ah yes:

 

https://jpa.kapsi.fi/nanopb/docs/index.html

 

Yea (details in the source code)

Protocol decoders - sigrok

 

I threw together a basic nanopb example program to experiment with.

 

example.proto

syntax = "proto3";

message Example_Message {
    fixed32 a = 1;
    fixed32 b = 2;
    fixed32 c = 3;
    fixed32 d = 4;
}

example.c

#include <avr/io.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <util/delay.h>

#include "example.pb.h"
#include "pb_encode.h"

static void configure_usart0( void )
{
    UCSR0B = ( 0 << UCSZ02 ) |
             ( 0 << TXEN0  ) |
             ( 0 << RXEN0  ) |
             ( 0 << UDRIE0 ) |
             ( 0 << TXCIE0 ) |
             ( 0 << RXCIE0 );

    UCSR0A = ( 0 << MPCM0 ) |
             ( 0 << U2X0  );

    UCSR0C = ( 1 << UCSZ00  ) |
             ( 1 << UCSZ01  ) |
             ( 0 << USBS0   ) |
             ( 0 << UPM00   ) |
             ( 0 << UPM01   ) |
             ( 0 << UMSEL00 ) |
             ( 0 << UMSEL01 );

    UBRR0 = 103;
}

static void enable_usart0( void )
{
    UCSR0B = 1 << TXEN0;
}

static void transmit_usart0( uint8_t data )
{
    while ( !( UCSR0A & ( 1 << UDRE0 ))) {}

    UDR0 = data;
}

static uint32_t generate_value(
    char a,
    char b,
    char c,
    char d
)
{
    return (((uint32_t)a ) << 24 ) |
           (((uint32_t)b ) << 16 ) |
           (((uint32_t)c ) <<  8 ) |
           (((uint32_t)d ) <<  0 );
}

static bool transmit_callback(
    pb_ostream_t       * stream,
    uint8_t      const * data,
    size_t               count
)
{
    (void)stream;

    for ( size_t i = 0; i < count; ++i ) {
        transmit_usart0( data[ i ] );
        _delay_ms( 3 );
    } // for

    return true;
}

int main( void )
{
    configure_usart0();
    enable_usart0();

    for ( ;; ) {
        Example_Message const message = {
            .a = generate_value( 'a', 'b', 'c', 'd' ),
            .b = generate_value( 'e', 'f', 'g', 'h' ),
            .c = generate_value( 'i', 'j', 'k', 'l' ),
            .d = generate_value( 'm', 'n', 'o', 'p' ),
        };

        pb_ostream_t stream = {
            .callback      = transmit_callback,
            .state         = NULL,
            .max_size      = SIZE_MAX,
            .bytes_written = 0
        };

        pb_encode_delimited( &stream, Example_Message_fields, &message ); // encoded size is 21 bytes (varint message size plus 5 bytes per field)

        _delay_ms( 5000 );
    } // for
}

Compiled using avr-gcc 8.3.0 with the following flags/definitions:

-std=c17
-Werror -Wall -Wextra
-Wpointer-arith -Wstrict-prototypes
-mmcu=atmega328p -DF_CPU=16000000UL
-Os
-DNDEBUG

avr-size output:

   text	   data	    bss	    dec	    hex	filename
  10600	    518	      0	  11118	   2b6e	example

avr-size output with link time optimization enabled (-flto):

   text	   data	    bss	    dec	    hex	filename
   4014	    246	      0	   4260	   10a4	example

avr-size output with link time optimization enabled (-flto) and nanopb error strings disabled (-DPB_NO_ERRMSG):

   text	   data	    bss	    dec	    hex	filename
   3670	    68	      0	   3738	    e9a	example

Using some of the other nanopb compilation options may lead to further code size reductions.