Shutdown Headless Raspberry Pi (English)


Ready4Prod

A modern operating system does not like being turned off on a dime, that is to say, being turned off before being shut down. For computers with a graphic interface this is as easy as pressing the right button. However, if a computer doesn’t have a screen or a mouse, like a Raspberry Pi (RPi) working as a server hidden away in a dark corner, this offers some difficulty. The only way to shut it down is by logging in through SSH and running the “shutdown -h now” command.

Een Nederlandse vertaling vindt u hier.

In this post I will explain a way to use software, two buttons, four resistors and one LED to shutdown or reset the RPi neatly.

For this project I will use two General Purpose Input/Output (GPIO) ports on the RPi. These ports can be programmed as either Input ór an Outpot port. The RPi has several of these ports. These are found on the P1 connector, but there are also four ports on the Rev2 board at the P5 connector. The P5 connector needs to be soldered to the RPi. Because I plan on using the P1 connector for other purposes, I have chosen to use the P5 connector. If you want to use another port, you can change the software to select which GPIO port you want to use.

RaspberryPi

On the Rev2 boards of the RPi there is space for a connector which can be used to reset the RPi or to start the RPi after a “shutdown -h now” command. To do this, you need to solder a P6 connector on the RPi. By making pin 1 (the square on the illustration) “low” (connecting it with earth) the RPi will boot again.


GPIO_IN

There are two ways to connect a switch to a GPIO defined as an input. In the example on the left the rest state for a GPIO port is set to “high” (+3V3). This is because the 10K ohm resistor draws the port to +3V3 (called a Pull-Up resistance). When the switch is pushed, the port changes to “low” (GND). The extra resistor in serie with the GPIO is not necessary, but it prevents a GPIO port which is defined as an output from burning down.

In the example on the right the rest state of the GPIO port is set to “low” (or GND, 0V). This is because of the resistor of 10K ohm pulls the port to GND (this is called the Pull-Down resistor). When the switch is pressed, the port becomes “high” (+3V3). In this example the extra resistor helps as a security barrier in case the port is defined as Output.


Schema01
The schematic on the left shows how the RPi, with the use of some software, can be shutdown neatly. For me, the label “DO NOT PRESS” makes me curious to do the opposite. That is why I linked the reset button in series with the shutdown button and set the GPIO-Input in rest state to “high”. Pin 1 of P6 becomes “low” only when both buttons are pushed at the same time.

Because you don’t want the RPi to shutdown when the button is pushed by accident, this command is triggered at a delay which can be changed with the software (standard is between four and six seconds).

Test01a

When testing these schematics I noticed that the lack of feedback is not helpful. By adding a LED –which is triggered via software– in to the chain it becomes possible to see the current state of the program. When software is running the LED flashes once every two seconds. When the shutdown button is pressed, the frequency changes to four times per second. When the LED start to emit constant, the shutdown command is executed.


This is the definitive schematic:
Complete Schematic

I soldered the different components onto a PCB-board in such a way that the print falls exactly over the pins of P5 and P6.

Proto01b Proto01a

Ready2Test2 Ready2Test1

This is the code to control the GPIO port’s:

#!/bin/sh
#-----------------------#
#    GPIOshutdown.sh    # 
#-----------------------#
BASENAME=`basename ${0}`
PIDFILE="/var/run/${BASENAME%.sh}.pid"
if [ -f ${PIDFILE} ]; then
    echo "${BASENAME} allready running..."
    exit
else
    echo ${$} > ${PIDFILE}
