16/9/2024

Raspberry Pi achtergrond

Filed under: — cybrarian @ 2:40 pm

De achtergronden van de Raspberry Pi zijn landschappen, steden, enz.
Er is maar één meer abstracte achtergrond, dat is PiSystem.png; een witte achtergrond met zacht grijs getekende onderdelen die met pi/pi400 te maken hebben.

Rechtsklik, Burobladvoorkeuren, tab Desktop: Picture (toont de beelden uit /usr/share/rpd-wallpaper/

Je kan ook gewoon een achtergrondkleur instellen. Trouwens als je een tweede scherm aansluit, heeft dat enkel een achtergrondkleur.

Raspberry Pi opstarten met programma op desktop

Filed under: — cybrarian @ 2:25 pm

De Rapsberry Pi laten opstarten in een bepaalde toepassing

Er is een map waar bij het opstarten gekeken wordt welke programma’s te starten:/home/pi/.config/autostart

ps: In documentatie vind ik ook nog andere gelijkaardige mappen: /home/pi/.config/lxsession/LXDE-pi/autostart

Het kan dat de map ~/.config/autostart nog niet bestaat;

  • op één pi bestond die niet en heb ik die gemaakt
  • op de andere bestond die wel en bevatte die een bestand LXinput-setup.desktop, met toetsenbord/muisinstellingen

Een programma dat je in deze map zet wordt automatisch uitgevoerd.

Opstarten met een zelfgeschreven applicatie in gambas3
– Vanuit de gambas programmeeromgeving (Gambas3-IDE) kan je een programma compileren tot uitvoerbaar, met de optie om een link op de desktop te maken; doe dat.
– de link kan je dan naar de autostart map verplaatsen (of kopieren).

3/7/2024

Raspberry Pi OS

Filed under: — cybrarian @ 9:09 am

Raspberry Pi OS

Raspberry Pi OS is sterk verwant aan Debian, maar is niet hetzelfde. Debian werkt met versies, en Raspberry Pi OS volgt die in grote lijn maar is tussendoor in “continual development” een beetje als een “rolling release” (vgl bv tumbleweed). Dat heeft zijn voordelen (altijd doorlopende ontwikkeling en verbeteringen zonder te moeten wachten op een nieuwe grote versie), maar ook nadelen; er zal in de loop der tijd gemakkelijker iets “breken”, terwijl je dat bij afgelijnde versies eerder zal hebben bij overgang naar de nieuwe grote “versie”.

Onderhoud
Apt-get is stilaan vervangen door apt.
Verder is het gebruik gelijkaardig als vroeger, behalve (vanwege de rolling release) voor de “upgrade”!

Zoeken

apt-cache search gambas3

Toon meer info:
apt-cache show gambas

Installeren van software
Eerst:
sudo apt update

+ installeren:
sudo apt install gamba3-ide

De-installeren:
sudo apt remove gambas3

Werkelijk ook alles wissen:
sudo apt purge gambas3

Upgrade
Dit is anders dan de bekende apt-get upgrade:

sudo apt full-upgrade

Check eerst eventueel de vrije schijfruimte:
df -h

Ruimte vrij maken (overgebleven bestanden van installatie/updates)
sudo apt clean

https://www.raspberrypi.com/documentation/computers/os.html#update-software

GPIO

https://www.raspberrypi.com/documentation/computers/os.html#gpio-and-the-40-pin-header

Firmware
Wees voorzichtig, maak een backup!

sudo rpi-update
...
sudo reboot

Vorige firmware versie:

sudo apt-get update

sudo apt install --reinstall raspi-firmware

1/7/2024

De Raspberry Pi 400 in 2024

Filed under: — cybrarian @ 1:43 pm

Raspberry Pi 400 FR Kit

Deze kit bevat de embedded-toetsenbord-Raspberry Pi 400 met systeem op een 16 G grote SD-kaart er reeds in, een SD-card adapter, een voedingsadapter, en een bijpassende muis. In de doos ook een mini-hdmi naar hdmi kabel (de aanlsuiting is idd mini), en een -natuurlijk- Franstalig boekje: “Le Guide Officiel du débutant .. comment utiliser votre nouvel ordinateur”; inleiding in Raspberry Pi (een algemeen boek, niet alleen over de 400).

Het opstartscherm toont een eventueel toegewezen ip adres. De opstartprocedure leidt je snel door een paar keuzes; gebruiker en wachtwoord, land, taal, wifi of ethernet, en dan wordt de software gecheckt (updates worden afgehaald).
ps: Als je hier voor Belgie als land kiest, wordt de toetsenbordinstelling op Belgisch gezet, en staan een paar tekens niet meer juist (verschil Azerty BE en Azerty FR).
Er is geen root account wachtwoord gevraagd geweest.

Installatie eindigt met :

System is up to date

Daarna wordt aangeboden om te herstarten.

De commandolijn/terminal vermeldt Raspbian GNU/Linux 11 met kernel 6.1 aarch64 (geen Raspberry Pi OS).

Dan kan je verder software installeren: menu Voorkeuren, Add/Remove software .. bv “Ontwikkeling” (“Development”: Programmeren enz): het duurt even eer de lijst getoond wordt, dus waarschijnlijk wordt online gecheckt wat beschikbaar is …
Je krijgt een zeer lange alfabetische lijst, gelukkig is er links boven een “zoek” veld: “gambas..”; beschikbare versie is 3.15 (“Complete visual development environment”). Om verder te gaan moet het wachtwoord ingegeven worden.

Na installatie vind je het programma terug in het menu: Gambas 3.15.2.

Rechtstreeks starten
De Raspberry Pi bordjes hebben geen aan/uit schakelaar, (je moet de voeding onderbreken om ze te starten), maar deze Pi 400 heeft een toets op het toetsenbord waar een rood aan/uit icoon bij de F10 toets staat. Het leek een optie-combinatie te zijn; ook de optie-toets betekenis wordt in rode symbolen aangegeven, zoals F11 en F12 die onder F1 en F2 staan, PgUp en PgDown die bij de pijltjes staan, en die met de framboos-toets omgeschakeld worden. Maar als de Pi 400 uitstaat, kan je rechtstreeks op de F10 toets duwen om hem aan te zetten, de optie is niet nodig.

Updates
Rechtsboven komt een “update” symbool te staan, waaronder je 2 keuzes krijgt: bekijk updates, haal updates af. Als de updates zijn uitgevoerd, verdwijnt het icoon.

13/6/2023

SD-card eigenschappen voor Raspberry Pi

Filed under: — cybrarian @ 9:07 am

SD voor Raspberry Pi
Voor een Raspberry Pi moet je al eens een nieuwe SD kaart kopen, want dat is het onderdeel dat na een paar jaar al eens faalt. Vroeger volstond een 4 tot 8 GB kaart (grootte van de ISO) voor het systeem van een Raspberry Pi, en als je een grotere kaart gebruikte, moest je speciale technieken aanwenden om de rest van de kaart-capaciteit te kunnen gebruiken. Maar de huidige versies van Raspberry Pi OS zorgen daar ondertussen automatisch voor. Resten nog de andere eigenschappen als snelheid.
Ik merk dat er nogal wat verschillende manieren zijn om de eigenschappen van de kaart aan te duiden; CLass 10 , UHS-I Class I Premium, .. ; wat is marketing en wat heeft betekenis?
Wat is relevant voor de Raspberry Pi?

De meeste kaartjes worden gepromoot voor gebruik in cameara’s, vandaar de nadruk op het snel kunnen schrijven van data, achtereenvolgens.
Maar bij een Raspberry Pi is het gebruik anders:
– het doorlopend schrijven op het kaartje gebeurt bij het schrijven van de ISO, installatie van het systeem op de kaart, één keer dus maar.
– daarna is het een wisselend lezen en schrijven dat de dienst uit maakt.
– de kaartlezer van de Raspberry Pi heeft ook zijn SDIO beperkingen: “De gemiddelde ‘bus’ snelheid van de SD kaartlezer is ong. 23MB/s lees of schrijfsnelheid” (jdb
Raspberry Pi Engineer & Forum Moderator)

Volgens https://forums.raspberrypi.com/viewtopic.php?t=232148
“De SD kaartjes die wij leveren voorgeformatteerd met het NOOBS besturingssysteem zijn optimaal voor lees/schrijf snelheid, typisch 1,5 MB/s willekeurig schrijven, 6 MB/s willekeurig lezen..”
Je moet dus al toegewijd gaan testen en meten om daar iets over te kunnen zeggen: “random 4k read/write performance”.

Een Pi 3B+ gebruiker bootte van een exnterne usb-stick, waardoor zijn kaartlezer vrij was om een testprogramma te draaien op lees/schrijf snelheid. Hij kwam uit rond 23 MB/s voor een paar verschillende kaartjes, wat klopt met bovenvermelde waarde.

Verder blijft de mogelijkheid met een extra SSD drive te werken, die door de aansluiting via de USB-poort (gedeelde USB controller voor de Pi poorten/netwerk) ook niet optimaal presteert, en misschien trager opstart, maar wel sneller werkt daarna. De Raspberry Pi 4 heeft (gigabit ethernet en) USB3, die is wat sneller (“tot 10 x sneller zegt de produkt aankondiging”).

SD card Eigenschappen

* Snelheid

U1 : minder snel dan U3.
U3: hogere snelheid, bv opnemen 4K-Ultra-HD video.

* Capaciteit:

U1: beperkte capaciteit
U3: gaat tot hogere capaciteit: 32 GB- 1 TB

* UHS bus-snelheid: Romeinse cijfers I, II en III

* UHS speed klasse Romeins cijfer of hoofdletter “V” (voor video?)

* Prijs
(06/2023)
Een merk-kaartje van 1TB kost meer dan honderd euro, bv 154 €.
Een merk-kaartje van 32 GB (class 10/UHS-I-120MB/s) SDHC kaart kost minder dan 10 euro; bv 8,5 €.

5/6/2023

Raspberry Pi OS

Filed under: — cybrarian @ 11:22 pm

Het is even geleden dat ik een Raspberry Pi geïnstalleerd heb (ze zijn nog altijd niet te krijgen, dus dat gebeurt enkel als ik er eens kan hergebruiken omdat het originele project niet meer loopt). Even snel in het klad mijn log:

Download
Raspberry Pi image (systeem) downloaden van https://www.raspberrypi.com/software/operating-systems/

keuze tussen bv 32 bit en 64 bit versies; bv 64 bit:

2023-05-03-raspios-bullseye-arm64.img

Als het afgehaalde bestand “gecomprimeerd” is moet je het “uitpakken” eventueel met een tool als Ark.

2023-05-03-raspios-bullseye-arm64.img.xz

Imager voor Raspberry Pi
De volgende stap is het overbrengen van
Er wordt aangeraden de imager te gebruiken, ik vind geen uitleg om gewoon de commandolijn te gebruiken met bv dd, zoals ik voor andere ISO’s doe. Maar goed, als iemand de moeite heeft gedaan er software voor Linux voor te schrijven, proberen we die. Ik zoek bij (opensuse) software en vind:

rpi-imager - Raspberry Pi Imaging Utility

Raspberry Pi Imager is the quick and easy way to install Raspberry Pi OS and other operating systems to a microSD card, ready to use with your Raspberry Pi. Watch our 45-second video to learn how to install an operating system using Raspberry Pi Imager.
Download and install Raspberry Pi Imager to a computer with an SD card reader. Put the SD card you’ll use with your Raspberry Pi into the reader and run Raspberry Pi Imager.

Na installatie te vinden in het menu onder “hulpmiddelen” als Imager (met een framboos icoon).

Indrukwekkend genoeg start die in het Nederlands (het was me niet onmiddellijk duidelijk of dat als root moest..)

* Kies besturingssysteem
Je kan een besturingssysteem kiezen uit een hele lijst van beschibkare systemen, er staat bij hoe groot de download is. Maar je kan ook een reeds gedownload bestand selecteren.

* Kies opslagapparaat
Interne SD kaartlezer..”Voorbereiden …” ..
“Schrijven …” ..
“Verifieren … ” ..

* Schrijf
Vraagt root wachtwoord.. (daarmee is die vraag beantwoord).

“Voorbereiden …” ..
“Schrijven …” ..
“Verifieren … ” ..

Ps: Er is ook een Annuleer knop voorzien.

Gemist
Pas als hij helemaal klaar is en vraagt de SD te verwijderen, zie ik de knop met het tandwieltje.
Die geeft een scherm met “geavanceerde instellingen”, die ubuntu-achtig verstopt waren dus.
Conclusie: Ik mistte de kans om de hostnaam in te stellen, de SSH te laten inschakelen, de gebruikersnaam/wachtwoorden in te stellen, de wifi te aktiveren en in te stellen, de regio-instelling te doen…

Met de optie “alleen voor deze sessie” of “altijd toepassen”.

Ok?
In ieder geval, nu zou je SD kaart klaar moeten zijn voor gebruik.

Eerste start

Bij het starten zie ik meldingen voorbijrollen als:

Resizing root filesystem (het zou fantastisch zijn als hij automatisch de rest van de kaartruimte bruikbaar maakt ..)
generating ssh keys
rebooting

Er start een Instellingen programma: een scherm dat doet denken aan de Raspberry Pi 400, met tekeningetjes van allerlei componenten op de witte achtergrond.

Country (kiezen uit een ellendige lijst en het toetsenbord werkt niet; scrollen dus … )
Belgium / Flemish / timezone Brussels (setting location..)

Create user, password: nu moet je zelf een gebruikersnaam kiezen, en een wachtwoord opgeven (vroeger was de standaard gebruiker “pi”, maar dat maakt het ook makkelijker voor aanvallers…).

Ik sla de wifi over.

Dan wordt gevraagd om te checken of er updates zijn, dus ik sluit de kabel aan.

Getting updates .. Downloading updates ..
Installing …
Setup Complete. System is up to date. Ok.
Restart to let the settings take effect.

Een vurige lucht vult het scherm, ik start de bestandenbeheerder, vrije ruimte: 24 G (dat is goed, de sd kaart is 32 Gig, dus het beschikbaar maken van de extra ruimte op de kaart gebeurt automatisch nu).

Installeren software
* Gambas
sudo apt install gambas3-ide (bevestigen)
Ok, menu programmeren, Gambas3, De Gambas IDE start als versie 3.15.2

Maar dan zijn er veel onderdelen niet mee geïnstalleerd, dus ik probeer nog
sudo apt install gambas3. Dat haalt nog een groot aantal onderdelen af.

Daarna: free: 23.4G

* MariaDb

3/1/2023

Arduino (Uno) pinnen, interrupts, enz

Filed under: — cybrarian @ 11:32 am

Uit de Robotics backend:

  • Pinnen, met Seriële communicatie (Power, digital, PWM, analogue, interrupt, communication: UART/GPIO Rx/Tx, I2C, SPI,..)
  • PinMode (pull up/down)
  • Led en button: of apart LED en drukknop
  • Interrupts: vermijdt Serial Library binnen interrupt
  • Multitasking, maar geen parrallel programming of multithreading
  • Delay(): of non-blocking delay?

16/12/2022

Arduino neopixel LEDs

Filed under: — cybrarian @ 2:54 pm

De pixels kunnen gestuurd worden met waarden van 0-255 per RGB kleur.

Met als extreme waarden voor Rood, Groen, Blauw:

Rood is (255,0,0)
Groen is (0,255,0)
Blauw is (0,0,255)
Geel is (255,255,0)
Oranje is (255,165,0)

Maar ook tussenwaarden geven mooie resultaten..

Zacht geel (60,40,0), minder fel
Flauw blauw ( 0,50,0), geschikt om te laten zien dat er stroom is maar zonder veel licht te geven.
Fuchsia (150,20,20)

enz..

12/12/2022

Serieel communiceren met Arduino

Filed under: — cybrarian @ 1:40 pm

Arduino naar Raspberry Pi/pc

Seriele communicatie uit de Arduino sturen was al duidelijk (Arduino seriele print uitlezen).

Arduino stuurt een stukje tekst over de serieële poort:

Serial.print("ERRROR: value ");
Serial.print(iValue);
Serial.print(" exceeds maxvalue ");
Serial.println(LEDCOUNT*3);

Pc/Raspberry Pi via USB van/naar Arduino

Nu moeten we nog via de seriele poort opdrachten of data naar de arduino kunnen sturen, vanuit een Linux pc/Rasberry Pi, via de usb kabel (gemakkelijkste manier).

Het programma op de Arduino moet daarvoor op bepaalde momenten “luisteren” naar de seriele poort.

// Serial data in from usb port
void setup() {
// run once:
Serial.begin(9600);
}
void loop() {
  if (Serial.available() > 0) {
    String sData = Serial.readStringUntil('\n');
    Serial.println("Hello from Arduino.. you sent me: ");
    Serial.println(sData);
  }
}

Of met een tellertje:

// Serial data in from usb port
long lCounter = 0;
int iLoop = 0;
void setup() {
// run once:
Serial.begin(9600);
Serial.println("Hello from Arduino...waiting for your signal");
}
void loop() {
  if (Serial.available() > 0) {
    String sData = Serial.readStringUntil('\n');
    Serial.println("Hello from Arduino.. you sent me: ");
    Serial.println(sData);
  }
  //delay(100);
  lCounter++;
  if (lCounter > 128000) {
    Serial.println("Silence? .. ");
    lCounter = 0;
    iLoop ++;
    Serial.println(iLoop);
  }
}

Het sturen van data van de Raspberry Pi naar de arduino zal dikwijls met Python gebeuren, daar is online veel documentatie over te vinden.

Maar het kan bv ook met Gambas3: http://gambas.copyleft.be/blog/archives/2774, zowel van als naar Arduino.

9/12/2022

Arduino 2.x op openSUSE 15.4

Filed under: — cybrarian @ 4:09 pm

Linux Arduino install

Zie ook vroeger de 1.x versie
1.8.13 IDE https://docs.arduino.cc/software/ide-v1/tutorials/Linux, download van de Arduino website https://www.arduino.cc/en/software : arduino-1.8.13-linux64.tar.xz

Maar er is ook een recentere versie, dus die geniet misschien de voorkeur:

Arduiono 2.0.3 IDE

– download de 2.x versie van de site: https://www.arduino.cc/en/software : arduino-ide_2.0.3_Linux_64bit.zip
– uitpakken: geeft een aantal submappen, maar nergens een shell script om te installeren.
– start het programma: arduino-ide (bv met dubbelklik, bevestigen dat je het vertrouwt).
– De bekende groene Arduino IDE start, en begint onmiddellijk allerlei dingen te downloaden en te installeren:

Downloading packages
arduino:avr-gcc@7.3.0-atmel3.6.1-arduino7
arduino:avrdude@6.3.0-arduino17
arduino:arduinoOTA@1.3.0
arduino:avr@1.8.6
Installing arduino:avr-gcc@7.3.0-atmel3.6.1-arduino7
arduino:avr-gcc@7.3.0-atmel3.6.1-arduino7 installed
Installing arduino:avrdude@6.3.0-arduino17

… (volledige log zie onderaan)

Poort

Met de arduino aangesloten kan je op de commandolijn:

lsusb

Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 003: ID 046d:c03d ... Optical Mouse
Bus 001 Device 002: ID 1a86:7523 QinHeng Electronics CH340 serial converter
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Device 002 is de Arduino nano clone

Kies de USB poort (bv: /dev/ttyUSB0 staat klaar)
Kies het aangesloten bord hier Arduino Nano (clone)

Tools, processor: ATmega 328p old bootloader
Programmer: Arduino as ISP

Toegang tot de seriële poort

Je kan zien in welke groepen je al zit met :

groups

users

Root kan toegang geven tot de hardware:
sudo usermod -a -G dialout $USER

groups

users dialout

En voor sommige borden als Arduino Uno WiFi Rev2, ATMEGA328 moet je ook nog deze twee:

echo "SUBSYSTEM==\"usb\", MODE=\"0660\", GROUP=\"$(id -gn)\"" | sudo tee /etc/udev/rules.d/00-usb-permissions.rules

udevadm control --reload-rules

(zie https://github.com/snapcrafters/arduino/issues/10#issuecomment-716683018)

Library
Om extra hardware aan te spreken moet je meestal een library installeren, bv voor een ledstrip met neopixels:

Selecteer bij library manager: Adafruit_NeoPixel (1.10.7 nu).
Je kan via meer info naar :
https://github.com/adafruit/Adafruit_NeoPixel
Of instaleren met een druk op de knop ‘install’

Downloading Adafruit NeoPixel@1.10.7
Adafruit NeoPixel@1.10.7
Installing Adafruit NeoPixel@1.10.7
Installed Adafruit NeoPixel@1.10.7

eindigt in

“Succesfully installed …”

Check
Bij problemen, check:
– Na starten IDE moeten soms de parameters terug ingesteld worden voor het specifiek gebruikte bord, seriële poort, …
– Om de sketch naar het bord te “uploaden” moet er verbinding zijn (zit de usb kabel in het bord (of draait het van batterij waardoor het aangesloten lijkt?)
– Heeft de gebruiker de nodige rechten? (probeer eens de ide te starten als root eventueel)


(meer…)

15/2/2022

Arduino’s seriele print data uitlezen

Filed under: — cybrarian @ 12:43 pm

Serial

Een Arduino bord heeft een programma dat (-bv om het te debuggen-) feedback geeft met print:

In de setup:
Serial.begin();

Je moet ook de snelheid opgeven, dus bv:
void setup() {
Serial.begin(9600);
}

In de code-loop:
Serial.println(someValue);

Bv in een loop:

void loop() {
Serial.println("Hello from Arduino..");
delay(1000);
}

De developer kan in de IDE de feedback zien met de tool “serial monitor”.

Losgekoppeld

Maar ook eens het programma loopt en de Arduino niet meer aan de programmeeromgeving hangt, kan je die seriële communicatie opvangen. Hang de usb-kabel aan een usb-poort van een Linux computer (Raspberry Pi, …).

1. Rechtstreeks vanuit het systeem/commandolijn
Om de hardware te benaderen moeten we root rechten hebben, ofwel telkens met sudo, ofwel:

su root

****

Werp een blik op de usb poorten:

lsusb

Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 003: ID 046d:c31c Logitech, Inc. Keyboard K120
Bus 001 Device 002: ID 046d:c077 Logitech, Inc. M105 Optical Mouse
Bus 001 Device 004: ID 2341:0043 Arduino SA Uno R3 (CDC ACM)
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

tty

Seriëel in de Linux (unix) wereld is “tty”; en er zijn heel wat seriële apparaten mogelijk:

ls /dev/tty*

/dev/tty    /dev/tty20  /dev/tty33  /dev/tty46  /dev/tty59    /dev/ttyS12  /dev/ttyS25
/dev/tty0   /dev/tty21  /dev/tty34  /dev/tty47  /dev/tty6     /dev/ttyS13  /dev/ttyS26
....
/dev/tty15  /dev/tty28  /dev/tty40  /dev/tty53  /dev/tty9     /dev/ttyS2   /dev/ttyS4
/dev/tty16  /dev/tty29  /dev/tty41  /dev/tty54  /dev/ttyACM0  /dev/ttyS20  /dev/ttyS5
/dev/tty17  /dev/tty3   /dev/tty42  /dev/tty55  /dev/ttyS0    /dev/ttyS21  /dev/ttyS6
...
/dev/tty2   /dev/tty32  /dev/tty45  /dev/tty58  /dev/ttyS11   /dev/ttyS24  /dev/ttyS9

stty

Het commando dat de afkorting is van “Set Teletype”:

stty – change and print terminal line settings

Gebruik:
stty [-F APPARAAT | --file=APPARAAT] [INSTELLING...]

Wat?
stty -F

-F, –file=APPARAAT te gebruiken apparaat in plaats van standaardinvoer

Speciale instellingen:
speed de snelheid van de terminal tonen

Dus:
stty -F /dev/ttyACM0 speed

9600

(vreemd ik zou verwachten 115200 ..)
Eens proberen of ik hem kan verzetten:

stty -F /dev/ttyACM0 speed 115200

9600

Terug opvragen:

stty -F /dev/ttyACM0 speed

115200

Lees nu uit:
cat /dev/ttyACM0

SCD30 Raw Data

Carbon Dioxide Concentration is: 930.56 ppm

SCD30 Raw Data

Carbon Dioxide Concentration is: 930.51 ppm

Carbon Dioxide Concentration is: 929.86 ppm

….

Dit is dezelfde uitvoer die je krijgt in de IDE.
Je kan de Arduino aan eender welke bereikbare* Linux-bak hangen en vanop afstand met ssh inloggen en uitlezen, naar een logfile laten sturen, enz…

* bekend ip-adres

2. Serieële communicatie ontvangen met software
Vanuit eigen geschreven software in python of gambas3 kan je de serieële poort uitlezen.

2.1 Python:
Grofweg gezegd: gebruik import serial, creeer een object met eigenschappen in parameters, en maak een lus met serialobject.readline()

2.2 Gambas: gebruik SerialPort, creëer een object, zet eigenschappen, maak methode _Read(), gebruik een lus of Timer om uit te lezen.

13/7/2021

15.6 inch FHD Monitor

Filed under: — cybrarian @ 9:15 am

Een scherm zonder handleiding
Een optie voor gebruik bij je raspberry pi: Een touch-scherm met ingebouwde batterij en aansluitingen voor hdmi en usb. Adapter met usb-C. Audio mini-jack out (audio van hdmi) wat handig is voor de Pi 400 die geen audio-uit heeft.
Er is enkel een kaartje bij met een QR code om te scannen, die leidt naar een webpagina https://www.waveshare.com/wiki/15.6inch_FHD_Monitor (link).

Eigenaardig gedrag als:

Demo
– na even niet gebruiken staat scherm af; zet terug aan met lang indrukken (op gevoel) eerste knop zet het scherm een rooster van 4×4 tekst “demo” op het scherm; afwisselend een kolom met blauwe achtergrond en grijze achtergrond; die blijft heel de tijd pinken. Terug af en aan gezet en het is weg..- toch niet, duikt terug op. Op de online documentatie is helemaal NIETS te vinden over een “demo” stand…; de power knop dient alleen voor aan uit volgens de handleiding, dus hoe ik in “demo” stand ben geraakt .. geen idee.

Batterij
Heel vervelend is dat je geen batterij melding krijgt.
Als je lang rondspeelt in het menu van OSD (On Screen Display), dan vind je daar wel instellingen, en een van de diepst verstopte is die van de batterij-weergave. Die kan je aan en af zetten; als ze aan staat komt ze VAST rechtsboven in het scherm te staan.
Dat betekent voor de Pi: over het klokje. Het klokje wordt onleesbaar, en ook de batterij-weergave is maar leesbaar als je een donkere achtergrond hebt (bv mouseover op klokje).
Je kan de OSD weergave wel op meer transparant zetten om dat te verzachten; ik heb nu een moeilijk afleesbaar klokje en een bij mouseover af te lezen batterij-aanduiding. Je kan natuurlijk kiezen om de takenbalk van de Pi onderaan te zetten (rechtsklik voor instellingen).

12/7/2021

Raspberry Pi (scherm) valt uit

Filed under: — cybrarian @ 11:12 pm

Is er een power management? Is het een screensaver? Hier alvast iets:
https://raspberry-projects.com/pi/pi-operating-systems/raspbian/screensaver

7/7/2021

Eenvoudig beeld bewerken op Raspberry Pi OS

Filed under: — cybrarian @ 12:28 am

De standaard afbeeldingbekijker op Raspberry pi is nogal beperkt tot het bekijken van beelden, en ik wil geen Gimp installeren. Ik wil snel een foto verkleinen of kantelen zoals ik op mijn KDE desktop doe in het standaard beeld-programma Gwenview of zoiets.

Op Raspberry bestaat dat ook, en heet dat Mirage.

sudo apt-get install Mirage

Kantelen, spiegelen, uitsnede nemen, verkleinen tot zelfgekozen aantal pixels in lengte/breedte met mogelijkheid tot behoud van de verhoudingen, enz.

3/6/2021

nginx webserver op Raspberry Pi

Filed under: — cybrarian @ 12:23 pm

Als je een png beeld of een log/tekst wil laten raadplegen vanop afstand met een browser, kan je een eenvoudig webserver gebruiken: nginx
(uitgesproken “Engine X”)

sudo apt-get update
sudo apt-get install nginx

Dat is voldoende om op je localhost de welkom-pagina te zien van nginx:
(raspberry pi browser “localhost”)

De plaats waar die werkelijk staat is: /var/www/html/index.nginx-debian.html

Zet in die map een gewone index.html, en die zal worden weergegeven in de plaats van bovenstaande.

De map is van root, je hebt dus root rechten nodig om er te mogen schrijven/wijzigen.

Je kan bv een submap maken en daar het script dat de data maakt rechen geven om te schrijven.

26/5/2021

Vrije ruimte op SD kaart

Filed under: — cybrarian @ 9:48 pm

Als je een Raspberry Pi installeert met een image voor de SD kaart, is er waarschijnlijk nog niet-gebruikte ruimte na het “branden” van de “image”. Die kan je tegenwoordig gemakkelijk recupereren (raspi-config, Advanced options, Expand Filesystem). Of soms gebeurt dat al (*) bij installatie?

Bv met een micro-sd kaart van 32 GB:

Zet systeem op kaart:
# sudo dd bs=1M if=2021-03-04-raspios-buster-armhf-full.img of=/dev/sde

8212+0 records gelezen
8212+0 records geschreven
8610906112 bytes (8,6 GB, 8,0 GiB) copied, 772,7 s, 11,1 MB/s

fdisk -l


Schijf /dev/sde: 29,1 GiB, 31266439168 bytes, 61067264 sectoren
Disk model: SD/MMC
Eenheid: sectoren van 1 * 512 = 512 bytes
Sectorgrootte (logisch/fysiek): 512 bytes / 512 bytes
In-/uitvoergrootte (minimaal/optimaal): 512 bytes / 512 bytes
Schijflabeltype: dos
Schijf-ID: 0x257398ef
.
Apparaat Op. Begin Einde Sectoren Grootte ID Type
/dev/sde1 8192 532479 524288 256M c W95 FAT32 (LBA)
/dev/sde2 532480 16818175 16285696 7,8G 83 Linux

Bij het starten op de Raspberry Pi krijg je een tekst kort op het scherm, iets van resizing root/boot? filesysteem/partition ..

Daarna iets over checken van ssh keys.

En dan start de desktop. Je krijgt een welkom-scherm met een reeks vragen die je door de installatie loodsen; land, taal, toetsenbord (indien afwijkend), enz. Rechts beneden staat je ip adres indien van toepassing (bv 192.168.1.48).
Daarna word je gevraaagd het wachtwoord te kiezen. Vink hier zeker “Hide Characters” af, zodat je ziet wat je schrijft, want de toetsenbordindeling heb je op dit moment nog niet kunnen controleren. Ondanks de taalkeuze doet hij daarna trouwens vrolijk verder in het Engels.

Als je een netwerkkabel aangesloten hebt, kan je “skip” doen op de draadloze netwerken.
De projectie op het scherm wordt gecontroleerd: komt de afbeelding overeen met de werkelijke schermgrootte of missen er dingen of is er een zwarte rand? (bij mij is die goed)

Daarna kan het systeem gecontroleerd en bijgewerkt worden, wat even kan duren, downloadverkeer veroorzaakt, en extra ruimte inneemt; normaal mag dat allemaal geen probleem zijn en up-to-date is veiliger. “Next”.

22:24- compare,.. download, update …
22:38 ..installing updates – please wait …
22:41 System is up to date

(ok)
“Setup Complete”

Ik kijk in bestandsbeheer en zie dat ik nog 20 GB vrij heb, dus ik veronderstel dat hij de SD kaart wel optimaal benut en niet blijven hangen is op de bv 8 GB van de image.

*) Ps: Inderdaad, ondertussen gaat het Raspberry Pi OS na installatie zelf de overblijvende ruimte van de SD kaart bruikbaar maken voor het systeem, dat gebeurt automatisch bij de eerste opstart na installatie. Vroeger werd de overblijvende ruimte niet gebruikt, of moest je zelf aktie ondernemen om ze te formatteren en in het systeem aan te koppelen.

21/5/2021

Screenshot op Raspberry Pi

Filed under: — cybrarian @ 12:21 pm

Druk op de “Print Scrn” toets op je toetsenbord.
Er komt een bestand in je home map te staan met een naam als: 2021-05-21-121235_1824x984_scrot.png
Scrot is de naam van de screenshot applicatie.
Je moet het bestand daarna zelf bijsnijden als je maar een deel van het scherm wil.

15/5/2021

Raspberry Pi afsluiten zonder scherm

Filed under: — cybrarian @ 11:35 am

Wat als je Pi “headless” draait (of gewoon net niet het juiste kabeltje hebt om je Pi Zero van een scherm te voorzien) en toch je Pi wil afsluiten zonder de voeding uit te trekken?

Er zijn een paar verschillende mogelijkheden, die afhangen van wat er geïnstalleerd is: geen desktop, wel een desktop, netwerk en ssh draait, …

Met netwerk
Als een netwerkverbinding mogelijk is: inloggen met ssh en
sudo shutdown -h now voor afsluiten
sudo shutdown -r now voor herstarten

Zonder netwerk, zonder desktop
Sluit een toetsenbord aan (usb). Er zijn 2 mogelijkheden:
1. Je staat op een login prompt. Tik een bestaande gebruikersnaam en wachtwoord. (“pi”, enter, “raspberry”).
Ga hieronder verder.
2. Je staat in een aktieve terminal
tik shutdown -r now

Zonder netwerk, met Desktop
Sluit een toetsenbord aan en doe de handelingen in de desktop die je normaal zou doen om af te sluiten, maar gebruik de shortcuts op het toetsenbord:
– Open het menu: Pinguin-toets (of gnome of eender welk symbool op die menu toets staat);
– ga naar de Shutdown/Afmelden menukeuze: pijltje naar beneden bv 13 keer (tel op voorhand hoeveel bij jou van toepassing is; er zijn meer onderverdelingen als er meer software geïnstalleerd staat, bv: Programmeren, Onderwijs, Kantoor, Internet, Muziek-Video, Grafisch, Spelletjes, Systeemgereedschap, Hulpmiddelen, Help, Voorkeuren, Opdracht uitvoeren, Afmelden). De eerste keer pijl-naar-beneden maakt de bovenste menukeuze aktief, tel dan verder.
– Afmelden = enter
– Bevestigen = enter
(als je wil herstarten doe je pijltje naar beneden + enter)

12/1/2021

Programmeerbare led-boom; voorbeeld-led-loopjes

Filed under: — cybrarian @ 10:29 pm

Zie vorig artikel Nano-programmeerbare kerstboom

Als de hardware geïnstalleerd is, kan je spelen met de broncode in de Arduino IDE, gemakkelijkst is om te beginnen van een voorbeeldprogramma waar een element in zit dat je wil verkennen.

Behalve voor het beschreven bord-met-leds geldt veel van de software voor heel wat reeksen van led’s, met als ledstrip-lengte een aan te passen getal (bv #define LEDCOUNT 12)
Om het effect van de drie kleuren te verstaan: zoek op internet naar de afbeelding van een “color wheel for light”.

Om vat te krijgen op de juiste led, maken we eerst een programma dat de leds afloopt in volgorde van de nummering van het bord (begint bij nul).

We laten de rode led op de Nano mee- (of eerder tegen-) knipperen als controle.

Inhoud:

  • Eén led loopt rond tussen donkere leds
  • Eén led loopt rond in een gekleurde kerstboom
  • Een ribbe van de kerstboom heeft verschillende kleuren, draait weg naar de spits toe.
  • Bauw zwaailicht

Gemeenschappelijk is altijd het invoegen van de Adafruit NeoPixel bibliotheek:
(nota: de < en > tekens hebben een spatie gekregen die er uit moet)

#include < Adafruit_NeoPixel.h >
#define PIN 9
#define LEDCOUNT 12

En bijna altijd heb je een index of teller nodig:
int i=0;
… (* soms komt hier dan bv een array met led-volgnummers of andere definities)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDCOUNT, PIN, NEO_RGB); // + NEO_KHZ800);

En dan een algemene setup code die de leds initialiseert:
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
strip.begin();
strip.show(); // Initialize alle pixels 'off'

en daarna komt de oneindige programmalus “loop”:

void loop() {
// allerlei code, met een if of select voorwaarde of een andere herhaling
// dikwijls voorzien van een rustpauze van een aantal milliseconden:
delay(1000);
}

Eén led loopt rond tussen donkere leds

De rode led op het Nano bord pinkt om de programmaloop aan te tonen (mag er dus uit)

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // led op Nano aan
  delay(250);                       // even houden
  digitalWrite(LED_BUILTIN, LOW);    // led op Nano uit
  delay(250);                       // even wachten voor
  // boom
// led i kleursterktes (rood, groen, blauw)
  strip.setPixelColor(i, 10, 10, 200);
  strip.show();
  delay(1000);
  strip.setPixelColor(i, 0, 0, 0);     // led i terug uit
  i++;                        // volgend led tot laatste..
  if(i > LEDCOUNT) {
    i=0;                        // terug naar eerste
  }
}

Conclusie: led 0 staat onderaan op de boom, op de ribbe diagonaal aan de overkant van de aan-uit schakelaar (voor de batterij), waar eigenlijk C/5 het dichstbij staat.

A	B	C	D
			
2	8	3	9
1	7	4	10
0	6	5	11

Eén led loopt rond in een gekleurde kerstboom
Richting: van 0 naar 11.

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // bord led knippert tegen; aan
  delay(250);                       // houden..
  digitalWrite(LED_BUILTIN, LOW);    // uit
  delay(250);    // pauze alvorens led i te wijzigen;
  strip.setPixelColor(i, 10, 10, 200);    // led nummer i blauw
  strip.show();
  delay(1000); geniet
  strip.fill(strip.Color(0, 32, 0), 0, 12); // Kerstboom terug groen
  strip.show();
  delay(500);                       // even houden zo
  i++;  // schuif door naar nummer volgende led tot laatste
  if(i > LEDCOUNT) {
    i=0; // dan terug naar eerste
  }

Rond de boom …

Met het volgen van de leds zoals ze intern genummerd zijn, worden de ribben van de boom-piramide gevolgd, van onder naar boven en over de top terug naar onder (zie boven).

Maar wij willen ze zo laten lopen:

A	B	C	D
			
8	9	10	11
4	5	6	7
0	1	2	3

We laten niet de led-nummer optellen, maar wel de index in een rij van led-nummers.

0	6	5	11	1	7	4	10	2	8	3	9

In de definities boven de setup moeten de volgorde van het aanspreken van de pixels vooraf vastgelegd worden om gemakkelijk te kunnen rondlopen:

 int ledPins[] = {
    0, 6, 5, 11, 1, 7, 4, 10, 2, 8, 3, 9
  };

Pinkende ribben, rond-uitloop naar top

  void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // bord led knippert tegen; aan
  delay(250);                       // houden..
  digitalWrite(LED_BUILTIN, LOW);    // uit
  delay(250);    // pauze alvorens boom te wijzigen;
  strip.setPixelColor(ledPins[i], 200, 200, 0);    // pixel i aan, geel
  strip.setPixelColor(ledPins[i+4], 40, 40, 255);    // pixel op volgende laag boven blauw
  strip.setPixelColor(ledPins[i+8], 150, 20, 20);    // pixel op daaropvolgende laag rood
  strip.show(); // pixelnummers boven LEDCOUNT geen probleem, worden onzichtbaar
  delay(1000); pauze voor kleur terug uit; m.a.w. boom volledig kleuren;
  strip.fill(strip.Color(2, 50, 2), 0, 12); // Kerstboomgroen, bv 2, 50, 2 of 0, 32, 0
  strip.show();
  delay(100);                       // wachtebeke
  i++; // opschuiven tot laatste led, 
  if(i >= LEDCOUNT) {
    i=0; //  dan opnieuw
  }
}

