Handleiding Piccolino

Handleiding Piccolino Installatie van de benodigde software, en aansluiten van de hardware.

(c)2012 Bert van Dam

INLEIDING INSTALLATIE INSTRUCTIES VOORBEELD PROGRAMMA PROGRAMMEREN LUKT NIET GEBRUIK PICCOLINO MET SMALL BASIC GEBRUIK PICCOLINO MET JAL BOEKEN GEBRUIK PICCOLINO MET HYPER TERMINAL OF PYSERIAL HOE NU VERDER PICCOLINO (JAL) TAAL INSTRUCTIES INDEX

3 8 11 23 24 26 28 29 32 53

2

Inleiding Gefeliciteerd met de aanschaf van uw Piccolino! De Piccolino is een prototype platform dat gebruikt kan worden om razendsnel opstellingen te maken en te testen. Alle basisvoorzieningen zijn aanwezig op de Piccolino, en door middel van de headers kunnen extra componenten eenvoudig aangesloten worden. Daarnaast is het mogelijk op de headers uitbreidingsmodules aan te sluiten. U kunt die aanschaffen, maar het is ook mogelijk ze zelf te maken. Gebruikt u bij uw prototypes altijd bepaalde componenten dan maakt u er zelf gewoon een uitbreidingsmodule van. Door op deze modules ook headers te plaatsen kan hier bovenop ook weer een uitbreidingsmodule geplaats worden. Zonder koelplaatje op de voedingsstabilisator kan de Piccolino ongeveer 100 mA via de headers leveren. De Piccolino heeft volgende eigenschappen: 1. 2. 3. 4. 5. 6. 7.

Geen programmer nodig; de Piccolino programmeert zichzelf. Ingebouwde gestabiliseerde 5 volt voeding met indicatie LED. Ingebouwde RS232 poort (losse USB convertor verkrijgbaar). Voorzien van LED, schakelaar en potmeter om meteen van start te kunnen. Reset schakelaar en auto-reset jumper. Ruimte voor stapelbare uitbreidingsmodules. Moderne PC16f887 microcontroller: • 20 MHz (5 MIPS). • 8192 words Flash geheugen. • 768 bytes RAM. • 256 bytes EEPROM. • 35 I/O, waarvan 25 op de headers. • 14 analoge ingangen. • 2 PWM uitgangen. • 2 Comparatoren. • Communicatie RS232-TTL, RS232, I2C, SPI, one wire. • Aarde, 5 volt en Vin op de header.

De 16f887 zit in een voetje en kan dus omgewisseld worden voor een ander exemplaar. Dat gaat echter niet zomaar want deze PIC bevat een speciale bootloader die er voor zorgt dat hij zichzelf kan programmeren. Wilt u een andere PIC gebruiken dat moet deze ook van een bootloader voorzien worden anders werkt de Piccolino niet meer! Vervangende PIC's met bootloader kunt u bij Elektor kopen.

3

Let op: wanneer u de PIC uit de Piccolino haalt en met een gewone programmer programmeert dan wordt de bootloader overschreven en kunt u de PIC niet meer in de Piccolino gebruiken.

Figuur 1. De Piccolino met uitleg van de componenten.

De Piccolino heeft een externe voeding nodig. Deze hoeft niet gestabiliseerd te zijn, maar moet wel gelijkspanning leveren met de plus op de middenpin. Het voltage van de voeding ligt bij voorkeur tussen de 7 en 10 volt. Meer mag wel, maar dan wordt de spanningsregelaar op de Piccolino wel snel warm. Optioneel kunt u de Piccolino ook met een 9 volt batterij voeden. U kunt uw Piccolino in dat geval gebruiken zonder dat er een stopcontact in de buurt is. Het Piccolino Sidekick pakket bevat een stekker hiervoor. Het verstandigst is om een oplaadbare batterij te gebruiken. De inhoud van de headers is als volgt: Naam a0 AN0 a1 AN1 a2 AN2 a3 AN3 a4 a5 AN4 e0 AN5 c

Omschrijving Pin a0, verbonden met de analoge unit AN0. Pin a1, verbonden met de analoge unit AN1. Pin a2, verbonden met de analoge unit AN2. Pin a3, verbonden met de analoge unit AN3. Pin a4. Pin a5, verbonden met de analoge unit AN4. Pin a6, verbonden met de analoge unit AN5. Pin c0.

Naam b7 TTL out b6 TTL in b5 AN13 b4 AN11 b3 AN9 b2 AN6 b1 AN10 b0 AN12

Omschrijving Pin b7, de seriële RS232-TTL uitgang. Pin b6, de seriële RS232-TTL ingang. Pin b5, verbonden met de analoge unit AN13. Pin b4, verbonden met de analoge unit AN11. Pin b3, verbonden met de analoge unit AN9. Pin b2, verbonden met de analoge unit AN6. Pin b1, verbonden met de analoge unit AN10. Pin b0, verbonden met de analoge unit AN12.

Naam Vin +5 V NC GND d0 d1 d2 d3

Omschrijving Voltage op de Piccolino voedingsstekker. Gestabiliseerde +5 volt. Niet in gebruik.1 Aarde van de voeding. Pin d0. Pin d1. Pin d2. Pin d3.

Naam c3 SCL c5 SDO c4 SDA c2 CCP1 c1 CCP2 NC NC NC

Omschrijving Pin b7, seriële kloklijn (SPI en I2C) Pin b6, seriële data out (SPI en I2C) Pin b5, seriële data in (SPI en I2C) Pin b4, CCP1 module. Pin b3, CCP2 module. Niet in gebruik. Niet in gebruik. Niet in gebruik. Tabel 1.Header informatie.

Deze omschrijving, evenals de teksten op de Piccolino zelf, zijn alleen ter referentie. Uiteraard hebben de pinnen, voor zover aangesloten, de normale functionaliteit zoals

1

De NC pinnen zijn niet in gebruik, en bestemd voor toekomstige Piccolino modellen.

5

beschreven in de datasheet. U kunt de Piccolino dus ook gebruiken in combinatie met de JAL boeken van dezelfde auteur.2

Figuur 2. Functie van de pinnen volgens de datasheet van de 16f887.

Overigens zijn niet alle pinnen met de headers zijn verbonden, en andersom ook niet alle headers met pinnen. Een deel wordt gebruikt voor interne doeleinden, denk bijvoorbeeld aan de ingebouwde LED. Verder is rekening gehouden met toekomstige modellen van de Piccolino die andere functionaliteiten hebben, die ook pinnen nodig hebben. Let op: om automatisch programmeren mogelijk te maken moet de auto-reset jumper geplaatst zijn. U hoeft deze jumper in feite nooit te verwijderen, tenzij u de Piccolino liever met de hand reset. Een aantal communicatie pakketten maakt gebruik van software flow control die niet uitgezet kan worden, bijvoorbeeld Hyper Terminal. Wilt u van een dergelijk pakket gebruik maken dan moet u de jumper eerst verwijderen. Datzelfde geldt voor de pySerial module van Python. Als aanvulling op uw Piccolino kunt u de Piccolino Sidekick kopen.3 In dit uitgebreide onderdelenpakket zitten alle spullen die u nodig heeft voor dit boek, en voor vele andere leuke en spannende experimenten. 2 3

Zie de sectie 'Hoe nu verder" voor meer informatie. "Sidekick" is Engels voor "maatje" of "vriendje".

Figuur 3. Het Sidekick pakket.

4

De inhoud van de Piccolino Sidekick: 1 1 20 7 5 2 2 2 2 1 4 1 3 1 1 1 1 1 1

Steekbord (circa 6 bij 17 centimeter). Set draden voor gebruik met het steekbord en de Piccolino. Weerstanden: 47 - 3x330 - 3x1k - 47 - 3x2k2 - 2k7 - 4x10k - 100k 1M - 2x10M. Condensatoren: 100nF - 220nF - 1µF - 2,2µF - 22µF - 220µF - 1000 µF . Spoelen: 1,0mH - 4,7mH - 10mH - 22mH - 47mH OPAMPs: LM358 - MAX492. BJTs: BC547C - BC679A. MOSFETs: BS170 - IRF740. LEDs. IC: NE555. Instelpotmeters: 2k2 LIN - 2 x 10k LIN - 100k LIN. Mini stereostekker, male. Steekbordschakelaars. Weerstand array 10k. Diode 1N4007. Servomotor Hitec HS-422 of soortgelijk. LDR. TC74 A0 5.0 VAT. 9 volt batterij aansluitdraad met stekker.

4

De componenten en de samenstelling kunnen in de praktijk iets afwijken. De informatie in de Elektor webwinkel is correct.

7

Installatie Instructies Voor het programmeren van de Piccolino wordt gebruik gemaakt van JAL (Just Another Language), een op Pascal lijkende hoog niveau taal. Het is de enige geavanceerde gratis taal, en kent een grote internationale actieve gebruikersgroep. Het adres hiervan vindt u op www.boekinfo.tk. Daarnaast is er ook informatie over beschikbaar in diverse boeken en op websites. JAL is configureerbaar en uitbreidbaar door middel van bibliotheken (libraries) en kan gecombineerd worden met assembler. Dit is een voorbeeld van een JAL programma waarmee de LED van de Piccolino gaat knipperen gaat knipperen. include 16f887_bert_piccolino forever loop pLED = on delay_100ms(1) pLED = off delay_1s(1) end loop U ziet dat u zonder enige kennis van JAL of de Piccolino het programma toch een beetje kunt begrijpen. De LED gaat aan, er wordt even (100 milliseconden) gewacht, dan gaat de LED weer uit, en er wordt weer even (1 seconde) gewacht.5 Voor het schrijven van het programma gebruiken we JALedit. Deze gratis editor is speciaal bedoeld voor gebruik in combinatie met JAL heeft een aantal unieke eigenschappen: • • • • • • • • •

5

JAL opdrachten zijn kleur gecodeerd. Overzicht van gebruikte variabelen, constanten en procedures in een programma. Blokcommentaar toevoegen/verwijderen. Met één klik compileren en downloaden naar de Piccolino. Ingebouwde ASCII tabel, rekenmachine, terminal. Source export naar html (voor publicatie op een website). Automatische backups. Compileer resultaat in een aparte Window. Kan meerdere bestanden tegelijk laden.

Weet u weinig van het programmeren van microcontrollers af, of wilt u uw kennis vergroten, schaf dan het boek "PIC Microcontrollers programmeren - in 10 boeiende lessen" aan (ISBN 97890-5381-270-9) . Dit populaire boek, van dezelfde auteur, leert u stap voor stap hoe u JAL kunt gebruiken. Bij iedere les horen vragen waarvan de antwoorden achterin het boek staan.