fi
#
# GPIO numbers should be from this list (P1)
# 0, 1, 4, 7, 8, 9, 10, 11, 14, 15, 17, 18, 21, 22, 23, 24, 25
#
# GPIO numbers should be from this list (P5)
# 29, 31
#
# Note that the GPIO numbers that you program here refer to the pins
# of the BCM2835 and *not* the numbers on the pin header. 
# So, if you want to activate GPIO7 on the header you should be 
# using GPIO4 in this script. Likewise if you want to activate GPIO0
# on the header you should be using GPIO17 here.
#
GPIO_IN=29        # Input - change it into the port you want to use
GPIO_LED=31       # Ouput - GPIO29 = P5-04, GPIO31 = P5-06
#
# Set up GPIO_IN and set to Input
echo "${GPIO_IN}" > /sys/class/gpio/export
echo "in" > /sys/class/gpio/gpio${GPIO_IN}/direction
#
# test of input hoog is, anders is er niets op
# deze GPIO_IN aangesloten...
I=0             
SW=`cat /sys/class/gpio/gpio${GPIO_IN}/value`
echo "value GPIO_${GPIO_IN} is [${SW}]"
while [ ${SW} -eq 0 ];
do
    I=$((I+1))
    if [ ${I} -gt 10 ]; then
        echo "..pfff"
        echo "GPIO_${GPIO_IN} niet aangesloten"
        rm -f ${PIDFILE}
        exit
    fi
    SW=`cat /sys/class/gpio/gpio${GPIO_IN}/value`
    echo -n "${I}"
    sleep 1
done
#
# Set up GPIO_LED and set to output
echo "${GPIO_LED}" > /sys/class/gpio/export
echo "out" > /sys/class/gpio/gpio${GPIO_LED}/direction
#
I=0        # Duur van de KeyPress (Ticks-Teller)
LED=0      # LED Aan=1, Uit=0
S=2        # Seconden sleep
while true
do
    sleep ${S}
    #
    if [ ${LED} -eq 1 ]; then
        echo "0" > /sys/class/gpio/gpio${GPIO_LED}/value
        LED=0
    else
        echo "1" > /sys/class/gpio/gpio${GPIO_LED}/value
        LED=1
    fi
    #
    SW=`cat /sys/class/gpio/gpio${GPIO_IN}/value`
    if [ ${SW} -eq 0 ]
    then
        I=$((I+1))    # Tel het aantal Ticks dat de Key is ingedrukt
        S=0.25        # KeyPress, dan 0.25 seconden sleep
        echo -n "${I}"
        if [ ${I} -gt 16 ]
        then
            echo "..."
            echo "Key pressed  for [${I}] ticks.."
            I=0
            echo "1" > /sys/class/gpio/gpio${GPIO_LED}/value
            # Clean up
            echo "${GPIO_IN}" > /sys/class/gpio/unexport
            echo "/sbin/shutdown -h now"    # Gebruik dit om te testen
#           /sbin/shutdown -h now           # Gebruik dit voor productie
            rm -f ${PIDFILE}                # Verwijder PID file
            sleep 5                         # Settle down..
            exit
        fi
    else
        I=0        # Toets is weer los gelaten, reset Ticks Teller
        S=2        # Sleep weer op 2 seconden zetten
    fi       
done
#
echo "0" > /sys/class/gpio/gpio${GPIO_LED}/value
#
# Clean up
echo "${GPIO_IN}" > /sys/class/gpio/unexport
#echo "${GPIO_LED}" > /sys/class/gpio/unexport
#
echo "Done...."
#

Paste this code in to “/usr/local/bin/GPIOshutdown.sh” and then
sudo chmod +x /usr/local/bin/GPIOshutdown.sh

To run the program automatically when the RPi starts you have several options. I like running the program as ‘daemon’. If you want to run the program as daemon as well, paste the following code into a file called “/etc/init.d/GPIOshutdown”:

#! /bin/sh
### BEGIN INIT INFO
# Provides:          GPIOshutdown
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: check if GPIO29 is low and shutdown the system
# Description:       check if GPIO29 is low and shutdown the system
#                    bla bla bla
### END INIT INFO

# Author: Willem Aandewiel (Willem@Aandewiel.nl)
#

# Do NOT "set -e"

# PATH should only include /usr/* if it runs after the mountnfs.sh script
PATH=/sbin:/usr/sbin:/bin:/usr/bin
DESC="check GPIO input for LOW and halt the system"
NAME=checkKeyPress
DAEMON=/usr/local/bin/${NAME}.sh
DAEMON_ARGS=""
PIDFILE=/var/run/$NAME.pid
SCRIPTNAME=/etc/init.d/$NAME

# Exit if the package is not installed
[ -x "$DAEMON" ] || exit 0

# Read configuration variable file if it is present
[ -r /etc/default/$NAME ] && . /etc/default/$NAME

