Betriebssystem für Bascom: Unterschied zwischen den Versionen

Version vom 8. März 2006, 20:24 Uhr

Inhaltsverzeichnis

1 Betriebsystem für Bascom
2 SYS.BAS Demo
3 Befehls-Referenz
4 Autor
5 Siehe auch

Betriebsystem für Bascom

Die im Text angesprochenen Bascom-Libraries befindet sich im Community-Download-Bereich, zusammen mit einem einfachen Beispielprogramm.

MYSYSLIB.ZIP

Bascom-Libraries --> In das Bascom-Lib Verzeichnis kopieren
- Mybuffer.LBX Interne Hilfsfunktionen
- Myunit.LBX UNIT Kontrolle
- Mymsgque.LBX MESSAGE-QUEUE Kontrolle
- Myrncom.LBX Kommunikations Module
Bascom-include-Files--> In ein Bascom Projekt- Verzeichnis kopieren
- Myunit.BAS
- Mymsgque.BAS
- Myrncom.BAS
Bascom-Demo-TestProgramm
- SYS.BAS, ausgelegt f. RNBFRA 1.2 ebenfalls in ein Projekt-Verzeichnis

Kommunikations-Test-Parter f. PC
- RN_SERVER.EXE f. XP, W98, W2k
- MFC42(d).DLL, was das jemandem fehlen sollte

Wenn alles verbunden und gestartet ist, steuert der PC im Sekundentakt die 4 LEDs auf der RNBFRA Karte.

Im Wesentlichen ist es die Aufgabe eine Betriebssystems, das Zusammenspiel der verschiedenen Programmteile, aus denen ja so eine µC-Applikation besteht, zu regeln. Die Nachteile des gewissen Overheads und der natürlich erforderlichen Restriktionen´sollten durch die Vorteile der Standardisierung und Modularisierung deutlich aufgewogen werden.

Bascom bietet für sehr viele AVR-intere Geräte und Peripherie Funktionen an, die oft ganz einfach durch "Config" Anweisungen initiiert werden können und dem Programmierer viel Detailentwicklungsarbeit abnehmen. Ein unschätzbarer Vorzug. Was aber immer wieder bleibt, ist das Problem des Zusammenwirkens dieser Komponenten und die gewünschte Mehrgleisigkeit, "Multithreading", des gesamten Projekts.

Es soll hier ein Konzept vorgestellt werden, das hauptsächlich in Hinblick auf eine Standardisierung der Rechner-Kommunikation entwickelt wurde. Also µC <-> PC und µC <-> Peripherie.

Das verwendete "Message-Queueing" ist natürlich keine neue Erfindung, jeder Windows-Programmierer kennt das. Das Problem war es, eine Form zu schaffen, die sich in Bascom so eingliedern läßt, daß auch die "normale" Verwendung des Compilers möglich ist. Nur an den Schnittstellen zu den Sys-Funktionen müssen die Konventionen eingehalten werden.

Anmerkung: Dieses Multi-tasking beruht natürlich darauf, daß so ein einzelnes "Task-Slice" kurz gehalten wird und keine wesentlichen Wait-States beinhaltet. Schließlich muß für die anderen ja auch was übrigbleiben. Auch ausführlich "FOR" Schleifen sollten zu Einzel-Slices umgewandelt werden, d.h. bei jedem Aufruf EIN Step. Was daraus folgt, ist, daß die einzelnen Tasks im Grunde als "State-Machine" arbeiten, z.B.

FOR-Start
FOR-Step
FOR-Limit

Begriffe

