.Build - Bouw je eigen mobiele opslag

Het is nog niet zo lang geleden dat smartphones en tablets standaard van een nogal karige 16GB opslag werden voorzien. Als je pech had, kon dat ook niet uitgebreid worden en was je veroordeeld tot het regelmatig verwijderen van je video’s of muziek om ruimte te maken voor nieuw materiaal. Dat was extra lastig als je met vakantie ging, want wilde je nou liever Spongebob aflevering 7 of de discografie van The Village People meenemen? Intussen hebben fabrikanten hun leven gebeterd en zijn telefoons met 16GB opslag een zeldzaamheid geworden. Bovendien zijn er steeds meer clouddiensten voor muziek, video en opslag beschikbaar gekomen, waardoor je die niet lokaal hoeft op te slaan.

Maar stel, je beschikt niet over een internetverbinding, bijvoorbeeld omdat je met vakantie bent, of je hebt geen zin om alles in de cloud te zetten, dan zul je een externe harde schijf of een grote usb-stick mee moeten nemen. Wat is er dan mooier dan op je vakantieadres aankomen en je mobiele opslag uitpakken, aanzetten en niet meer naar om hoeven kijken?

Het uitgangspunt van dit project is een Raspberry Pi met snelle wifi. De Pi 3B+ en de 4B hebben een vlotte 802.11ac-wifiadapter ingebouwd, maar met een Pi 3B of 2B en een vlotte usb-adapter moet het ook lukken. Daarnaast gebruiken we een usb-stick van 128GB, maar je kunt er via usb ook een externe harde schijf aan hangen. Om de externe opslag ook op plekken zonder stopcontact, zoals naast het zwembad of midden in de jungle, te kunnen gebruiken, willen we hem het liefst voorzien van een zonnepaneel. Het nadeel van een zonnepaneel is echter dat de geleverde energie niet gegarandeerd is. Als de zon draait en het paneel niet, wordt er minder energie geleverd, net als wanneer er een wolk voor de zon schuift. Er moet dus een accu als buffer tussen.

Als accu kun je denken aan een powerbank, maar die heeft twee nadelen. Om te beginnen kunnen veel powerbanks niet tegelijk worden opgeladen en een ander apparaat voeden, bijvoorbeeld met een zonnepaneel en in dit geval de Pi. Daarnaast kun je de status van een powerbank niet uitlezen en dat willen we juist wel. Als het zonnepaneel midden in de nacht geen stroom meer levert en de accu ook leeg begint te raken, willen we namelijk dat de Pi dat weet en zichzelf netjes afsluit, zonder bestandsverlies en misschien wel belangrijker: zonder dat de sd-kaart corrupt raakt.

De oplossing voor dat probleem is de PiJuice, een hat, of hardware attached on top, die op de gpio-pinnen van de Raspberry Pi kan worden gezet. Op de PiJuice kun je een accu aansluiten, die vervolgens de Pi van energie voorziet. Die accu kan tegelijk opladen en de Pi voeden. Bovendien kun je met de bijbehorende software ontzettend veel statistieken over de accu uitlezen, zoals de temperatuur en de spanning. Je kunt bij de PiJuice verschillende accu’s bestellen, maar standaard wordt hij voorzien van een Motorola BP7X-accu, die een capaciteit van 1820mAh bij een spanning van 3,7 volt heeft.

Er hangt dus via usb een externe harde schijf of usb-stick aan de Pi, er zit een accu op en vervolgens richten we de Pi in als accesspoint, zodat je er via je telefoon, tablet of laptop verbinding mee kunt maken. We willen dingen als acculading in de gaten kunnen houden. Daarnaast is het handig om te weten hoeveel ruimte er nog vrij is op de externe opslag en wat je ook alweer als ssid en wachtwoord had ingesteld. Daarom zetten we een tweede hat op de Pi, die voorzien is van een e-inkscherm. Het e-inkscherm dat we hebben besteld, is afkomstig van Waveshare en met twee tientjes valt de prijs mee.

Installeren

Het besturingssysteem dat we gebruiken, is Raspbian, een variant van Debian Linux die door de Raspberry Pi Foundation speciaal voor de Pi is gemaakt. Er zijn verschillende versies van de distro, waaronder een met een grafische omgeving. Voor deze .build hebben we de grafische schil van het besturingssysteem niet nodig en kiezen we voor de versie die alleen met de commandline werkt.

