SetBfree Hammond Organ (4)

Een Hammond Organ voor iedereen!

Tekst en technische afbeeldingen: Marjan Waldorp
Artikel uit Turning Wheel 2024-2

In deel 3 hebben we kennis gemaakt met concepten van besturingssystemen en UNIX/Linux in het bijzonder. Tijd om praktisch aan de slag te gaan en een SBC (Single Board Computer) te installeren met een Linux besturingssysteem. De bedoeling daarbij is dat we geheel "self-supporting" worden, zodat we eenvoudig opnieuw kunnen beginnen, mocht er in de loop van ons project iets helemaal fout gaan. Concreet zullen we de Linux installatie uitvoeren op een "ODROID N2+" SBC, maar andere SBC's, zoals een Raspberry Pi, kunnen op een vergelijkbare manier geïnstalleerd worden.

De ODROID N2+ is een moderne krachtige SBC met een 384kHz/32bit HiFi audio DAC on-board, waarmee we direct ons Hammond synthesizer project kunnen realiseren. De extra CPU-kracht (SetBfree zou met minder toekunnen) maakt het mogelijk om later uit te breiden met andere applicaties, zoals de muziekstudio "Ardour".

Voordat we met de Linux installatie beginnen, eerst een korte uitleg over de Linux Shell en het Security model van een Linux systeem.

Linux Shell

De afgelopen decennia zijn er in de UNIX/Linux wereld diverse shells ontwikkeld. In Linux is de standaard shell "bash" (Bourne Again Shell), een reïncarnatie van de UNIX shell ontwikkeld door Stephen Bourne in 1979.

In een grafische omgeving starten we de shell op door een "Terminal" applicatie te openen, in het menu veelal te vinden onder "System Tools". In de terminal meldt de shell zich met een "$" teken, de "prompt". In de prompt vinden we ook vaak de naam van de gebruiker of de computernaam (hostname). De prompt is programmeerbaar via de variabele "PS1". De commandoregel van de shell is opgebouwd als de naam van het programma, gevolgd door nul of meer argumenten:

Argumenten, die beginnen met "-" of "+", zijn opties. In dit voorbeeld laat het programma "ls" (list) door de optie "-l" (long) een "uitvoerige" lijst zien van bestanden die eindigen op ".txt" en ".TXT". Argumenten worden gescheiden door spaties. Bestandsnamen met spaties zijn dus niet praktisch, al kan dit wel via "quoting":

 $ more 'mijn speech.txt'

Met het commando "type" kunnen we zien hoe de shell een commando zal afhandelen:

 $ type more more is /usr/bin/more

Voor het "more" commando zal de shell dus het programma "/usr/bin/more" in het werkgeheugen laden en uitvoeren. Maar wat veel gebruikers zich niet realiseren is dat de shell een uitgebreide voorbewerking (parsing) doet van de ingevoerde commandoregel! ¹ Door "echo" vòòr de commandoregel te typen, kunnen we in de keuken van de shell kijken:

 $ echo ls -l *.txt *.TXT ls -l aap.txt noot.txt mies.txt *.TXT

Na de parsing telt deze commandoregel dus 5 argumenten i.p.v. 3! Een goede lezer kan nu voorspellen welke foutmelding de oorspronkelijke commandoregel zal geven!

Tot slot: waar vinden we informatie over programma's en hun opties? Allereerst in de "manual pages":

 $ man man

Daarnaast hebben veel moderne Linux programma's een ingebouwde "help":

 $ vi --help

Linux security

Evenals UNIX kent Linux een security model van gebruikers, gebruikersgroepen en toegangsrechten op bestanden. (UNIX werd destijds meteen als multi-user systeem ontworpen, zodat meer gebruikers de dure computerhardware konden delen!) ² Daarnaast is er een systeembeheerder met gebruikersnaam "root", die niet aan toegangsrechten is gebonden! De systeembeheerder "root" mag alles, kan alles en kan dus ook gemakkelijk het systeem om zeep helpen! Het is dus niet aan te raden standaard als gebruiker "root" in het systeem te werken! Een gewone gebruiker kan systeembeheertaken uitvoeren door te schakelen naar de "root" user met het "su" (switch user) commando en het "root" wachtwoord te geven. Gebruiker "root" heeft "uid=0" (user id). In de shell is de rootprompt ter onderscheiding een "#". Naast "su" is er in Linux systemen een "sudo" commando, waarmee bepaalde (te configureren) gebruikers het recht krijgen om programma's uit te voeren als "root". Het "sudo" commando vraagt naar het wachtwoord van de gebruiker. Met het commando "id" kan een gebruiker zijn identiteit opvragen:

 $ sudo bash [sudo] password for odroid: # id uid=0(root) gid=0(root) groups=0(root) # exit $