Haal voor u verder leest het download pakket op dat bij de Piccolino hoort. We gebruiken hiervoor het pakket dat bij het boek "Supersnel Interfacen" hoort. Ga naar www.boekinfo.tk, en zoek de link naar het boek "Supersnel Interfacen" in uw taal. Klik op de link om naar de supportpagina te gaan, en download daar het downloadpakket. Dit pakket bestaat uit JALedit, een mooie editor waarmee u JAL programma's kunt schrijven, de bijbehorende JAL compiler, de software die met de Bootloader in de Piccolino praat en een grote verzameling bibliotheken en functies. 6 Unzip het pakket met behoud van de directory structuur, er is circa 18 Mb ruimte nodig. Het maakt niet uit waar u het pakket uitpakt - we verplaatsen het straks - maar het is wel belangrijk dat de mappen behouden blijven.7 Alle programma's en bestanden zijn voorgeconfigureerd, het enige dat u hoeft te doen is de gehele map op de juiste plaats te zetten. Kopieer de map PICcolino en alles wat er onder zit naar schijf C. Het resultaat moet eruit zien zoals weergegeven in de volgende figuur. Voor de duidelijkheid zijn andere mappen die niets met de Piccolino te maken hebben niet in de figuur afgebeeld.

Figuur 4. Uitgepakt downloadbestand op schijf C.

Is dat niet zo dan heeft u het ZIP bestand niet goed uitgepakt (de mappen zijn verloren gegaan) of map PICcolino niet goed gekopieerd. Probeer het opnieuw, want als dit niet klopt werken de programma's niet!

6

Het pakket bevat ook de broncodes van het "Supersnel Interfacen" boek, maar daar hebt u zonder boek weinig aan. U kunt deze map (c:\PICcolino\book) na de installatie wissen. U kunt natuurlijk ook het betreffende boek kopen, dan leert u alles over interfacing tussen PC en Piccolino. 7 Wanneer u niet in het bezit bent van een unzip programma dan vindt u op de supportwebsite een link naar een gratis programma. U kunt ook naar de officiële website van Winzip gaan daar een betaalde versie aanschaffen.

9

Ga naar het bestand jaledit.exe in map c:\PICcolino\JAL\JALedit en maak een snelkoppeling naar het bureaublad.8 Dit programma is JALedit, de editor waarmee u zo dadelijk JAL programma's gaat maken. U heeft het zeer regelmatig nodig, vandaar de snelkoppeling.

Figuur 5. Snelkoppeling naar JALedit op het bureaublad.

9

Controleer op jaledit.exe inderdaad in map "c:\PICcolino\JAL\JALedit" staat. U kunt dit gemakkelijk zien door van de snelkoppeling die u zojuist op het bureaublad geplaatst heeft de eigenschappen op te vragen.

Figuur 6. Juiste pad controleren in de snelkoppeling. 8

Ga naar het bestand jaledit.exe, en klik erop met de rechter muisknop. Kies niet "Snelkoppeling maken, maar wel "Kopiёren naar" en dan "Bureaublad (snelkoppeling maken)". 9 Alle PC afbeeldingen in dit boek zijn gemaakt op een Windows 7 64 bit machine, Nederlandse versie. Op uw PC kan het er dus iets anders uit zien, maar de inhoud moet hetzelfde zijn.

Is dat niet zo dan heeft u het download bestand niet goed uitgepakt, of niet goed op schijf C neergezet. Klopt het niet ga dan niet door maar doe de installatie opnieuw. Als de installatie niet klopt heeft doorgaan geen zin want dan werken de programma's niet.

Voorbeeld programma Om de Piccolino te kunnen programmeren moeten we in JALedit invoeren aan welke seriële of COM poort de Piccolino is aangesloten. Wanneer u gebruik maakt van een USB-to-Serial convertor dan kunt het betreffende poortnummer bij Windows Apparaatbeheer vinden. Open de Device Manager op uw PC - met de Piccolino aangesloten - om te kijken wat het nummer is dat uw PC aan deze poort heeft gegeven en noteer dat nummer.10 Heeft u meerdere virtuele seriële poorten en twijfelt u dan kiest u nu een willekeurige poort. Mocht straks blijken dat het programmeren van de Piccolino niet lukt dan probeert u een voor een de andere poorten totdat u de juiste heeft gevonden.

Figuur 7. De virtuele COM poort waar de Piccolino mee is verbonden.

10

Op Windows XP kiest u: Start - Uitvoeren en dan tikt u devmgmt.msc in en drukt op de enter toets. Op Windows 7 machines kiest u Start, en dan tikt u devmgmt.msc in het zoekvenstertje in. In de lijst met gevonden programma's klikt u op devmgmt.msc.

11

Op mijn PC is het virtuele poort nummer 5, maar op uw PC is dat naar alle waarschijnlijkheid anders. Wanneer u in deze handleiding een verwijzing ziet naar poort 5 vervang deze dan door het poort nummer dat voor uw PC van toepassing is. Om u te helpen herinneren welk nummer dat is kunt u dat hieronder noteren. Piccolino poort nummer Wanneer u gebruik maakt van een gewone seriële poort dan is het poortnummer wat lastiger te bepalen. In de meeste gevallen is het nummer 1, dus als u twijfelt vul dan poort 1 in. Mocht straks blijken dat het programmeren van de Piccolino niet lukt dan probeert u 2, 3 en 4. Een gewone COM poort heeft zo goed als nooit een nummer hoger dan vier. De software voor de Piccolino wordt geschreven met behulp van een editor: JALedit. Uiteraard is iedere editor bruikbaar, maar deze heeft speciale voorzieningen die het gebruik in combinatie met JAL erg eenvoudig maken. In de sectie "Software - JAL" heeft u een snelkoppeling gemaakt naar JALedit. Dubbelklik op deze snelkoppeling om JALedit te starten. JALedit wordt bediend vanaf een enkel scherm dat in de volgende figuur is weergegeven.11 Het is een standaard Windows venster dus u kunt het op de gebruikelijke manier vergroten, verkleinen, schermvullend maken en afsluiten. Het scherm is verdeeld in vier delen. Bovenaan vindt u de knoppenbalk. Links bevindt zich de (bron)code explorer.12 Hier kunt u snel een overzicht krijgen van belangrijke code elementen die in het programma aanwezig zijn, zoals includes, functies, procedures en variabelen. Rechts naast de code explorer bevindt zich de werkruimte met daarin de werkbladen. In de volgende figuur bevat de werkruimte één leeg werkblad met als naam "untitled1.jal". Uw programma komt in zo'n werkblad te staan. U kunt meerdere werkbladen programma's dus eigenlijk - tegelijk inladen. Zo kunt u gemakkelijk stukje van het ene in het andere programma kopiëren. Slechts een van de werkbladen is actief, dat wil zeggen dat daar het programma staat dat naar de Piccolino gestuurd gaat worden. Het tabje van dit blad is blauw. 11

Kies in het menu File voor optie New om hetzelfde scherm te krijgen als in deze figuur. De broncode is het programma in voor mensen leesbare vorm. Het programma is de vertaalde broncode die door een computer of microcontroller leesbaar is. Programmeurs gebruiken deze woorden vaak door elkaar, en korten broncode vaak af tot code. Het Engelse woord voor broncode is sourcecode. Ook dat wordt vaak afgekort tot code, of tot source. U ziet dat programmeurs het niet zo nauw nemen met taal.. 12

Onderin bevindt zich de compile results ruimte, hier komen de resultaten van de compilatie te staan. Compileren is het omzetten van de broncode in een vorm die de microcontroller kan lezen.

Figuur 8. Het scherm van JALedit.

Op het scherm vindt u de volgende mogelijkheden. 1. Code Explorer ruimte, hiermee kunt u belangrijke elementen uit uw broncode snel vinden. 2. Broncode ruimte, hier staat uw programma. 3. Compile results ruimte, hier komen de resultaten van de compilatie, bijvoorbeeld of er fouten in uw programma zitten. 4. Geheugen overzicht. Hier kunt u zien hoeveel geheugen van de Piccolino verbruikt wordt. Het verbruik wordt aangegeven in procenten, wanneer een van de waarden over de 100% gaat dan past uw programma niet. 5. Begin een nieuw programma. U krijgt een nieuwe leeg werkblad met als naam "untitled.jal", met achter untitled een nummer. 6. Open een programma dat op de harde schijf staat. U kunt het programma inladen door erop te dubbelklikken. 7. Sla het huidige programma op. Er wordt om een pakkende naam voor het programma gevraagd. U kunt kiezen wat u wilt, maar zet de extensie (.jal) er niet achter, dat doet JALedit zelf voor u.13 Om het overzicht te bewaren is het handig 13

Let op: de naam van uw programma mag geen spaties bevatten, en het pad naar die naam ook niet. Wilt u toch meerdere woorden gebruiken dan kunt u een underscore gebruiken (mijn_eerste_programma), of creatief omgaan met hoofdletters (MijnEerstePrograma). Merk op

13

8.

9.

10.

11.

voor elk programma een andere map te maken. Behalve het programma kunt u in die map allerlei andere dingen opslaan die met dat programma te maken hebben. Denk hierbij aan documentatie, achtergrond informatie e.d. Start de compilatie. Dat wil zeggen dat uw programma van JAL omgezet wordt in Assembler in HEX formaat. U kunt het dan zelf niet meer lezen. De Piccolino wordt nog niet geprogrammeerd, u gebruikt deze knop om te kijken of uw programma foutloos is, geen waarschuwingen veroorzaakt, en of het geheugen niet te vol raakt. Start de compilatie en stuur het resultaat naar de Piccolino. Deze knop doet hetzelfde als knop 8, echter deze keer wordt het programma naar de Piccolino gestuurd. De ASCII tabel. Computers (en dus ook microcontrollers)werken met cijfers en niet met letters of andere tekens. Om toch van andere tekens gebruik te kunnen maken is afgesproken dat alle cijfers ook een letter of teken kunnen voorstellen. Welke dat zijn staat in de zogenaamde ASCII tabel.14 De afspraak is gemaakt in de tijd dat computers 7 bits waren, er zijn dus 127 tekens gedefinieerd. Nummers boven de 127 worden ook wel gebruikt, echter daar kan iedere fabrikant zijn eigen uitleg voor kiezen, standaard is dat geenszins! Het ingebouwde terminal programma van JALedit. U kunt hiermee communiceren met de Piccolino. U dient daarvoor de volgende instellingen te gebruiken: Setting Port15 Baud rate Data bits Stop bits Parity Flowcontrol

Waarde De COM poort waar de Piccolino mee verbonden is, in mijn geval dus COM5. 115200 8 1 None None

