SI2-CBB filosofie

English text
Na 20 jaar ervaring met allerlei CANbus producten viel mijn oog begin 2012 op een product, dat naast CAN ook nog andere nostalgische gevoelens opriep. De Duinomite Mega, die volgens het artikel de jaren 80 deed herleven met een "ouderwetse" Basic interpreter. Nu was begin jaren 80 mijn liefde voor computers begonnen met de Tandy TRS80 en vele oude guldens zijn destijds gespendeerd aan mijn toenmalige hobby. De hobby is jaren geleden al uitgegroeid tot iets, dat geen guldens meer kost, maar dat euro's oplevert. Omdat het genoemde stukje elektronica slechts 30 Euro kostte en daarvoor mij zowel een professionele CANbus, als een nostalgische Basic gaf, was de aanschaf al snel geregeld.

De Duinomite Mega
De Duinomite Mega is een single-board computer van de Bulgaarse firma Olimex. De hardware is volledig open en kan en mag door iedereen nagebouwd worden. Het heeft echter in mijn ogen weinig zin, want de prijs/kwaliteitsverhouding van de module is erg goed. De hardware is opgebouwd rond een PIC32 controller van Microchip. Deze heeft een Ethernet, een CANbus, een USB, een RS232, een VGA, een PS-2, evenals een groot aantal multifunctionele in- en uitgangen als interface geïntegreerd. Alle interfaces, behalve het Ethernet zijn ook naar buiten uitgevoerd. De multifunctionele I/O via Arduino (de Duino in de naam) compatibele headers, waardoor eenvoudige uitbreidingen ook zo van de plank beschikbaar zijn. Overigens is er inmiddels voor 10 Euro meer eveneens een eMega versie beschikbaar, die ook een Ethernet aansluiting heeft. Mij ging het qua hardware echter vooral om de CANbus en USB interfaces.

Zoals gezegd de locale software op de Duinomite Mega bestaat uit een Basic interpreter. De DM-Basic is een versie van MM-Basic, een Basic interpreter die origineel gemaakt is door Geoff Graham voor een ander PIC32 gebaseerd single board systeem, te weten de Maximite (de mite in Duinomite). Hoewel men bij Olimex getracht heeft alle hardware zo goed mogelijk te ondersteunen, bleek men toch met de CANbus hier niet uitgekomen te zijn. Dit was dan ook mijn enige teleurstelling in mijn, toen nog te boek staande, hobbyproject. DM-Basic is inmiddels ook een bevroren versie van MM-Basic. Dit heeft misschien het nadeel, dat geen nieuwe functionaliteit meer wordt toegevoegd, maar heeft wel het voordeel, dat deze versie nog volledig "open source" is. MM-Basic versies zijn nog wel vrij te downloaden, echter niet meer in source vorm. De Duinomite Mega is echter nog volledig opgebouwd met open hardware en open software en dat heeft zo zijn voordelen, zoals we later zullen zien.

Van hobby tot serieus product
Enkele weken nadat ik de Duinomite Mega in huis had, kwam ik tot de conclusie, dat de hardware veel krachtiger was dan ik me ooit had kunnen voorstellen. Ik besefte ook al wel dat ik een heleboel interfaces voor mijn gebruik niet nodig zou hebben. Zo waren een VGA en PS-2 keyboard aansluiting wel leuk, maar de USB interface gebruiken als terminal aansluiting op de laptop werkt veel handiger. Ik gebruik Teraterm nu onder Windows XP, Vista, 7, 8 en 10, zonder dat ik iets aan de driver heb hoeven aanpassen. Ook onder Linux draait het standaard terminal programma feilloos. De Duinomite Mega wordt gewoon gezien als COM poort, echter wel met de snelheid van USB. Een externe voedingsaansluiting is dan ook niet meer nodig, want de USB voeding is ruim voldoende voor de module. Een goedkoop uSD kaartje van 4-32 GB is een uitstekende disk, die niet alleen voor de locale processor dient, maar tevens met een simpel commando omgetoverd wordt tot externe harde schijf voor mijn laptop. Ook dit was weer een aangename verrassing.