Units: Ein Programmteil, der sozusagen mitspielen will, wird als Unit od. "Einheit" bezeichnet. In den meisten Fällen wird so eine Unit die verschiedenen Funktionen umfassen, die für die Bedienung eines bestimmten Device od. "Gerät" erforderlich sind.
Class/Ident: Es gibt Geräteklassen, die sich durch ein Set von "Methoden" definieren, die auf eines oder mehrere tatsächliche Geräte angewendet werden können. Anschauliches Beispiel: die Klasse "ADC", die für 8 Channels angewendet werden kann. Grundsätzlich werden die ADC-Channels ja völlig gleich behandelt, aber für jeden Kanal gelten unter Umständen verschiedene Parameter: Natürlich die Kanal-Nummer 0-7, aber auch Umrechnungsfaktoren und Grenzwerte
Tags: Jeder Class/Ident-Ausprägung wird ein Tag ("Etikett") zugeordnet, das einen vom System verwalteten Bereich bezeichnet, der für die Kommunikation Unit <-> System erforderlich ist. Tags werden bei jedem Aufruf an das System verwednet und bei Aufrufen durch das System immer mitgeliefert.
Message-Queueing: An sich können alle Funktionen eines Units "normal" verwendet, also aufgerufen werden. Doch jede Unit bietet wenigstens eine "Sub"-function an, die auch indirekt über Messages angesprochen werden kann und daher auch ein standardisiertes Format haben muß.

  DECLARE SUB unit-entry ( Tag AS WORD, Byval cmd as BYTE, Byval Param as WORD )

Das ist auch die SUB, die beim Einlangen einer Nachricht über das Netzwerk aufgerufen wird.

Tag ist das erwähnte Etikett, mit dem die SUB alle ihre Referenzen zu privaten Daten und individuellen Parametern (im Flash Speicher) verwaltet.
Cmd ist eine Aufrufspezifischer Code, der über die Art des Aufrufes Auskunft gibt. Einige Codes sind fest durch das System vergeben, andere können beliebig von der Geräteklasse für spezielle Befehle festgelgt werden
Param ist ein Beiwert zu CMD, der daher völlig unterschiedliche Bedeutung haben kann. (Beim Netzwerk-Nachrichten zeigt er auf die eingelangten Daten, die von der Unit zu bearbeiten sind).

TAG-Referenzen

Das System findet durch den Tag die zugeordnete SUB-Routine (Vector). Die Unit hingegen findet durch die System-Function "Unit_REF()" ihre privaten Daten, und kann auch durch "Unit_parbyte(tag), Unit_parword(tag),Unit_parlong(tag),Unit_parsing(tag)" ihre individuellen Parameter abfragen.

Die ersten beiden Bytes der Flash-Parameter sind genormt und beinhalten den Class-Code und Identifier der Unit. Die übrigen sind vom System nicht festgelegt und können beliebige Werte beinhalten.

Message-Queue

Durch msg_enqueue() wird ein indirekter Aufruf in die Queue gestellt. Es gibt keine Festlegung darüber, wann und wo dieser Call erfolgen kann.
Die Abarbeitung erfolgt FIFO durch msg_dequeue(). Bei jedem Aufruf wird EINE Message (wenn eine vorhanden ist) abgearbeitet. Auch für diesen Aufruf gibt es keinen zwingenden Platz, doch ist es zweckmäßig und empfehlenswert, ihn nur einmal an zentraler Stelle (DO..LOOP) zu tätigen.

Anmerkung: Enqueue() und Dequeue() führen sowohl Sub-Vector als auch Tag. "Vector" hat Vorrang, wenn er aber nicht angegeben wird (NULL), wird eben der Standard-Unit-Vector verwendet. Sonderfall: Bei Angabe von "Vector" ist die Befüllung von TAG nicht zwingend. Dadurch kann auch jede x-beliebige sub-function aufgerufen werden, nur das Declare-Format MUSS stimmen. ("TAG" ist beim Aufruf dann eben NULL).

SYS.BAS Demo

Statt umfangreicher theoretischer Abhandlungen einfach das Sys.BAS Demoprogramm mit einigen Kommentaren.

$regfile = "m32def.dat"
$crystal = 8000000

Const Tmr_c_prescale = 64
Const Tmr_c_preload = 131

