Hallo,

ich arbeite derzeit (bzw. bin am Finalisieren) einer API für ein 
Buskommunikationsmodul das sich DevComSlave nennt. Es handelt sich dabei 
im Wesentlichen um ein Modul, das einen Protokollstack für diverse 
Bussysteme auf Master-Slave-Basis (z.B. und hauptsächlich gedacht für 
RS485) implementiert, über dessen Protokoll Daten sowie Befehle 
ausgetauscht werden können. Im Modul werden Fehlererkennung (& 
Behandlung), Acknowledgeing, Buszugriff und einige Befehle verarbeitet, 
diese Funktionen sollen vom Applikationsprogrammierer nicht verändert 
werden müssen  dürfen  können.

Ziel ist es, eine API zu schaffen, die - ich sag mal vorsichtig - 
annähernd objektorientiert ist und einigermaßen Hardwareunabhängig ist 
(vorerst mal auf AVR). Dazu wird eine statische Library erzeugt und über 
ein Headerfile ein Interface geschaffen (Bibliothek muss natürlich zum 
Projekt dazugebunden werden)

Mir geht es jetzt darum, wie verständlich und gut zu handhaben ihr 
angehängte Zugriffsmethoden und Funktionsprinzipien findet. Main.c ist 
mit mitgelinkter static Library so voll funktionsfähig.

Headerdatei (also Interfacedefinition) findet sich im Anhang.

Habe jetzt bewusst nicht die gesamte Doku mitgeliefert da es mir um die 
Lesbarkeit des Codes geht und ich kenne einige Programmierer die sowieso 
nie Doku lesen - also gehts mir auch darum, den Code und Handhabung 
halbwegs intuitiv zu halten. Ein Teil der Bibliotheksbeschreibung der im 
Wesentlichen das DevCom-Prinzip unabhängig von der Implementierung 
beschreibt ist als PDF angehängt. Protokollspezifikation (großteils bis 
auf einige Details fertig (Masterimplementierung und paar Kleinigkeiten 
fehlen noch)) ebenfalls im Anhang.

Main.c (Initialisiert und startet ein DevComSlave-Module, polled das 
Flag, in dem signalisiert wird, dass neue Daten verfügbar sind)

#include <avr/io.h>
#include "DevComSlave.h"

uint8_t fooCmdHandler(const unsigned char* cmd, unsigned char lastCtrlByte, unsigned char upperBound, unsigned char responseAllowed)
{    
  switch(cmd[0])
  {
    case 0x0D: 
        // Handle Command 0x0D
        return(DCS_CMDHANDLER_SUCCESS); 
        break;
    default: break;
  }    
  // Command is unknown  
  return(DCS_CMDHANDLER_ERROR);
}

#include "crc8.h"

int main()
{
  DevComSlave_t dc;

  dcs_setDefaults(&dc,10);        // Default, with SA=10. use of dcs_setDefaults recommended..  
  dc.MCAddress = 0x04;
  
  // RW-Output
  dc.RWPort = &PORTD;            
  dc.RW_bp = PD2;
  dc.RWPolarity = 1;            
  
  // Commandhandling
  dc.CommandHandler = fooCmdHandler;    // Callbackfunction for user-commands
  
  dc.DataUpperBound = 9-1;      // Datasets are expected to be 9 Bytes long
  dc.ID = 0x1234;            // Device ID is 0x1234 (e.g. for identification by master application)
      
  dcs_atmega88_rw_init(&dc, F_CPU, 500000);  // Initialize with 500kbps
  // DevComSlave-Module now Ready and listening..
      
  while(1)
  {
    if(dc.NewReceived & DCS_REC_DATA_gm)
    {
      // Do something, access Data ranging from dc.Data[0] .. dc.Data[dc.DataUpperBound]
      
      dc.NewReceived &= ~(DCS_REC_DATA_gm); // Reset Flags
    }
  }  
}

Kurz noch zum Projektstatus:
- Slaveimplementierung für Atmega fertig, für XMegas in Testphase. 
Durch. Codegröße: 2500 Bytes derzeit... is aber glaub ich noch was drin
- Masterimplementierung für C# / Managed C++ fertig (läuft über 
USB-Serial Umsetzer oder wahlweise TCP-Verbindungen (z.b. Moxa NPORTs)
- Protokollspezifikation gerade in Finalisierung
- Am Multimaster feil ich noch, läuft derzeit nur stabil mit 1 Master im 
System

Habe vor das ganze dann open source zu machen, eventuell kanns ja der 
ein oder andere brauchen. Bei uns in der Firma wirds erfolgreich 
eingesetzt (im Innen- und Außenbereich), Datenübertragungsraten bis zu 
1Mbit/s sind bei 20MHz Quarz i.d.R. möglich, 500kbit/s auf jeden Fall.


Bei Interesse stelle ich natürlich gerne weitere Informationen zur 
Verfügung.


Zerreist es in der Luft ;)

Vielen Dank schon einmal für eure Mühe
Thomas