Wat zou een apparaat zijn zonder knipperende lampjes ?
De knipperende lampjes worden verzorgd door een microcontroller.
Veel mensen zouden hiervoor een Raspberry of een Arduino board gebruiken, maar ik ben dat stadium voorbij, dus ik prak een programma in een microcontroller. Een PIC, om precies te zijn. Microcontrollers zijn complete computers in één chip. Alles zit er in : CPU, ROM, RAM, IO. Eigenlijk een complete Apple II in een chip. In die orde van grootte ligt de snelheid ook, hoewel er supersnelle digitale signaalverwerkers bij zijn.
Ze kosten een paar euro per stuk, afhankelijk van het aantal aansluitingen/mogelijkheden, de hoeveelheid geheugen en de snelheid.
Ik had geen zin om heen en weer te schakelen tussen Linux en Windows, dus alle tools werken onder Linux. ( de tools van de fabrikant van de chips kunnen alleen overweg met Windows )
Programma’s schrijven voor microcontrollers voegt een dimensie toe aan het debuggen. Want de bug hoeft niet in de software te zitten. Het kan ook gewoon een losse draad zijn. ( Of een display dat het niet doet ). De fabrikant van de Microchip controllers heeft een apparaatje waarmee je je chip kan debuggen terwijl hij nog in de schakeling zit. Dat is helemaal handig. Het kost alleen nogal wat moeite om het ding zelf werkend te krijgen.
Een microcontroller wil geprogrammeerd worden in assembler, en hoewel een PIC een simpele (RISC) instructieset heeft, gaat het erg veel tijd kosten om daar in thuis te raken. Wil je programmeren in een hogere programmeertaal, dan moet je een geschikte compiler hebben. Die is duur. Maar er is gelukkig wel een open-source compiler. Alleen niet voor C. De small-C compiler voor PIC’s is kennelijk een dood project. JAL ( just another language ) lijkt een beetje op Pascal, en is door iemand speciaal voor dit soort controllers ontworpen en later voorzien van een open-source licentie.
Anderen hebben daarna de compiler verbeterd en een library met allerhande routines gemaakt.
Je vindt op internet prachtige programma’s voor microcontrollers. Helaas zijn de meesten geschreven door Indiërs of Amerikanen, en die schrijven alles in C. Of ze ook betaald hebben voor die mooie ontwikkelsoftware betwijfel ik. ( prijzen tussen 200 en 1100 dollar )
Er is onder Linux een open-source simulator voor PIC controllers beschikbaar. Dan kun je op je PC de fouten uit het controller-programma halen.
Er zit een bibliotheek bij met virtuele componenten, zoals schakelaars. Heel luxe, maar een beetje lastig in het gebruik.
Na wat prutsen werkt de hele toolchain. Ik kan dus een programma schrijven, compileren en daarna in de chip laden, via de prototype-programmer.
Die programmer is aangesloten op de seriële poort van mijn PC. Een beetje ouderwets, maar het ding lag ook al een aantal jaren in de kast.
Het is een in-circuit programmer.
Je hoeft de controller dus niet uit de schakeling te halen en in de programmer te steken, hij kan gewoon blijven zitten en je kan direct het resultaat zien.
Via de programmer kan het programma in de microcontroller ook informatie terugsturen naar de PC.
Het enige nadeel is, dat als die schakeling iets stoms doet, je via de seriële poort ook je PC kan opblazen.
Na het obligate “blink-a-led” programma, kwam stap 2 : een digitale thermometer.
Display heb ik inderdaad uit een oude wekkerradio geript.(*)
Op de foto zie je dat het water in het glas ongeveer 40 graden is. De temperatuursensor is het glimmende ding in het glas. De controller heeft een 10 bit ADC, ofwel hij kan onderscheid maken tussen 1024 meetwaarden. Natuurlijk moeten de overige onderdelen dan wel zo nauwkeurig zijn, anders meet je heel precies onzin. Het bosje draden dat rechts uit beeld verdwijnt gaat naar de programmer die verbonden is met de PC.
Je ziet hoe weinig onderdelen er nodig zijn om een complete computer te maken. Eigenlijk alleen een 5 Volt voeding, een kwartskristal, en een paar onderdeeltjes om het wekkerradio-display te multiplexen.
(*) voor anderen die dat ook willen proberen : niet wanhopen als het F-segment van het eerste cijfer het niet doet. Dat is Chinese zuinigheid. Voor de getallen 1 en 2 heb je maar 6 van de 7 segmenten nodig.
En ja, je moet zelf uitzoeken welk draadje waarvoor dient en een tabel maken waar in staat dat een 0 bestaat uit 6 streepjes.
Het lijkt heel simpel, maar het kan op 3.000 manieren fout.
(**)
Knutselsmurf aanvaardt geen aansprakelijkheid voor kapotte apparaten, maar wil wel waarschuwen dat het niet verstandig is de temperatuursensor in een daarvoor vaak gebruikte lichaamsopening te steken.
Er is namelijk een kleine kans dat je via de netvoeding wordt ge-elektrocuteerd.
update 30-11-2013
Ik heb er nog wat onderdelen bij geprikt, en nu kan ik ook luchtvochtigheid meten met een GY-HR002 sensor. Dat is minder simpel dan temperatuur meten met een NTC, want een luchtvochtigheidssensor wil alleen wisselspanning op zijn pootjes en hij is verre van lineair, zoals je ziet aan de logarithmische schaal in de documentatie. En hij is ook nog eens zwaar temperatuurafhankelijk.
Ik vond een voorbeeld van een schakeling bij prosje.be
Hij gebruikt een ander merk processor dan ik, maar wat die doet, kan een PIC ook. Alleen zijn alle constanten anders.
Ik heb de PWM module van de PIC gebruikt om een blokgolf op te wekken. Ik gebruik een extra condensatortje parallel aan R5 om de golfvorm een beetje af te ronden, want de sensor verwacht een min of meer sinusvormige spanning.
Ik gebruik een extra analoge ingang verbonden met het knooppunt van R2 en R3 om te bepalen waar het nulpunt van de wisselspanning zit. Prosje gebruikt een C-compiler. Die heb ik ook niet, maar ik denk dat ik de code wel ongeveer snap.
Hij gebruikt om een of andere reden 2 gekoppelde processoren ( misschien om op afstand de luchtvochtigheid te meten ). Ik heb alles in één processor gestopt. Ik heb het programma iets verfijnd : Er wordt gebruik gemaakt van interpoleren om de RV in stappen van 1% te bepalen. De waarde is echter ook afhankelijk van de temperatuur van de sensor, dus ik interpoleer zowel horizontaal als vertikaal. Want 4 graden temperatuurverschil levert zomaar een verschil van 5% RV.
In principe zou dit nauwkeuriger moeten zijn, maar de stoorsignalen die de lange draden op het testbordje oppikken, verpesten de meting. Het is gortdroog in huis, door de verwarming. Juist een lage RV is heel moeilijk te meten. De analoge ingangen van de processor willen graag aangestuurd worden door een lage impedantie, en dat is de sensor niet. Als je het echt mooi wil doen, moet er een ( omgekeerd logarithmische ) signaalversterker voor.
De sensor gaat trouwens niet lager dan 20% RV.
Het “Hama” weerstation op de boekenplank beweert dat de RV ll% is. Dat is zijn manier om te zeggen dat het te laag is om te meten.
Even blazen tegen de sensor geeft een spectaculaire stijging van de waarde. Dat bewijst
a dat ik nog leef
b dat de sensor het doet.
Opwarmen van de temperatuursensor laat zien dat de RV-waarde verschuift naar een lagere waarde.
Leave a Reply