$baud = 9600
$hwstack = 64
$swstack = 256
$framesize = 64


Const Max_c_unit = 8
Const Max_c_msg = 16

Const Rx_bufsize = 48

$include "myrncom.bas"
$include "myunit.bas"
$include "mymsgque.bas"

Hier erfolgen die Definitionen für die Library

Die Timer-Werte sind für 1 mS Interrupt bei 8MHZ ausgelegt.
Max_c_unit gibt an, wieviele Units maximal verwendet werden können.
Max_c_msg gibt an, wieviele Messages gleichzeitig verwendet werden können.
rx_buffersize gibt die Größe des (Ring)Buffers für den RNCOM-Empfang an.
Include: in den definitions-includes werden alle notwendigen Werte festgelegt.

'-------------------------------------------------
'           Common Commands
'-------------------------------------------------
Const Cmd_nop = 0
Const Cmd_setup = 1
Const Cmd_init = 2

Const Cmd_time = 4
Const Cmd_set = 5
Const Cmd_msg = 16

Das sind Muster für festgelegte Codes für Kommandos. Dem System ist es gleich, was man definiert. Es muß halt in ein Byte reinpassen.

'-------------------------------------------------
'           RNBFRA I2C
'-------------------------------------------------
Config I2cdelay = 5
Config Scl = Portc.0                                        'Ports fuer IIC-Bus
Config Sda = Portc.1
'-------------------------------------------------
'           RNBFRA I2C Addresses
'-------------------------------------------------
Const Pwr_adr = &H74                                        'I2C Adress Powerport
Const Out_adr = &H72                                        'I2C Adress Extension-Out Port
Const Exp_adr = &H7E                                        'I2C Read Adress Expansion-In Port


Const Pwr_default = &HFF                                    'I2C Powerport
Const Out_default = &H00                                    'I2C Extension-Out Port

Das ist dem RNBFRA-User alles vertraut, braucht man wohl nicht zu erklären.

'-------------------------------------------------
'           Class IDs
'-------------------------------------------------
Const Cls_pcf = &H42                                        ' ASCII "B"

Das sollte man für den Demo-Test nicht ändern, da es auch im PC-Programm so verwendet wird.

'-------------------------------------------------
'           CLASS entries     R8:R9=Flash Param  (restore indiv.params)
'-------------------------------------------------
Declare Sub Pcfclass(byval Tag As Word , Byval Cmd As Byte , Byval Param As Word)

Die Deklaration der UNIT-Haupt-Funktion. Der Name ist beliebig, das Format muß aber genau so sein.

'=========================================================================================
' Timer0 Prescale for 1mS Interrupt
'=========================================================================================
Config Timer0 = Timer , Prescale = Tmr_c_prescale           'Timer 1mS
On Timer0 Interrupt_ticker                                  ' Timer for Timer Queue

Hier wird Timer0 initialisiert.Das System selbst verwendet den Timer nicht. Nur um "getimete" Messages abzusetzen, braucht man natürlich schon irgendeinen Timer

'-------------------------------------------------
' frequently used units
'-------------------------------------------------
Dim Pwrtag As Word
Dim Outtag As Word
Dim Exptag As Word

'-------------------------------------------------
'           work data
'-------------------------------------------------
Dim Par_byte As Byte
Dim Par_word As Word
Dim Par_addr As Word
Dim Mytag As Word
Dim Tempb As Byte

'-------------------------------------------------
'   enable
'-------------------------------------------------
   Enable Timer0
   Enable Interrupts

Es werden 3 Units mit der selben Funktion erzeugt. Jede Unit steuert einen PCF-Chip auf dem RNBFRA-Board.