Tabel 2. Communicatie instellingen.

dat in "c:\mijn documenten" een spatie zit, u kunt die map dus niet gebruiken, òòk niet wanneer u er een submap zonder spaties in maakt, zoals "c:\mijn documenten\mijnmap". 14 American Standard for Computer Information Interchange, Amerikaanse standaard voor de uitwisseling van informatie tussen computers. 15 U kunt alleen COM poorten selecteren die ook daadwerkelijk bestaan, Maakt u gebruik van een USBtoRS232 kabel, en is die kabel niet aangesloten dan bestaat die COM poort voor uw PC niet. De oplossing is om eert de kabel aan te sluiten, en eventueel de Piccolino aan te zetten, en pas dan de COM poort in te stellen.

Let op: dit is en standaard terminal programma, en het kan dus alleen afdrukbare ASCII waarden aan in de range 32 tot en met 255 (waarbij 129 tot en met 255 niet gestandaardiseerd zijn). 12. De naam van de actieve JAL file. Dit is de broncode die daadwerkelijk gecompileerd wordt wanneer u op button 8 of 9 drukt. Het tabje van de actieve JAL file is blauw, let u daar goed op wanner u meerdere broncode tegelijk open hebt staan! U zult niet de eerste zijn die zich afvraagt waarom het programma niet werkt om er dan na lang puzzelen achter te komen dat de verkeerde broncode actief was. 13. De naam van de actieve JAL file compleet met pad. U kunt dit gebruiken om snel te zien of uw pad en programma naam niet per ongeluk een spatie bevat.

Figuur 9. Aanpassen van de COM poort in JALedit.

Nu het programma is opgestart kan het programma ingetypt worden. We gaan echter eerst de juiste COM poort instellen. Kies in JALedit de menu optie "Tools" en dan "Environment Options". Klik vervolgens op de TAB "Programmer". Onderaan staat de tekst "%F -p com5 -r 300". Vervang het cijfer 5 door het nummer van de seriële poort op uw PC. Let goed op dat u niet per ongeluk ook anders aanpast! Klik vervolgens op de OK button. JALedit is nu klaar voor gebruik.

15

Figuur 10. JALedit met het demo programma.

Een programma bestaat uit een aantal opdrachten. Deze opdrachten vertellen de Piccolino wat hij moet gaan doen. Ze worden op volgorde van boven naar beneden afgewerkt, tenzij u andere instructies geeft. De programmeertaal die in dit boek gebruikt wordt (JAL) is niet zo kritisch over de manier waarop u de opdrachten over de regels verspreidt. Maar u moet het zelf natuurlijk nog wel snappen, daarom maken we een paar afspraken: 1. Op iedere regel komt maar één opdracht. 2. Met kort commentaar geven we aan wat de bedoeling is van de opdrachten. 3. Bij lussen en voorwaardelijke opdrachten wordt ingesprongen. Wat regel drie precies inhoudt komen we straks op terug. Om de leesbaarheid verder te vergroten voegt JALedit allerlei kleuren toe aan uw tekst. Op de werking van het programma zelf heeft dit geen enkele invloed. Allereerst moet een library geladen worden. Een library is een soort bibliotheek met extra opdrachten. Het gaat dan bijvoorbeeld om opdrachten die niet in de programmeertaal zelf kunnen zitten omdat ze voor elke microcontroller anders zijn. Om u daar niet mee te vermoeien zijn al die verschillen weggestopt. Het enige dat u als gebruiker hoeft te doen is de library te gebruiken die bij de microcontroller hoort. In de Piccolino zit de 16f887 dus nemen we de library die daar bij hoort: de 16f887_bert_piccolino. Het laden van deze library gebeurt met de volgende opdracht: include 16f887_bert_piccolino

U kunt met intikken overigens het best even wachten totdat alle stukjes programma zijn uitgelegd, omdat ik ze niet altijd in de juiste volgorde behandel. Aan het eind van deze paragraaf staat het complete programma. De standaard JAL opdrachten worden door de editor herkend en krijgen een mooi kleurtje. Variabelen en opdrachten uit libraries zijn blauw. De eerste regel begint met include (Engels voor invoegen) en dan de naam van de library. Alles wat in die library staat wordt op dat punt in het programma gevoegd, zonder dat u daar verder iets van ziet. De Piccolino bevat een drietal standaard hardware componenten die u kunt gebruiken zonder dat u die eerst moet declareren. Component Rode LED

Naam pLED

Schakelaar

pButton

Potmeter

pPot Op analoog kanaal pAN

Tabel 3. Standaard componenten van de Piccolino.

We gaan in dit demo project de LED op de Piccolino laten knipperen. De LED kan aan en uitgezet worden met de opdrachten "on" en "off". pLED=on pLED=off Tussendoor moet een kleine pauze ingelast worden, anders gaat het knipperen zo snel dat u er niets van ziet. We laten de LED 1 seconde aan: delay_1s(1) Het cijfer tussen haakjes geeft aan hoe vaak er 1 seconde gewacht moet worden. Zou hier bijvoorbeeld delay_1s(3) staan dan wacht het programma op die plaats 3 x 1 seconde is 3 seconden. En vervolgens laten we hem 100 milliseconde (0,1 seconde) uit: delay_100ms(1) Met de bovenstaande opdrachten knippert de LED eenmaal, maar een echt knipperlicht houdt natuurlijk niet na eenmaal op. Daarom moeten de laatste opdrachten herhaald worden, in feite eindeloos: 17

forever loop end loop Alle stukjes programma bij elkaar ziet er als volgt uit: include 16f887_bert_piccolino forever loop pLED = on delay_1s(1) pLED=off delay_100ms(1) end loop U ziet dat de loop (in het Nederlands: lus) die eindeloos herhaald wordt opdrachten bevat die inspringen. Op die manier is goed te zien waar de lus begint en waar hij eindigt. Dat is de derde afspraak die we gemaakt hadden over het intikken van een programma: Bij lussen en voorwaardelijke opdrachten wordt ingesprongen Wellicht is dit een goed moment om het programma in zijn geheel in te tikken en meteen even op te slaan. Met behulp van het File menu kiest u Save As en verzint een pakkende naam, bijvoorbeeld demo (de extensie .jal komt er vanzelf achter). Plaats het programma in een passende map, bijvoorbeeld c:\PICcolino\tmp Het is overigens handig voor elk project dat u maakt een andere directory te gebruiken. Zo komt alles wat met dat ene project te maken heeft netjes bij elkaar. Let op: de naam van het bestand en de naam van het pad mogen geen spaties bevatten! Zitten die er wel in dan krijgt u vreemde foutmeldingen. 16 Allereerst kan gekeken worden of het programma foutloos is ingetypt. Klik op de button met het groen driehoekje (compile active JAL file), of druk op F9.

16

Wilt u toch meerdere woorden gebruiken dan kunt u een underscore gebruiken (mijn_eerste_programma), of creatief omgaan met hoofdletters (MijnEerstePrograma). Merk op dat in "c:\mijn documenten" een spatie zit, u kunt die map dus niet gebruiken, òòk niet wanneer u er een submap zonder spaties in maakt, zoals "c:\mijn documenten\mijnmap".

Figuur 11. Compile Active JAL

U kunt meerdere bestanden tegelijk openen, echter er is er maar één de "active" file. Van dit bestand is het tabje bovenaan blauw. Als u de instructies netjes heeft opgevolgd heeft u maar één bestand open (namelijk wat u net heeft ingetypt) dus dat is automatisch de actieve. Er verschijnt even een window, en daarna komt onderaan in de "compile results" window een mededeling. Compilation started at :5/22/2012 4:35:49 PM jal 2.4o (compiled May 8 2011) 17 Compiler CommandLine: C:\PICdev\JAL\Compiler\jalV24o\JALv2.exe -clear -no-variable-reuse -s c:\picdev\jal\libraries "C:\PICcolino\tmp\demo.jal" Errors :0 Warnings :0 Code :156/8192 Data:17/368 Hardware Stack : 2/8 Software Stack :96

Geen fouten betekent overigens niet dat het programma doet wat u wilt, het betekent alleen dat u geen taalfouten gemaakt heeft. Stel dat u bijvoorbeeld per ongeluk deley in plaats van delay geschreven zou hebben dan krijgt u daar meteen een melding van: [Error] (demo.jal) [Line 5] {FOREVER starts at C:\PICcolino\tmp\demo.jal:3} [Error] (demo.jal) [Line 5] "deley_1s" not defined [Error] (demo.jal) [Line 5] unexpected token: deley_1s Compiler CommandLine: C:\PICdev\JAL\Compiler\jalV24o\JALv2.exe -clear -no-variable-reuse -s c:\picdev\jal\libraries "C:\PICcolino\tmp\demo.jal" Errors :5

Warnings :0

De fout is gemaakt in regel 5 en wordt netjes gemeld: "deley_1s" not defined. Door deze fout raakt de compiler in de war en snapt nu regel 5 helemaal niet meer. Het lijkt daarom alsof u meerdere fouten hebt gemaakt. Het beste is de eerste fout aan te passen, en dan 17

Wanneer een andere JAL versie gebruikt wordt staat hier een ander nummer en een andere 'compiled' datum. Dat maakt echter niets uit.

19

opnieuw op Compileren te klikken. Dan lost u weer de eerste fout op, net zolang totdat er geen fouten meer zijn. Er vanuit gaande dat het programma foutloos is wordt het tijd het naar de Piccolino te downloaden. Sluit de Piccolino aan op de voeding, en op uw PC.

Figuur 12. Piccolino aan de PC en voeding aangesloten.

Zet de spanning op de Piccolino. Als het goed is gaat de rode power LED meteen aan. Is dat niet zo dan is de voeding niet goed aangesloten, of niet geschikt.18

Figuur 13. De auto-reset jumper (omcirkeld) moet geplaatst zijn.

18

De voeding hoeft niet gestabiliseerd te zijn, maar moet wel gelijkspanning leveren met de plus op de middenpin. Het voltage moet bij voorkeur tussen de 7 en 10 volt liggen. Meer mag wel, maar dan wordt de spanningsregelaar op de Piccolino wel snel warm. Optioneel kunt u de Piccolino ook met een 9 volt batterij voeden.

Let op: om automatisch programmeren mogelijk te maken moet de auto-reset jumper geplaatst zijn, zie de voorgaande figuur. U hoeft deze jumper in feite nooit te verwijderen, tenzij u de Piccolino liever met de hand reset.19 Gaat de rode LED aan druk dan op de PC op de button met het IC en het groene pijltje erop (compile + program) of druk op Ctrl-F9.

Figuur 14. Compile + Program