DM-Basic deed me ook beseffen, dat de programmeerklok rond was. Na de Basic op de TRS80 destijds wilde ik wel weer eens wat sneller en kwam dus op een Pascal compiler en zelfs op een Assembler (ooit een van de eerste producten van Microsoft). DOS PC's, UNIX en real-time systemen deden me in o.a. C en zelfs ADA belanden. De volgende stap was in de jaren 90 een geavanceerde Windows vierde generatie programmameer omgeving, te weten Testpoint. Hierin werden alle CAN applicaties ontwikkeld. In de jaren 90 heb ik ook met een scheef oog nog gekeken naar Java, Labview en IEC1131 omgevingen. Toen e.e.a. ook remote beschikbaar moest komen, kwamen de Internet Scripttalen JavaScript en PHP om de hoek. Terug naar het embedded platform met slechts een 128 kbyte (nog altijd 32 keer meer dan mijn originele TRS80) aan intern RAM geheugen is dan weer terug naar af. Dus "Back to Basic" is dan ook wel weer logisch, maar het bloed gaat dan ook weer sneller stromen als je weer tegen dezelfde problemen als vroeger aanloopt.

Bij de TRS80 liep ik destijds tegen het probleem aan, dat ik extra hardware met assembler routines moest aansturen, nu liep ik vast met mijn CAN interface. In het verleden werden de Assembler routines met POKE statements in het Basic programma tussengevoegd. Nu ging ik maar eens onderzoeken of ik ook met PEEK en POKE in de PIC32 CAN-controller kon komen. Dus de specifieke informatie maar eens gedownload van de Microchip site en ik kwam al snel tot de conclusie, dat dit niet zomaar een CAN-controller is, maar een zeer krachtige en vooral flexibele. Doordat de CAN-controller een stuk van het RAM geheugen gebruikt als FIFO hoef ik alleen maar in Basic een array te definiëren en te zorgen dat daar alle CAN informatie in terecht komt, waarna ik het zelfs met Basic op een lagere snelheid kan uitlezen. Klinkt achteraf eenvoudig, maar dat was het in eerste instantie niet echt. Toen ik deze basis functionaliteit draaiend had, nam ik wel de beslissing om hier ook een serieus product mee te gaan maken.

De CAN Blackbox werd geïntroduceerd. Iedereen moest zijn eigen functies kunnen bedenken voor de box, echter daarvoor moest wel een "framewerk" geschapen worden. Het eerste idee was om een Basic programma te maken, waarmee de box volledig te configureren is. Daarmee liep ik na een paar weken programmeren tegen de geheugenlimiet aan. Het Basic programma mocht niet groter worden dan zo'n 40 kbytes. Dus daarom heb ik de zaak maar opgedeeld in een aantal deelfuncties. Hiermee was de eerste versie van de CBB geboren.

De SI2-CBB Standaard
Voor de Duinomite Mega had Olimex ook een speciale behuizing laten maken. Qua hardware hebben we een verloopkabel naar een 9-polige SUB-D connector voor CAN, een standaard USB-kabel en een 4 GB uSD flashkaartje toegevoegd. De hardware was compleet. Afhankelijk van de wensen van de klant zetten we er dan de gewenste Basic programma's op. Sommige programma's kunnen zelfs volledig stand-alone uitgevoerd worden. Zo kan bijvoorbeeld op een LED zichtbaar gemaakt worden of er fouten op de CANbus hebben plaatsgevonden. Als de LED is gaan knipperen, is er wel eens iets fout gegaan. Ook een automatische bitrate detectie kan standalone uitgevoerd worden. Een optimalisatieprogramma voor de bitrate kan gebruikt worden om verder met de bitrate te experimenteren. Het configureren van fifo's, filters, maskers kan eveneens met een programma gerealiseerd worden. De bus kan in verschillende toestanden gebruikt worden. Natuurlijk kunnen berichten op de CANbus gezonden worden en de al dan niet gefilterde berichten ook weer ontvangen.