# Load the VERBOSE setting and other rcS variables
. /lib/init/vars.sh

# Define LSB log_* functions.
# Depend on lsb-base (>= 3.2-14) to ensure that this file is present
# and status_of_proc is working.
. /lib/lsb/init-functions

#
# Function that starts the daemon/service
#
do_start()
{
    # Return
    #   0 if daemon has been started
    #   1 if daemon was already running
    #   2 if daemon could not be started
    start-stop-daemon --start --quiet --background --pidfile $PIDFILE --nicelevel 19 --exec $DAEMON --test > /dev/null \
        || return 1
    start-stop-daemon --start --quiet --background --pidfile $PIDFILE --nicelevel 19 --exec $DAEMON -- \
        || return 2
    # Add code here, if necessary, that waits for the process to be ready
    # to handle requests from services started subsequently which depend
    # on this one.  As a last resort, sleep for some time.
}

#
# Function that stops the daemon/service
#
do_stop()
{
    # Return
    #   0 if daemon has been stopped
    #   1 if daemon was already stopped
    #   2 if daemon could not be stopped
    #   other if a failure occurred
    start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --name $NAME
    RETVAL="$?"
    [ "$RETVAL" = 2 ] && return 2
    # Wait for children to finish too if this is a daemon that forks
    # and if the daemon is only ever run from this initscript.
    # If the above conditions are not satisfied then add some other code
    # that waits for the process to drop all resources that could be
    # needed by services started subsequently.  A last resort is to
    # sleep for some time.
    start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
    [ "$?" = 2 ] && return 2
    # Many daemons don't delete their pidfiles when they exit.
    rm -f $PIDFILE
    return "$RETVAL"
}

case "$1" in
  start)
    [ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME"
    do_start
    case "$?" in
        0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
        2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
    esac
    ;;
  stop)
    [ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
    do_stop
    case "$?" in
        0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
        2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
    esac
    ;;
  status)
    status_of_proc "$DAEMON" "$NAME" && exit 0 || exit $?
    ;;
  restart)
    #
    # If the "reload" option is implemented then remove the
    # 'force-reload' alias
    #
    log_daemon_msg "Restarting $DESC" "$NAME"
    do_stop
    case "$?" in
      0|1)
        do_start
        case "$?" in
            0) log_end_msg 0 ;;
            1) log_end_msg 1 ;; # Old process is still running
            *) log_end_msg 1 ;; # Failed to start
        esac
        ;;
      *)
        # Failed to stop
        log_end_msg 1
        ;;
    esac
    ;;
  *)
    echo "Usage: $SCRIPTNAME {start|stop|status|restart}" >&2
    exit 3
    ;;
esac
:

Don’t forget to
sudo chmod +x /etc/init.d/GPIOshutdown

To start the daemon type:
sudo /etc/init.d/GPIOshutdown start
The LED starts blinking.

To stop the daemon type the commando:
sudo /etc/init.d/GPIOshutdown stop
The LED turns off.

To start the daemon automatically with every reboot of RPi, you have to install the service with the command:
cd /etc/init.d
sudo insserv GPIOshutdown

Rest assured that the script does not take up too much of the available processor capacity. When the ‘sleep’ command is ran, it uses almost no processor time.

Please Note: the P5 connector is meant to be soldered to the bottom of the RPi. Because I found this inconvenient for this particular project, I soldered it to the top (component side). Because of this, the Pin numbers are in the wrong order. The squares on the RPi-board always mark pin 1.
I only used the even pin-numbers where the +3V3 is on the outside of the RPi.

P5_Header P1_Header

Test02a

Geplaatst in Computer, Scripts | Getagged | 1 reactie

Hurghada 2013

Vakantie 2013

Geplaatst in Geen categorie | 2 Reacties

Shutdown Headless Raspberry Pi


Ready4Prod

Een modern Operating System (OS) vindt het niet prettig als het niet netjes wordt afgesloten voordat de computer wordt uitgezet. Voor computers met een beeldscherm en toetsenbord is dat niet zo’n probleem. Bij een systeem met een grafische interface is het vaak zelfs een kwestie van “op de juiste knop klikken“.
Als de computer echter geen beeldscherm en/of toetsenbord heeft, zoals een Raspberry Pi (RPi) die als server ergens in een donker hoekje zijn ‘ding doet‘, wordt het een stuk lastiger. De enige manier is dan om met SSH in te loggen en het “shutdown -h now” (of gewoon het “halt”) commando in te toetsen.