'-------------------------------------------------
'           setup Units
'-------------------------------------------------
' RNBFRA PCF Ports

      Exptag = Unit_new()
      Par_addr = Loadlabel(exp_par)                         ' PCF Inp-Port
      Call Pcfclass(exptag , Cmd_setup , Par_addr)

      Outtag = Unit_new()
      Par_addr = Loadlabel(out_par)                         ' PCF OUT-Port
      Call Pcfclass(outtag , Cmd_setup , Par_addr)

      Pwrtag = Unit_new()
      Par_addr = Loadlabel(pwr_par)                         ' PCF PWR-Port
      Call Pcfclass(pwrtag , Cmd_setup , Par_addr)

Nur zur Erläuterung habe ich die Unit-Paramter gleich hier eingefügt, in SYS.BAS sind die natürlich weiter hinten.

'-----------------------------------------------
'        Class parameter
'-----------------------------------------------
'         class   idn  devadr    default      timeout mS
Out_par:
   Data Cls_pcf , 1 , Out_adr , Out_default , 0%            ' passive device
Pwr_par:
   Data Cls_pcf , 2 , Pwr_adr , Pwr_default , 0%            ' passive device
Exp_par:
   Data Cls_pcf , 3 , Exp_adr , 0 , 1500%                   ' auto sensor device

Für jede Unit gibt es vorgegebene Werte:

Die ersten Byten Bytes müssen den Unit-Code (Klasse, Ident) beinhalten, der Rest ist wahlfrei
- Klassencode
- Die Ident-Nummer 1-3
Wahlfrei
die I2C Addresse des PCF, der zu bedienen ist
Ein Anfangswert für diese Port. Beim Input (3) ist das sinnlos,
dafür steht nur bei diesem der Wert 1500 als automatischer Wiederholungswert. Beim 1mS Timer ergibt das 1.5 Sekunden.

'-------------------------------------------------
'           main loop
'-------------------------------------------------
   Do
      Gosub Rxinput
      Call Msg_dequeue(0 , 0 , 0)
   Loop
End

Die Hauptschleife ist ziemlich einfach gehalten. Es wird jedesmal abgefragt, ob der PC was gesendet hat, danach wird geguckt, ob eine Message zum Abarbeiten ist. Und so geht's die ganze Zeit dahin.

'==============================================================================
' Timer 0  interrupt
'==============================================================================
Interrupt_ticker:
   Timer0 = Tmr_c_preload
   Gosub Time_scan
Return

Die Timer ISR. Jedesmal wird mit "Time-Scan" geprüft, ob eine "Getimete" Message fällig ist. Wenn ja, wird sie aktiviert.

'==============================================================================
' Workout Frame
'==============================================================================
Dim Class As Byte                                           'destination Class
Dim Ident As Byte                                           'destination Ident
Dim Msg As Word                                             'Message-Base
Dim Leng As Byte

Rxinput:
   Msg = Com_msg()
   If Msg <> 0 Then
      Leng = Com_rdbyte()
      If Leng >= 3 Then
         Class = Com_rdbyte()
         Ident = Com_rdbyte()
         Mytag = Unit_find_clsid(class , Ident)
         If Mytag <> 0 Then
            Call Unit_call(mytag , Cmd_msg , 0)
         End If
      End If
      Call Com_msgdone(msg)
   End If
   Return

Durch "Com-MSG()" wird gefragt, ob eine (komplette) Message eingetroffen ist. Entspricht etwa dem "Ischarwaiting()" vom Bascom selbst. Ist was da, wird das erste Byte der Message gelesen, das die Länge enthält. Nur, wenn die plausibel ist, wird die Zieladresse gelesen. Mit

        Mytag = Unit_find_clsid(class , Ident)

wird geschaut, ob wir so ein Unit auch haben. Wenn ja, wird mit

           Call Unit_call(mytag , Cmd_msg , 0)

die Funktion aufgerufen, mit dem Kommando cmd_msg, der Beiwert (argument) ist in diesem Falle NULL.

Verarbeitet oder nicht, auf jeden Fall wird der noch reservierte Message-Bereich im UART-Buffer wieder freigegeben

     Call Com_msgdone(msg)

Und damit hat sich's.

Die Unit-PCF