De window van het compileren verschijnt opnieuw, maar daarna komt een window met zwarte achtergrond. Deze hoort bij de software die de Piccolino gaat programmeren.

Figuur 15. Window van de programmer.

De window gaat te snel weer weg om te lezen wat er precies in staat, u kunt de tekst in de voorgaande figuur rustig nalezen. 19

Maakt u gebruik van Hyper Terminal of pySerial lees dan de sectie "Gebruik Piccolino met Hyper Terminal of pySerial" verderop in dit document.

21

Als alles goed gaat knippert de LED op de Piccolino nadat deze window zich weer automatisch gesloten heeft. U heeft zojuist uw eerste microcontroller programma gemaakt, gefeliciteerd! Als alles goed is gegaan kunt u deze paragraaf verder overslaan en door gaan naar de volgende sectie. Ging het niet goed zoek uw probleem dan op in deze tabel, voer de oplossing uit die er bij hoort, en probeer compile+program opnieuw. symptoom De window met zwarte achtergrond komt niet.

1.

2.

3.

In de window met zwarte achtergrond komt een foutmelding en de window blijft staan. U kunt de window sluiten door op enter te drukken.

1.

2.

3. 4.

5.

6.

oplossing Er zitten fouten in het programma, kijk in de window onderaan (compile results) of daar foutmeldingen staan. U heeft het software pakket niet volgens de instructies geïnstalleerd. Lees de instructies bij het download pakket en volg ze exact op. U heeft de software op een andere plaats geïnstalleerd dan in de instructies aangegeven. Ga in JALedit naar "environment opties" in het menu "compile", kies de tab "programmer" en vul de juiste gegevens in. Let op: de directory namen mogen geen spaties bevatten. Lees de foutmelding en los het genoemde probleem op. Meestal zijn de meldingen duidelijk, anders kan een van de volgende punten ook de oorzaak zijn. De seriële poort klopt niet (de Piccolino zit aan een andere poort). Pas het nummer aan volgens de instructies eerder in deze sectie. De stroom is niet ingeschakeld, doe dat alsnog. Een ander programma maakt gebruik van de seriële poort waar ook de Piccolino op zit, en houdt deze bezet (bijvoorbeeld een terminal programma). Sluit dit programma af en probeer het opnieuw. Herstart eventueel de computer indien het andere programma de poort niet correct vrijgeeft. Uw voeding is niet stabiel genoeg. Zorg er voor dat de ingangsspanning voor de Piccolino hoog genoeg is (bij voorkeur zeven volt of meer). De auto-reset jumper is niet geplaatst. Plaats de jumper en probeer het opnieuw.

Het programma is gedownload maar de LEDs knipperen niet. In het zwarte venster blijft de tekst "Establishing contact etc" staan. Het is u eerder wèl gelukt de Piccolino te programmeren.

De LED knippert wel maar supersnel, controleer of u (een van) de delay opdracht(en) wellicht vergeten bent. Een Piccolino programma dat gegevens stuurt naar de PC kan het onmogelijk maken dat de Piccolino geprogrammeerd wordt. In het zwarte venster blijft de tekst "Establishing contact etc" staan totdat het PC programma het uiteindelijk op geeft. De oplossing hiervoor is eenvoudig: wanneer de melding in het zwarte venster blijft staan drukt u op de reset toets van de Piccolino, telt rustig tot drie, en laat de reset toets los. Op dat moment gaat het programmeren alsnog van start. Mocht dat ook niet werken: zet dan de Piccolino uit. Programmeer de Piccolino opnieuw maar zet de Piccolino pas aan wanneer het zwarte scherm met "Establishing contact etc" er staat. Nu lukt het programmeren wel.20

Tabel 4. Overzicht mogelijke problemen, met oplossing

Als het ondanks de bovenstaande instructies niet wil lukken controleer alles dan nogmaals, desnoods een dag later; een frisse blik doet wonderen. Bent u er van overtuigd alles goed gedaan te hebben kom dan naar de JAL gebruikersgroep op Yahoo (zie de support pagina voor actuele adressen) en stel uw vraag. De voertaal in deze groep is Engels, de deelnemers bevinden zich overal in de wereld, zij zullen u graag verder helpen.

Programmeren lukt niet Een Piccolino programma dat gegevens stuurt naar de PC kan het onmogelijk maken dat de Piccolino geprogrammeerd wordt. In het zwarte venster blijft de tekst "Establishing contact etc" staan totdat het PC programma het uiteindelijk op geeft. Dit probleem ontstaat wanneer het Piccolino programma ongevraagd gegevens naar de PC stuurt. Bijvoorbeeld met zo'n lus: forever loop serial_hw_write(data) end loop 20

Zie ook de volgende sectie: "Programmeren lukt niet".

23

Wanneer die niet luistert, bijvoorbeeld omdat u aan het herprogrammeren bent, loopt de buffer van de PC vol. Wanneer u dan het programma in de Piccolino wilt zetten krijgt het programmeerprogramma in plaats van antwoord van de Piccolino de oude gegevens die nog in de buffer staan. En dus lukt het programmeren niet. De oplossing hiervoor is eenvoudig: wanneer de melding in het zwarte venster blijft staan drukt u op de reset toets van de Piccolino, telt rustig tot drie, en laat de reset toets los. Op dat moment gaat het programmeren alsnog van start. Werkt dat ook niet zet dan de Piccolino uit. Probeer de Piccolino opnieuw te programmeren, maar zet de Piccolino pas aan wanneer het zwarte scherm met "Establishing contact etc" er staat. U kunt dit probleem gemakkelijk voorkomen door de Piccolino alleen gegevens naar de PC te laten sturen wanneer die daarom vraagt. Bijvoorbeeld op deze manier: forever loop serial_hw_wait(something) serial_hw_write(data) end loop

Gebruik Piccolino met Small Basic De Piccolino, in combinatie met Small Basic stelt u in staat razendsnel applicaties te maken waarbij de PC de Piccolino aanstuurt, of via de Piccolino metingen verzameld en op de PC laat zien. Piccolino include 16f887_bert_piccolino forever loop if pButton then serial_hw_write(adc_read_low_res(pAN)) delay_10ms(1) end if end loop Let op: het Piccolino programma gaat uit van COM poort 5. Wanneer u een andere COM poort gebruikt moet u dit in het programma aanpassen (de betreffende opdracht is vetgedrukt).

PC GraphicsWindow.BackgroundColor = "Black" GraphicsWindow.PenColor = "LightGreen" GraphicsWindow.Width = 505 GraphicsWindow.Height = 280 GraphicsWindow.BrushColor = "LightGreen" GraphicsWindow.FontBold = "no" GraphicsWindow.DrawBoundText(30, 0, GraphicsWindow.Width, "Piccolino Variable resistor") GraphicsWindow.BrushColor = "Black" if ComPort.OpenPort("com5",115200)= "true" then While("True") lasty=y y=255-ComPort.RXbyte() 'TextWindow.Write(y) x=x+1 If x>500 Then 'GraphicsWindow.Clear() x=0 endif 'wis een stukje van de grafiek GraphicsWindow.FillRectangle(x,20,4,GraphicsWindow.Height-20) If x>1 then 'zet de gegevens +20 om de tekst te vermijden GraphicsWindow.DrawLine(x-1, lasty+20, x, y+20) EndIf Endwhile comport.ClosePort() else TextWindow.WriteLine("This comport doesn't exist") endif

Deze set voorbeeld programma's meet de stand van de potmeter op de Piccolino en laat die op de PC in een eenvoudige grafiek zien.21 De gegevens worden alleen doorgestuurd

21

Wilt u meer weten over Small Basic raadpleeg dan de boeken "PC Programmeren in XX lessen" en "Supersnel Interfacen".

25

zolang de knop op de Piccolino ingedrukt is. Wanneer het scherm vol is begint de grafiek opnieuw en veegt de oude grafiek langzaam uit.

Figuur 16. Resultaat van de programma's.

U heeft voor dit projectje alleen de Piccolino nodig, uiteraard aangesloten op een PC.

Gebruik Piccolino met JAL boeken U kunt de Piccolino ook gebruiken in combinatie met de JAL boeken.22 Het enige dat u hoeft te doen is de broncodes uit de boeken om te zetten naar de 16f887, de microcontroller op de Piccolino. Normaal gesproken is dat een hele operatie, maar door het gebruik van de _bert libraries valt het in de praktijk enorm mee. Het kan zijn dat de microcontroller mogelijkheden heeft die de 16f887 niet heeft, in dat geval is het overzetten van de software uiteraard onmogelijk. Bij de JAL boeken komt dat zelden voor. In een enkel geval moet u in het programma ook een poort wijzigen omdat deze in de Piccolino niet bestaat, of voor iets anders gebruikt wordt. Bovendien kunt u natuurlijk gebruik maken van de componenten die reeds op de Piccolino aanwezig zijn. Component Rode LED

Naam pLED

Schakelaar

pButton

Potmeter

pPot Op analoog kanaal pAN

Tabel 5.Standaard componenten van de Piccolino. 22

Zie de sectie "Hoe nu verder" over de namen van deze JAL boeken.

Als voorbeeld nemen we het tutorial project, uit het boek 'PIC Microcontrollers". Op de microcontroller zijn twee LEDs aangesloten die om de beurt aan een uit gaan. De hardware ziet er als volgt uit: LED 330

c4

330

d3

LED GND

Figuur 17. Aansluiting LEDs op de Piccolino.

Figuur 18. De complete opstelling.

De pinnen die het tutorial project voor de 16f877A gebruikt zijn ook beschikbaar op de Piccolino. Het enige dat we moeten doen is de include veranderen van "16f877A_bert" in "16f887_bert_piccolino" en het programma werkt. Een beetje flauw voorbeeld wellicht, maar in de meeste gevallen is het inderdaad zo eenvoudig!

27

Tutorial programma 16f877A

Tutorial programma Piccolino

include 16f877A_bert

include 16f887_bert_piccolino

-- definities pin_c4_direction = Output pin_d3_direction = Output

-- definities pin_c4_direction = Output pin_d3_direction = Output

forever loop

forever loop

-- LEDs in stand 1 pin_d3 = high pin_c4 = low delay_1s(1)

-- LEDs in stand 1 pin_d3 = high pin_c4 = low delay_1s(1)

-- LEDs omgewisseld pin_d3 = low pin_c4 = high delay_1s(1)

-- LEDs omgewisseld pin_d3 = low pin_c4 = high delay_1s(1)

end loop

end loop Tabel 6. Tutorial programma in de Piccolino.

Let op: een aantal communicatie pakketten maakt gebruik van software flowcontrol die niet uitgezet kan worden, bijvoorbeeld Hyper Terminal. Deze software flowcrontrol gebruikt dezelfde pin die de Piccolino gebruikt voor de auto-reset. Wilt u van een dergelijk pakket gebruik maken dan moet u de Piccolino jumper eerst verwijderen.