We zouden twee Tweakers Magazines kunnen volschrijven over de vervolgstappen, zoals ssh aanzetten, de Pi als accesspoint instellen, de accusoftware configureren en het scherm aansturen, maar dat kan eenvoudiger. Mocht je deze .build ook willen bouwen, dan kun je de image met voorgeconfigureerde PiJuice- en e-inkschermsoftware downloaden.

Met behulp van bijvoorbeeld Etcher, ondersteund door macOS, Windows en Linux, kun je de image op een sd-kaart zetten. Daarna kun je je eigen draadloze opslag bouwen. Voordat we bestanden op de usb-opslag zetten, formatteren we de opslag met het exFAT-bestandssysteem. ExFAT is een modern bestandssysteem dat door Windows, macOS en Linux goed wordt ondersteund. Vervolgens steken we de opslag in de Pi en zetten we hem aan. Als de Pi is gestart en alles goed is verlopen, gaat het e-inkscherm knipperen en geeft het de status van de accu weer met daaronder de standaardinstellingen voor het ssid en wachtwoord. Als je er een usb-stick of externe harde schijf aanhangt, zie je ook de gebruikte en totale opslag. De usb-opslag, door Raspbian ‘sda1’ genoemd, wordt automatisch gemount in de map /mnt/usb/, maar er ontbreekt nog een protocol voor het delen van bestanden op de usb-opslag.

Ssh op de Pi is ingeschakeld en nadat je de image op de sd-kaart hebt gezet, kun je in Linux en macOS via de terminal of in Windows bijvoorbeeld via PuTTY inloggen op de Pi. Op dit moment is nog een ethernetaansluiting nodig voor de internetverbinding, want er moeten pakketten worden gedownload. De standaardgebruiker is ‘pi’, maar het standaardwachtwoord (raspberry) hebben we veranderd in ‘tweak123’. Als je draadloos via ssh verbindt, kun je de pi vinden op ip-adres 192.168.5.10. Als je inlogt, zie je het script draaien dat het e-inkscherm aanstuurt en dat kun je afbreken met ctrl+c, want eerst is het zaak om samba te installeren. Samba is een op vrijwel alle besturingssystemen ondersteund netwerkprotocol en is te installeren met de volgende commando’s:

Sudo apt-get update

Sudo apt-get install samba samba-common-bin

Tijdens de installatie verschijnt er een wizard over de WINS-instellingen, waar je ‘No’ kunt antwoorden. Vervolgens moet er een gedeelde map op de usb-opslag komen, die we in dit geval ‘share’ noemen, maar je kunt de map ook een andere naam geven:

Sudo mkdir -m 0777 /mnt/usb/pi_share

Samba moet natuurlijk wel weten welke map er gedeeld is en welke rechten eraan toegekend mogen worden. Daarom bewerken we de config-file:

Sudo nano /etc/samba/smb.conf

Onderaan moeten de volgende regels worden toegevoegd:

[pi_share]
Comment = Pishare
Path = /mnt/usb/pi_share
Browseable = yes
Writeable = yes
Only guest = no
Create mask = 0777
Directory mask = 0777
Public = yes
Guest ok = yes

Iedereen die verbinding maakt met de Pi, kan nu bestanden op de usb-opslag lezen en schrijven. Mensen die als gast inloggen, worden ook toegestaan. Sla het config-bestand op met ctrl+x en vervolgens is het nog van belang om een wachtwoord voor samba in te stellen met:

Sudo smbpasswd -a pi

Tot slot herstart je de samba-service met:

Sudo service smbd restart

...en de gedeelde map met bestanden moet zichtbaar zijn zodra je verbinding maakt met het draadloze netwerk.

AFP

Samba werkt in principe met alle besturingssystemen, maar als je alleen Apple-hardware bezit, zou je in plaats van samba ook netatalk kunnen installeren, wat een opensource-implementatie van AFP, ofwel Apple Filing Protocol, is:

Sudo apt-get install netatalk

Als netatalk is geïnstalleerd, moet het nog geconfigureerd worden:

Sudo nano /etc/netatalk/afp.conf

De regels met puntkomma (;) worden genegeerd, dus voor [Global] en Global server settings kunnen die weggehaald worden. Daaronder kan de regel 'guest account = pi' worden toegevoegd. Vervolgens halen we de ; weg bij [My AFP Volume] en geven dat een eigen naam. Het path veranderen we in het pad van de share. In dit geval gebruiken we dezelfde map als in het voorbeeld bij de configuratie van smb: /mnt/usb/pi_share. Als die map nog niet bestaat, is hij aan te maken met:

Sudo mkdir -m 0777 /mnt/usb/pi_share

Om netatalk met de nieuwe instellingen te starten, gebruiken we:

Sudo systemctl restart netatalk

In de Finder is de Raspberry Pi nu vindbaar en kan hij worden benaderd met dezelfde gebruikersnaam-wachtwoordcombinatie als die van de Pi.

Accesspoint configureren

Het accesspoint is standaard geconfigureerd op 802.11ac en om bijvoorbeeld video’s te streamen, is dat ook aan te raden, maar sommige oudere netwerkapparatuur ondersteunt het niet en dan zit er niets anders op dan 802.11n in te schakelen. Dan gaat de snelheid wel omlaag, van 10 naar ongeveer 5,5MB/s, maar dat is in principe genoeg om films en muziek te streamen als de bitrate niet te hoog is. Wisselen naar 802.11n gaat door het hostapd.conf-bestand aan te passen:

Sudo nano /etc/hostapd/hostapd.conf