Ik heb besloten de programma's zowel afzonderlijk, als gebundeld op een unit op de markt aan te bieden. Het grote voordeel: alles is open. Men hoeft eigenlijk de software maar eenmalig aan te schaffen en kan de hardware kopen op de plaats waar die het goedkoopst is. Een hobbyist kan ervoor kiezen om aan de hand van programma voorbeelden een geheel eigen toepassing te maken. Mijn opzet was dan ook om te kijken of we een soort netwerk konden opzetten en programma's zo verder uitwisselen. In gesprekken met anderen bleek dit niet echt de goede formule. Wel kwam naar voren, dat het interessant zou kunnen zijn, als er meer geïntegreerde functionaliteit in de box beschikbaar zou kunnen komen. Het idee om Basic alleen nog te gebruiken als scripttaal voor het configureren en de andere functies toevoegen aan de firmware kwam bij me op.

Eigen firmware voor de Duinomite Mega
Zoals reeds gezegd is de Basic firmware van de Duinomite Mega volledig open source. Dit betekent, dat iedereen voor eigen gebruik hier veranderingen in kan aanbrengen. De aanpassingen moeten dan ook weer voor anderen beschikbaar gesteld worden. In een bericht in de Duinomite "praatgroep" had ik al gezien, dat het vrij eenvoudig is om een Basic commando toe te voegen. In 2012 had Frank Voorburg van Feaser (http://www.feaser.com) al een uitbreiding voor de CANbus aan DM-Basic toegevoegd. Dit waren echter alleen de noodzakelijke basis commando's, te weten het openen en sluiten van de CANbus en het ontvangen en zenden van een bericht. Na bestudering van deze commando's besloot ik, dat het mogelijk zou moeten zijn om een speciale firmware te maken, waarin veel meer functionaliteit op zou zijn genomen. Na overleg met hem en Olimex ben ik daar in de zomermaanden van 2012 mee begonnen. Dus direct weer mijn tweede stap in de nieuwe programmeercyclus gestart, het programmeren in C. Tussendoor ben ik ook al weer met de derde fase gestart. Omdat de driver voor de Duinomite Mega ervoor zorgt, dat hij gezien wordt als serieel device, kan hij ook direct vanuit PHP met een Apache server aangestuurd worden. Een mini terminal programma zorgt ervoor dat ook aansturing vanuit een browser nu mogelijk is: Remote besturing en WEB visualisatie voor de SI2-CBB. In een jaar tijd heb ik de volledige programmeercyclus, waarover ik de vorige keer 30 jaar gedaan had, herhaald.

De SI2-CBB Geavanceerd en de SI2-CBB Speciaal
We hebben inmiddels de CBB in een echte "zwarte doos" verpakt. Zoals eerder reeds opgemerkt, hebben we in vele toepassingen voldoende aan een USB- en een CANbus aansluiting. Deze hebben we nu standaard naar buiten uitgevoerd. Alle andere aansluitingen zijn optioneel. De box kan nu echt gezien worden als een vervanging van de vele CAN-USB interfaces die op de markt beschikbaar zijn. Vervang de computer door een USB adapter voor 220 Volt ~ of 12 of 24 Volt = en we hebben een stand-alone CAN-logger. Sluit enkele in- en/of uitgangen aan en we hebben een CAN I/O module. Dus de hardware mogelijkheden zijn legio. We noemen alles wat meer aansluitingen heeft dan een USB- en een CANbus de speciale uitvoering.

Het belangrijkste commando, dat ik in de software wilde toevoegen, is het CANLOG commando. Dit logt ontvangen CAN-berichten op het scherm of op de flashdisk. Vele opties zorgen ervoor, dat dit zo flexibel mogelijk kan gebeuren. Via een script kan een ontvangen CAN-bericht vertaald worden naar een willekeurig protocol. CANopen en J1939 zijn het meest standaard, maar elk klantspecifiek protocol kan eveneens op de SI2-CBB geïmplementeerd worden. Ook het zenden van CAN-berichten is flexibel uitgebreid. Zo kunnen met behulp van één zendcommando tot wel 32 CAN-berichten de bus opgestuurd worden. Natuurlijk zijn ook de commando's voor het configureren van FIFO's, filters en maskers toegevoegd. Vanuit een aantal eenvoudige Basic programma's kan alles aangestuurd worden. Met een aantal gereserveerde Basic variabelen wordt er op een slimme wijze data uitgewisseld tussen het Basic "script" en de "embedded" CAN commando's.

Het gebruik van Basic als scripttaal
We kunnen gerust stellen, dat Basic in het Internet tijdperk geen rol van betekenis meer speelt als programmeertaal. Ook voor embedded toepassingen is de taal veel te beperkt en vooral te langzaam doordat er gebruik gemaakt wordt van een interpreter in plaats van een compiler. De eenvoudige commando's geven echter wel een goed overzicht van wat er gebeurt en zeker door het gebruik van regelnummers is een Basic programma goed te lezen door een niet ICT-er. Doordat er nu goede specifieke CAN-commando's aan toegevoegd zijn, kan een werktuigbouwkundige of een elektrotechnisch installateur eenvoudig zijn eigen toepassingen ermee maken. Plug en Play een dag later.

Plug en Play toepassingen
De SI2-CBB is ook direct in te zetten voor het loggen van CANdata. Flexibele scripts zorgen ervoor dat men naar eigen goedvinden de data kan opslaan of direct op het scherm zichtbaar maken. Ook het genereren van CAN berichten voor bijvoorbeeld simulatie/emulatie op de bus kan eenvoudig vanuit een standaard programma ingesteld worden. Tevens zijn er programma's voor foutanalyse, stressmeting en betrouwbaarheidsmetingen beschikbaar. En wat vooral geldt: wat nog niet beschikbaar is, kan waarschijnlijk nu snel, flexibel en zeer kostefficiënt gemaakt worden.

Aangepaste hardware op basis van standaard module
Olimex heeft ook een aangepaste versie van de Duinomite module gamaakt, waarmee snel een functioneel embedded systeem gemaakt kan worden. Daar hebben we vanaf 2014 klantspecifieke projecten mee gerealiseerd. De basismodule heeft dan wel geen CAN transceivers, maar die zijn eenvoudig toe te voegen. Dit hadden we ook al reeds gedaan op een Arduino uitbreidingsmodule waar de tweede interne CANpoort van de processor op uitgevoerd is. De module rechts is nu uitgebreid met een voedingscircuit voor 12 of 24 Volt voeding, 2 CAN transceivers en de I/O weer op Arduino compatibele sockets. In Basic is een CANBRIDGE commando gekomen, waarmee we eenvoudig CAN berichten van de ene poort kunnen copiëren naar de andere en vice versa.

CANobjecten gaan eigen leven leiden met CANOBJECT
Inmiddels is de software uitgebreid met een enorm krachtig commando, dat volledig is afgestemd op de PIC32 hardware. Reeds eerder is gezegd, dat de PIC32 CAN-controller zeer flexibel en krachtig is. Dit is met name doordat de bufferruimte voor de CANberichten eenvoudig, maar wel zeer flexibel, gedefinieerd wordt binnen het standaard RAM geheugen. Deze bufferruimte kan onderverdeeld worden in 32 verschillende objecten, die ook weer allemaal 32 berichten diep kunnen zijn. Dus eigenlijk hebben we 32 verschillende FIFO's elk met een diepte in te stellen tussen 1 en 32 berichten. Elk FIFO is volledig zelfstandig te configureren voor zenden of ontvangen, waarbij filters en maskers aangelegd kunnen worden, zodat elk FIFO zijn eigen taak krijgt binnen het totaalproces.
Ik heb lang nagedacht hoe ik optimaal gebruik kon maken van deze krachtige structuur en de meeste toepassingen werden dan ook eenvoudig gerealiseerd met twee FIFO's, een voor ontvangen en een voor zenden. In de Basic wordt gebruik gemaakt van een interrupt routine, die aangeroepen kan worden op tijdbasis met een resolutie van 1 ms of op basis van een digitale ingang. Toen ik me daar verder in ging verdiepen, kwam ik tot de conclusie, dat daarvoor dezelfde 1 ms interrupt werd gebruikt, die ook de real-time klok bijhield. Wat nu als ik deze zelfde interrupt gebruik voor de CAN-berichten, dan kan ik eenvoudig met een tijdsresolutie van 1 ms CANberichten versturen en in de ontvangstFIFO's elke ms kijken of er nieuwe berichten zijn bijgekomen. De configuratie van de FIFO's gebeurt in het Basic programma, maar de objecten blijven stand-alone doordraaien. Objecten kunnen ook aan elkaar gekoppeld zijn of gekoppeld aan een eigen Basic interrupt routine. Kortom het is een enorm krachtig mechanisme geworden met een zeer grote flexibiliteit.

CAN meten op fysiek niveau
Met een heel speciaal project ben ik in 2016 bezig geweest. Iemand wilde kijken of het mogelijk was om wat reverse engineering te doen op basis van het meten van fysieke signalen op de CANbus. Aangezien CAN vooral een embedded netwerk is, weten we in het algemeen niet wie welk bericht genereert. Iemand die metingen aan voertuigen deed, kreeg het idee om signalen op fysiek niveau te gaan meten en dan aan de hand van de analoge spanningsniveaus te kijken of het mogelijk is onderscheid te maken tussen de verschillende deelnemers. Voor metingen op fysiek niveau hadden we een Gemac CBT-2 tester tot onze beschikking. Al snel bleek, dat we daarmee met een resolutie van 50 mV te maken hadden. Hiermee is het goed mogelijk om te kijken of een node voldoet aan de specificaties, echter niet om echte verschillen te ontdekken tussen meerdere deelnemers. De ingebouwde ADC in de PIC32 controller heeft een 10 bit resolutie, hetgeen neerkomt op zo'n 3 mV. We zijn toen een project gestart om te kijken of we op basis van onze SI2-CBB hardware een oplossing konden bewerkstelligen.
Allereerst was het belangrijk om te kijken of we op analoge wijze het bitpatroon van een CANbericht konden volgen. Dit is een eerste vereiste om de ADC op het juiste moment te triggeren. Dit triggersignaal moest een digitale input zijn en daarom lag het voor de hand om het signaal op de Rx input van de CANcontroller te pakken. Omdat we op de basismodule hier niet bij kunnen, hebben we direct besloten de tweede CAN poort op een Arduino extensie module hiervoor te gebruiken. Ingangen op de PIC32 controller kunnen direct gekoppeld worden aan interrupt routines. Twee verschillende ingangen hebben we gebruikt, een die een routine start bij verandering hoog naar laag en een tweede voor de verandering van laag naar hoog. Het volledige patroon konden we hiermee volgen tot een CAN snelheid van 500 kb/sec. Aangezien we in principe alleen het dominante niveau hoeven te meten, kunnen we volstaan met één flank te detecteren. Dit lukte ook bij 1 Mb/sec. De ADC triggeren we dan met het signaal. De conversietijd is in principe 1 uS, maar met de delay in triggering en verwerking zijn we zo'n 2 a 3 uS kwijt. Daarom hebben we de instelling gemaakt, dat bijvoorbeeld alleen de metingen geldig zijn als de bus gedurende 2 tot 5 periodes dominant blijft. Uiteindelijk hebben we voor het doel waarvoor we de ontwikkeling gestart hebben, de SI2-CBB niet kunnen inzetten, maar we hebben er uiteindelijk wel een fraai extra statement CANPHYS mee kunnen realiseren.
CANPHYS werkt alleen met de extra hardware en geeft op een heel flexibele wijze resultaten door over de analoge niveaus op zowel CAN High als CAN Low, maar tevens over de timing, gemeten met een zeer nauwkeurige klok, ca. 0,01 uS. Allerlei fysieke metingen kunnen hiermee uitgevoerd worden.

Low level scripts voegen extra CAN commando's toe
2017 stond voor mij in het teken van het CANSCRIPT statement, dat ik toegevoegd heb. Zoals eerder vermeld had ik een eigen scripttaaltje ontwikkeld om protocollen als CANopen en J1939 te kunnen analyseren. Met een viertal eenvoudige bewerkingen, CALC, IF, WRITE en SPEC, kan men per regel de data in het juiste formaat weergeven. Door wat extra SPEC (lees:speciale) commando's toe te voegen, kan men bijvoorbeeld ook direct berichten zenden, CANOBJECTen toevoegen en data wegschrijven naar een flexibel BASIC array. Het nieuwe CANSCRIPT commando geeft nu de mogelijkheid om tot maximaal 16 verschillende scripts in het systeem weg te schrijven. Men kan er in feite zijn eigen CAN commando's mee maken. Er is een online editor beschikbaar hiervoor. Aan de hand van CANSCRIPT hebben we een CANopen slave voorbeeldprogramma gemaakt, waarin de verschillende CANopen objecten, zoals PDO's, SDO's, EMCY's, SYNC, Timestamp, heartbeat en NMT state machine, in scripts zijn weggeschreven. Deze CANopen slave module heeft met name het voordeel, dat de I/O zeer flexibel te configureren is.

Alles op basis van de 1 mS clock
Begin 2018 is versie 2.0 van de SI2-CBB software uitgebracht. Naast het CANOBJECT statement heb ik in deze versie een eigen PWM statement toegevoegd, dat eveneens gebruik maakt van de 1 mS klok. Hiermee kunnen tot maximaal 8 digitale uitgangen gebruikt worden als analoge uitgang op basis van PWM. In versie 2.1 die eind 2018 op de markt is gebracht, is dit statement verder geoptimaliseerd. De analoge uitgang kan nu eenvoudig met de SETPIN en PIN commando's aangestuurd worden. Aldoende kreeg ik het idee om ook de andere I/O op basis van de genoemde 1 mS klok te meten cq aan te sturen. Door de I/O dan tevens te linken aan de data van CANOBJECTen hoeven we de Basic niet meer te gebruiken om in een lus continue de I/O te meten of te sturen. Daarvoor heb ik het CANIOLINK statement toegevoegd. Optioneel kan er dan ook nog een correctie plaats vinden op basis van een in te stellen "gain/offset" en zelfs een complexe berekening middels een ander Basic statement (bijvoorbeeld Sinus of Logaritme). Via een universeel bruikbaar Basic programma kunnen we nu achtereenvolgens de CANbus, de CANOBJECTen en de CANIOLINKs configureren. Een configuratiefile wordt geschreven en de volgende keer wordt de configuratie automatisch geladen. Het Basic programma wordt beëindigd, terwijl de I/O en de CANbus communicatie gewoon door blijven draaien.

Toevoegingen m.b.t. het video gebeuren
In 2019 heb ik besloten, dat in feite alle benodigde CAN functionaliteit nu wel beschikbaar was binnen de SI2-CBB. Daarom heb ik me maar eens gestort op iets dat binnen de CAN toepassingen praktisch niet gebruikt wordt, nl. het videogeheugen. In het algemeen wordt de unit gekoppeld aan een computer via de USB poort en niet gebruikt als stand-alone unit met monitor en keyboard. In de embedded uitvoering zijn deze interfaces zelfs niet beschikbaar. Toch is er naast de hardware interfaces (VGA/keyboard) ook een groot gedeelte van het RAM geheugen (26KB) dat daarvoor gereserveerd is. Tevens neemt het continue verversen van dit geheugen ook nog aardig van CPU capaciteit in beslag.
In versie 2.2 van de software kunnen we het video geheugen nu ook uitschakelen. Daarmee komt het videogeheugen beschikbaar als extended RAM geheugen. Dit kan zowel gebruikt worden als extra programma geheugen of voor opslag van een groot array (_EXTMEM). Om e.e.a. mogelijk te maken heb ik het GOSUB commando aangepast. Naast het aanroepen van een subroutine met een regelnummer, kan dit nu ook met een naam. De subroutine zal dan weggeschreven moeten zijn in een array. Dit array kan dus ook de naam _EXTMEM hebben, waarmee de subroutine in het extended geheugen komt te liggen. De routines worden nu ook weggeschreven in de z.g. tokenstructuur, hetgeen betekent, dat alle commando's, functies en bewerkingen vertaald zijn naar z.g. tokens. Met deze versie kan men dan ook programma's opslaan en inlezen (SAVE en LOAD) in zowel de standaard Basic tekstvorm als in de token vorm. Deze laatste vorm heeft drie voordelen: hij is kleiner, sneller en onleesbaar voor derden. Dat laatste betekent dus dat gebruikers niets meer kunnen veranderen aan de code. Basic wordt hiermee minder open, maar heeft dan wel een voordeel dat niet iedere hobbyist het programma kan aanpassen, zodanig dat het niet meer werkt.
Na versie 2.2 is er eind 2019 ook nog een versie 2.3 gekomen. Deze heeft naast de uitbreidingen van versie 2.2 ook nog ondersteuning voor een tweetal embedded displays van Olimex. Reeds in versie 2.0 hadden we het OLED commando toegevoegd, waarmee een klein gedeelte van het videogeheugen gekopieerd kon worden op een klein embedded OLED display (MOD-OLED-128x64). Een nieuwer display met ook een touchscreen (MOD-LCD2.8RTP) kan in versie 2.3 nu een groter gedeelte van het video geheugen (320x240), of bij gebruik van de composiet video zelfs het gehele video geheugen, weergeven. Tevens is er ondersteuning voor het touchscreen. Hiervoor is het OLED commando aanzienlijk uitgebreid. Eigenlijk zou dit commando nu ook een andere naam moeten hebben, maar om de versie compatibel te houden met voorgaande versies is dit niet gedaan. Met name in combinatie met de embedded uitvoering van de SI2-CBB kan er nu een klein stand-alone meetinstrument gemaakt worden voor één of zelfs twee CAN poorten. Volledige bediening en uitlezing via één display.

Het jaar 2020, start van een nieuw decennium met nieuwe functionaliteit
In 2020 heb ik eerst gewerkt aan een goede universele software voor de kleine stand-alone embedded CAN analyser. Via verschillende scripts kunnen we daarmee klantspecifieke instrumenten configureren. Analyse op basis van ruwe CAN data, maar ook op basis van CANopen, J1939, OBD-II of een heel eigen protocol. Meerdere protocollen kunnen tegelijkertijd in het systeem opgeslagen worden en er kan snel van protocol gewisseld worden. De foto toont een samengesteld prototype. Het zou mooi zijn als iemand er een goed passende behuizing om zou kunnen bouwen.
Hoewel het eigenlijk niet de bedoeling was om nog extra functionaliteit toe te voegen in de firmware, kwam ik er bij een testproject toch achter, dat er eigenlijk nog iets in het CANOBJECT commando ontbrak en dat er tevens in het verleden een begin gemaakt was om ook data op de seriële interfaces te kunnen loggen, echter nooit daadwerkelijk geïmplementeerd. Aangezien we nu toch in Covid-19 lockdowns terechtgekomen waren, heb ik me hier toch nog maar eens verder in verdiept. Al snel merkte ik, dat er wel 4 seriële poorten op de basismodule beschikbaar waren, maar dat er maar zeer beperkte ondersteuning voor was. Dus was het zaak, dit eerst in orde te brengen. Wat met name interessant is, is dat de poort op de UEXT connector nu met toevoeging van een Olimex MOD-RS485 of MOD-RS485-ISO daadwerkelijk geschikt is voor RS485 netwerken door de 9-bit data structuur. Het COMLOG commando is geschikt gemaakt voor meerdere COM poorten tegelijk. Hiermee is de SI2-CBB ook een COM BLACK BOX geworden.
Een aanpassing aan het CANOBJECT commando bestaat uit de interpretatie van de databytes in het Transmit object. Met de variabele CANOBJxxDATA(y) wordt de waarde van de verschillende databytes ingegeven. Deze waarde is normaal gesproken van 0 tot 256. In de nieuwe versie kan deze ook hoger worden, waardoor de waarde zonder tussenkomst automatisch volgens een bepaald patroon varieert. Dit is uitermate handig bij het testen van CAN installaties.

CAN over de voedingslijnen
Een bijzonder project verscheen op mijn pad in 2021. Een machinebouwer wilde CAN toepassen, maar dat moest vanwege bewegende onderdelen over sleepleidingen plaatsvinden, 2 voedingslijnen en 2 lijnen voor het CAN signaal. Deze sleepleidingen bleken voor het CAN signaal echter te storingsgevoelig te zijn. We zijn toen naar alternatieven gaan zoeken en kwamen uit bij een systeem van de Israëlische firma Yamar, die via modulatie op een hogere frequentie het CAN signaal op de voedingslijnen superponeert. Mij werd gevraagd dit verder uit te testen bij verschillende bitrates en onder verschillende omstandigheden. Dit hebben we gedaan met de SI2-CBB, waarbij de 2de CANpoort zonder standaard CAN transceiver werd uitgevoerd en daarvoor in de plaats een DCAN500C module van Yamar. Door deze te plaatsen op een Arduino uitbreidingsmodule hebben we nu een systeem gecreëerd met slechts 2 draden naar buiten voor zowel de voeding als het CAN signaal. Zie bijgaande foto.

Remote toegang tot de SI2-CBB via het Internet
Reeds een aantal jaren geleden, had ik een bluetooth printje (MOD-BT) aangesloten op de SI2-CBB en kon ik met mijn smartphone via een terminal programma communiceren. Dit is misschien handig om ter plaatse nog gegevens draadloos in te brengen, maar biedt verder niet veel voordelen. Handiger is het om via WIFI en het Internet te kunnen communiceren. Dit kan sinds enkele jaren met de embedded IOT modules van Olimex (bijv. MOD-WIFI-ESP8266). Heel veel uren heb ik in 2021 gespendeerd om een goed remote interface te maken voor de SI2-CBB. Inmiddels kunnen we communiceren met elke SI2-CBB ergens in de wereld, die uitgevoerd is met een SI2-ESP (een ESP8266 interface met onze firmware). Zowel op basis van een simpel Telnet protocol, maar ook geavanceerd op basis van een uitgebreide website. Deze is nog niet openbaar toegankelijk, maar voor liefhebbers wel uit te testen. Communicatie kan geschieden op basis van het ingeven van Basic commando's, maar ook in een real-time situatie in een draaiend programma. Tevens is het mogelijk om op basis van het XMODEM protocol files te uploaden/downloaden. Het is een complexe klus geworden met programmering in Basic (met terugval op de C source van bijv. het XMODEM protocol), de Arduino IDE (C-like compiler), PHP en JavaScript. Het was een enorme uitdaging.

Nieuw manual voor versie 2.4
In 2021 heb ik het manual ook volledig herschreven. Daarbij heb ik de bestaande Basic commando's gecombineerd met de extra functionaliteit, die ik zelf inmiddels toegevoegd heb om tot de SI2-CBB te komen. Dit manual is te downloaden op: http://www.si-kwadraat.nl/si2-cbb/manuals/en/can-manual2_4.pdf.

In 2022 heb ik besloten om een laatste versie 2.5 van de Basic software te maken. Hierin zitten nog enkele kleine toevoegingen, zoals het openen van een COM poort as REMOTE waarmee de eerder genoemde SI2-ESP aangestuurd wordt. Tevens is er een optie toegevoegd om de CTRL-C te blokkeren, zodat niet per ongeluk het run-time programma beëindigd wordt. Het volledige manual is nu te vinden op: http://www.si-kwadraat.nl/si2-cbb/manuals/en/can-manual2_5.pdf

Het nieuwe project, dat ik gestart ben, is een groot gedeelte van de specifieke CAN software onder te brengen in een Arduino IDE library. Hierover later meer.