Gebruik Piccolino met Hyper Terminal of pySerial Een aantal communicatie pakketten maakt gebruik van software flow control die niet uitgezet kan worden, bijvoorbeeld Hyper Terminal en de pySerial module van Python. Wilt u van een dergelijk pakket gebruik maken dan moet u de jumper na het programmeren verwijderen. Doet u dat niet dan wordt de Piccolino door deze pakketten tijdens de communicatie continu gereset, en kan dus niet reageren. U merkt dit doordat de Piccolino nergens op lijkt te antwoorden, en ook niets lijkt te verzenden.

Hoe nu verder Wilt u meer weten over programmeren in JAL, over het aansluiten van verschillende soorten hardware? Er zijn van dezelfde schrijver nog vier interessante Nederlandstalige boeken over JAL verschenen, boordevol leuke en spannende projecten. Deze boeken maken geen gebruik van de Piccolino, maar de conversie is inde meeste gevallen eenvoudig.

Figuur 19. "PIC Microcontrollers programmeren - in 10 boeiende lessen"

Met het boek "PIC Microcontrollers programmeren - in 10 boeiende lessen" leert u hoe u zelf een microcontroller kunt programmeren. Het boek start aan het absolute begin, en bouwt vandaar de kennis op. U heeft dus geen voorkennis nodig: iedereen kan met dit boek aan de slag. Wanneer u alle lessen volgt (dat wil zeggen: de oefeningen ook daadwerkelijk maakt) dan kunt u wanneer u het boek uit heeft zelf PIC microcontroller programma's schrijven, en programma's van anderen lezen. U leert de functie van JAL opdrachten zoals include, pin, delay, forever loop, while loop, case, exit loop, repeat until, if then, en het gebruik van functies, procedures en timer- en poortinterrupts. U laat een LED knipperen, maakt een tijdschakelaar, meet de stand van een potmeter, maakt geluiden, voorkomt contactdender en regelt de helderheid van een LED. En uiteraard leert u debuggen: hoe u in uw programma's fouten kunt vinden en oplossen. U leert verschillende onderdelen zoals PIC microcontroller, potmeter en kristal herkennen, en hoe u een PIC microcontroller aan moet sluiten en met uw PC moet verbinden. U maakt hierbij gebruik van een steekbord zodat u de opstelling gemakkelijk kunt aanpassen om verder te experimenteren.

29

Figuur 20. PIC Microcontrollers - 50 projecten voor beginners en experts.

Het boek "PIC Microcontrollers" behandelt 50 spannende en leuke projecten met PIC microcontrollers, zoals een tijdschakelaar, dobbelsteen, codebel, donkerschakelaar, stil alarm, motor aansturing, mensen-sensor, ultrasoon-sensor, plaatjes van licht, nachtzoemer, elektrische kaars. U kunt dit boek gebruiken om de verschillende projecten na te bouwen en daarna in praktijk te brengen. Door de duidelijke uitleg, schema’s en zelfs foto’s van de opstelling op een steekbord is het nabouwen een erg leuke bezigheid. U kunt dit boek ook als studieboek gebruiken. Per project wordt uitgelegd waarom het project op die manier is uitgevoerd. Ook het gebruik van de datasheet komt regelmatig aan de orde. Al doende leert u veel over het project en de gebruikte microcontroller, en kunt u het project zelf aanpassen en uitbreiden naar uw eigen wensen... ook ideaal voor scholen. Het boek is verder ideaal als naslagwerk. U vindt er de uitleg van alle opdrachten van de programmeertaal JAL in terug. Zelfs als u alle projecten een keer gemaakt heeft, zal dit boek nog lang een plekje naast uw PC behouden.

Figuur 21. 50 PIC microcontroller projecten - voor beginners en experts.

Het boek "50 PIC microcontroller projecten" boek bevat eveneens 50 leuke en spannende projecten met PIC microcontrollers zoals een laser alarm, USB plaagmuis, eierwekker, jongerenverjager, geluidsschakelaar, capacitieve vloeistofniveau meting, "vinger in het water" sensor, bewaking van een ruimte met een camera, 220 volt lichtdimmer, pratende microcontroller en nog veel meer. Er komen talloze technieken aan de orde zoals relais, wisselstroomregeling (ook 220 volt), I2C, SPI, RS232, USB, pulsbreedte modulatie, rotary encoder, interrupts, infrarood, analoog-digitaal conversie (en andersom), 7-segment display en zelfs CAN bus. U kunt dit boek gebruiken om de verschillende projecten na te bouwen en daarna in de praktijk te brengen. Door de duidelijke uitleg, schema's en zelfs foto's van de opstelling is het nabouwen een leuke bezigheid. Bij ieder project wordt uitgelegd waarom het juist op die manier is uitgevoerd, en wordt kort de theorie behandeld. U kunt dit boek dus gebruiken als studieboek, of als basis voor grotere en ingewikkeldere projecten. Alle schakelingen zijn op een steekbord uitgevoerd zodat uitbreiden en aanpassen gemakkelijk is. De drie PIC microcontrollers die in dit boek gebruikt worden zijn de 16f877A, 18f4455 en 18f4685. Daarnaast komt aan de orde hoe u de programma's van de ene naar de andere microcontroller kunt overzetten (er worden 15 types ondersteund) inclusief twee praktijkvoorbeelden. Dit boek is geen vervolg, maar wel een aanvulling op het "PIC Microcontrollers" boek van dezelfde schrijver. Heeft u beide boeken dan heeft u maar liefst 100 projecten voor zes verschillende microcontrollers!

31

Figuur 22. Kunstmatige Intelligentie - Breng uw microcontroller tot leven!

Het boek "Kunstmatige Intelligentie" bevat 23 zeer bijzondere en spannende projecten over kunstmatige intelligentie en lerende machines, voor PIC microcontroller en PC. U leert hoe u een neuraal netwerk in een microcontroller opzet, en hoe u het netwerk zelflerend kunt maken. U ontdekt hoe u robots kunt kweken, en hoe u door verandering van een fitness functie een totaal ander gedrag krijgt. U merkt hoe een PC programma uw zwakke punten vindt en deze in een spelletje meedogenloos uitbuit. Talloze technieken uit de kunstmatige intelligentie komen in de projecten aan de orde zoals expert systeem, neuraal netwerk, subsumptie, emergent gedrag, genetisch algoritme, cellulaire automaat en roulette hersenen. Ieder project bevat duidelijke instructies met schema's en foto's zodat u meteen aan de slag kunt. Overal vindt u ideeën en veel literatuur verwijzingen om nog veel meer projecten te kunnen maken. Zelfs als u alle projecten uit dit boek gemaakt heeft zal het zodoende nog lang als ideeënboek en naslagwerk naast uw PC blijven staan. Een uniek boek vol informatie die u nergens anders kunt vinden, in eenvoudige en duidelijke taal. Een schitterend boek voor iedereen met interesse in kunstmatige intelligentie en lerende machines.

Piccolino (JAL) taal instructies JAL (Just Another Language) is een niet aan indeling gebonden taal. De opdrachten kunnen over de regels verspreid worden naar keuze. Tab, spatie, nieuwe regel wordt allemaal als spatie gelezen. Er is geen scheidingsteken tussen opdrachten. In theorie kunnen alle opdrachten dus op een regel achter elkaar gezet worden, in de praktijk leidt deze vrijheid er toe dat programma's juist zeer leesbaar geschreven worden.

Het is de enige geavanceerde gratis taal, en kent een grote en internationale actieve gebruikersgroep. JAL is configureerbaar en uitbreidbaar door middel van bibliotheken en kan gecombineerd worden met assembler. Een typisch JAL programma bestaat uit het aanroepen van een library die tenminste de gegevens van de PIC bevat waarvoor het programma bedoeld is. Gebruikt u bijvoorbeeld de Piccolino met de 16f887 microcontroller dan roept u die library aan. include 16f887_bert_piccolino Daarna worden de variabelen en constanten gedeclareerd: var byte a Waarna de opdrachten volgen: forever loop a=a+1 end loop Het is een goed gebruik in het programma door middel van commentaar regels aan te geven wat het programma precies doet, en aan te geven voor welke JAL versie het geschreven is. Het totale programma zou er dus als volgt uit zien: --JAL 2.4j include 16f887_bert_piccolino var byte a --demo programma forever loop a=a+1 end loop Variabelen Hier wordt meteen de kracht van JAL zichtbaar; zowel unsigned (alleen positief) als signed (positief en negatief) variabelen kunnen gebruikt worden tot 32 bits aan toe.23

23

Voor variabelen met meer dan 16 bits moeten microcontrollers beschikken over zogeheten shared memory. Van de microcontrollers waarvoor een _bert bibliotheek beschikbaar is bevatten

33

naam bit byte sbyte word sword dword sdword

omschrijving 1 bit unsigned boolean 8 bit unsigned 8 bit signed 16 bit unsigned 16 bit signed 32 bit unsigned 32 bit signed

range 0 of 1 0 t/m255 -128 t/m127 0 t/m 65.535 -32.768 t/m 32.767 0 t/m 4.294.967.296 -2.147.483.648 t/m 2.147.483.647

Tabel 7. Verschillende typen variabelen die JAL kent.

Bovendien is het mogelijk een variabele op maat te definiëren. Bijvoorbeeld: var bit*2 demo Deze opdracht zorgt ervoor dat variabele demo nu 2 bits lang is (en dus de waarden 0,1,2 en 3 kan bevatten). Wanneer een waarde aan demo wordt toegekend hoeft de waarde niet persé twee bits te zijn, echter alleen de laagste twee bits worden in demo gezet (de rest past immers niet).24 Dus: demo = 99 maakt van demo in werkelijkheid 3 (99 is 1100011 binair, de laagste twee bits zijn 1, en dat is decimaal 3). Behalve decimale waarden kunnen ook andere basisstelsels gebruikt worden. Hiervoor wordt een prefix aan het getal toegevoegd. Toegestane stelsels zijn: 23 0x1F 0b01

decimaal hexadecimaal binair

de 10f200 en de 12f675 dit soort geheugenplaatsen niet. Bij deze microcontrollers bent u dus beperkt tot 16 bits of minder. 24 De compiler ziet dit wel en geeft u een waarschuwing. Als dit uw bedoeling was (zoals in dit voorbeeld) kunt u deze waarschuwing negeren. Gebruikt u het download pakket dan krijgt u deze waarschuwingen overigens niet te zien, want deze staan standaard uit.

En uiteraard kunnen er ook letters gebruikt worden: "Hello"