Das ist ein Muster, das man auch ganz anders machen kann. Festgelegt ist nur der Einstieg und das Format. Natürlich erwartet das System, daß das Kommando durchgeführt wird, aber alle Details sind Sache der Anwenders.

'------------------------------------------------------------------------------
'        UNITS
'------------------------------------------------------------------------------
'------------------------------------------------------------------------------
'        Class PCF
'        private class data
'------------------------------------------------------------------------------
Const Max_c_pcf = 3
Dim Pcfidx As Byte

Dim Pcf_bck(max_c_pcf) As Word                              ' backlink to tag
Dim Pcf_value(max_c_pcf) As Byte                            ' private data

Wir wollen drei Units verwenden, also werden die verwendeten Daten als array dreifach angelegt. für den PCF haben wir eigentlich nur ein Byte, das den Soll oder Istwert des PCF aufnehmen kann.

'---------------------------------------------------------------------------
Sub Pcfclass(byval Tag As Word , Byval Cmd As Byte , Byval Param As Word)
Local Pcf_index As Byte

   Pcf_index = Unit_ref(tag)                                ' get private ref

   Select Case Cmd

Command SETUP

'----------------------------------------------------------------------------
'         SETUP Command
'----------------------------------------------------------------------------
   Case Cmd_setup:
      Call Unit_flg_set(tag , 1)                            ' set active
      Par_word = Loadlabel(pcfclass)
      Call Unit_vec_set(tag , Par_word)                     'set vector
      Call Unit_par_set(tag , Param)                        'set FLASH parameter
      Incr Pcfidx                                           'make private Index
      Call Unit_ref_set(tag , Pcfidx)                       'store it
      Pcf_index = Pcfidx
      Pcf_bck(pcf_index) = Tag                              ' Backlink to unit
      Pcf_value(pcf_index) = Unit_parbyte(tag , 3)          ' default value
      Pcf_index = Unit_ref(tag)                             ' set received value
      I2cinit

In den folgenden Zeilen unterscheidet der Code, ob der jeweilige PCF als INPUT oder als OUTPUT zu verwenden ist.

Ist ein TImeout angegeben, soll es wohl INPUT sein, d.h. es wird ein Timer aufgesetzt
Sonst ist es wohl OUTPUT, daher wird der Anfangswert lt. Parameter an der PCF gesendet.

      Par_word = Unit_parword(tag , 4)                      ' refresh time
      If Par_word <> 0 Then
         Gosub Pcf_refresh_time                             ' sensor device
      Else
         Gosub Pcf_send_val                                 ' act.device
      End If

Command MESSAGE (from PC)

'----------------------------------------------------------------------------
'         MESSAGE RECEIVED  Command
'----------------------------------------------------------------------------
   Case Cmd_msg:
      Tempb = Com_rdbyte()                                  ' ignore source class
      Tempb = Com_rdbyte()                                  ' ignore source ident
      Tempb = Com_rdbyte()                                  ' data byte
      Pcf_value(pcf_index) = Tempb                            ' store
      Gosub Pcf_send_val

Der empfangene Wert wird zum PCF gesendet.

Command SET

Wird im Beispiel nicht verwendet.

'----------------------------------------------------------------------------
'         SET DEVICE Command
'----------------------------------------------------------------------------
   Case Cmd_set:
      Pcf_value(pcf_index) = Param                            ' store
      Gosub Pcf_send_val

Command TIME

Wenn der TImer (1500, s.o.) abgelaufen ist, wird die Unit mit diesem Kommando aufgerufen. Es wird der aktuelle Wert vom PCF geholt, und als Message an den PC geschickt. Danach wird ein neuer Timer aufgesetzt.

'----------------------------------------------------------------------------
'         TIME ELAPSE   Command
'----------------------------------------------------------------------------
   Case Cmd_time:
      Gosub Pcf_sens_val                                    ' read PCF Device
'----------------------------------------------------------------------------
'send Message to host
      Call Com_txstart()