Blauw zwaailicht

 digitalWrite(LED_BUILTIN, HIGH);   // led op bord aan (voltage hoog)
  delay(30);                       // wacht even
  digitalWrite(LED_BUILTIN, LOW);    // led op bord uit (voltage laag)
  delay(30);                       // wacht even


speel met deze delays (en die op het einde) voor de snelheid van het ronddraaien…

 strip.fill(strip.Color(4, 4, 25), 0, 12); // zwak blauw licht tussendoor
  strip.show();
  strip.setPixelColor(ledPins[i], 2, 2, 255);    // turn pixel on, ? color
  strip.setPixelColor(ledPins[i+4], 2, 2, 254);    // turn pixel on, ? color
  strip.setPixelColor(ledPins[i+8], 2, 2, 253);    // turn pixel on, ? color
  strip.show();
  delay(70);                       // wait for ..

De +4 en +8 zorgen ervoor dat de boven elkaar liggende leds samen gebruikt worden.
De waarden voor de kleuren zijn een tikje anders gezet, waardoor je boven/onder kan herkennen

  i++;
  if(i >= LEDCOUNT-8) {
    i=0;
  }


Dit laatste stuk zorgt ervoor dat het licht, eens helemaal rond, terug bij de eerste ribbe begint. Voor een politie-zwaailicht effect kan je de delay tijden korter zetten.