Here you will find an English translation.

In deze post beschrijf ik een manier om met twee drukknopjes, vier weerstandjes, één LED en een stukje software, de RPi netjes af te sluiten of eventueel te resetten.

Voor dit ‘projectje‘ wordt gebruik gemaakt van twee General Purpose Input/Output (GPIO) poorten van de RPi. Dit zijn poorten die, via een softwarematige instelling, kunnen worden ingesteld als een Input óf als een Output poort. De RPi heeft een aantal van dit soort poorten. Deze bevinden zich op de P1 connector, maar er zitten er op het Rev.2 board ook vier (GPIO28, 29, 30 en 31) op de P5 connector. De P5 connector moet je dan zelf nog even op de RPi solderen. Omdat ik van plan ben de P1 connector nog voor andere uitbreidingen te gaan gebruiken heb ik ervoor gekozen om een connector op de P5 plek te solderen en die te gebruiken. Wil je dat niet doen dan moet je in de software aangeven welke GPIO poorten je wél wilt gebruiken.

RaspberryPi
Op de Rev.2 boards van de RPi is er ook plaats voor een connector waarmee de RPi ge-reset kan worden of waarmee hij, na een ‘shutdown -h now’ commando, weer gestart kan worden. Hiervoor moet een P6 connector op de RPi worden gesoldeerd. Door pin 1 (het ‘vierkante’ eilandje op het plaatje) ‘laag’ te maken (verbinden met ‘aarde’) zal de RPi opnieuw opstarten.


GPIO_IN

Er zijn twee manieren om een schakelaar op een als Input gedefinieerde GPIO poort aan te sluiten. In het linker voorbeeld hiernaast is de rust toestand van de gebruikte GPIO poort ‘hoog’ (oftewel +3.3V). Dit komt door de weerstand van 10K ohm die de poort naar +3.3V trekt (dit is een zgn. Pull-Up weerstand). Wordt op de schakelaar gedrukt, dan wordt de poort ‘laag’ (GND). De extra weerstand in serie met de GPIO poort is strikt genomen niet nodig, maar zorgt ervoor dat een, per ongeluk als Output poort gedefinieerde GPIO poort, niet direct de geest zal geven.
In het rechter voorbeeld is de rust toestand van de gebruikte GPIO poort ‘laag’ (oftewel GND, 0V). Dit komt door de weerstand van 10K ohm die de poort naar GND trekt (dit is een zgn. Pull-Down weerstand). Wordt op de schakelaar gedrukt, dan wordt de poort ‘hoog’ (+3.3V). Ook hier dient de extra weerstand in serie met de GPIO poort als extra beveiliging voor het geval deze als Output poort gedefinieerde is.


Schema01

Hiernaast het schema waarmee, met wat software, de RPi netjes kan worden afgesloten. Bij mij heeft de waarschuwing: “Pas op: Niet op deze knop drukken” altijd het effect dat ik juist wél op die knop wil drukken. Daarom heb ik de reset knop in serie met de Shutdown knop geschakeld en heb ik voor de GPIO-Input poort de “in rust ‘hoog’” variant gebruikt. Pin 1 van P6 wordt dan alleen ‘laag’ als de twee drukknoppen gelijktijdig worden ingedrukt.

Omdat je niet wilt dat de RPi bij het ‘per ongeluk indrukken‘ van de Shutdown knop direct het ‘Shutdown -h now’ commando uitvoert, wordt dit commando pas na het voor langere tijd ingedrukt houden van de knop uitgevoerd (in de software instelbaar, standaard tussen de vier en zes seconden).

Test01a

Tijdens het testen van deze schakeling merkte ik dat het ontbreken van feedback over het functioneren van de schakeling en de software niet prettig is. Door een LED, die door de software wordt aangestuurd, in de schakeling op te nemen is het mogelijk om te zien in welke toestand de software zich bevindt. In rust en als de software ‘loopt’ knippert de LED met een frequentie van 1 maal per twee seconden. Wordt de Shutdown knop ingedrukt, dan wordt de frequentie 4x per seconden. Is het Shutdown commando gegeven, dan brandt de LED constant.