string

Voor betere leesbaarheid kunnen getallen van underscores worden voorzien op elke gewenste positie. Voor de compiler is 100 dus identiek aan 10_0. Een voorbeeld van een binaire waarde toewijzing met underscores: a = 0b_1001_1110 Het declareren van variabelen moet plaatsvinden voordat ze gebruikt worden. Er zijn een aantal mogelijkheden: opdracht var byte a

omschrijving a is gedeclareerd als byte

var byte a = 0x1F

idem, a krijgt meteen als waarde 1F (hexadecimaal).

var byte a at 0x06.

a is gedeclareerd als byte op geheugenplaats 0x0625.

var byte volatile a

a is gedeclareerd als byte en mag door de compiler niet weg geoptimaliseerd26 worden.

var byte a is b

a is een synoniem of alias voor b (deze moet dan eerst gedeclareerd worden). Tabel 8. Declareren van variabelen.

25

Normaal moet u erg goed weten wat u doet voor u variabelen op een geheugen plaats dwingt. Het kan echter ook op een handige manier gebruikt worden om een variabele op te splitsen. Dit voorbeeld definieert een array op dezelfde plaatst als het word demo: var word demo var byte dem[2] at demo Demo is een word en dus twee bytes lang. Aangezien de array dem[2] ook twee bytes lang is, en op dezelfde plaats in het geheugen staat is het eerste item in de array dem[0] de lage byte en het tweede item dem[1] de hoge byte van demo. 26 De compiler optimaliseert het programma tijdens compilatie. Zo worden bijvoorbeeld ongebruikte stukken van bibliotheken verwijderd. Ongebruikte variabelen worden dus ook verwijderd. Door een variabele als volatile te definiëren wordt deze verwijdering voorkomen. Dit is vooral van belang als een variabele naar een pin verwijst. De compiler 'weet niet' dat pinnen van buitenaf kunnen veranderen en zal de opdracht dus als 'zinloos' wissen. Overigens is dit vooral van belang in bibliotheken. Wie verwijst naar pin_a4 verwijst in werkelijkheid naar een variabele in een bibliotheek. De normale gebruiker zal volatile zelden of nooit nodig hebben.

35

De laatste opdracht kunt u gebruiken om aan pinnen gemakkelijkere namen te geven. Stel dat aan pin c1 een rode led zit, dan kunt u na het geven van deze opdracht: var bit redled is pin_c1 Met bijvoorbeeld redled = 1 de pin c1 hoog maken en dus de led aanzetten. Behalve dat het programma daardoor een stuk leesbaarder wordt is het ook makkelijk bij de eventuele migratie naar een ander type microcontroller. Stel bijvoorbeeld dat deze helemaal geen c1 pin heeft, dan hoeft u alleen de definitieregel te veranderen in bijvoorbeeld var bit redled is pin_a1 waarbij de rest van het programma ongewijzigd kan blijven. Constanten Wanneer u van te voren weet dat een variabele niet van waarde gaat veranderen, dan is het geen variabele maar een constante. U kunt dit aangeven met de opdracht const, bijvoorbeeld: const byte demo = 5 Het grote voordeel hiervan is dat een variabele RAM geheugen gebruikt - in de meeste microcontrollers een schaars goed - en een constante niet. Deze komt namelijk in het programma geheugen, waar veel meer van beschikbaar is. Het loont dus de moeite waar mogelijk constanten te gebruiken. Forever loop Deze opdrachten set zorgt ervoor dat een bepaald programmadeel eindeloos herhaald wordt. Veel microcontroller programma's maken van deze set gebruik omdat dit een handige manier is om ervoor te zorgen dat het programma nooit stopt. forever loop [opdrachten] end loop Met de opdracht Exit Loop kunt u de eindeloze lus desgewenst verlaten.

While loop Deze opdrachten set zorgt ervoor dat een serie opdrachten herhaald wordt zolang aan een bepaalde conditie is voldaan. In het onderstaande voorbeeld worden de opdrachten herhaald zolang aan de conditie voldaan is (true). Is aan de conditie niet meer voldaan (false) dan verlaat het programma de lus. while [conditie] loop [opdrachten als aan de conditie voldaan is ] end loop Met de opdracht Exit Loop kunt u de lus verlaten ook als de conditie nog steeds waar is. Repeat until Met deze opdracht kunt u een serie opdrachten herhalen totdat aan een bepaalde voorwaarde is voldaan. repeat [opdrachten als aan conditie voldaan wordt ] until [conditie] In het volgende voorbeeld wordt geteld totdat de teller waarde 8 heeft bereikt: repeat teller = teller + 1 until teller == 8 Let op het dubbele is-gelijk teken, het betreft hier immers een conditie en geen som. In feite lijkt deze opdracht op een while-loop met de test aan het einde, dus die minimaal 1 maal doorlopen wordt. Met de opdracht Exit Loop kunt u de lus verlaten ook als nog niet aan de conditie is voldaan. For loop Deze opdrachten set zorgt ervoor dat een serie opdrachten een vast aantal keren uitgevoerd wordt.

37

In het onderstaande voorbeeld worden de opdrachten een “aantal keer” herhaald. for [aantal keer] loop [opdrachten ] end loop Normaal telt de compiler "voor zichzelf", maar u kunt hem ook dwingen een bepaalde variabele voor het tellen te gebruiken met behulp van de opdracht using. Dat kan handig zijn wanneer u bijvoorbeeld met deze teller de positie in een array wilt bepalen for 10 using teller loop [ opdrachten ] waarde = demo[teller] end loop Omdat microcontrollers bij 0 beginnen met tellen krijgt teller dus de waarden 0 tot en met 9. Met de opdracht Exit Loop kunt u de lus verlaten ook wanneer deze nog niet vaak genoeg uitgevoerd is. Procedure Een procedure is een stukje programma dat op meerdere plaatsen gebruikt wordt. Dit stukje programma kan apart gezet worden in een soort apart programma, procedure genaamd. Zo hoeft het niet telkens opnieuw ingetypt te worden. Bovendien komt het de leesbaarheid van een programma zeer ten goede. In het onderstaande voorbeeld staat de procedure demo procedure demo is [opdrachten] end procedure Deze procedure wordt aangeroepen met de opdracht demo U kunt in een procedure ook variabelen gebruiken. Wanneer u deze binnen de procedure declareert gelden ze alleen in die procedure. In dit voorbeeld:

procedure demo is var byte a [opdrachten] end procedure is de variabele a buiten de procedure niet bekend. Wilt u een waarde aan een variabele geven van buiten de procedure, dan moet u deze in de aanroep doorgeven. Daarmee wordt hij automatisch gedeclareerd. De procedure zelf ziet er dan zo uit: procedure demo (byte in a) is [opdrachten waarin a gebruikt wordt] end procedure Binnen deze procedure kunt u nu dus variabele a gebruiken, die bij de aanroep meteen een waarde krijgt. De aanroep gaat als volgt wanneer u bijvoorbeeld waarde 6 wilt doorgeven naar variabele a: demo (6) Op dezelfde manier kunt u ook variabelen weer uit de procedure doorgeven, maar dan met "byte out" in plaats van "byte in". Als voorbeeld een echte procedure: procedure serial_hw_Write ( byte in data ) is -- wacht totdat TXREG leeg is while ! TXIF loop end loop -- stop dan de variabele data in TXREG ter verzending TXREG = data end procedure

Wanneer deze procedure met bijvoorbeeld serial_hw_Write(6) aangeroepen wordt krijgt data waarde 6, en wordt in de regel TXREG=data gebruikt. Zo kunt u dus nieuwe opdrachten maken en die aan JAL toevoegen. Wanneer u bijzondere procedures heeft gemaakt, bijvoorbeeld voor de aansturing van een bepaalde chip of functie, dan kunt u deze ook in een apart bestand zetten. Dit bestand wordt dan een bibliotheek die met de opdracht include gebruikt kan worden. Het voordeel hiervan is dat het programma leesbaarder wordt, maar ook dat u bij een volgend programma dat van dezelfde chip of functie gebruik moet maken alle relevante opdrachten meteen bij de hand heeft.

39

Interrupt Een interrupt routine is een procedure die onder bepaalde voorwaarden wordt aangeroepen, bijvoorbeeld doordat een pin van status verandert of doordat een systeemteller afloopt. Het normale programma wordt onderbroken en in plaats daarvan wordt de interrupt procedure uitgevoerd. Na afloop gaat het gewone programma weer verder waar het gebleven was. procedure demo is pragma interrupt [opdrachten] end procedure De eerste regel van een interrupt routine moet altijd het commando pragma interrupt bevatten. Aangezien bij een interrupt, ongeacht de reden, alle interruptprocedures aangeroepen worden moet u zelf controleren of het wel de interrupt betreft waarin u geïnteresseerd bent. U kunt net zoveel interrupt procedures maken als u maar wilt: de compiler plakt ze voor u achter elkaar. In het algemeen is het echter het best om het gebruik van interrupts te vermijden tenzij het absoluut nodig is. Interrupt routines mogen niet aangeroepen worden vanuit het hoofdprogramma of andere procedures of functies. Functie Een functie is eigenlijk hetzelfde als een procedure, met als verschil dat een functie altijd een antwoord moet geven. Welk antwoord dat is moet in de functie aangegeven worden met de return statement. In het onderstaande voorbeeld wordt variabele a in de functie met 1 vermeerderd: function demo (byte in a) return byte is var byte b b=a+1 return b end function

In de definitie van de functie wordt aangegeven dat een input verwacht wordt (byte in) en dat het antwoord dat de functie gaat geven een byte is. In de procedure zelf wordt met "return b" aangegeven dat dit de waarde is die teruggegeven wordt. De aanroep van deze functie kan als volgt gebeuren: x = demo(4) waarbij x dan de waarde 5 krijgt (immers 4 + 1). Functies worden vooral veel gebruikt om als antwoord geen getal te geven maar een status indicatie true of false, of een getal én een status indicatie. Dit is een mooi praktijk voorbeeld: function serial_hw_read ( byte out data ) return bit is -- kijk of er wat in de buffer zit en zo ja haal het eruit if RCIF then data = RCREG else return false end if return true end function

Deze functie kijkt of RCIF true is, wat wil zeggen: er zijn gegevens in de buffer van de seriële hardware poort. Als dat zo is worden deze gegevens in de variabele data gezet. De functie krijgt als antwoord true. Zijn er geen gegevens dan krijgt de functie als antwoord false. In dat laatste geval weet u dus dat er geen gegevens ontvangen zijn en dat variabele data dus niets nieuws bevat. Wilt u in uw programma wachten totdat er iets ontvangen is dan kan dat zo: while !serial_hw_read(data) loop end loop