Linux installatie op de ODROID N2+ SBC

Installatie van een besturingssysteem op een SBC is relatief eenvoudig, doordat de fabrikanten veelal kant-en-klare voorgeïnstalleerde "image" bestanden aanbieden. Het enige wat we nog hoeven te doen is zo'n image bestand op een opslagmedium schrijven (flashen), zoals een micro-sd kaartje. Daarna is het "sd-kaartje in het sleufje van de SBC steken en stroom erop"! Wie een SBC "Starters Kit" aanschaft, heeft het zelfs nog makkelijker. In zo'n kit zit een kant-en-klaar door de fabrikant geflashed sd-kaartje, waarmee je direct kunt starten. Als we echter "self-supporting" willen zijn en opnieuw willen kunnen beginnen, mocht er tijdens ons project iets fout gaan, dan moeten we in staat zijn zelf een sd-kaartje van een image te voorzien!

SBC-fabrikanten bieden voor het flashen vaak een image schrijfprogramma aan, maar wie over een Linux systeem beschikt, heeft zo'n programma helemaal niet nodig! Wel, als we de ODROID N2+ SBC opstarten met het sd-kaartje uit de Starter Kit voorzien van Linux "ODROID Ubuntu Mate", beschikken we over een draaiend Linux systeem! Het enige dat we daarbij nog nodig hebben, is een nieuw of gebruikt sd-kaartje (min. 16GB, premium kwaliteit) dat overschreven mag worden met een image bestand en een usb-cardreader. Het sleufje van de SBC kunnen we hiervoor niet gebruiken! In dat sleufje zit het sd-kaartje, waarmee de SBC opstart en dat als de "harddisk" van de SBC fungeert. Zolang de SBC loopt, mogen we dit sd-kaartje dus nooit uit het sleufje verwijderen!

En dan hebben we natuurlijk nog een image bestand nodig. Het ligt voor de hand dezelfde Linux "ODROID Ubuntu Mate" te downloaden, echter die is een beetje gedateerd en heeft een paar vervelende bugs, waaronder een haperende RTC ondersteuning. Dus als de ODROID is opgestart en we grafisch ingelogd hebben als user "odroid" (wachtwoord: odroid), surfen we met Firefox naar "www.armbian.com" ³ en downloaden een "Armbian Bookworm XFCE" image file voor "odroid-n2".

Hoe flashen we een image bestand op een sd-kaartje? Dat is niet een kwestie van het image bestand naar het sd-kaartje kopiëren. Dat werkt niet! Een image bestand is letterlijk een afbeelding van alles wat op het opslagmedium staat: bootloader, partitietabel, partities, hun filesystems en bestanden. Het image bestand moet dus één op één (carbon copy) naar het sd-kaartje worden geschreven, zodat dit blok voor blok exact de data bevat van het image bestand. Hé, werden computernerds niet blij van het schrijven van diskblokken (deel 3)? Precies! We moeten het image bestand blok voor blok schrijven naar het device file van het sd-kaartje. Een heel destructieve actie, want daarbij zal alles, maar dan ook alles wat op het opslagmedium stond, worden overschreven!

Tijdens het schrijven van de data naar het sd-kaartje is het essentieel dat we ongestoorde exclusieve toegang tot het medium hebben! Alleen dan zal de data op het sd-kaartje één op één overeenkomen met de data van het image bestand. Moderne grafische Linux omgevingen zitten ons hier echter een beetje in de weg. Wanneer we ingelogd in de grafische omgeving van ODROID Ubuntu Mate een opslagmedium, zoals een sd-kaartje, insteken, gaat Ubuntu Mate automatisch het filesystem op het medium openen (mount). Dat is heel gebruikersvriendelijk, wanneer we op de bestanden van het medium willen toegrijpen, maar zal nu, bij het compleet overschrijven van het opslagmedium, tot corrupties leiden! Weliswaar is Ubuntu Mate zo te configureren dat media niet automatisch gemount worden, maar nog makkelijker is het de grafische omgeving gewoon links te laten liggen! We loggen dus uit van de grafische omgeving. Daarna schakelen we met de toetscombinatie CTRL-ALT-F1 naar niet-grafische terminal "tty1" en loggen in als user "odroid". (Terug naar grafisch: CTRL-ALT-F7)