Dit is het definitieve schema:
GPIOshutdown

Ik heb de onderdelen op een stukje experimenteer printplaat gesoldeerd (waarbij ik er achter kwam dat experimenteer printplaat met dubbelzijdige en door-gemetaliseerde eilandjes een stuk handiger werkt dan de enkelzijdige die ik gebruikt heb) waarbij het printje direct over de gebruikte rij pinnen van P5 en P6 valt.

Proto01b Proto01a

Ready2Test2 Ready2Test1

Dit is het programma om het één en ander aan te sturen:

#!/bin/sh
#-----------------------#
#    GPIOshutdown.sh    # 
#-----------------------#
BASENAME=`basename ${0}`
PIDFILE="/var/run/${BASENAME%.sh}.pid"
if [ -f ${PIDFILE} ]; then
    echo "${BASENAME} allready running..."
    exit
else
    echo ${$} > ${PIDFILE}
fi
#
# GPIO numbers should be from this list (P1)
# 0, 1, 4, 7, 8, 9, 10, 11, 14, 15, 17, 18, 21, 22, 23, 24, 25
#
# GPIO numbers should be from this list (P5)
# 29, 31
#
# Note that the GPIO numbers that you program here refer to the pins
# of the BCM2835 and *not* the numbers on the pin header. 
# So, if you want to activate GPIO7 on the header you should be 
# using GPIO4 in this script. Likewise if you want to activate GPIO0
# on the header you should be using GPIO17 here.
#
GPIO_IN=29        # Input - gebruik de poort die jij handig vindt
GPIO_LED=31       # Ouput - gebruik de poort die jij handig vindt
#
# Set up GPIO_IN and set to Input
echo "${GPIO_IN}" > /sys/class/gpio/export
echo "in" > /sys/class/gpio/gpio${GPIO_IN}/direction
#
# test of input hoog is, anders is er niets op
# deze GPIO_IN aangesloten...
I=0             
SW=`cat /sys/class/gpio/gpio${GPIO_IN}/value`
echo "value GPIO_${GPIO_IN} is [${SW}]"
while [ ${SW} -eq 0 ];
do
    I=$((I+1))
    if [ ${I} -gt 10 ]; then
        echo "..pfff"
        echo "GPIO_${GPIO_IN} niet aangesloten"
        rm -f ${PIDFILE}
        exit
    fi
    SW=`cat /sys/class/gpio/gpio${GPIO_IN}/value`
    echo -n "${I}"
    sleep 1
done
#
# Set up GPIO_LED and set to output
echo "${GPIO_LED}" > /sys/class/gpio/export
echo "out" > /sys/class/gpio/gpio${GPIO_LED}/direction
#
I=0        # Duur van de KeyPress (Ticks-Teller)
LED=0      # LED Aan=1, Uit=0
S=2        # Seconden sleep
while true
do
    sleep ${S}
    #
    if [ ${LED} -eq 1 ]; then
        echo "0" > /sys/class/gpio/gpio${GPIO_LED}/value
        LED=0
    else
        echo "1" > /sys/class/gpio/gpio${GPIO_LED}/value
        LED=1
    fi
    #
    SW=`cat /sys/class/gpio/gpio${GPIO_IN}/value`
    if [ ${SW} -eq 0 ]
    then
        I=$((I+1))    # Tel het aantal Ticks dat de Key is ingedrukt
        S=0.25        # KeyPress, dan 0.25 seconden sleep
        echo -n "${I}"
        if [ ${I} -gt 16 ]
        then
            echo "..."
            echo "Key pressed  for [${I}] ticks.."
            I=0
            echo "1" > /sys/class/gpio/gpio${GPIO_LED}/value
            # Clean up
            echo "${GPIO_IN}" > /sys/class/gpio/unexport
            echo "/sbin/shutdown -h now"    # Gebruik dit om te testen