Zolang de functie false is (not true) wordt de while-loop herhaald. Pas als de functie true is, en er dus een gegeven ontvangen is, wordt de lus verlaten. In-line assembler In JAL programma's kan ook gebruik gemaakt worden van assembler. Normaal komt dat niet zo vaak voor, maar wellicht bent u een interessant stukje programma op internet tegen gekomen of wilt u een voorbeeld uit de datasheet gebruiken. Individuele assembler opdrachten kunnen gebruikt worden door er asm voor te zetten, zoals hier: 41

asm movlw 0xFF

Betreft het meerdere opdrachten dan is het handiger de assembler statement te gebruiken: assembler movlw 0xFF bsf 5 movwf pr2 bcf 5 end assembler

27

Interessant wellicht is dat de compiler behalve de HEX file die naar de microcontroller gaat ook een assembler file aanmaakt. U kunt deze gebruiken om programma's uit te wisselen met assembler gebruikers, of om de tools van Microchip te gebruiken. Alle assembler opdrachten ("mnemonics") die u in de datasheet vindt zijn bruikbaar. Daarnaast zijn een paar extra opdrachten opgenomen die u in programma's op internet nogal eens als macro tegenkomt (en dus ook gewoon kunt gebruiken), bijvoorbeeld: opdracht

omschrijving

OPTION k

Kopieer literal k naar het OPTION register. 28

TRIS {5,6,7}

Kopieer W naar het TRIS {5,6,7} register.

MOVFW f

Kopieer f naar W (een synoniem voor MOVF f, W).29

SKPC

Een synoniem voor BTFSS _status, _c.

SKPNC

Een synoniem voor BTFSC _status, _c.

SKPZ

Een synoniem voor BTFSS _status, _z.

SKPNZ

Een synoniem voor BTFSC _status, _z. Tabel 9. Voorbeelden van in JAL bruikbare ASM macro's.

27

Een heel gedoe om in assembler de waarde 0xFF aan pr2 toe te kennen omdat het programma in geheugen bank 0 staat, en pr2 in geheugen bank 1. In JAL hoeft u daar geen rekening mee te houden (u hoeft niet eens te weten wat geheugenbanken zijn) en kunt u gewoon pr2 = 0xFF gebruiken. 28 In het Engels wordt het woord move gebruikt, dat 'verplaats' betekent. De originele waarde blijft echter behouden, dus feitelijk is het geen verplaatsen maar kopiëren. 29 W is het werkregister, f het register file adres. MOVFW myvar zet de waarde van myvar in W, MOVLW myvar zet het adres van myvar in w.

Gebruikt u in uw assembler blok variabelen uit het JAL deel van uw programma dan kunt u niet zeker weten waar deze staan, omdat JAL de variabelen in een willekeurige geheugenbank opbergt. Het gevolg daarvan is dat u op het moment dat het JAL programma onderbroken wordt ook niet weet waar de bank pointers op dat moment naar toe wijzen. Omdat u niet weet waar de bank pointers naar wijzen kunt u ook niet zomaar bij registers, ook al weet u wel waar die staan. De oplossing hiervoor is de compiler te vragen de bank verwijzingen in orde te maken. U doet dat door in elke regel waarin u JAL data of registers aanspreekt het keyword bank op te nemen. procedure register_write( byte in Address, byte in data ) is assembler bank movf address,w ; zet address in werk variabele w movwf FSR ; verplaats address naar het file select register bcf irp ; maak irp nul zodat we bank 0 en1 gebruiken ; (indirect register bank selectie), 0 = bank 0/1 bank movf data,w ; verplaats data naar w movwf indf ; verplaats data naar indirect file register zoals ; aangeduidt door fsr end assembler end procedure

In het bovenstaande fragment afkomstig uit de door mij geschreven library regedit ziet u dat het bank keyword gebruikt wordt bij regels waar address en data in voorkomen. 30 Van deze JAL gegevens is immers niet bekend waar ze staan. De regels die naar de registers FSR, IRP en INDF wijzen hebben geen bank keyword omdat deze registers in alle banken staan. Task Hoewel een PIC maar één ding tegelijk kan doen kan er (net als op een PC) aan multitasking gedaan worden. Met de task opdracht kunnen de verschillende taken gedefinieerd worden. Telkens wanneer het programma een suspend opdracht tegenkomt wordt de huidige taak onderbroken en kijkt de scheduler welke taak het langst staat te wachten. Deze "oude" taak krijgt dan de controle. Dit systeem werkt dus alleen als alle taken eerlijk zijn, en met enige regelmaat de suspend opdracht gebruiken.

30

Een library waarmee u in een lopend programma registers kunt uitlezen en aanpassen vanaf uw PC. De nieuwste versie van deze library (die in het downloadpakket dus) is overigens volledig in JAL geschreven, dus daar komt u deze constructie niet meer tegen.

43

Binnen een taak kunnen, net als bij een procedure, parameters gedeclareerd en meegegeven worden. Omdat een taak in feite een soort programma is moet een foreverloop gebruikt worden wanneer het de bedoeling is dat de taak altijd blijft draaien.

task naam1 (parameters) is [ opdrachten ] suspend [ opdrachten ] end task task naam2 (parameters) is [ opdrachten ] suspend [ opdrachten ] end task start naam1(parameterwaarden) start naam2(parameterwaarden) forever loop suspend end loop Voordat een taak daadwerkelijk begint moet hij gestart worden met de opdracht "start [naam]". U kunt dit doen vanuit een andere taak of vanuit het hoofdprogramma. Merk op dat het hoofdprogramma altijd start (net als normaal) maar een taak alleen wanneer u daar expliciet opdracht toe geeft. U kunt een taak permanent stoppen met de opdracht “return” of door het programma de opdracht “end task” tegen te laten komen. U kunt een taak dus alleen stoppen vanuit de taak zelf, niet vanuit een ander taak. Een task die gestopt is wordt niet meer aangeroepen, tenzij u hem expliciet weer start. Let op: Indien een programma met taken gecompileerd wordt moet aan de compiler medegedeeld worden hoeveel taken er zijn. Het hoofdprogramma wordt ook als taak geteld! Het voorgaande programma telt dus 3 taken. U kunt hiervoor de opdracht: Pragma task 3

gebruiken. U plaats deze opdracht aan het begin van het programma net onder de include van de _bert library. In oude JAL versies moet u het aantal taken op de commando regel meegeven, in dat geval dus met -task 3. 31 Vergeet niet binnen elke taak een forever-loop opdracht of iets dergelijks te gebruiken anders wordt uw taak slechts eenmaal uitgevoerd. If then else Deze opdracht wordt gebruikt om een keuze te kunnen maken uit een tweetal situaties. Als (if) de ene situatie zich voordoet dan (then) moet een bepaalde actie uitgevoerd worden, anders (else) moet iets anders gebeuren. In het onderstaande voorbeeld krijgt b als waarde 2 wanneer a gelijk is aan 1, in alle andere gevallen krijgt b waarde 3. if a == 1 then b=2 else b=3 end if Deze opdracht kan genest worden, dat wil zeggen dat er meerdere statements in elkaar grijpen zoals in het onderstaande voorbeeld. if a == 1 then b=2 else if a == 2 then b=3 else b=4 end if end if Merk op dat else if twee woorden zijn. De bovenstaande constructie levert het volgende resultaat op:

31

Maakt u gebruik van JALedit dan kunt u dit bij Compile - Environment Option - Additional Commandline Parameters opgeven.

45

if

then

a=1

b=2

a=2

b=3

a = iets anders

b=4

In plaats van else if kunt u ook de opdracht elsif gebruiken. De syntax ziet er als volgt uit: if a == 1 then b=2 elsif a == 2 then b=3 elsif a == 3 then b=4 else b=5 end if In de praktijk komt u elsif zelden tegen. Case Geneste if-then else opdrachten komen de leesbaarheid van een programma niet ten goede. In zulke gevallen is het beter de CASE opdracht te gebruiken. Het onderstaande voorbeeld wordt afhankelijk van de waarde van a een waarde aan b gegeven. Heeft a waarde 3 dan wordt b 4. Heeft a waarde 4 of 5 dan wordt b 59. Staat de waarde van a niet aangegeven dan (otherwise) wordt b 6. case a of 1: b = 20 2: b = 13 3: b = 4 4,5: b = 59 otherwise b = 6 end case In tegenstelling tot if-then else mag hier slechts één opdracht per keuze gegeven worden. Wilt u indien a de waarde 1 heeft b een waarde geven maar bijvoorbeeld ook c dan gaat dat niet. U zult in dat geval een procedure moeten gebruiken, of de block opdracht.

Block Met de block opdracht kan een aantal opdrachten gegroepeerd worden. Variabelen die binnen een blok gedeclareerd zijn kunnen alleen binnen dat blok gebruikt worden. Een blok staat gewoon in het programma en kan niet "aangeroepen" worden zoals een procedure. block [ opdrachten ] end block Dit is vooral handig in combinatie met de case opdracht of wanneer u variabelen heel lokaal in maar een klein stuk van uw programma wilt houden. Dat kan voorkomen wanneer u delen van verschillende programma's wilt gebruiken, die echter wel dezelfde variabelen bezitten. case a of 1: b = 20 2: block b = 13 c = 188 end block 3: b = 4 4: b = 59 otherwise b = 6 end case Array Normaal heeft een variabele maar één waarde. Met een array kan aan een variabele een hele rij waarden worden gegeven. In het onderstaande voorbeeld wordt aan de array "demo" een rij van vijf waarden toegekend. var byte demo[5] = {11,12,13,14,15} Om een van de waarden in deze array te lezen moet tussen vierkante haakjes de positie van dat getal in de reeks aangegeven worden. Let op: zoals voor computers gebruikelijk begint de telling bij 0. Het eerste getal uit deze reeks heeft dus als nummer 0 !! Dus demo[0] heeft als waarde 11 en demo[4] heeft als waarde 15. Demo[5] bestaat niet. De onderstaande opdracht geeft aan a de waarde van het vierde getal uit de array, dus 14.

47