Veel plezier…

9/1/2021

Nano-programmeerbare kerstboom

Filed under: — cybrarian @ 12:35 am

Het ontbrekende handboek
(mijn doel is er een universeel monitoring apparaat van te maken: geluidsniveau, temperatuur, netwerkaktiviteit, …)
Een weinig gedocumenteerd object (Arexx creatie) en verkocht in verschillende vormen/versies op ondermeer Duitse webwinkels als Reichelt en Conrad (Als “MakerFactory”);

Voordeel: Je kan kiezen om hem:

  • gewoon aan te steken en alles blauw-blauw te laten (Dat is de teststoestand bij opstarten: alle leds blauw, beetje koud hard blauw licht maar leuk in industrieële omgeving en de leds geven veel licht (dat belooft voor de batterij..).
  • te voorzien van een micro:bit. De micro-bit kan je dan weer voorzien van een programma dat je afhaalt, en waarmee je de kleurtjes van de kerstboom laat varieren, rondlopen, verkleuren enz. Een micro:bit van de eerste versie volstaat. Je kan dan ook de rest van de micro:bit aansturen in je programma, voor het deel van de leds van de kerstboom moet je de Neopixel bibliotheek aanroepen voor een ledstrip van 12 leds RGB. Je kan bv tegelijk de temperatuur weergeven op de leds van de micro-bit, scrollend, en de lichtjes van de boom laten verlopen van kleur tegen een zelfgekozen tempo.
  • te voorzien van een bijgeleverde “arduino-compatibele” nano die je in een voet kan steken die je op de printplaat moet solderen. Op het ene van de twee papiertjes die mee in de doos zitten, staat dat je de batterijhouder moet verwijderen (hoe?) en dan de ic voet op het bord solderen, en de batterijhouder vastsolderen. Daarna “programmeren als WS-2812” is het enige wat de erg summiere handleiding op het tweede bladje er verder over zegt.
  • De bijgeleverde nano bevat standaard wel een demo: zachtjes opkomende en weer uitdovende kleur van de hele boom; groen, rood, blauw. Als je je eigen programma’s er in laadt, is deze natuurlijk weg.

Er wordt in alle talen verwezen naar “lesboeken en werkbladen met oefeningen en voorbeelden”, maar wel zonder te zeggen hoe of waar; ik heb ze online niet gevonden.

Micro:bit
De micro:bit is het gemakkelijkst te gebruiken, je moet hem maar in de speciale sleuf steken, en hij is onmiddellijk bruikbaar.

* Zelf bijeen puzzelen

BBC Micro:bit
WS-2812

Online bronnen:
* Een zip-bestand met een aantal “programma’s” om te downloaden:
software-2195092-makerfactory-mf-6585276-christmas-tree-mobile-kerstboom.zip

Uitgepakt geeft dat:

└── Software
    ├── Arduino
    │   ├── VU_meter
    │   │   └── VU_meter.ino
    │   └── Zwaailamp
    │       └── Zwaailamp.ino
    └── Microbit
        ├── analog_read_led.hex
        ├── analog_read_led_log.py
        ├── analog_read_led.py
        ├── led_and_button_test_2boards.hex
        ├── led_and_button_test_2boards.py
        ├── led_and_button_test.hex
        ├── ledtest.hex
        └── README.txt

5 directories, 10 files

Namen als “VU-meter”? “Zwaailamp”? Ik had eerder iets ivm kerstboom verwacht, maar ja…
* Aankoppelen
Sluit de micro:bit aan met de USB kabel aan de computer. Het ziet eruit alsof je een usb-drive aansluit, je kan die openen en ziet bestanden staan.
De uitvoerbare programma’s uit de Micro:bit directory van de download kan je naar de usb-Micro:bit kopiëren, je ziet onderaan een gele led flikkeren terwijls ze worden opgepikt door de Micro:bit; als dat stopt verdwijnt het bestand uit die usb-micro:bit map en start het programma met de uitvoering of wacht op bv de druk op een knop.

* Micro:bit programmeren
Bij Microbit zie je bestanden met uitgang
.hex: dat is het uitvoerbare bestand.
.py : dat is de wijzigbare broncode in python
Het is de broncode in python die nadien gecompileer wordt tot het hex bestand, dat kan je lokaal of via een website, waar je als download een .hex krijgt.

Je zou verwachten dat er telkens een broncode bestand is (.py) en daarvan een gecompileerde versie (.hex).
Helaas:

analog_read_led.py
analog_read_led.hex

analog_read_led_log.py
led_and_button_test_2boards.py
led_and_button_test_2boards.hex

led_and_button_test.hex
ledtest.hex

Gelukkig is er het README.txt bestand om alles te verduidelijken:

analog_read_led.hex VU meter
led_and_button_test.hex Looplicht. Met indrukken knop veranderd smiley op display microbit en worden leds rood ipv blauw.
led_and_button_test_2boards.hex Zelfde, echter nu met 16 LEDS (tweede board aangekoppeld via J2)

Euh??

Uitproberen van de .hex (en bekijken van .py indien beschikbaar);
* analog_read:
– Er brandt: 1 kant 3 blauwe leds; overkant bovenste blauwe led; andere kant onderste led groen: knippert onregelmatig (analoog? Maar op basis van wat? Random? Pin0? Ik krijg geen verandering in het patrook van knipperen.
– In de code valt me op dat er gewerkt wordt met pixelcount van 8, terwijl we er twaalf hebben.

* led_and_button_test.hex:
– op de micro:bit staat een sip kijkende smiley “:(” en er branden 3 blauwe leds op 1 ribbe, en 1 blauwe led op de tegenoverliggende. Er loopt 1 led rond op 8 leds die niet branden. Als je op de Micro:bit knop A indrukt, verandert de kleur van de rondlopende led naar rood. Als je loslaat terug naar vorige toestand.
– we hebben hier geen broncode van, maar de beschrijving is wel een beetje te volgen, waarschijnlijk ook een verkeerd aantal leds gedefinieerd voor deze boom.

* ledtest.hex:
– doet alle leds blauw branden, net alsof je de boom zonder micro-bit zou aanzetten.
– geen broncode.

* led_and_button_test_2boards
– Micro:bit geeft sip gezicht; doet verder een enkele blauwe led rondlopen : van beneden naar boven, over de top terug naar beneden. Even pause (ongeveer 4 tellen). Op de andere ribben ook weer van beneden naar boven en over de top naar beneden; dan ineens terug naar uitgangspositie. Als je knop A indrukt op de micro:bit verandert het gezicht naar een smiley en de kleur die rondloopt naar rood, zolang je de knop ingedrukt houdt.
– broncode spreekt van pixelcount 16; dus dat verklaart de 4 tellen waar we niets zien gebeuren?


Arduino Nano:

Om de “arduino” Nano te monteren moet de batterijhouder verwijderd worden en dat ziet er op het eerste zicht gemakkelijk uit, want die is vastgezet met 2 boutjes; losdraaien en klaar? Neen. De batterijhouder zit ook met 2 pinnen vast(gesoldeerd?) op het bord, nl waarmee de stroom doorgegeven wordt. Die moet je dus voorzichtig los solderen, want nadien moet hij er terug aan. Het nano-blaadje uitleg geeft al toe dat de voet voor de nano-processor niet past op het bord van de kerstboom: je moet 1 paar tegenoverliggende voetjes ombuigen. Daarna moet je de voet vastsolderen (volgens de handleiding met de nano erin, is dat wel voorzichtig?), en daarna moet je de nano er uit halen en de batterijhouder terug vastsolderen. Alleen spijtig dat je daar zo goed als niet meer aankan, want de voet zit in de weg nu.

De handleiding zegt: “Als de Arduino Nano op de print gesoldeerd is, kun je de kerstboom niet meer met de Micro:bit gebruiken”, maar de Arduino is niet vastgesoldeerd (past ook niet rechtstreeks), enkel de voet. En daardoor kan je de Nano er wel uithalen; en – vermoed ik- terug gebruiken met de Micro:bit (misschien een overblijfsel van een vorige versie?).

* Arduino software
Installatie (hier op Ubuntu 18.10):
Arduino “IDE” kan je downloaden voor Linux, bv in versie 1.8.13:
https://downloads.arduino.cc/arduino-1.8.13-linux64.tar.xz
Uitpakken, …

~/IOT-SBC/arduino-1.8.13-linux64/arduino-1.8.13$ ls
arduino examples java reference tools-builder
arduino-builder hardware lib revisions.txt uninstall.sh
arduino-linux-setup.sh install.sh libraries tools

en het installatieprogramma draaien:

~/IOT-SBC/arduino-1.8.13-linux64/arduino-1.8.13$ sudo ./install.sh

Adding desktop shortcut, menu item and file associations for Arduino IDE…

Starten met “arduino” (op de commandolijn) of uit het menu of link op de desktop.

* Configuratie
Je moet ervoor zorgen dat je toegang hebt tot de hardware van je computer, meer bepaald de seriële poort. Dat kan bv door je gebruiker aan een bepaalde groep toe te voegen die toegang heeft tot die seriële poorten. Of de luie, verwerpelijke, onveilige manier is de arduino software te starten met root rechten: sudo arduino.
Als het onmiddellijk lukt een een voorbeeldprogramma uit het menu “Files, Examples, Basic, Blink” te laden en dat naar de Nano te sturen (met de upload pijl), de Nano-led flikkert, en er begint een LED te pinken, dan lijkt het ok.
De software is gemaakt voor een heel groot aantal Arduino borden (en compatibelen), die toch allemaal wat onderling verschillen, bv van mogelijkheden, processor, communicatiechips enz.
In de software moet je mogelijk wat instellingen doen om die aan te passen aan het apparaatje dat je zelf hebt. Ik denk niet dat het kwaad kan, en ik heb het in ieder geval gedaan, om te proberen tot je een instelling vindt die werkt.
Voorbeeld:
-Tools, Board: Arduino Nano – je moet niet aangeven dat het geen echte Arduino is..
-Tools, Processor: ATmega 328P (old bootloader) – “old bootloader” maakte bij mij het verschil
-Tools, Port: /dev/TTYusb0 – kan bv op /dev/TTYs0 staan
-Programmer: Arduino as ISP
Zo lukte het doorsturen van het programma en daarna werkte de knipperende led (op de Nano zelf).

Bibliotheekbeheerder
In menu Tools, Library Manager, bij “Adafruit” zoeken naar “NeoPixel” (hier 1.7.0), druk “install”.

Als je een terminal venster openhebt zie je daar:

Installer Thread] Connect to https://downloads.arduino.cc/libraries/github.com/adafruit/Adafruit_NeoPixel-1.7.0.zip, method=GET, request id=AA5FE6A11AC24BAA
2021-01-11T23:32:53.124Z INFO c.a.u.n.HttpConnectionManager:157 [LibraryManager Installer Thread] Request complete URL="https://downloads.arduino.cc/libraries/github.com/adafruit/Adafruit_NeoPixel-1.7.0.zip", method=GET, response code=206, request id=AA5FE6A11AC24BAA, headers={null=[HTTP/1.1 206 Partial Content], Server=[cloudflare], Content-Range=[bytes 0-68907/68908], Last-Modified=[Thu, 05 Nov 2020 20:35:25 GMT], X-Amz-Cf-Id=[B_S_zxqMpHC22E8beW3D2fzEpQ_U0-4tpC7F1ZgKRmxFLMHJiQberQ==], Set-Cookie=[__cfduid=d583a54e468bb8f35f5c2779301d625a91610407973; expires=Wed, 10-Feb-21 23:32:53 GMT; path=/; domain=.arduino.cc; HttpOnly; SameSite=Lax], Content-Length=[68908], Age=[1257687], cf-request-id=[079564a8da0000f951dfb56000000001], Content-Type=[application/zip], X-Cache=[Miss from cloudfront], CF-Ray=[61027087c9b0f951-BRU], X-Amz-Cf-Pop=[BRU50-C1], Connection=[keep-alive], x-amz-version-id=[6Yh0xZLsEcmrSOLunFynfok9_0CfS0_4], Date=[Mon, 11 Jan 2021 23:32:53 GMT], Via=[1.1 99578e20c0b3a3e3de02b1f1fe508f98.cloudfront.net (CloudFront)], x-amz-replication-status=[COMPLETED], CF-Cache-Status=[HIT], Cache-Control=[private], ETag=["4eaaaa04f12af651fe17d3f5c4fafbc6"], Vary=[Accept-Encoding], x-amz-request-id=[081CA622C45AA4DD], x-amz-id-2=[v6sY2mUeZxs4GmWgvhuYtTVHb4ll/YLu7BOz6dbfpYY6Ey8xCYshTYf1TNM6XqbigeTh2Bv+DhQ=], Expect-CT=[max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"]}

Als je daarna terug in menu Tools, Manage Libraries naar deze library gaat, zie je hem staan als “installed”.

Sketch, Include Library, selecteer Adafruit NeoPixel; er wordt bovenaan een lijn ingevoegd met:

 # include < Adafruit_NeoPixel .h  > 

Je hebt de pin nodig waaruit gestuurd wordt:
#define PIN 9

Definieer de strip:
Adafruit_NeoPixel strip = Adafruit_NeoPixel(12, PIN, NEO_RGB);

Daarna in de setup function (initialiseren op af):

strip.begin();
strip.show();

en dan in de programma loop, bv zet pixel nul (eerste in de rij) op rood:

strip.setPixelColor(0, 255, 0, 0); //turn pixel on red green blue
strip.show();

Of voor een hele reeks leds, “fill” met gebruik van de functie “Color” om de kleur te maken:

strip.fill(strip.Color(12, 64, 0), 0, 12);
strip.show();

Samengevat:
# include
#define PIN 9
Adafruit_NeoPixel strip = Adafruit_NeoPixel(12, PIN, NEO_RGB);
#
void setup() {
// put your setup code here, to run once:
strip.fill(strip.Color(12, 64, 0), 0, 12);
strip.show();
strip.begin();
strip.show();
}
#
void loop() {
// put your main code here, to run repeatedly:
strip.setPixelColor(0, 255, 0, 0); //turn pixel on red green blue
strip.show();
}

en dan uploaden …

Als de test werkt kan het echte programmeerwerk beginnen…

Succes!

Powered by WordPress