#           /sbin/shutdown -h now           # Gebruik dit voor productie
            rm -f ${PIDFILE}                # Verwijder PID file
            sleep 5                         # Settle down..
            exit
        fi
    else
        I=0        # Toets is weer los gelaten, reset Ticks Teller
        S=2        # Sleep weer op 2 seconden zetten
    fi       
done
#
echo "0" > /sys/class/gpio/gpio${GPIO_LED}/value
#
# Clean up
echo "${GPIO_IN}" > /sys/class/gpio/unexport
#echo "${GPIO_LED}" > /sys/class/gpio/unexport
#
echo "Done...."
#

Plaats deze code in “/usr/local/bin/GPIOshutdown.sh” en maak het executable:
sudo chmod +x /usr/local/bin/GPIOshutdown.sh

Om het programma automatisch te starten bij het opstarten van je RPi zijn er verschillende mogelijkheden. Ik vind het prettig om het programma als ‘daemon’ te draaien. Wil je dat ook, dan moet je de volgende code in “/etc/init.d/GPIOshutdown” zetten:

#! /bin/sh
### BEGIN INIT INFO
# Provides:          GPIOshutdown
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: check if GPIO29 is low and shutdown the system
# Description:       check if GPIO29 is low and shutdown the system
#                    bla bla bla
### END INIT INFO

# Author: Willem Aandewiel (Willem@Aandewiel.nl)
#

# Do NOT "set -e"

# PATH should only include /usr/* if it runs after the mountnfs.sh script
PATH=/sbin:/usr/sbin:/bin:/usr/bin
DESC="check GPIO input for LOW and halt the system"
NAME=checkKeyPress
DAEMON=/usr/local/bin/${NAME}.sh
DAEMON_ARGS=""
PIDFILE=/var/run/$NAME.pid
SCRIPTNAME=/etc/init.d/$NAME

# Exit if the package is not installed
[ -x "$DAEMON" ] || exit 0

# Read configuration variable file if it is present
[ -r /etc/default/$NAME ] && . /etc/default/$NAME

# Load the VERBOSE setting and other rcS variables
. /lib/init/vars.sh

# Define LSB log_* functions.
# Depend on lsb-base (>= 3.2-14) to ensure that this file is present
# and status_of_proc is working.
. /lib/lsb/init-functions

#
# Function that starts the daemon/service
#
do_start()
{
    # Return
    #   0 if daemon has been started
    #   1 if daemon was already running
    #   2 if daemon could not be started
    start-stop-daemon --start --quiet --background --pidfile $PIDFILE --nicelevel 19 --exec $DAEMON --test > /dev/null \
        || return 1
    start-stop-daemon --start --quiet --background --pidfile $PIDFILE --nicelevel 19 --exec $DAEMON -- \
        || return 2
    # Add code here, if necessary, that waits for the process to be ready
    # to handle requests from services started subsequently which depend
    # on this one.  As a last resort, sleep for some time.
}

#
# Function that stops the daemon/service
#
do_stop()
{
    # Return
    #   0 if daemon has been stopped
    #   1 if daemon was already stopped
    #   2 if daemon could not be stopped
    #   other if a failure occurred
    start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --name $NAME
    RETVAL="$?"
    [ "$RETVAL" = 2 ] && return 2
    # Wait for children to finish too if this is a daemon that forks
    # and if the daemon is only ever run from this initscript.
    # If the above conditions are not satisfied then add some other code
    # that waits for the process to drop all resources that could be
    # needed by services started subsequently.  A last resort is to
    # sleep for some time.
    start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
    [ "$?" = 2 ] && return 2
    # Many daemons don't delete their pidfiles when they exit.
    rm -f $PIDFILE
    return "$RETVAL"
}

case "$1" in
  start)
    [ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME"
    do_start
    case "$?" in
        0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
        2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
    esac
    ;;
  stop)
    [ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
    do_stop
    case "$?" in
        0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
        2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
    esac
    ;;
  status)
    status_of_proc "$DAEMON" "$NAME" && exit 0 || exit $?
    ;;
  restart)
    #
    # If the "reload" option is implemented then remove the
    # 'force-reload' alias
    #
    log_daemon_msg "Restarting $DESC" "$NAME"
    do_stop
    case "$?" in
      0|1)
        do_start
        case "$?" in
            0) log_end_msg 0 ;;
            1) log_end_msg 1 ;; # Old process is still running
            *) log_end_msg 1 ;; # Failed to start
        esac
        ;;
      *)
        # Failed to stop
        log_end_msg 1
        ;;
    esac
    ;;
  *)
    echo "Usage: $SCRIPTNAME {start|stop|status|restart}" >&2
    exit 3
    ;;