Door ‘hw_mode=a’ te veranderen in ‘hw_mode=g’ en vervolgens ‘wmm_enabled=1’ te veranderen in ‘wmm_enabled=0’ werkt de Pi in 802.11n-modus. Vervolgens is het van belang om de comment (‘#’) weg te halen voor ‘channel=7’ en een comment te plaatsen voor ‘channel=36’ en voor ‘ieee80211ac=1’. In hostapd.conf kun je ook de naam van het draadloze netwerk en het wachtwoord aanpassen in de regels ‘ssid=’ en ‘wpa_passphrase=’. Als alles goed is ingesteld, kun je opslaan met ctrl+x en vervolgens moet de hostapd-service opnieuw worden gestart met:

Sudo systemctl restart hostapd.service

Aan de instellingen van de PiJuice hebben we weinig veranderd. Als je de bijgeleverde BP7X-accu gebruikt en de dipswitches op de onderkant van de PiJuice goed staan (1 on, 2 off), maakt de PiJuice gebruik van een vooringesteld profiel voor die accu. De software kun je starten met behulp van:

Pijuice_cli

In de software kun je de status van de accu bekijken, maar ook de knoppen op de PiJuice instellen en bijvoorbeeld instellen wat de leds doen. Voor dit project is het belangrijkste dat de Pi netjes afsluit als de accu begint leeg te raken, want als dat niet gebeurt, loop je het risico op dataverlies of een corrupte sd-kaart. In het menu ‘System Task’ hebben we de minimale lading van de accu op vijf procent gezet en vervolgens bij het menu ‘System Events’ ingeschakeld dat de PiJuice bij dat percentage de Pi uitschakelt.

Voor het opladen van de accu kun je een usb-voeding gebruiken die sterk genoeg is en daarvoor zouden we een adapter gebruiken die minstens 2A bij 5V kan leveren, zodat de accu geladen kan worden terwijl de Pi is ingeschakeld. Als je echter compleet draadloos wilt werken, is het leukste natuurlijk om een zonnepaneel te gebruiken, zodat een adapter niet nodig is. Kies je voor een zonnepaneel, dan is het wel belangrijk om er een te kopen van goede kwaliteit en die zijn over het algemeen niet goedkoop.

Wij hebben wel een goedkoop zonnepaneel besteld, voor vijftien euro uit China, dat volgens de verkoper 20W kan leveren. Dat leek op voorhand veel, maar als het geleverde vermogen op een kwart daarvan zou uitkomen, waren we al tevreden geweest. Dat bleek niet het geval, want recht in de volle zon komt er een stroom van 0,7A uit het paneel bij een spanning van ongeveer 4,4V. Dat is iets meer dan een watt of drie. Vervelender is dat de spanning zo laag is dat de PiJuice moeite heeft met opladen, vooral als de spanning nog verder inzakt als er een wolk voor de zon komt. Een paneel dat wel netjes 5W bij een spanning van 5V levert, moet genoeg zijn om de Pi continu van energie te voorzien. Afhankelijk van het gebruik is de accuduur namelijk een uur of anderhalf en de accu heeft een capaciteit van 6,7Wh. Gemiddeld wordt dus 4,5W verstookt en daarbij zou een zonnepaneel van 5W volstaan.

Het e-inkscherm aansturen

De grootste uitdaging voor een Tweakers-redacteur zonder programmeerervaring bleek het aansturen van het e-inkscherm te zijn. Op de site van de maker, waveshare.com, staan gelukkig de documentatie en voorbeeldcode, in Python, om ermee aan de slag te kunnen. Daarvoor moet de spi-interface van de Pi eerst worden ingeschakeld en zijn er nog wat pakketten en een lettertype nodig om het e-inkscherm daadwerkelijk iets te laten weergeven. In de eerder genoemde image zijn alle pakketten echter geïntegreerd. Met hulp van een programmeur hebben we vervolgens een scriptje gebouwd dat te vinden is in /home/pi/epaper/nieuw.py. Het script leest de PiJuice uit en toont vervolgens op het scherm wat de status van de accu is, of die wordt opgeladen of niet, wat de spanning is en wat het accupercentage is. Daarnaast zoekt het script in het hostapd.conf-bestand naar de ingestelde ssid en het bijbehorende wachtwoord, en geeft het weer op het scherm. Met behulp van shutil kijkt het script naar de gebruikte en de totale ruimte in de map /mnt/usb, waar de usb-opslag gemount is.

#!/usr/bin/python
# -*- coding:utf-8 -*-

import epd2in7b
import time
from PIL import Image,ImageDraw,ImageFont
from pijuice import PiJuice
import traceback
import psutil
import re
import os
import RPi.GPIO as GPIO


# Configuration constants
BYTE_SCALE = 'GB' # GB or TB
DISK_USAGE_PATH = '/mnt/usb'
APCFG_PATH = '/etc/hostapd/hostapd.conf'

key1 = 5
key2 = 6
key3 = 13
key4 = 19

GPIO.setmode(GPIO.BCM)

GPIO.setup(key1, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key2, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key3, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(key4, GPIO.IN, pull_up_down=GPIO.PUD_UP)

def get_ap_ssid():
    # Open het configuratiebestand en lees het hele bestand in variabel cfg
    file = open(APCFG_PATH, 'r') 
    cfg = file.read()
    file.close()

    # Zoek het SSID op middels een regular expression
    result = re.search("ssid=(.*)", cfg)
    return result.group(1)


def get_ap_passphrase():
    # Open het configuratiebestand en lees het hele bestand in variabel cfg
    file = open(APCFG_PATH, 'r') 
    cfg = file.read()
    file.close()

    # Zoek het SSID op middels een regular expression
    result = re.search("wpa_passphrase=(.*)", cfg)
    return result.group(1)

def get_battery_status():
    #Instantiate PiJuice interface object
    pijuice = PiJuice(1, 0x14) 

    juicestat = pijuice.status.GetStatus()
    batterystatus = juicestat['data']['battery']

    if batterystatus == 'CHARGING_FROM_IN' or batterystatus == 'CHARGING_FROM_5V_IO':
        return 'Charging'
    if batterystatus == 'NORMAL':
        return 'Discharging'
    if batterystatus == 'NOT_PRESENT':
        return 'Battery not installed';

def get_disk_usage():
    if BYTE_SCALE == 'GB':
        byte_exponent = 3
    else:
        byte_exponent = 4

    disk_usage = psutil.disk_usage(DISK_USAGE_PATH)
    used = str(round(disk_usage.used / 1024 ** byte_exponent, 1))
    total = str(round(disk_usage.total / 1024 ** byte_exponent, 1))

    return used + "/" + total + " " + BYTE_SCALE

def update_epaper():
    try:
        epd = epd2in7b.EPD()
        epd.init()
        #print("Clear...")
        #epd.Clear(0xFF)
        

        # Drawing on the Horizontal image
        HBlackimage = Image.new('1', (epd2in7b.EPD_HEIGHT, epd2in7b.EPD_WIDTH), 255)  # 298*126
        HRedimage = Image.new('1', (epd2in7b.EPD_HEIGHT, epd2in7b.EPD_WIDTH), 255)  # 298*126    
        
        # Horizontal
        print("Drawing")
        
        drawblack = ImageDraw.Draw(HBlackimage)
        drawred = ImageDraw.Draw(HRedimage)
        font24 = ImageFont.truetype('/usr/share/fonts/truetype/wqy/wqy-microhei.ttc', 19)
        
        pijuice = PiJuice(1, 0x14) # Instantiate PiJuice interface object

        volt = pijuice.status.GetBatteryVoltage()
        volt = volt['data']
          
        batperc = pijuice.status.GetChargeLevel()
        batperc = batperc['data']

        batstat = get_battery_status()

        
                  

        drawblack.text((10, 21), str(batstat), font = font24, fill = 0)
        drawred.text((10, 46), "Voltage", font = font24, fill = 0)
        drawblack.text((130, 46), str(volt), font = font24, fill = 0)
        drawblack.text((175,46),"mv", font= font24, fill = 0)
        drawred.text((10,71), "Charge", font = font24, fill = 0)
        drawblack.text((130,71), str(batperc), font = font24, fill = 0)
        drawblack.text((150,71), "%", font = font24, fill = 0)
        drawred.text((10,96),"SSID", font = font24, fill = 0)
        drawblack.text((130,96), str(get_ap_ssid()), font = font24, fill = 0)
        drawred.text ((10,121), "Password", font = font24, fill = 0)
        drawblack.text((130,121), str(get_ap_passphrase()), font = font24, fill = 0)
        drawred.text((10,146), "Disk use", font = font24, fill = 0)
        drawblack.text((130,146), str(get_disk_usage()), font = font24, fill = 0)
       
        
        
        epd.display(epd.getbuffer(HBlackimage), epd.getbuffer(HRedimage))
        #time.sleep(2)


        
        epd.sleep()
            
    except :
        print ('traceback.format_exc():\n%s',traceback.format_exc())
        exit()

update_epaper()

while True:
    key1state = GPIO.input(key1)
    key2state = GPIO.input(key2)
    key3state = GPIO.input(key3)
    key4state = GPIO.input(key4)
        
    if key1state == False:
        update_epaper()
        time.sleep(0.2)
    if key2state == False:
        os.system("sudo shutdown now")
        time.sleep(0.2)

Het script wordt samen met Raspbian gestart en ververst één keer bij het starten het e-inkscherm. Vervolgens blijft het actief, want we hebben ook twee van de knoppen links van het scherm ingesteld. De bovenste knop, key1, is om te kijken wat de actuele status van de hardware is en ververst het scherm. De tweede knop, key2, sluit het systeem af en unmount daarbij netjes de externe opslag, zodat je geen data kwijtraakt.

Behuizing

Tot slot heeft een projectje als dit natuurlijk een behuizing nodig, want we zijn zuinig op onze hardware. Collega Willem heeft daarom een behuizinkje ontworpen waar het e-inkscherm boven op ligt, zodat je goed bij de knoppen kunt. Aan de zijkant zit de knop om de PiJuice aan te zetten, waardoor het hele systeem gaat draaien. Als je die knop enkele seconden indrukt, sluit de Pi ook netjes af. Heb je een 3d-printer en wil je de behuizing printen, dan staat het ontwerp op Thingiverse.

Tot zover is onze Pi af, maar we hebben ideeën genoeg om het project uit te breiden. Zo kun je er met een 4g-modem eraan een router met ingebouwde fileserver van maken, bijvoorbeeld om met vakantie te gebruiken. Met een externe draadloze netwerkkaart kunnen de snelheden waarschijnlijk nog wel wat omhoog en een Pi 4 in plaats van deze 3B+ moet ook sneller zijn. Je kunt hem ook bijvoorbeeld in je auto inbouwen, zodat passagiers media op hun smartphone kunnen streamen, of hem thuis neerzetten en als fileservertje gebruiken, maar dan wel gewoon met de ethernetaansluiting.