' write empfänger--------
      Tempb = 0
      Call Com_txbyte(tempb)                                ' dest class
      Call Com_txbyte(tempb)                                ' ident
' write absender---------
      Tempb = Unit_parbyte(tag , 0)                         '
      Call Com_txbyte(tempb)                                ' source class
      Tempb = Unit_parbyte(tag , 1)                         ' source ident
      Call Com_txbyte(tempb)
' write data-------------
      Tempb = Pcf_value(pcf_index)
      Call Com_txbyte(tempb)                                ' Data
' finish message---------
      Call Com_txclose()
'----------------------------------------------------------------------------

      Gosub Pcf_refresh_time                                ' refresh timer

   Case Else:

   End Select
   Exit Sub

Noch einige Sub's für die Unit.

Pcf_refresh_time:
   Par_word = Unit_parword(tag , 4)                         ' refresh time
   Par_byte = Time_entry(0 , Tag , Cmd_time , Par_word)     'new timer
   Return
Pcf_send_val:
   Par_byte = Unit_parbyte(tag , 2)                         ' device address
   Tempb = Pcf_value(pcf_index)
   I2cstart
   I2cwbyte Par_byte
   I2cwbyte Tempb
   I2cstop
   Tempb = 0
   Return
Pcf_sens_val:
   Par_byte = Unit_parbyte(tag , 2)                         ' device address
   Incr Par_byte                                            ' I2C Read addr
   I2cstart
   I2cwbyte Par_byte
   I2crbyte Tempb , Nack
   I2cstop
   Pcf_value(pcf_index) = Tempb
   Return
End Sub

Befehls-Referenz

UNIT

 Declare Sub Unit_call(tag As Word , Byval Cmd As Byte , Byval Param As Word)
 Declare Function Unit_new() As Word
 Declare Function Unit_find_clsid(byval Class As Byte , Byval Ident As Byte) As Word
 Declare Sub Unit_vec_set(tag As Word , Byval Vec As Word)
 Declare Sub Unit_par_set(tag As Word , Byval Par As Word)
 Declare Sub Unit_ref_set(tag As Word , Byval Flg As Byte)
 Declare Sub Unit_flg_set(tag As Word , Byval Flg As Byte)
 Declare Function Unit_flg(tag As Word) As Byte
 Declare Function Unit_vec(tag As Word) As Word
 Declare Function Unit_par(tag As Word) As Word
 Declare Function Unit_ref(tag As Word) As Byte
 Declare Function Unit_parbyte(tag As Word , Byval Offset As Byte) As Byte
 Declare Function Unit_parword(tag As Word , Byval Offset As Byte) As Word
 Declare Function Unit_parintg(tag As Word , Byval Offset As Byte) As Integer
 Declare Function Unit_parlong(tag As Word , Byval Offset As Byte) As Long
 Declare Function Unit_parsing(tag As Word , Byval Offset As Byte) As Single

MESSAGES & TIMER

 Declare Function Msg_enqueue(byval Vector As Word , Byval Tag As Word , Byval Cmd As Byte , Byval Param As Word) As Byte
 Declare Sub Msg_dequeue(byval Tag As Word , Byval Cmd As Byte , Byval Param As Word)
 Declare Function Time_entry(byval Vector As Word , Byval Tag As Word , Byval Cmd As Byte , Byval Param As Word) As Byte
 Declare Sub Time_scan()

Kommunikation

 Declare Sub Com_msgdone(msg As Word)
 Declare Function Com_msg() As Word
 Declare Sub Com_txstart()
 Declare Sub Com_txclose()
 Declare Sub Com_txbyte(byval Val As Byte)
 Declare Function Com_rdbyte() As Byte
 Declare Function Com_rdword() As Word
 Declare Function Com_rdlong() As Long
 Declare Function Com_rdintg() As Integer
 Declare Function Com_rdsing() As Single

Autor

PicNick

Siehe auch