esac
:

Vergeet niet dit bestand execute rechten te geven:
sudo chmod +x /etc/init.d/GPIOshutdown
Om de daemon te starten tik je in:
sudo /etc/init.d/GPIOshutdown start
De LED zal nu met een frequentie van 0.5Hz gaan knipperen. Als je de Shutdown knop indrukt dan zal binnen twee seconden de LED met een frequentie van 4Hz gaan knipperen. Laat je de knop binnen vier seconden weer los, dan gaat de LED weer met 0.5Hz knipperen en blijft de RPi ‘draaien’. Hou de de Shutdown knop lang genoeg ingedrukt, tot de LED continu gaat branden, dan wordt de RPi netjes afgesloten (uiteindelijk blijft er nog slechts één intern LEDje op de RPi branden).
Als je de beide knoppen tegelijkertijd even indrukt, zal de RPi weer opstarten en zal, als je de service goed hebt geïnstalleerd de LED weer gaan knipperen.
Let op: Druk je beide knoppen gelijk in terwijl de RPi gewoon draait, dan Reset de RPi zichzelf.

Je kunt de daemon stoppen met het commando:
sudo /etc/init.d/GPIOshutdown stop
De LED gaat nu uit.

Om de daemon automatisch te starten bij iedere reboot van de RPi moet je de service installeren met het commando:
cd /etc/init.d
sudo insserv GPIOshutdown

Wees niet bang dat dit script teveel tijd van je beperk aanwezige processor capaciteit op slokt. Het ‘sleep’ commando gebruikt nagenoeg geen processor tijd!


Let op: de P5 connector is bedoeld om aan de onderkant van de RPi te solderen. Omdat ik dat voor dit project niet handig vind heb ik hem aan de bovenkant (component side) gesoldeerd. Hierdoor is de pin-nummering echter omgedraaid. De vierkante eilandjes op de printplaat geven altijd pin 1 aan. Ik heb alleen de even pin-nummers gebruikt waarbij de +3.3v aan de buitenkant van de RPi zit!

P5_Header P1_Header

Test02a

Geplaatst in Computer | Een reactie plaatsen

Einduitslag MARATHON van ALMERE (1998)

Ooit (3 mei 1998) heb ik mee gelopen in de Marathon van Almere. Niet helemaal, het korte, 10 kilometer parcours.

Hieronder vindt u de uitslag (ingekort) van de 10 kilometer loop.

Plaats  Tijd   Naam, vereniging, woonplaats                     Trim Catag Pts  
                                                                                
     1 0:29:40 Jackson Omweri, Kenia                                 Senio   1  
     2 0:29:49 Berthold Berger, START '78,                           Senio   2  
     3 0:29:57 Edo Baart, P.H.VUCHT, Diemen                          Senio   3  
     4 0:30:02 Robert Smits, ARGO '77,                               Senio   4  
     5 0:31:12 Jan Kortekaas, LEIDEN ATLETIEK, Roelofarendsveen      Senio   5  

   167 0:52:57 P. Baartscheer, Almere                           Recr        99  
   168 0:53:02 N. V.D. Klaauw, LRRC, Alphen a.d. Rijn           Recr       100  
   169 0:53:19 Pieter Aandewiel, Almere                         Recr       101 
   170 0:53:21 R. Gudde, Almere                                 Recr       102  
   171 0:53:21 R.A.J. Pappot, V.B.A., Almere                         Bussn  43  

   276 1:07:33 Edwin Rovekamp, E&S SPORTIEF, Almere                  Bussn  65  
   277 1:08:21 Geertje Schmidt, Almere                          Dame        52  
   278 1:08:36 Trineke Koelman, Almere                          Dame        53  
   279 1:09:42 Willem Aandewiel, Almere                         Recr       145  
   280 1:10:08 Elsabe Kalsbeek, Amsterdam                       Dame        54 