Wanneer we naar het device file van het nieuwe te overschrijven sd-kaartje willen schrijven, is het heel belangrijk dat we zeker weten dat we het juiste device file openen! Als we onze destructieve actie op het verkeerde device uitvoeren, is het leed immers niet te overzien! We geven een "lsblk" (list block devices) commando, steken het nieuwe sd-kaartje in de usb-cardreader en geven nogmaals een "lsblk" commando. Vergelijkend zien we nu twee nieuwe block devices "sda" en "sda1". Dit zijn dus de device files van het nieuwe sd-kaartje.

 $ lsblk .. sda 8:0 1 29.7G 0 disk └─sda1 8:1 1 29.7G 0 part

Vervolgens controleren we of het sd-kaartje gemount is:

 $ df .. /dev/sda1 31154688 2350112 28804576 8% /media/usb0

En verdraaid! Het sd-kaartje blijkt toch gemount op directory "/media/usb0", maar dit is eigenlijk een bug! Boosdoener is het pakket "usbmount", weg ermee! We unmounten (umount!) het sd-kaartje en verwijderen pakket "usbmount":

 $ sudo umount /dev/sda1 $ sudo apt-get purge usbmount

Daarna trekken we het sd-kaartje uit de usb-cardreader en steken het opnieuw in. Het zal nu niet gemount zijn. Nu kunnen we veilig het image file naar het sd-kaartje schrijven:

 $ cd ~/Downloads $ ln Armbian_24.2.1_Odroidn2_bookworm_current_6.6.16_xfce_desktop.img.xz \ Armbook-xfce.img.xz $ sudo xzcat Armbook-xfce.img.xz | dd of=/dev/sda bs=1M conv=fsync .. 6928990208 bytes (6.9 GB, 6.5 GiB) copied, 302.51 s, 22.9 MB/s

Allereerst geven we het image bestand een wat handzamere tweede naam met een "ln" (link) commando (deel 3: "UNIX Filesystem Concept"). Het image bestand is gecomprimeerd (.xz). We moeten het dus eerst decomprimeren alvorens de data op het sd-kaartje te kunnen schrijven. Via een "pipe" (|) constructie kan dat echter in één keer. We decomprimeren het image bestand met "xzcat" en sturen de data via een pipe naar "dd". Het programma "dd" is een copieer programma met diverse bijzondere opties. Je kunt bijv. de grootte van de copieerbuffer instellen (bs=1M). Een grotere buffer versnelt het copiëren. De optie "conv=fsync" zorgt er voor dat alle data uit de "cache" geheugenbuffer fysiek naar het opslagmedium wordt geschreven alvorens te eindigen. Tijd voor een kopje koffie! Het schrijven van ca. 7GB data gaat ongeveer 5 min. in beslag nemen.

Als "dd" zijn werk gedaan heeft, zijn we feitelijk klaar, maar het is aan te bevelen het resultaat te verifiëren. We noteren het aantal door "dd" geschreven bytes: 6928990208. Wederom met "dd" lezen we precies dit aantal bytes van het sd-kaartje terug en bepalen de md5 checksum. Vervolgens bepalen we de md5 checksum van het image bestand. (De "tee" constructie legt de md5sum vast in een bestandje voor eventueel later hergebruik.) Als beide md5 checksums overeenkomen, is de data op het sd-kaartje integer.

 $ sudo dd if=/dev/sda bs=512 count=$(( 6928990208 / 512 )) | md5sum e0e709cc7cdd474e2a1d889c6313d663 - $ xzcat Armbook-xfce.img.xz | md5sum | tee Armbook-xfce.img.md5sum e0e709cc7cdd474e2a1d889c6313d663 -

Klaar voor ons project

Tijd om afscheid te nemen van ODROID Ubuntu Mate. We brengen de ODROID N2+ down:

 $ sudo shutdown -h now

Wanneer het rode LEDje gedoofd is, kunnen we de voedingssteker lostrekken en het sd-kaartje met "ODROID Ubuntu Mate" uit het sleufje verwijderen. Dit sd-kaartje bewaren we voor toekomstige flash operaties. We verwijderen ook de usb-cardreader, anders probeert de ODROID N2+ van de usb-cardreader op te starten! In het sleufje van de SBC steken we nu het nieuw geflashde "Armbian Bookworm" sd-kaartje. De eerste opstart nog even een "root" wachtwoord instellen en een gebruiker inrichten, en we kunnen met ons project beginnen!