a = demo[3] Een andere waarde in de array stoppen gaat op soortgelijke wijze. In het voorbeeld krijgt het vierde getal uit de array waarde a. demo[3]= a Overigens kan het programma middels de opdracht count nagaan hoe lang een array is. Bijvoorbeeld: a = count(demo) Dus count is een "reserved" woord (kan niet als variabele gedeclareerd worden). Een array moet binnen een RAM geheugenbank passen. Een bit array is niet mogelijk. Long table (ook wel: Lookup table of LUT) Heeft u meer ruimte nodig dan in een array past dan kan vanaf JAL versie 2.0.5 een long table gebruikt worden. Deze array mag alleen constante waarden bevatten. U kunt hem dus eenmalig definiëren en mag er daarna niets meer in wijzigen. Dat komt omdat dit weliswaar ook een soort array is, maar in plaats van in het RAM geheugen zit deze array in het programma (flash) geheugen. De long table kan dus zeer lang zijn (in de 18f4455 maximaal zo'n 10000 bytes!), maar de totale lengte kan niet meer zijn dan er aan vrij programmageheugen beschikbaar is. U kunt hier zelf op letten bij het gebruik, door eerst het programma met een long table van bijvoorbeeld 1 te compileren. Aan de hand van de resulterende programmalengte kan de maximale lengte van de long table bepaald worden. Wanneer de long table niet in het geheugen past kan het programma niet in de microcontroller gezet worden, u krijgt hier vanzelf een foutmelding van. De syntax van de long table is: const byte long_table[2049] = { 1, 2, 3, 4, 5, ...} var word x var byte y y = long_table[x] waarbij de lengte 2049 en de inhoud 1,2,3 uiteraard als voorbeeld gelden.

Operators JAL kent een grote hoeveelheid operators. De onderstaande tabel geeft de belangrijkste met uitleg en waar nodig een eenvoudig voorbeeld. Operator !!

Uitleg Logische operator, geeft aan of een variabele 0 is of niet. Bijvoorbeeld !!5 = 1, en !!0 = 0

!

Not, maakt op bit niveau van elke 0 een 1 en omgekeerd. Dus !5 = 250 want !0b_0000_0101 = 0b_1111_1010

*

Vermenigvuldiging

/

Deling zonder rest. Dus 9/2 = 4

%

Restdeling (ook wel MOD of modulo genoemd) Dus 9%2 = 1

+

Optellen.

-

Aftrekken.

<

Left shift, schuift alle bits 1 naar links op. Let op: het extra plekje is niet altijd een 0. Wanneer het een variabele is met een teken wordt dit teken bewaard en niet mee geschoven.

>> <

Right shift, idem maar dan de andere kant op. Minder dan.

<=

Minder dan of gelijk aan.

==

Gelijk aan, merk op dat dit twee is-gelijk tekens achter elkaar zijn. Maar één is-gelijk teken gebruiken is een vaak voorkomende fout (dit mag u rustig als understatement lezen!).

!=

Ongelijk aan (of anders gezegd: niet gelijk aan).

>=

Groter dan of gelijk aan.

>

Groter dan.

49

AND op bitniveau, waarbij per bit geldt: 1&1=1 1&0=0 0&1=0 0&0=0

&

OR op bitniveau, waarbij per bit geldt: 1|1=1 1|0=1 0|1=1 0|0=0

|

XOR (eXclusive OR) op bitniveau, waarbij per bit geldt: ^

1^1=0 1^0=1 0^1=1 0^0=0 Tabel 10. Operatoren.

Pragma Pragma is een opdracht voor de compiler. Het is een krachtige maar helaas daardoor ook complexe opdracht. Een detail uitleg voert een beetje te ver voor dit boek, bovendien zult u de meeste pragma's in de praktijk zelden of nooit nodig hebben. De onderstaande tabel geeft de belangrijkste pragma's met uitleg:

opdracht

omschrijving

pragma eedata

Met deze opdracht worden gegevens opgeslagen in het eeprom geheugen van de PIC. Bijvoorbeeld pragma eedata "O","K" slaat de letters O en K op.

pragma interrupt

Deze opdracht mag alleen in procedures gebruikt worden. Het resultaat is dat deze procedure aan de interrupt keten wordt toegevoegd. Er is geen grens aan het aantal procedures in een interrupt keten, echter de volgorde waarin ze afgehandeld worden is niet gedefinieerd. Interrupt procedures mogen niet door het programma aangeroepen worden, of door andere procedures of functies.

pragma clear yes

Maak alle variabelen 0 aan het begin van het programma. Dit geldt niet voor volatile variabelen, en variabelen die de gebruiker expliciet een waarde heeft gegeven.

Pragma task

Geeft aan hoeveel taken er tegelijk moeten draaien. Gebruikt u taken dan telt het hoofdprogramma ook voor een taak! Het is handiger deze pragma te gebruiken dan het aantal taken op de commandoregel in te vullen (want daar vergeet u het gegarandeerd). Het kan echter wel, omdat oudere JAL versies deze pragma opdracht niet kennen. Tabel 11. Meest relevante pragma's.

Commentaar Een commentaar regel wordt vooraf gegaan door twee liggende streepjes of een puntkomma. U moet dat per regel doen. ; dit is een commentaar regel -- en dit ook Commentaar regels worden gebruikt om opmerkingen in het programma te plaatsen. Voor uzelf, zodat u later nog weet wat ook al weer de bedoeling was, of voor anderen wanneer u uw programma's via internet met anderen deelt. Het is een goed gebruik om op de eerste regel aan te geven voor welke JAL versie uw programma geschreven is. Dat voorkomt een hoop vragen! Goed commentaar gaat niet over wat een opdracht doet want dat weet de lezer al, maar vooral over waarom u die opdracht gebruikt. Maakt u zelf bibliotheken dan is het gebruikelijk daarin uitgebreid uit te leggen hoe de library gebruikt wordt, en waarvoor. Een library zonder deze informatie is voor anderen compleet waardeloos.

51

De _bert_piccolino bibliotheek Bibliotheken (libraries) worden gebruikt om gegevens die bij een microcontroller horen gemakkelijk toegankelijk te houden, en vooral om extra opdrachten te kunnen definiëren. Omdat iedereen naar eigen goeddunken bibliotheken kan schrijven en publiceren werken niet alle bibliotheken goed samen. Bij dit boek hoort een pakket bibliotheken die samengevoegd zijn tot één grote bibliotheek: 18f4455_bert_piccolino.32 Hiermee wordt een fikse hoeveelheid extra opdrachten aan JAL toegevoegd. Bovendien zijn alle eventuele compatibiliteitsproblemen opgelost. De eer voor de inhoud van deze bibliotheken gaat naar de schrijvers. Deze combinatie library voegt een hele reeks opdrachten toe aan JAL die u in de JAL boeken zult tegenkomen, voor bijvoorbeeld analoge conversie, seriële communicatie, lezen en schrijven naar het geheugen en nog veel meer. De belangrijkste komen in deze paragraaf aan de orde. Uiteraard zijn ze alleen van toepassing wanneer de betreffende microcontroller deze functionaliteit bezit. Deze bibliotheek wordt hier niet besproken maar komt aan de orde in mijn JAL projecten boeken. Zie sectie 5, "Klaar, en wat nu", voor meer informatie over deze boeken. Overige bibliotheken In de download bevinden zich nog veel meer bibliotheken, voor bijvoorbeeld USB, gebruik van een camera etc. Deze bibliotheken worden hier niet besproken, zij komen aan de orde in mijn JAL projecten boeken. Zie sectie 5, "Klaar, en wat nu", voor meer informatie over deze boeken.

32

De _bert_piccolino bibliotheek is speciaal voorde Piccolino gemaakt. Er zijn ook samengestelde bibliotheken voor "losse" microcontrollers die met een aparte programmer geprogrammeerd moeten worden. Deze bibliotheken hebben als achtervoegsel _bert. Deze bibliotheken zijn maar voor een beperkte groep microcontrollers beschikbaar. Wilt u een microcontroller kopen controleer dan eerst of er een _bert bibliotheek van is. U vindt een lijst met ondersteunde microcontrollers op www.vandam.tk, volg de links naar de Starterpack.

Index ! ........................................................ 49 !! ........................................................ 49 % ........................................................ 49 & ........................................................ 50 ^ ........................................................ 50 _bert bibliotheek ................................. 52 | ........................................................ 50 <<........................................................ 49 16f877A .............................................. 27 16f887 ................................................... 3 16f887_bert_piccolino ........................ 16 18f4455 ............................................... 27 ANx ...................................................... 4 array .................................................... 47 asm ...................................................... 41 assembler ............................................ 42 auto-reset jumper ................................ 21 Baud rate ............................................. 14 binair ................................................... 35 bit ........................................................ 34 bit at .................................................... 35 bit is .................................................... 36 blauw tabje.......................................... 12 block ................................................... 47 byte ..................................................... 34 byte in ................................................. 39 byte is.................................................. 35 byte out ............................................... 39 case ..................................................... 46 CCP1..................................................... 5 CCp2 ..................................................... 5 Code Explorer ..................................... 13 COM poort instellingen ...................... 14 commentaar ........................................ 51 compile ............................................... 18 compile results .................................... 13 compileren .......................................... 14 const .................................................... 36

Constante .............................................36 Data bits...............................................14 delay_100ms..........................................8 delay_1s(1) ..........................................17 dword...................................................34 else.......................................................45 elsif ......................................................46 end loop .................................................8 end task................................................44 Errors. JALedit ....................................19 Establishing contact.............................23 Establishing contact.............................23 exit loop ...............................................36 Flowcontrol .........................................14 for loop ................................................37 forever loop .....................................8, 36 functie ..................................................40 GND ......................................................5 headers...................................................4 iclude ...................................................16 if then...................................................45 include ...................................................8 in-line assembler .................................41 interrupt ...............................................40 JAL ........................................................8 JALedit ..................................................8 JALEdit ...............................................12 jumper, Piccolino ................................21 Left shift ..............................................49 long table .............................................48 lookup table .........................................48 LUT .....................................................48 NC .........................................................5 Nieuw ..................................................13 Openen ................................................13 operator................................................49 Opslaan ................................................13 otherwise .............................................46 53

pAN .............................................. 17, 26 Parity................................................... 14 pButton ......................................... 17, 26 Piccolino ............................................... 1 Piccolino Sidekick ................................ 6 Piccolino, kan niet programmeren ...... 24 pLED ............................................ 17, 26 pPot ............................................... 17, 26 pragma ................................................ 50 pragma clear ....................................... 51 pragma eedata ..................................... 50 pragma interrupt ........................... 40, 51 pragma task ................................... 44, 51 procedure ............................................ 38 programmeren, leren........................... 29 projecten ................................. 30, 31, 32 repeat until .......................................... 37 return............................................. 40, 44

Right shift ............................................49 sbyte ....................................................34 SCL .......................................................5 SDA .......................................................5 SDO .......................................................5 sdword .................................................34 start ......................................................44 stop bits ...............................................14 suspend ................................................44 sword ...................................................34 task ......................................................43 variabele op maat ................................34 Vin .........................................................5 virtuele seriële poort ............................11 volatile .................................................35 werkblad ..............................................12 while loop ............................................37 word.....................................................34

55