Er deden 280 lopers mee.
Wat ik me nog kan herinneren is dat Elsabe Kalsbeek behoorlijk zwanger was…

Geplaatst in Van Alles | Een reactie plaatsen

Piet Aandewiel (1892 – 1979)

piet-aandewiel
Mijn grootvader. Precies zoals ik mij hem herinner.



Lees verder

Geplaatst in Geen categorie, Van Alles | Getagged , | 3 Reacties

Raspberry PI met WordPress

WPlogo   RPi_Logo

In mijn post Raspberry PI inrichten als webserver heb ik beschreven hoe je de raspberry pi (RPi) moet inrichten met een webserver (lighttpd). In deze post beschrijf ik stap-voor-stap wat je moet doen om WordPress op je RPi te installeren.
Lees verder

Geplaatst in Computer, Scripts | Getagged , , , | 8 Reacties

Raspberry PI inrichten als webserver

RPi_Logo De raspberry pi is een creditcard formaat computer systeem. De ontwikkeling heeft vooral in het teken gestaan van “compleet, goed en zo goedkoop mogelijk“. Het resultaat is een complete computer voor rond de € 40,- met een SDHC memory kaartje als opslag (in plaats van een harde schijf).

RPi
Deze computer is uitstekend te gebruiken als privé webserver voor bijvoorbeeld een Blog. Uiteraard kan deze computer geen high-volume websites hosten. Daar zijn de specificaties (ARM11 @700Mhz) gewoon te beperkt voor. Al vanaf het begin is de raspberry pi een lieveling van de Linux gemeenschap. Er zijn verschillende Linux distributies geschikt gemaakt voor dit creditcard computertje.
Lees verder

Geplaatst in Computer, Nodo, Scripts | Getagged , , , , , , , , | 30 Reacties

Raspberry PI inrichten met Postfix

postfixDeze handleiding beschrijft hoe je postfix op de rapsberry pi moet installeren en wat er daarna aan de ‘standaard’ configuratie van postfix moet veranderen om de gmail SMTP-server te gebruikt om berichten van de Raspberry over het internet te versturen. Deze handleiding is een vervolg op Raspberry PI inrichten als webserver.
Lees verder

Geplaatst in Computer, Nodo, Scripts | Getagged , , , | 2 Reacties

Raspberry PI voor de Nodo webapp

Nodo-Domotica is, volgens eigen zegge, een initiatief van hobbyisten voor hobbyisten met als doel om rond een Arduino board hard- en software te ontwikkelen waarmee Domotica (Home Automation?) kan worden gerealiseerd. Ze doen dit door Klik-Aan-Klik-Uit schakelaars aan te sturen (maar daarnaast ook nog heel veel andere devices). Kijk vooral op hun website als je hier ook interesse in hebt (maar let op, de structuur van de websites (forum, wiki) is soms ondoorgrondelijk. Een beet onderzoek-drang helpt)!

MyNodo1 Ik kwam in augustus 2012 per ongeluk op hun website en werd meteen gegrepen door de eenvoud van de hardware en de kwaliteit van de software. Ik had al wat ervaring met het werken met Arduino boardjes maar dit is voor de thuis knutselaar echt een hard- en software-project(je) om je handen bij af te likken.

Lees verder

Geplaatst in Computer, Nodo | Getagged , , | 1 reactie

Het Wederweerzien

Thera was blij dat het de afgelopen dagen wat warmer was geworden, ze kon nu eigenlijk nog net niet met blote benen s’avonds de deur uit, maar ze deed het toch – ze droeg tenslotte altijd minder kleren dan gebruikelijk was bij het weertype. Het zwarte jurkje zat strak om haar lichaam en bedekte haar armen. Zwart stond haar prachtig, vond Thera: het kleurde haar huid nog bruiner en haar haar nog blonder. Ze droeg weinig make-up en trok een gekleurd vestje over haar jurk om zichzelf een beetje warm te houden om de fiets.

Lees verder

Geplaatst in Verhaaltjes | Getagged , , , , | Reageren uitgeschakeld