Mein derzeitiger Ansatz ist daher die automatisierte Nutzung von caffinate. Dabei wird das folgende Skript im Hintergrund ausgeführt und prüft, ob aktuell eine Citrix-Verbindung besteht. Wenn ja, wird der Schlafmodus deaktiviert indem caffinate gestartet wird. Besteht keine Citrix-Verbindung oder wurde diese in der Zwischenzeit beendet, wird der Schlafmodus wieder deaktiviert indem der caffinate-Prozess beendet wird.

#!/usr/bin/env bash

# Log-Datei für Debugging
LOG_FILE="/tmp/citrix_energy.log"
exec >> "$LOG_FILE" 2>&1

# Funktion: Schlafmodus deaktivieren
disable_sleep() {
    echo "$(date) | Deaktiviere Schlafmodus (Citrix läuft)" >> "$LOG_FILE"
    caffeinate -dims &
    CAFFEINATE_PID=$!
    echo "Caffeinate PID: $CAFFEINATE_PID" >> "$LOG_FILE"
}

# Funktion: Schlafmodus wieder aktivieren
enable_sleep() {
    echo "$(date) | Aktiviere Schlafmodus (Citrix beendet)" >> "$LOG_FILE"
    if kill "$CAFFEINATE_PID" 2>/dev/null; then
        echo "Caffeinate ($CAFFEINATE_PID) beendet" >> "$LOG_FILE"
    else
        echo "Fehler: Caffeinate-Prozess nicht gefunden" >> "$LOG_FILE"
    fi
}

# Hauptschleife
LAST_STATE=false
while true; do
    # Prüfe, ob Citrix Viewer läuft
    if pgrep -xq 'Citrix Viewer'; then
        CURRENT_STATE=true
        if [ "$LAST_STATE" = false ]; then
            disable_sleep
        fi
    else
        CURRENT_STATE=false
        if [ "$LAST_STATE" = true ]; then
            enable_sleep
        fi
    fi
    LAST_STATE=$CURRENT_STATE
    sleep 10  # Prüfe alle 10 Sekunden
done

Zusätzlich, wenn man das Ganze automatisch im Hintergrund starten möchte, müssten wir noch ein Iten für den LaunchAgent unter ~/Library/LaunchAgents/com.user.citrixenergy.plist einrichten.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.citrixenergy</string>

    <key>ProgramArguments</key>
    <array>
      <string>/Users/user/bin/citrix_energymanager.sh</string>
    </array>

    <key>RunAtLoad</key>
    <true/> <!-- Startet beim Login -->

    <key>KeepAlive</key>
    <true/> <!-- Startet neu, falls das Skript crasht -->

    <key>StandardOutPath</key>
    <string>/tmp/citrix_energy.log</string>
    <key>StandardErrorPath</key>
    <string>/tmp/citrix_energy_error.log</string>
</dict>
</plist>

Irgendwann sah ich dann so etwas:

unknown terminal "xterm-ghostty"

Und siehe da, Ghostty setzt die Variable $TERM nun anders (!? ist mir eventuell vorher nicht aufgefallen !?). Steht auch zusammen mit einigen Workarounds in der Doku 😀.

Alternativ kann man auch das Folgende machen:

if [[ "$TERM" =~ "ghostty" ]]; then
    export TERM=xterm-256color
fi

In den drei Zeilen wird geschaut, ob die Variable $TERM “ghostty” enthält und falls ja, wird diese durch xterm-256color überschrieben. Das Ganze kann man sich in seine .bashrc oder .zshrc packen.

Send testmails

gitlab-rails console
# on rails console:
Notify.test_email('you@example.com', 'Message Subject', 'Message Body').deliver_now

Reset you initial root password

gitlab-rake "gitlab:password:reset[root]"

Solve Error 500 when (changing application settings)

gitlab-psql -d gitlabhq_production
# on PSQL-Shell 
DELETE FROM application_settings;

Linux

Linux Terminal key combinations

Kubernetes

Working with container registries

Get all available container images

curl --insecure -s -X GET -u user:pass https://container-registry:5000/v2/_catalog | jq
{
  "repositories": [
    "alpine-base",
    "alpine_base",
    "alpine_base_apache",
    "alpine_base_tomcat",
    "alpine_base_wildfly",
    "alpine_dimag_ingestlist",
    "alpine_dimag_ipm",
    "alpine_dimag_km"
  ]
}

Get al available tag of a container image

 curl -s --insecure -X GET -u user:pass https://container-registry:5000/v2/alpine_base_apache/tags/list | jq
 {
  "name": "alpine_base_apache",
  "tags": [
    "latest",
    "php82"
  ]
}

from hashlib import sha256

names = ['dragonite', 'fidough', 'fuecoco', 'gyarados', 'munchlax', 'bellibolt', 'greavard', 'charmeleon',
         'charmander', 'bulbasaur', 'charizard', 'blastoise', 'ivysaur', 'pawmi', 'pichu', 'pikachu', 'quaxly',
         'smoliv', 'raichu', 'sprigatito', 'squirtle', 'venusaur', 'wartortle']

for name in names:
    hsh = sha256(name.encode('utf-8')).hexdigest()
    print(f'{name: <{10}} | https://pokemon.actimel.de/welcome?scan={hsh}')

This results in the following:

Have fun 😉.

Kontrolle über S6 Services in Containern. S6-SVC Doku

Wass ist Chat-GPT eigentlich und warum funktioniert es überhaupt? Stephen Wolfram

Momentan arbeite ich als Fullstack JAVA-Entwickler im DIMAG-Verbund.

Technologien

In den letzten Zeit habe ich mich mit folgenden Technilogien auseinandergesetzt:

• Kubernetes (K3s und OpenShift)
• Containerisierung mit Podman und Docker
• Virtualisierung mit Proxmox und Hyper-V
• Automatisierung mit Ansible

Programmiersprachen

• JAVA
• Python
• Go(lang)

sudo mv AtmelICE.kext /Library/Extensions/
sudo chown -R root:wheel /Library/Extensions/AtmelICE.kext
sudo chmod -R 755 /Library/Extensions/AtmelICE.kext
sudo kextload /Library/Extensions/AtmelICE.kext

Disconnect and reconnect your device, and it should be ready to use. For simple testing the device communication I used avrdude to talk to the device. Choose the correct programmer interface is essential for this part. If your board is using the ISP-interface, you would have to use atmelice_isp. For using JTAG, you have to use atmelice. Please check the avrdude docs for further information. You could install avrdude using homebrew.

avrdude -c atmelice_isp -p m32u4 -P usb

#!/usr/bin/env python
#
# https://stackoverflow.com/questions/25697664/how-would-i-parse-front-matter-with-python
#
import frontmatter
import io 
from os.path import basename, splitext
import glob

auths = ['daniel']

path = "content/docs/*.md"

for fname in glob.glob(path):
    with io.open(fname, 'r') as f:
        post = frontmatter.load(f)

        if post.get('author') == None:
            post['authors'] = auths
            newfile = io.open( fname, 'w', encoding='utf8')
            #frontmatter.dump(post, newfile)
            newfile.write ( frontmatter.dumps(post) )
            newfile.close()

The script above checks the existence of authors in all markdown files inside the predefined path. Contains the post an existing parameter it does nothing, is it missing it will be added automatically. Very convenient!

Math

The amplitude modulation uses a high frequency signal $U_{C}$ which carriers the low frequency signal $U_{NF}$ into a higher frequency band.

$$ \begin{aligned} U_{NF} &= \hat{U}_{T} + \hat{U}_{NF} \cdot cos\left( \omega t \right)\\ U_{C} &= \hat{U}_{C} \cdot cos \left( \Omega t \right) \end{aligned}$$

For mathematical description, we choose \(\hat{U}_{C}\) to be \(1\) and we will end up.

$$ \begin{aligned} U_{AM} &= U_{NF} \cdot U_{C} \\ &= \left( \hat{U}_{T} + \hat{U}_{NF} cos\left( \omega t \right) \right) \cdot cos \left( \Omega t \right) \\ &= \hat{U}_{T} \cdot cos \left( \Omega t \right) + \frac{\hat{U}_{NF}}{2}\left( cos \left( \left( \Omega - \omega \right) \right) + cos \left( \left( \Omega + \omega \right) \right) \right) \end{aligned}$$

The last equation shows clearly the circumstance of three existing signals. The first one describes the DC¹ component of the used low frequency signal, but with carrier frequency. The remaining two parts describing the produced sideband signals. They have the half amplitude of the low frequency signal and are positioned around the carrier frequency. For this script I demodulate the transmitted signal by using the convolution theory. Insted of use an envelope detector, it is also possible to multiply the time series of the carrier function again. Multiplication in the time domain will occur an convolution of booth signals in the frequency domain and as the low frequency part is shifted to higher frequencies, there will be existe multiple copies of the same alogn the frequency axis.

Python implementation

Import packages and libs

At first we will iport the needed packages. As you can see, I used matplotlib, numpy and scipy for this script. RaisedCos and Noisgen are selfwritten classes for signal generation.

import matplotlib.pyplot as plt
import numpy as np
import scipy as sp
import scipy.signal

from raised_cos import RaisedCos, Noisegen

Define constants

The constant values for this script are described below. I used a carrier frequency of 33 kHz and a signal frequency of 5.5 kHz for the lower signal part. The whole script uses a sample frequency of 1 MHz, so we get a sample period of 100 ns. ffc describes the cutoff frequency of the used reconstruction/low-pass filter and N is the number of used filter coefficients.

fc = 33e3                   # 33 kHz carrier
fs = 5.5e3                  # 5.5 kHz signal
fa = 1e7                    # sample frequency
dt = 1/fa                   # time resolution
ffc= 1.5*fs/fa              # cutoff frequency fir
N  = 150                    # filter order

Generate Signals and filter coefficients

For source signal generation I implemented the raised cosine function in Python. These function provides the possibility of a controllable bandwidth. The bandwidth may be modified by increasing the order \(N\). $$ \begin{aligned} U_{RC, N}\left( t\right) &= \frac{\left( -1 \right)^N}{2} \left(1 - cos\left( \frac{\omega t}{N} - \phi \right) \right) \cdot cos \left( \frac{\omega}{2} t - \phi\right) \end{aligned}$$

The Figure above shows the generated signal in time and frequency domain without noisefloor for different orders. As you can see the bandwidth is decreasing while the order was increased. For this example I used the sixth order, but neverless to say any other order would be also suitable.

Points = int(round(20e-4/dt))
# filter coefficients
h = sp.signal.firwin(numtaps=N, cutoff=fc, nyq=fa/2)
# time vector
x = np.arange(0,20e-4,dt)
ulf = np.zeros(Points)
# noise floor
noise = Noisegen( Points, 40)
#Points = int(round(4e-4/dt + 1))
# ultrasonic impulse
r = RaisedCos(6, Points, dt, 0, fs )
ulf = r.signal
#ulf = np.sin(2*np.pi*fs*x)
ulf += noise.signal
# thermal signal carrier
ucr = np.sin(2*np.pi*2*fc*x)
# carrier multiplied with low frequency signal
uam = ucr*ulf
# demodulate signal by mupltiplying the amplitude modulated signal again
ud = uam * ucr
# applyng the lowpass filter
r = sp.signal.lfilter(h, 1.0, ud )
# Scaling the amplitude
y  = 2*r

Plotting the signals

# plotting
f, axarr = plt.subplots(1, 3)
f.set_size_inches(16, 8)
axarr[0].plot(x*1e3, ulf)
axarr[0].set_title('Input signal')
axarr[0].set_ylabel('Amplitude [V]')
axarr[0].set_xlim([0, 2])
axarr[0].set_ylim([-1, 1])
axarr[0].grid()
axarr[1].plot(x*1e3, uam)
axarr[1].set_title('Modulated channel')
axarr[1].set_xlim([0, 2])
axarr[1].set_ylim([-1, 1])
axarr[1].grid()
axarr[2].plot(x*1e3, y)
axarr[2].set_title('Rescaled reconstruction')
axarr[2].set_xlabel('Time [ms]')
axarr[2].set_xlim([0, 2])
axarr[2].set_ylim([-1, 1])
axarr[2].grid()

plt.savefig('signals.png',dpi=150)

Calculations

Difference between actual and reference temperature : $$\Delta T = D_2 - C_5 \cdot 2^8 $$ Offset for temperature compensated pressure : $$OFF = C_2 \cdot 2^{17} + \frac{C_4 \cdot \Delta T} {2^6}$$ Sensivity for actual temperature : $$SENS = C_1 \cdot 2^{16} + \frac{C_3 \cdot \Delta T}{2^7}$$

Temperature (in 0.01 °C resolution) : $$T = 2000 + \Delta T \cdot \frac{C_6}{2^{23}}$$ Pressure (in 0.01 mbar resolution): $$P = \frac{\dfrac{D_1 \cdot SENS}{2^{21}} - OFF}{2^{15}}$$ Relative humidity (in %) : $$RH = -6 + 125 \cdot \frac{S_{RH}}{2^{16}}$$

import serial
import math
import matplotlib.pyplot as plt
import numpy as np
import time

BUSPIRATE_PORT = 'com5' #customize this! Find it in device manager.

def sendPirate(ser,cmd,silent=True):
    """
    send the command and listen to the response.
    returns a list of the returned lines.
    The first item is always the command sent.
    """
    ser.write(str(cmd+'\n').encode('ascii')) # send our command
    lines=[]
    for line in ser.readlines(): # while there's a response
        lines.append(line.decode('utf-8').strip())
    if not silent:
        print("\n".join(lines))
        print('-'*60)
    return lines

def sendSensor( ser, register, addrwrite=0xEC,  addrread=0xED, silent=True):
    """
    Sending data to sensor by using the bus priate device
    """
    sendPirate (ser,'[%s %s]' % (addrwrite, register), silent=silent) # read two bytes

def readSensor (ser, noBytes, register=0x00, addrwrite=0xEC, addrread=0xED, readonly=False, silent=True):
    """
    Reading data from sensor by using the bus priate device.
    """
    if not readonly:
        lines=sendPirate(ser,'[%s %s [ %s r:%d]' % (addrwrite, register, addrread, noBytes ) ,silent=silent) # read three bytes from adc
    else:
        lines=sendPirate(ser,'[%s r:%d]' % ( addrread, noBytes ) ,silent=silent) # read three bytes from adc

    for line in lines:
        if line.startswith("READ:"):
            line=line.split(" ",1)[1].replace("ACK",'')
            while "  " in line:
                line=" "+line.strip().replace("  "," ")
            word = 0
            validx = 1
            line=" "+line.strip().replace("0x"," ")
            vals = line.split(" ")
            vals=' '.join(vals).split()
            nVals = len(vals)
            for iVal in vals:
                cVal = int(iVal, 16)
                word += cVal * math.pow ( 2 , 8 * (nVals - validx ) )
                validx +=1
    return int(word)

def getPressure( ser, addrwrite=0xEC, register=0x4A, addrread=0xED, silent=False):
    """
    get ambient pressure
    """
    sendSensor ( ser, register, silent=silent )
    time.sleep ( 0.5 )
    word = readSensor ( ser, 3, 0x00, addrwrite, addrread, readonly=False, silent=silent )
    return int(word)

def getTemperature( ser, addrwrite=0xEC, register=0x5A, addrread=0xED, silent=False):
    sendSensor ( ser, register, silent=silent)
    time.sleep (0.5)
    word = readSensor ( ser, 3, 0x00, addrwrite, addrread, readonly=False, silent=silent )
    return int(word)


def getHumidity( ser, addrwrite=0x80, register=0xA0, addrread=0x81, silent=False):
    # start humidity conversion
    # 0xF5 no hold master
    # 0xE5 hold master
    sendSensor ( ser, 0xF5, addrwrite=addrwrite,  addrread=addrread, silent=silent )
    time.sleep(0.5)
    word = readSensor ( ser, 2, register, addrwrite, addrread, readonly=True, silent=silent )
    return int(word)

def getCalibrationWord( ser, register, addrwrite=0xEC, addrread=0xED, silent=False):
    word = readSensor ( ser, 2, register, addrwrite, addrread, readonly=False, silent=silent )
    return int(word)


def initpirate(ser, silent=False):
    # have a clean starting point
    sendPirate(ser,'#',silent=silent) # reset bus pirate (slow, maybe not needed)
    #sendPirate(ser,'v') # show current voltages

    # set mode to I2C
    sendPirate(ser,'m',silent=silent) # change mode (goal is to get away from HiZ)
    sendPirate(ser,'4',silent=silent) # mode 4 is I2C
    sendPirate(ser,'3',silent=silent) # 100KHz
    sendPirate(ser,'W',silent=silent) # turn power supply to ON. Lowercase w for OFF.
    sendPirate(ser,'P',silent=silent) # enable pull-up resistors
    sendPirate(ser,'(1)',silent=silent) # scan I2C devices. Returns "0x90(0x48 W) 0x91(0x48 R)"

def initSensor ( ser, silent=False):
    sendSensor ( ser, 0x1E,silent=silent )
    time.sleep ( 0.5 )
    # reset humidity sensor
    sendSensor ( ser, 0xFE ,  addrwrite=0x80, addrread=0x81, silent=silent )
    time.sleep (0.3)
    PTCal = getPTCalibrationData ( ser, silent=silent )
    return PTCal


def getPTCalibrationData(ser, silent=False ):
    PTCalibration=[]
    for i in range(0,6):
        PTCalibration.append (getCalibrationWord( ser, register=(0xA2 + 2*i),silent=silent) )
        if  not silent:
            print ( "register 0x%X => 0x%X" % ( int(0xA2 + 2*i) , PTCalibration[i] ))
    return PTCalibration


ser=serial.Serial(BUSPIRATE_PORT, 115200, timeout=.1)

# init buspirate
initpirate(ser,silent=True)
# reset PT sensor
PTCal= initSensor(ser, silent=True )

# start pressure conversion
D1   = getPressure ( ser, silent=True )

# start temperature conversion
D2   = getTemperature ( ser , silent=True)
dT   = D2 - PTCal[4] * 256
Temp = 2000 + dT * PTCal[5] / 8388608

OFF  = PTCal[1] * 131072 + (PTCal[3] * dT) / 64
SENS = PTCal[0] * 65536 + (PTCal[2] * dT ) / 128

if Temp >= 2000 :
    Ti   = 5 * (dT * dT) / 274877906944
    OFFi = 0
    SENSi= 0
elif Temp < 2000 :
    Ti   = 3 * (dT * dT) / 8589934592
    OFFi = 61 * ((Temp - 2000) * (Temp - 2000)) / 16
    SENSi= 29 * ((Temp - 2000) * (Temp - 2000)) / 16
    if Temp < -1500:
        OFFi = OFFi + 17 * ((Temp + 1500) * (Temp + 1500))
        SENSi= SENSi + 9 * ((Temp + 1500) * (Temp +1500))

OFF2    = OFF - OFFi
SENS2   = SENS - SENSi
cTemp   = (Temp - Ti) / 100.0
fTemp   =  cTemp * 1.8 + 32
pressure= ((((D1 * SENS2) / 2097152) - OFF2) / 32768.0) / 100.0
D3      = getHumidity ( ser, silent=True )
humidity= (-6.0 + (125.0 * (D3 / 65536.0)))

print ( "Temperature %2.2f °C / Pressure %3.2f mbar / Humidity %3.1f %%" % ( cTemp , pressure, humidity ))

For some simulation topics of my Ph.D., I had to learn/recapitulate some basics about simulations techniques and fluid simulations. The original procedure and code could be found at Archer (UK National Supercomputing Service). This is a simple example for applying the finite difference approach to determine the flow pattern (CFD¹) in a cavity. For simplicity, we’re assuming a perfect liquid without viscosity, which also implies that there’re no vortices. The \(z\)-dimension of this setup was defined to be endless. We are interested in the directional velocity of the fluid.

A bit of math

Finite Difference Method

First order PDE

For solving a first or higher order PDE² several methods exist. The easiest one is the finite difference method. For that method we’re needing a suitable approximation for the first derivative, for example the left aligned or forward difference:

$$ \frac{\partial}{\partial x} F \approx \frac{F(x + \Delta x) - F(x)}{\Delta x} + \mathcal{O(\Delta x)} $$

Also possible, the right aligned or backward difference:

$$ \frac{\partial}{\partial x} F \approx \frac{F(x) - F(x - \Delta x)}{\Delta x} + \mathcal{O(\Delta x)} $$

For a better approximation, we could also use the combination of forward and backward difference. This method is called the centered difference and is able to describe the derivative on position \(x\) only with knowledge about the neighbors left and right.

$$ \frac{\partial}{\partial x} F \approx \frac{F(x + \Delta x) - F(x - \Delta x)}{2\Delta x} + \mathcal{O(\Delta x)} $$

Second and higher order PDE

$$ \begin{align} \frac{\partial^2 F}{\partial x^2} & = \frac{\partial } {\partial x} \left( \frac{\partial F}{\partial x}\right) \\ & \approx \frac{1}{\Delta x}\left(\frac{\partial F(x + \Delta x)}{\partial x} - \frac{\partial F(x - \Delta x)}{\partial x} \right) \\ & \approx \frac{1}{ \Delta x} \left( \frac{F(x+\Delta x) - F(x)}{ \Delta x} - \frac{F(x) - F(x - \Delta x)}{ \Delta x} \right)+ \mathcal{O}(\Delta x)^2 \\ & \approx \frac{1}{(\Delta x)^2} \Bigg( F(x + \Delta x) - 2F(x) + F(x - \Delta x) \Bigg) + \mathcal{O}(\Delta x)^2 \end{align} $$

Cavity problem solving

For the given problem the following second-order PDE exist for the fluid flow \(\Psi\) which neglecting the existence of viscosity and toroids.

$$\frac{\partial^2 \Psi}{\partial x^2} + \frac{\partial^2 \Psi}{\partial y^2} = 0$$

Using the finite difference approach for second order PDEs we could rewrite the equation, which fully satisfies our problem.

$$ \begin{align} \frac{\partial^2 \Psi}{\partial x^2} + \frac{\partial^2 \Psi}{\partial y^2} & \approx \frac{1}{(\Delta x)^2} \Bigg( \Psi(x + \Delta x, y ) - 2 \Psi (x, y) + \Psi (x - \Delta x, y) \Bigg)\\ & + \frac{1}{(\Delta y)^2} \Bigg( \Psi(x, y + \Delta y) - 2 \Psi(x,y) + \Psi(x, y - \Delta y) \Bigg) \end{align} $$

For discretization we replace the continous terms \(x\) and \(y\) by their discrete replacements \(i\) and \(j\) and set the spatial resolution in \(x\)- and \(y\)-direction to \(1\) (\(\Delta x=\Delta y=1\) ).

$$ \frac{\partial^2 \Psi}{\partial x^2} + \frac{\partial^2 \Psi}{\partial y^2} \approx \Psi_{i+1,j} + \Psi_{i-1, j} + \Psi_{i,j-1} + \Psi_{i, j+1} - 4\cdot\Psi_{i,j} = 0 $$

With this approximation and the usage of the Dirchlet boundary condition (borders without sources are set to \(0\)) we could solve our problem. For velocity field \( \vec{u} \) computation, we calculate the partial differentiations.

$$ u_x (x,y) = \frac{\partial\Psi}{\partial y} = \frac{1}{2} \left( \Psi_{i,j+1} - \Psi_{i,j-1} \right)$$

$$ u_y (x,y) = \frac{\partial\Psi}{\partial x} = \frac{1}{2} \left( \Psi_{i+1,j} - \Psi_{i-1,j} \right) $$

Implementation

Boundary conditions

    psi = [[0 for col in range(m+2)] for row in range(n+2)]

    # Set the bondary conditions on bottom edge
    for i in range(b+1, b+w):
        psi[0][i] = float(i-b)
    for i in range(b+w, m+1):
        psi[0][i] = float(w)
    # Set the bondary conditions on right edge
    for j in range(1, h+1):
        psi[j][m+1] = float(w)
    for j in range(h+1, h+w):
        psi[j][m+1] = float(w-j+h)

Solver implementation

The implementation supports booth convergence criteria: maximum number of iteration steps and minimum achievable tolerance \(\sigma\). For determining the current tolerance we consider the current and iteration step before. Therefore we calculate the Euclidean distance (magnitude normal) to get the achieved gain between these steps. Was the change less than the given tolerance, we skip further iterations.

$$ | \Psi_k - \Psi_{k-1}| \le \sigma $$

    def solver ( tol, nMaxIterations, psi, dx, dy ):
        M = len(psi) - 2
        N = len(psi[0]) - 2
        tmp = [[0 for col in range(M+2)] for row in range(N+2)]
        cStep = 0;
        xs = pow(dx,2)
        ys = pow(dy,2)
        while ( cStep < nMaxIterations ):
            # store old residue
            res_old = np.linalg.norm(np.array ( psi ) - np.array ( tmp ) )
            # differeniation in booth directions
            for i in range(1, M+1):
                for j in range(1, N+1):
                    tmp[i][j] = 0.25 * (psi[i+1][j]+psi[i-1][j]+psi[i][j+1]+psi[i][j-1])

            cStep += 1
            # update residue
            res_new = np.linalg.norm(np.array ( psi ) - np.array ( tmp ) )
            # updating flow for next iteration
            for i in range(1, M+1):
                for j in range(1, N+1):
                    psi[i][j] = tmp[i][j]

            if ( np.linalg.norm( res_new - res_old ) <= tol ):
                break
        return cStep

Results

First contact and results

For data machining, there’re lots of tools inside these packages and they are able to compete with such huge software packages like Mathworks MATLAB³. Of course, MATLAB is in most cases the first choice for quick results and spontaneously written scripts. But there are lots of advantages like the platform independence, there existing Open Source licensed packages and it is highly automatable.

So in preparation for a presentation, I was tinkering with these Python packages and was able to generate these nice bivariate distributions. They are running on my office system (Windows 7), on my private MacBook and of course on my CI⁴ server. A win-win-win situation I guess.

Results

Conclusion

As I mentioned “Scientific Python” is a great way for data processing and visualization.

Code

#!/usr/bin/env bash
printf "%.0s-" {1..58}
printf "\n"
printf "| DEVICE%2s | SERIALNO%12s | MODEL%15s |\n"
printf "%.0s-" {1..58}
printf "\n"
for i in $( ls /dev/sd* ); do
	if [[ $i =~ ^[A-Za-z_//]+$ ]]; then
		SERNO=$(hdparm -i $i |grep -i SerialNo |cut -d ',' -f 3 | sed 's/^[ ]*[[:alnum:]]*=//')
		MODEL=$(hdparm -i $i |grep -i Model |cut -d ',' -f 1 | sed 's/^[ ]*[[:alnum:]]*=//')
		printf "| %8s | %20s | %20s |\n" "$i" "$SERNO" "$MODEL"
	fi
done
printf "%.0s-" {1..58}
printf "\n"

Output

Could by handy for later. 😃

Anyway, nice chance to play around with git’s hooks and let them do the hard work for us.

A hook is a trivial BASH-Script which would be executed by git under special circumstances like a new push to a special branch or special content inside the committed source (or what ever you wnat to keep managed).

So what must be done to create and activate a git-hook? The answer is very simple and including only three steps:

If it isn’t available, we’ve to install markdown first. On a machine which is based on Debian you could use your packaging-system for this task.

apt-get install markdown

Inside the “hooks”-directory of our bare repository, we only have to create a file named ‘post-receive’ and make it executable. As content we paste the following two line into the fresh file. The filename is mandatory in this case, because git will proof the existence of specific files and will execute them if possible.

#!/bin/sh
git cat-file blob HEAD:README.md | markdown > $GIT_DIR/README.html

So making it executable should be the easiest part of the job.

chmod +x post-recevie

And that’s it. You could find a very nice overview of all available hooks here.

The updated one should be something like this:

class Avrdude < Formula
  desc "Atmel AVR MCU programmer"
  homepage "https://savannah.nongnu.org/projects/avrdude/"
  url "http://download.savannah.gnu.org/releases/avrdude/avrdude-6.3.tar.gz"
  mirror "http://download-mirror.savannah.gnu.org/releases/avrdude/avrdude-6.3.tar.gz"
  sha256 "0f9f731b6394ca7795b88359689a7fa1fba818c6e1d962513eb28da670e0a196"

  bottle do
    sha256 "b2ac65f070879456e2047ba543a7fafb1d45c98b745b7915b4059ea90c10dfcd" => :el_capitan
    sha256 "4c092d851e6ed8ed58ac5a1997606db420ee153289d4289917fad50f8432d5ad" => :yosemite
    sha256 "a3b312dde0f3a268d6ccc9085e4a14d8d7703ff1ae09a9257b373976e7cf49ec" => :mavericks
  end

  head do
    url "svn://svn.savannah.nongnu.org/avrdude/trunk/avrdude/"

    depends_on "autoconf" => :build
    depends_on "automake" => :build
    depends_on "libtool" => :build
  end

  depends_on :macos => :snow_leopard # needs GCD/libdispatch
  depends_on "libusb-compat"
  depends_on "libftdi0"
  depends_on "libelf"
  depends_on "libhid" => :optional

  def install
    if build.head?
      inreplace "bootstrap", /libtoolize/, "glibtoolize"
      system "./bootstrap"
    end
    system "./configure", "--disable-dependency-tracking",
                          "--prefix=#{prefix}"
    system "make"
    system "make", "install"
  end

  test do
    assert_equal "avrdude done.  Thank you.",
      shell_output("#{bin}/avrdude -c jtag2 -p x16a4 2>&1", 1).strip
  end
end

Until now, everything works fine for me.

cd ...../config
wget https://raw.githubusercontent.com/bagder/ca-bundle/master/ca-bundle.crt

Danach sollte dieses Problem aus der Welt sein.

class Avrdude < Formula
  desc "Atmel AVR MCU programmer"
  homepage "https://savannah.nongnu.org/projects/avrdude/"
  url "http://download.savannah.gnu.org/releases/avrdude/avrdude-6.1.tar.gz"
  mirror "http://download-mirror.savannah.gnu.org/releases/avrdude/avrdude-6.1.tar.gz"
  sha256 "9e98baca8e57cad402aaa1c7b61c8de750ed4f6fed577f7e4935db0430783d3b"

  bottle do
    sha1 "2d759fea880b097754defe8016e026390dbcfb31" => :mavericks
    sha1 "83017c7fb34b0a2da5919b6b1dde9c05bf237f2a" => :mountain_lion
    sha1 "438562a4b84b4e868cdf01b81e7543053a89a7ff" => :lion
  end

  head do
    url "svn://svn.savannah.nongnu.org/avrdude/trunk/avrdude/"

    depends_on "autoconf" => :build
    depends_on "automake" => :build
    depends_on "libtool" => :build
  end

  patch :p2 do
    url "http://savannah.nongnu.org/file/stdint-fix.patch?file_id=31187"
    sha256 "709b82cacdf2bcb6b638dd855e57a176705a3c816d6d7b866bae9370b4511843"
  end

  patch :p3 do
    url "http://www.avrfreaks.net/sites/default/files/forum_attachments/avrice_fragment_fix2.patch"
    sha256 "e4cd8db7802c76b61fb953c055bdde066bd7e9f34ac0f7808fd29e909f57ee8a"
  end

  depends_on :macos => :snow_leopard # needs GCD/libdispatch
  depends_on "libusb-compat"
  depends_on "libftdi0"
  depends_on "libelf"
  depends_on "libhid" => :optional

  def install
    if build.head?
      inreplace "bootstrap", /libtoolize/, "glibtoolize"
      system "./bootstrap"
    end
    system "./configure", "--disable-dependency-tracking",
                          "--prefix=#{prefix}"
    system "make"
    system "make", "install"
  end
end

Damit funktionierte (bisher) avrdude unter El Capitan ohne weitere Einschränkungen. Ich werde das Ganze natürlich weiter beobachten.

Kommen wir nun zum eigentlichen Anlass des Beitrags. Er wollte unter OS X nicht funktionieren. AVRDude bekam einfach keinen Zugriff auf das USB-Device, da es von OS X gesperrt wurde. Ähnliches kann man hier nach lesen. Anscheinend ist es notwendig eine Kernel Extension (kext-File) zu laden um dem Problem Herr zu werden.

Besagtes kext-File gibt es im Forum bei avrfreaks.net inklusive der Anleitung was zu tun ist.

tar -xf AtmelICE.kext.tar.bz2
sudo cp -R AtmelICE.kext /System/Library/Extensions
# change permissions and ownership:
sudo chown -R root:wheel /System/Library/Extensions/AtmelICE.kext
sudo chmod -R 755 /System/Library/Extensions/AtmelICE.kext
# reload the kext cache:
sudo kextcache -system-caches

Gerät abziehen und neu anschließen und es funktionierte auf Anhieb.

[~/Downloads]$ avrdude -c atmelice -p x128a1 -P usb
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.01s
avrdude: Device signature = 0x1e974c
avrdude done.  Thank you.

Naja lange Rede, kurze Hilfestellung. Mit folgendem Befehl lässt sich das Zertifikat von der Passphrase befreien und gut ists.

openssl rsa -in fqdn.key.back -out fqdn.key

Umgebungsvariablen setzen

Ich brauche des Öfteren einige Umgebungsvariablen (Qt, OpenCV etc.) um nicht jedesmal den Pfad für die entsprechenden Bibliotheken angeben zu müssen. Die erweiterten Systemeinstellungen benötigen jedoch ein entsprechendes Administratorkonto. Um die spezifischen, den Benutzer betreffenden Variablen zu setzen, reicht es jedoch folgenden Befehl auszuführen.

rundll32 sysdm.cpl,EditEnvironmentVariables

Interessanterweise darf man dann seine eigenen Umgebungsvariablen selbst erstellen, verwalten etc.. Also genau das was man über den „Maus/Klick“-Weg nicht durfte.

Ansonsten war der Dreh recht schnell raus und nachdem die Grundform in FreeCAD erstellt wurde, hatte man mehr oder weniger die Bedienung verstanden. Das Einzigste was mir bisher noch fehlt ist die Erstellung simpler Bilder. Aber gut, das Manko macht die angesprochene 3D-Ansicht wett. Anbei die beiden Modelle (ohne Bohrung und mit Bohrung ) als Download. Die Dateien wurden bisher noch nicht gedruckt, daher gibt es auch keine Gewähr ob die Teile wirklich passen. Ich hoffe ich kann die Teile – zum Testen vom 3D-Drucker natürlich – morgen drucken und dann Feedback geben ob sie nun wirklich passen oder nicht. Btw. ist mir aufgefallen, dass es mit neuen Blogbeiträgen wie mit dem Vorhaben „Kellerausmisten“ ist. Man will es zwar machen, aber sich wirklich die Zeit dafür zu nehmen ist schon eine andere Hausnummer.

Fehler: Konnte alpm-Bibliothek nicht initialisieren (Konnte Verzeichniss \
 nicht finden oder lesen)

Schnelle Abhilfe schafft ein kurzes:

pacman-db-upgrade

Einen guten Rutsch.

Dazu gehören das teils ausgelieferte Rasbian basierend auf Debian und einer, zur ARM Plattform kompatiblen, Version von Arch Linux. Vorteil ist hier natürlich, dass man durch die Wahl gleicher Systeme sich Zeit bzgl. Umgewöhnung und einarbeitung spart, da man in der Regel sein Desktop-System am Besten kennt. Die Installation von ALARM (Arch Linux ARM) geht dabei eigentlich recht zügig und ist wie so Vieles andere auch ausführlich beschrieben.

Partitionierung

Zunächst wird, wie am Desktop auch, die SD-Karte entsprechend partitioniert und formatiert. Dazu wird das Blockdevice der Speicherkarte mittels fdisk geöffnet, dabei sollte jedoch das richtige Gerät ausgewählt werden. Nicht das man sich die Partitionierung der eigenen Festplatte zerlegt.

fdisk /dev/mmcblk0

Da der Bootloader (UBoot) Raspberry Pi einen Bootbereich auf der SD-Karte erwartet, müssen wir zwei Partitionen anlegen. Eine, mit 100 MB, etwas kleineren Bootbereich den UBoot lesen kann und eine entsprechende Linux Root-Partition.

# Löschen der vorhandenen Partitionen
o
# Anlegen einer neuen Partition
n
# primär
p
# 1 für die erste Partition
1
# Enter für den ersten Sektor als Startsektor

# Für den letzten Sektor einen Offset von 100 MB angeben
+100M
# Partitionstyp auf FAT32 mit LBA setzen
t
c
# Anlegen einer neuen zweiten Partition
n
# primär
p
# 2 für die zweite Partition
2
# zweimal Enter drücken um den restlichen Speicher auszuwählen


# Änderungen speichern und auf das Blockdevice schreiben
w

Formatierung

Formatiert wird wie unter Linux gewohnt mit den mkfs-Kommandos.

mkfs.vfat /dev/mmcblk0p1
mkfs.ext4 /dev/mmcblk0p2

Einbinden und Installation von ALARM

Um die SD-Karte einzubinden, brauchen wir natürlich entsprechende mountpoints. Diese erstelle ich meinst unter /mnt und hänge die Partitionen mit mount auf die erstellten mountpoints.

mkdir -p /mnt/boot
mkdir -p /mnt/root
mount /dev/mmcblk0p1 /mnt/boot
mount /dev/mmcblk0p2 /mnt/root
cd /mnt

Anschließend holen wir uns das aktuelle ALARM-Image von der Projektseite und entpacken es direkt.

wget http//archlinuxarm.org/os/ArchLinuxARM-rpi-latest.tar.gz
tar xpf ArchLinuxARM-rpi-latest.tar.gz -C root
sync
mv root/boot/* boot

Nun noch die Paritionen aushängen und wir sind fertig.

umount /mnt/root /mnt/boot

Speicherkarte aus dem Kartenleser entnehmen und ins Raspberry Pi stecken und booten lassen. Nach ein paar Sekunden sollte man sich via SSH als root mit dem Passwort root einloggen können. Der Standard-Host ist dabei dann alarmpi. Damit sollte die Installation von ALARM abgeschlossen sein und funktionieren.

Zunächst, was brauchen wir?

• Pakete
• Pfad wo das Repository eingebunden ist
• GPG-Schlüssel

Die ersten beiden Punkte sind dabei ja schon vorab geklärt worden. Die Erzeugung eines GPG-Schlüsselpaars kann nach dieser Anleitung durchgeführt werden.

Notwendige Änderungen bzgl. GPG

Zunächst muss das Build-System für die Signierung konfiguriert werden. Dazu sind einige kleinere Änderungen in der Datei /etc/makepkg.conf notwendig. Dazu wird die Signierung durch das Entfernen des Ausrufzeichens vor dem Wort sign in Zeile 56 aktiviert.

#
# /etc/makepkg.conf
#

#########################################################################
# SOURCE ACQUISITION
#########################################################################
#
#-- The download utilities that makepkg should use to acquire sources
#  Format: 'protocol::agent'
DLAGENTS=('ftp::/usr/bin/curl -fC - --ftp-pasv --retry 3 --retry-delay 3 -o %o %u'
          'http::/usr/bin/curl -fLC - --retry 3 --retry-delay 3 -o %o %u'
          'https::/usr/bin/curl -fLC - --retry 3 --retry-delay 3 -o %o %u'
          'rsync::/usr/bin/rsync --no-motd -z %u %o'
          'scp::/usr/bin/scp -C %u %o')

# Other common tools:
# /usr/bin/snarf
# /usr/bin/lftpget -c
# /usr/bin/wget

#########################################################################
# ARCHITECTURE, COMPILE FLAGS
#########################################################################
#
CARCH="x86_64"
CHOST="x86_64-unknown-linux-gnu"

#-- Compiler and Linker Flags
# -march (or -mcpu) builds exclusively for an architecture
# -mtune optimizes for an architecture, but builds for whole processor family
CPPFLAGS="-D_FORTIFY_SOURCE=2"
CFLAGS="-march=x86-64 -mtune=generic -O2 -pipe -fstack-protector-strong --param=ssp-buffer-size=4"
CXXFLAGS="-march=x86-64 -mtune=generic -O2 -pipe -fstack-protector-strong --param=ssp-buffer-size=4"
LDFLAGS="-Wl,-O1,--sort-common,--as-needed,-z,relro"
#-- Make Flags: change this for DistCC/SMP systems
#MAKEFLAGS="-j2"
#-- Debugging flags
DEBUG_CFLAGS="-g -fvar-tracking-assignments"
DEBUG_CXXFLAGS="-g -fvar-tracking-assignments"

#########################################################################
# BUILD ENVIRONMENT
#########################################################################
#
# Defaults: BUILDENV=(fakeroot !distcc color !ccache check !sign)
#  A negated environment option will do the opposite of the comments below.
#
#-- fakeroot: Allow building packages as a non-root user
#-- distcc:   Use the Distributed C/C++/ObjC compiler
#-- color:    Colorize output messages
#-- ccache:   Use ccache to cache compilation
#-- check:    Run the check() function if present in the PKGBUILD
#-- sign:     Generate PGP signature file
#
BUILDENV=(fakeroot !distcc color !ccache check sign)
#
#-- If using DistCC, your MAKEFLAGS will also need modification. In addition,
#-- specify a space-delimited list of hosts running in the DistCC cluster.
#DISTCC_HOSTS=""
#
#-- Specify a directory for package building.
#BUILDDIR=/tmp/makepkg

#########################################################################
# GLOBAL PACKAGE OPTIONS
#   These are default values for the options=() settings
#########################################################################
#
# Default: OPTIONS=(strip docs !libtool !staticlibs emptydirs zipman purge !upx !debug)
#  A negated option will do the opposite of the comments below.
#
#-- strip:      Strip symbols from binaries/libraries
#-- docs:       Save doc directories specified by DOC_DIRS
#-- libtool:    Leave libtool (.la) files in packages
#-- staticlibs: Leave static library (.a) files in packages
#-- emptydirs:  Leave empty directories in packages
#-- zipman:     Compress manual (man and info) pages in MAN_DIRS with gzip
#-- purge:      Remove files specified by PURGE_TARGETS
#-- upx:        Compress binary executable files using UPX
#-- debug:      Add debugging flags as specified in DEBUG_* variables
#
OPTIONS=(strip docs !libtool !staticlibs emptydirs zipman purge !upx !debug)

#-- File integrity checks to use. Valid: md5, sha1, sha256, sha384, sha512
INTEGRITY_CHECK=(md5)
#-- Options to be used when stripping binaries. See `man strip' for details.
STRIP_BINARIES="--strip-all"
#-- Options to be used when stripping shared libraries. See `man strip' for details.
STRIP_SHARED="--strip-unneeded"
#-- Options to be used when stripping static libraries. See `man strip' for details.
STRIP_STATIC="--strip-debug"
#-- Manual (man and info) directories to compress (if zipman is specified)
MAN_DIRS=({usr{,/local}{,/share},opt/*}/{man,info})
#-- Doc directories to remove (if !docs is specified)
DOC_DIRS=(usr/{,local/}{,share/}{doc,gtk-doc} opt/*/{doc,gtk-doc})
#-- Files to be removed from all packages (if purge is specified)
PURGE_TARGETS=(usr/{,share}/info/dir .packlist *.pod)

#########################################################################
# PACKAGE OUTPUT
#########################################################################
#
# Default: put built package and cached source in build directory
#
#-- Destination: specify a fixed directory where all packages will be placed
#PKGDEST=/home/packages
#-- Source cache: specify a fixed directory where source files will be cached
#SRCDEST=/home/sources
#-- Source packages: specify a fixed directory where all src packages will be placed
#SRCPKGDEST=/home/srcpackages
#-- Packager: name/email of the person or organization building packages
PACKAGER="Daniel Kotschate <daniel@epyx-online.de>"
#-- Specify a key to use for package signing
GPGKEY="866FE6E2"

#########################################################################
# COMPRESSION DEFAULTS
#########################################################################
#
COMPRESSGZ=(gzip -c -f -n)
COMPRESSBZ2=(bzip2 -c -f)
COMPRESSXZ=(xz -c -z -)
COMPRESSLRZ=(lrzip -q)
COMPRESSLZO=(lzop -q)
COMPRESSZ=(compress -c -f)

#########################################################################
# EXTENSION DEFAULTS
#########################################################################
#
# WARNING: Do NOT modify these variables unless you know what you are
#          doing.
#
PKGEXT='.pkg.tar.xz'
SRCEXT='.src.tar.gz'

# vim: set ft=sh ts=2 sw=2 et:</pre>

Weiterhin sollten wir die dafür vorgesehenen Daten für den Paket-Maintainer (Betreuer) abändern und die ID unseres GPG-Schlüssels eintragen. Dies erfolg in den Zeilen 112 bis 116 und ist denke ich selbst erklärend.

<pre class="lang:default mark:113,115 range:112-116 decode:true ">#
# /etc/makepkg.conf
#

#########################################################################
# SOURCE ACQUISITION
#########################################################################
#
#-- The download utilities that makepkg should use to acquire sources
#  Format: 'protocol::agent'
DLAGENTS=('ftp::/usr/bin/curl -fC - --ftp-pasv --retry 3 --retry-delay 3 -o %o %u'
          'http::/usr/bin/curl -fLC - --retry 3 --retry-delay 3 -o %o %u'
          'https::/usr/bin/curl -fLC - --retry 3 --retry-delay 3 -o %o %u'
          'rsync::/usr/bin/rsync --no-motd -z %u %o'
          'scp::/usr/bin/scp -C %u %o')

# Other common tools:
# /usr/bin/snarf
# /usr/bin/lftpget -c
# /usr/bin/wget

#########################################################################
# ARCHITECTURE, COMPILE FLAGS
#########################################################################
#
CARCH="x86_64"
CHOST="x86_64-unknown-linux-gnu"

#-- Compiler and Linker Flags
# -march (or -mcpu) builds exclusively for an architecture
# -mtune optimizes for an architecture, but builds for whole processor family
CPPFLAGS="-D_FORTIFY_SOURCE=2"
CFLAGS="-march=x86-64 -mtune=generic -O2 -pipe -fstack-protector-strong --param=ssp-buffer-size=4"
CXXFLAGS="-march=x86-64 -mtune=generic -O2 -pipe -fstack-protector-strong --param=ssp-buffer-size=4"
LDFLAGS="-Wl,-O1,--sort-common,--as-needed,-z,relro"
#-- Make Flags: change this for DistCC/SMP systems
#MAKEFLAGS="-j2"
#-- Debugging flags
DEBUG_CFLAGS="-g -fvar-tracking-assignments"
DEBUG_CXXFLAGS="-g -fvar-tracking-assignments"

#########################################################################
# BUILD ENVIRONMENT
#########################################################################
#
# Defaults: BUILDENV=(fakeroot !distcc color !ccache check !sign)
#  A negated environment option will do the opposite of the comments below.
#
#-- fakeroot: Allow building packages as a non-root user
#-- distcc:   Use the Distributed C/C++/ObjC compiler
#-- color:    Colorize output messages
#-- ccache:   Use ccache to cache compilation
#-- check:    Run the check() function if present in the PKGBUILD
#-- sign:     Generate PGP signature file
#
BUILDENV=(fakeroot !distcc color !ccache check sign)
#
#-- If using DistCC, your MAKEFLAGS will also need modification. In addition,
#-- specify a space-delimited list of hosts running in the DistCC cluster.
#DISTCC_HOSTS=""
#
#-- Specify a directory for package building.
#BUILDDIR=/tmp/makepkg

#########################################################################
# GLOBAL PACKAGE OPTIONS
#   These are default values for the options=() settings
#########################################################################
#
# Default: OPTIONS=(strip docs !libtool !staticlibs emptydirs zipman purge !upx !debug)
#  A negated option will do the opposite of the comments below.
#
#-- strip:      Strip symbols from binaries/libraries
#-- docs:       Save doc directories specified by DOC_DIRS
#-- libtool:    Leave libtool (.la) files in packages
#-- staticlibs: Leave static library (.a) files in packages
#-- emptydirs:  Leave empty directories in packages
#-- zipman:     Compress manual (man and info) pages in MAN_DIRS with gzip
#-- purge:      Remove files specified by PURGE_TARGETS
#-- upx:        Compress binary executable files using UPX
#-- debug:      Add debugging flags as specified in DEBUG_* variables
#
OPTIONS=(strip docs !libtool !staticlibs emptydirs zipman purge !upx !debug)

#-- File integrity checks to use. Valid: md5, sha1, sha256, sha384, sha512
INTEGRITY_CHECK=(md5)
#-- Options to be used when stripping binaries. See `man strip' for details.
STRIP_BINARIES="--strip-all"
#-- Options to be used when stripping shared libraries. See `man strip' for details.
STRIP_SHARED="--strip-unneeded"
#-- Options to be used when stripping static libraries. See `man strip' for details.
STRIP_STATIC="--strip-debug"
#-- Manual (man and info) directories to compress (if zipman is specified)
MAN_DIRS=({usr{,/local}{,/share},opt/*}/{man,info})
#-- Doc directories to remove (if !docs is specified)
DOC_DIRS=(usr/{,local/}{,share/}{doc,gtk-doc} opt/*/{doc,gtk-doc})
#-- Files to be removed from all packages (if purge is specified)
PURGE_TARGETS=(usr/{,share}/info/dir .packlist *.pod)

#########################################################################
# PACKAGE OUTPUT
#########################################################################
#
# Default: put built package and cached source in build directory
#
#-- Destination: specify a fixed directory where all packages will be placed
#PKGDEST=/home/packages
#-- Source cache: specify a fixed directory where source files will be cached
#SRCDEST=/home/sources
#-- Source packages: specify a fixed directory where all src packages will be placed
#SRCPKGDEST=/home/srcpackages
#-- Packager: name/email of the person or organization building packages
PACKAGER="Daniel Kotschate &lt;daniel@epyx-online.de&gt;"
#-- Specify a key to use for package signing
GPGKEY="866FE6E2"

#########################################################################
# COMPRESSION DEFAULTS
#########################################################################
#
COMPRESSGZ=(gzip -c -f -n)
COMPRESSBZ2=(bzip2 -c -f)
COMPRESSXZ=(xz -c -z -)
COMPRESSLRZ=(lrzip -q)
COMPRESSLZO=(lzop -q)
COMPRESSZ=(compress -c -f)

#########################################################################
# EXTENSION DEFAULTS
#########################################################################
#
# WARNING: Do NOT modify these variables unless you know what you are
#          doing.
#
PKGEXT='.pkg.tar.xz'
SRCEXT='.src.tar.gz'

# vim: set ft=sh ts=2 sw=2 et:

Die beschriebenen Änderungen führen dazu, dass ihr eure Passphrase (für den GPG-Key) eingeben müsst, sobald ein neues Paket währende der Erstellung signiert wird. Wenn man möchte, kann man seinen öffentlichen Schlüssel auch sofort manuell der eigenen Paketverwaltung hinzufügen. Jedoch wird bei der Aktualisierung der Paketlisten auch der Schlüssel in die Keyring eingetragen.

Signierung vom Repository

Die Pakete sind nun signiert, fehlt nur noch die Paketdatenbank. Dazu muss die bekannte Vorgehensweise nur minimal geändert werden und zu dem Aufruf von repo-add nur der Schalter -s hinzugefügt werden. Auch hier gilt, wie für die Paketerstellung, dass die Signierung eure Passphrase erfordert.

Daher habe ich mich mal etwas umgeschaut und dachte mir, dass es im Zeitalter der Smartphones und Instant Messenger (Whats-App, Threema und Co sind ja auch nichts Anderes) eine andere Möglichkeit geben müsste.

Jabber als Alternative?

Als mögliche Alternative sah ich Jabber. Mittlerweile wird Jabber/XMPP mit Cisco in Verbindung gebracht, was auch ok ist, da sie es  ja für ihre kommerziellen Produkte als Know-How eingekauft haben. Allerdings wird das Protokoll durch die XMPP Standards Foundation betreut. Wichtigster Punkt ist natürlich, dass es frei ist und es ein recht großes Portfolio an Bibliotheken (in verschiedenen Programmier-/Skriptsprachen) geben sollte. Das ist bei XMPP gegeben. So gibt es Bibliotheken für Hochsprachen wie C/C++ aber auch Module für Python und Perl.

Anwendungsfälle für Jabber

Wie oben genannt, lassen sich die Anwendungsszenarios beliebig wählen. Ich persönlich nutze es für meine privaten Backups mit rsnapshot. Sofern der Backupbefehl eine Ausgabe auf stderr zurückgibt, werde ich per Jabber benachrichtigt und kann dem Fehler auf die Spur gehen. Dabei nutze ich das folgende Python-Skript, welches ich einfach in meine Anacron-Tasks eingepflegt habe.

#!/usr/bin/python2
import sys
import xmpp
import ConfigParser

if ( len (sys.argv) < 3 ):
    print ("usage: sendxmpp.py resource text\n")
    print ("  resource:    jabber resource")
    print ("  text:        message to send\n")
else:
    snd = sys.argv[1]
    msg = sys.argv[2]

    config = ConfigParser.ConfigParser()

    # read ini file to ConfigParser
    data = config.read ( 'statxmpp.ini' )
    if ( len(data) == 0):
        print ("could not read >>statxmpp.ini<<" )
    else:
        # get values
        login = config.get( 'Connection', 'user' )
        pwd   = config.get( 'Connection', 'password' )
        srv   = config.get( 'Connection', 'server' )
        recv  = config.get( 'Connection', 'destination' )

        cnx = xmpp.Client( srv, debug=[] )
        cnx.connect( server=( srv ,5222) )
        cnx.auth(login, pwd, snd )
        cnx.send( xmpp.Message( recv , msg ) )

Das Skript erwartet eine Konfigurationsdatei mit den entsprechenden Einträgen für den erfolgreichen Verbindungsaufbau. Dazu zählen Benutzername, Passwort, der genutzte Server und natürlich die Empfängeradresse. Das Muster sieht wie folgt aus.

[Connection]
# username
user=
# password
password=
# receiver
destination=
# jabberserver to connect
server=

Abhängigkeiten des Skriptes sind die Pythonmodule pyxmpp (community) und ConfigParser (AUR), welche recht schnell installiert sind. Der rsnapshot wurde von mir dann noch wie folgt abgeändert

#!/bin/sh
## save stderr to var
ERR=$(/usr/bin/rsnapshot daily 3>&1 1>&2 2>&3)
### if command fails report via xmpp
if [ $? -ne 0 ]; then
        sendxmpp.py backup_status "${ERR}"
fi

und benachrichtigt mich über Probleme beim Backup. Empfangen kann man das Ganze dann mit einem Jabber-Client seiner Wahl (bspw. Pidgin, Empathy usw.) oder lässt es sich gleich auf Telefon schicken mit IM+ oder so, je nach Plattform oder App. Einziges Manko ist natürlich, dass die Nachricht auf dem Client quittiert wird, von dem sie abgerufen wird.

xdg-mime query default inode/directory

Was in meinem Fall `anjuta.desktop lieferte. Ok Treffer. Zum Setzen der zugehörigen Anwendung nutzen wir erneut xdg-mime und setzen unsere Anwendung wie folgt.

xdg-mime default nautilus.desktop inode/directory

Auf der gleichen Art und Weise funktioniert das natürlich auch mit anderen MIME-Typen und Anwendungen.

Was braucht man?

• einen Webserver (bzw. wenn das Repository lokal ist nicht einmal den) + Zugriff auf das Dateisystem Dabei ist es von Vorteil, wenn man (zu mindestens für das Repository) das Indexing erlaubt (bspw. für nginx).
• seine Pakete

Anlegen und Füllen des Repository (unter Arch Linux)

Ich bin mir nicht ganz sicher ob die Skripte zur Erzeugung der Datenbank nicht auch auf anderen Distributionen laufen würden, daher die Einschränkung. Die Auslieferung funktioniert unabhängig von der Distribution, da nur ein Webserver benötigt wird.

1. Zu allererst verschafft man sich Zugang zu seinem Webserver. Dabei bietet es sich an, den Ort wo die Pakete liegen sollen in das lokale Dateisystem zu mounten. Wie man es macht ist eigentlich egal, ich benutzte zur Zeit sshfs jedoch würde es sicherlich auch mit einer nfs-Freigabe funktionieren.
2. Kopieren der fertigen Pakete in das Verzeichnis
3. Erzeugen der Paketdatenbank (im Verzeichnis)

## hinzufügen aller Pakete
repo-add mypkgs.db.tar.gz *.pkg.tar.xz 
## hinzufügen eines Pakets
repo-add {reponame}.db.tar.gz {paketname}.pkg.tar.xz

Repository in die Paketverwaltung eintragen

[{reponame}]
SigLevel = Optional TrustAll
Server = http://host/pfad/zur/datenbank

Dabei sollten die Werte für {reponame} in Schritt 3 und 4 übereinstimmen. Wichtig ist dabei, dass man das Siglevel entsprechend anpasst. Optional TrustAll setzt keine Signierung der Pakete durch den Ersteller voraus und bietet sich daher zum Testen an.

Aktualisieren der Paketlisten (auf jedem Rechner)

pacman -Syuu

Fertig ist das eigene Arch Linux Repository. So muss ich nicht alle Pakete auf jedem Rechner mit Arch Linux bauen, sondern kann sie via vServer allen Rechnern an denen ich arbeite bequem aktuell halten. Der nächste Schritt wäre die Signierung und ein bis zwei Spiegelserver. Wobei diese dann auch im LAN stehen könnten.

Ein großer Vorteil von Arch Linux ist ohne Zweifel das Arch User Repository (AUR), welches der Community ermöglicht Pakete in Form von PKGBUILDs bereit zu stellen.

Hierbei handelt es sich um „Vorschriften“ zur Erzeugung der Pakete und beinhalten das Herunterladen und Bearbeiten der Quellen sowie die Installation in einer Fakeroot-Umgebung sowie die Erstellung des Pakets. Natürlich könnte man danach aufhören und mit pacman -U das erzeugte Paket einfach installieren, jedoch kann die Übersetzungszeit bei großen Bibliotheken auf schwächeren Systemen schon mal eine halbe Ewigkeit dauern. Weiterhin können die Pakete aus dem AUR durchaus instabil arbeiten und/oder neue Funktionen enthalten, die das Arbeiten im bisherigen Sinne verkomplizieren oder unmöglich machen. Um mir zu mindestens nur einmal die Zeit für die Erstellung der Pakete nehmen zu müssen, war der Entschluss für ein eigenes privates Repository (plus folgendem Spiegelserver im LAN) schnell gefasst.

Pakete erstellen unter Arch Linux

Wie oben beschrieben, gibt es im AUR schon vorgefertigte Kochrezepte für die Erstellung Pakete.

Also sollte man dort zunächst mit der Suche starten. Als Beispiel habe ich mit die Bibliothek „MAT File I/O Library“ ausgesucht, da ich sie auch des Öfteren für eigene Programme benötige. Das dazugehörige PKGBUILD sieht dabei wie folgt aus:

# Maintainer: Stefan Husmann <stefan-husmann@t-online.de>
# Contributor: Alexander Rødseth <rodseth@gmail.com>
# Contributor: William Rea <sillywilly@gmail.com>

pkgname=libmatio
pkgver=1.5.2
pkgrel=3
pkgdesc='C library with a fortran 90/95 module interface for reading/writing MATLAB MAT-files'
arch=('x86_64' 'i686')
license=('custom:BSD')
url='http://sourceforge.net/projects/matio'
depends=('zlib' 'hdf5')
options=('!libtool' '!emptydirs')
source=("http://downloads.sourceforge.net/matio/matio-$pkgver.tar.gz")
sha1sums=('d5a83a51eb2550d75811d2dde967ef3e167d4f52')

build() {
  cd matio-$pkgver
  ./configure --prefix=/usr --enable-shared --with-hdf5
  make
}
 
package() {
  cd matio-$pkgver
  make DESTDIR="$pkgdir" install
  install -Dm644 COPYING "$pkgdir"/usr/share/licenses/$pkgname/COPYING
}

Die einzige Bedingung für das Gelingen sind also nur ein Internetanschluss und das Paket „base-devel“ (eventuell auch abs) installiert ist und die Abhängigkeiten (siehe depends Zeile) geklärt sind. Lädt man sich diese hier herunter, speichert man es sinnvollerweise in einem Verzeichnis eurer Wahl. wichtig ist dabei, dass es die einzige Datei im Verzeichnis ist. Dies ist notwendig da das Skript, welches von Arch Linux ausgeliefert wird, den notwendigen Verzeichnisbaum für die Paketierung selbstständig erzeugt und es somit zwangsläufig Probleme bei mehr als einem Paket geben wird. Anschließend wechselt man mit dem Terminal in das Verzeichnis und startet das Skript: 

makepkg -s

Das Skript erledigt die im PKGBUILD definierten Aufgaben und komprimiert anschließend das Paket, so das es für pacman verdaubar wird. Ist der Vorgang abgeschlossen, sollte eine Datei mit der Endung „*.xz“ im Verzeichnis vorliegen, welche ihr wie oben beschrieben installieren könnt.

==> Säubere Installation...
  -> Bereinige ungewollte Dateien...
  -> Entferne libtool Dateien...
  -> Entferne static library Dateien...
  -> Entferne leere Verzeichnisse... 
  -> Komprimiere Man-Pages und Info-Seiten...
  -> Entferne unnötige Symbole aus Binär-Dateien und Bibliotheken...
==> Erstelle Paket "libmatio"...
  -> Erstelle .PKGINFO Datei...
  -> Erstelle .MTREE-Datei
  -> Komprimiere Paket ... 
==> Verlasse fakeroot Umgebung.
==> Beendete make: libmatio 1.5.2-2 (Do 18. Sep 10:27:01 CEST 2014)

Weiter mit dem eigenen Repository geht es dann im nächsten Beitrag zu dem Thema. Bei Fragen nutzt bitte die Kommentarfunktion.

Programmiergeräte / Starterkits

Originale Geräte haben zwar meist eine höhere Qualität und lassen sich im Betrieb meist problemlos nutzen, haben meiner Meinung nach aber einen großen Nachteil was die ISP-Schnittstelle angeht. Denn Leider ist bei den meisten ATMEL Boards der VCC Pin spannungslos und wird vom Programmierer stets genutzt um die Versorgungsspannung des Targets einzulesen. Das heißt also, das eine externe Spannungsquelle von Nöten ist. Beim STK600 ist es allerdings möglich die Spannung via AVRStudio zu regeln. Unter Linux hat man bekanntlich kein AVRStudio/ ATMEL Studio, aber die Onlinehilfe gibt Infos bzgl der Connection-Sheets usw..

AVR-Dragon

Sehr preisgünstiger Original-Programmiergerät, welches JTAG, PDI (bei einigen Modellen), ISP und HVPP unterstützt. Leider kommt das Gerät völlig nackt ohne Kabel, Sockel oder Gehäuse daher. Darüber hinaus ist das AVR-Dragon sehr anfällig was statische Aufladungen angeht. Abhilfe was die ESD-Schwäche betrifft kann und soll das Dragon Lair schaffen.

Auf der gleichen Seite findet man auch eine Anleitung wie man eventuell beschädigte Spannungswandler austauscht, da bei einigen Versionen zu kleine Exemplare verbaut wurden. Auskunft bzgl. Pinbelegungen der Programmierschnittstellen, Prototyping-Area etc gibt es in der AVRStudio-Onlinehilfe. Aus eigener Erfahrung kann ich sagen, dass das Gerät trotz der Schwächen zu empfehlen ist.

AVR-MKII

Der wohl beliebteste und weit verbreitetste Programmierer den es zu kaufen gibt. Relativ günstig in der Anschaffung, verfügt er jedoch nur über ISP und PDI als Programmierschnittstellen. Ich besitze privat keinen mkII, aber programmiere damit auf der Arbeit meine Targets.

Starterkit (STK) 600

Der STK500-Nachfolger, scheinbar nicht so angesagt und verbreitet wie das Vorbild. Angesichts des Preises aber auch nicht weiter verwunderlich. Bekommt man das STK500 für knapp 80 € muss man beim STK600 (ohne Daughterboards) mit 300 € schon etwas tiefer in die Tasche fassen. Vorteil gegenüber dem STK500 ist, dass das Starterkit über eine USB-Schnittstelle (STK500 serielle Schnittstelle mit Problemen bei USB-RS232-Wandler, soweit mit bekannt ist) verfügt und sogar bis 300 mA ohne Netzteil betrieben werden kann. Im Lieferumfang sind enthalten :

• STK600
• Netzstrippe ohne Wandwarze ( kann man für 300 € nicht verlangen}
• Flachbandkabel ( zum programmieren )
• USB-B-Kabel
• Daughter-Board mit ATMega2560
• zweipolige Verbindungskabel ( für UART, CAN, TWI denke ich )

Komisch finde ich, dass das Board über eine JTAG-Programmierschnittstelle verfügt, aber das Debugging über jene nicht im Funktionsumfang ist. Nicht umsonst liest man von verdutzten Käufern, dass sie Hilfe beim JTAG-Debugging brauchen und man ihnen meist nur sagen kann : „Es geht nicht!“. Weiterhin ist das sog. DIP-Package sehr interessant, wohinter sich eine Sammlung von Adapter-Boards und ein Daughter-Board mit Testsockel verbirgt um Controller im Dual-Inline-Package flashen zu können.

usbPROG

Die eierlegende Wollmilchsau von Benedikt Sauter Projektseite, die mittels Firmwarepool alles geben kann was man in einen ATMega32 bekommt. Mit der Firmware für den mkII-Klon verwandelt sich das USB-Gerät in einen vollwertigen AVR-Programmer und lässt sich wie das Original via AVRStudio oder avrdude nutzen. Vor kurzem wurde die Firmware aktualisiert, so das man den mkII-Klon auch mit AVRStudio 5 nutzen kann.

mySmartUSB MK2

Das war es auch schon mit dem kurzem Überblick. Sollte jemand noch andere spannende Bibliotheken (außer Arduino-Kram), dann kann er diese ja in einem kurzem Kommentar vorstellen.

Atmel Softwarebibliotheken

Ein wirklich schöner und auf das Wesentliche beschränkter Programmer ist der mySmartUSB MK2 von myAVR. Er bietet neben einem AVR911-Programmer auch noch über die Möglichkeiten einen USB-RS232-Wandler (CP2102) zu nutzen und lässt sich im Betrieb umschalten. Ich besitze ihn zwar immer noch, aber er kommt nicht mehr zum Einsatz.

So nun zum zweiten Teil der (hoffentlich mehrteiligen) Serie. In diesem Beitrag solle es jedoch mehr um die Software-Ebene bzw. genauer um Bibliotheken handeln. Es ist natürlich auch klar, dass ich nicht alle Bibliotheken auflisten kann. Daher beschränke ich mich im Wesentlichen auf die, die ich schon benutzt habe bzw. mit denen ich schon etwas herumgespielt habe. Klassiker wie die TWI-Master- oder die UART-Bibliothek von Peter Fleury lasse ich mal außen vor, möchte sie jedoch wenigstens erwähnt haben. Grund dafür ist, dass man dafür genügend Artikel bei mikrocontroller.net oder ähnlichen Seiten findet.

Software USB 1.1 mit VUSB für Atmel Controller

Unter VUSB (Projekt-Homepage) verbirgt sich eine Softwareimplementierung des USB 1.1 Standards für Atmel Mikrocontroller und stellt eine kostengünstige Alternative zu den USB/RS232-Wandlern der Firma FTDI da. In der gängigsten Variante sind nur 3 Widerstände und zwei Zener-Dioden notwendig um die Hardwareseite zu erfüllen. Ein stark abgespeckter Softcore ist sogar auf einem Atmel ATTiny45 mit internem Oszillator und PLL lauffähig. Vorteil dieser Variante ist, dass der Mikrocontroller weiterhin mit +5V betrieben werden kann.

Kleines Beispiel für eine HID-Schnittstelle:

Hardware USB für Atmel Controller mit USB-Interface

Eine wahre Fundgrube an Beispielen und verschiedenen Implementierungen der USB-Schnittstelle für neuere Controller mit Hardware-Schnittstelle ist die LUFA-Biliothek. Dabei stehen dem geneigten Entwickler eigentlich alle Türen und Tore offen. Ob es nun HI-Devices (Mäuse, Tastaturen oder ähnliches Gerät) oder eine Kommunikationsgerät (bspw. CDC) ist, es ist realisierbar. Nicht umsonst haben die Entwickler der Arduino-Plattform im letzen Hardware-Rework den FT232 von ihren Boards geputzt und ihn gegen einen USB-fähigen Controller ersetzt. Unter den Beispielen der LUFA-Bibliothek sind daher nicht umsonst ein Arduino Programmer (Duce) und ein AVRISP-MK2 Clone vertreten. 😉 Letzterer bildet dabei die Protokolle ISP, PDI und TPI ab und wird vom ATMEL Studio als Original erkannt.

USI TWI-Slave für die kleinen ATTiny-µCs

Martin Junghans stellt auf seiner Projektseite eine Bibliothek samt Beispielimplementierung zur Ansteuerung der USI (Universal Serial Interface)-Schnittstelle als TWI-Interface bereit. Das US-Interface findet besonders bei den kleinen Controllern von Atmel Verwendung. Bisher noch nicht getestet, aber einige Ideen zur Verwendung gäbe es da schon. Die Bibliothek konnte ich erfolgreich einsetzen um bei einem Roboter die Motorsteuerung durch einen ATTiny2313 zu realisieren.

Bspw. bei der Nutzung eines Notebooks möchte man nach Möglichkeit zwischen mehreren Anzeigegeräten automatisch umschalten. Andernfalls müsste man das Gerät immer herunterfahren und nach einem Neustart entsprechend mit xrandr konfigurieren – von Hand natürlich! Nachdem mir das Ganze heute mehr als auf die Nerven ging, habe ich mir auf die „Schnelle“ ein kleines Skript geschrieben und führe dieses nun mittels Udev-Regel aus um automatisch umschalten zu können.

#!/bin/bash

DP2STATUS="$(cat /sys/class/drm/card0-DP-2/status)"
DP3STATUS="$(cat /sys/class/drm/card0-DP-3/status)"
export DISPLAY=:0.0
XAUTHORITY=/home/daniel/.Xauthority
#XAUTHORITY=/var/run/slim.auth

authtoken=$( xauth -f "${XAUTHORITY}"  nlist | cut -d" " -f 9 );
xauth add $DISPLAY MIT-MAGIC-COOKIE-1 $authtoken

## get current display number from process list
# export DISPLAY=`ps aux | grep X |  awk '$12 ~ /:[0-9]/ {print $12}'`

echo "changing" >> /tmp/dock

if [ "${DP2STATUS}" = disconnected ]
then
    xrandr --output LVDS1 --auto --primary --output DP2 --off
elif [ "${DP2STATUS}" = connected ]
then
    if [ "${DP3STATUS}" == disconnected ]
    then
        xrandr --output LVDS1 --off --output DP2 --primary --auto
    else
        xrandr --output DP2 --primary --auto
        xrandr --output LVDS1 --off
        xrandr --output DP3 --right-of DP2 --auto
    fi
fi


/usr/bin/which nitrogen 1 &> /dev/null 2 &> /dev/null
if [ $? -eq 0 ]; then
    nitrogen --restore
fi

Die dazugehörige Udev-Regel sieht folgendermaßen aus:

KERNEL=="card0", ACTION=="change", RUN+="/home/daniel/bin/monitor.sh"

Wichtig ist dabei, dass der Xauthority-Token und das Display exportiert werden, sonst geht es in die Hose. Natürlich sollten die Pfade, die Schnittstelle des Displays und eventuell die Grafikkarte entsprechend angepasst werden.

habe ich die Commits meiner Masterarbeit auch durch gource als Video darstellen lassen. Nicht das man das machen müsste, aber man ist ja irgendwie erleichtert und froh das man das Kapitel ruhen lassen kann.

Noch ein Vortrag und es ist komplett. Wer das selbst mal machen will, der findet das Skript (Einzeiler) hier:

#!/bin/bash
gource -s 0.4 -i 0 -1280x800 --highlight-users --highlight-dirs --file-extensions --hide mouse,filenames --key --stop-at-end \
    --output-ppm-stream - | ffmpeg -y -r 60 -f image2pipe -vcodec ppm -i - -vcodec libx264 -preset ultrafast -pix_fmt yuv420p -crf 1 -threads 2 -bf 0 gource.mp4

Vorbereitung

Zunächst müssen wir uns gitlist von der offiziellen Projektseite herunterladen. Das geht relativ fix mittels wget und sollte keine großen Probleme machen.

# Verzeichnis erstellen
mkdir -p /var/www/gitlist/
# Verzeichnis wechseln
cd /var/www/gitlist
# downloaden von gitlist
wget –no-check-certificate https://s3.amazonaws.com/gitlist/gitlist-0.4.0.tar.gz

Installation von gitlist

Zur Installation sollten wir das Archiv noch entpacken und mit den entsprechenden Rechten versehen.

# Archiv entpacken
tar -xzvf gitlist-0.4.tar.gz
# Rechte anpassen
chown -R www-data:www-data /var/www/gitlist
find /var/www/gitlist/ -type d -exec chmod 775 {} \; 
find /var/www/gitlist/ -type f -exec chmod 664 {} \;
# Cache Verzeichnis benötigt gesondert Rechte
chmod 777 /var/www/gitlist/cache

Schon ist gitlist installiert. Natürlich muss euer Web-Server ( bspw. apache, nginx oder lighttpd) entsprechend konfiguriert werden, damit er den Inhalt auch entsprechend anzeigen kann.

Konfiguration von gitlist

Im erstellten Verzeichnis gitlist sollte sich neben einigen PHP-Skripten auch eine Datei mit dem Namen „config.ini-example“ befinden. Diese wird zunächst kopiert bzw. umbenannt.

cp config.ini-example config.ini

Die Datei sollte im Groben so aussehen:

[git]
client = '/usr/bin/git' ; Your git executable path
default_branch = 'master' ; Default branch when HEAD is detached
repositories[] = '/home/git/repositories/' ; Path to your repositories
                                           ; If you wish to add more repositories, just add a new line

; WINDOWS USERS
;client = '"C:\Program Files (x86)\Git\bin\git.exe"' ; Your git executable path
;repositories[] = 'C:\Path\to\Repos\' ; Path to your repositories

; You can hide repositories from GitList, just copy this for each repository you want to hide
; hidden[] = '/home/git/repositories/BetaTest'

[app]
debug = false
cache = true

; If you need to specify custom filetypes for certain extensions, do this here
[filetypes]
; extension = type
; dist = xml

; If you need to set file types as binary or not, do this here
[binary_filetypes]
; extension = true
; svh = false
; map = true

; set the timezone
[Date]
; timezone = UTC

Unter der Annahme, dass der Befehl git sich unter /usr/bin finden lässt ist Zeile 4 sehr entscheidend. Sie setzt den Pfad, unter dem sich eure Repositories finden lassen. Sollen einige Repositories ausgeblendet werden, so kann man diese nach dem Muster in Zeile 12 einfügen. Es bietet sich an, hier das Repository für die Verwaltung (gitolite-admin) einzutragen.

Anpassung von gitolite

Leider muss die Standard umask von gitolite angepasst werden, da sonst die Rechte zu restriktiv vergeben werden und die Inhalte der einzelnen References aus den Repositories nicht gelesen werden können.

Dazu verändert man die Datei gitolite.rc unter /home/git/.gitolite.rc in Zeile 21 entsprechend ab.

# Orginal
-    UMASK                           =>  0700
# Änderung
+    UMASK                           =>  0002

Führt man diese Änderung nicht aus, so wird gitlist sich jedesmal beschweren, dass es keine Informationen des Repositories lesen konnte und euch mit einer Fehlermeldung begrüßen/abspeisen.

Dabei wird die Einrichtung in zwei Schritte gegliedert:

1. Einrichten der Server-Schnittstelle „gitolite“ (machen wir hier)
2. Einrichten des Webfrontends „gitlist“ (gibt es noch einen Post zu)

Gitolite

Gitolite ist ein Fork bzw. eine Weiterentwicklung des Projektes gitosis und ist in der Lage mehrere Repositories zu verwalten und verfügt obendrein noch über eine Rechte- und Benutzerverwaltung in Form einer Konfigurationsdatei. Die Authentifizierung erfolgt dabei über SSH und Private- bzw. Public-Keys.

Vorbereitung

Da die Installation von gitolite git benötigt, sollte das entsprechende Paket auch installiert sein.

# Paketlisten updaten
apt-get update
# Updates installieren sofern nötig
apt-get upgrade
# das PAket git installieren
apt-get install git

Weiterhin wird zur sauberen Trennung, ein separater Nutzer eingerichtet.

adduser git

Daraufhin wechselt man den Benutzer, nimmt die Umgebung mit und wechselt in das Benutzerverzeichnis des soeben erstellten Benutzers.

su - git
cd ~

Da für die Authentifizierung ein SSH-Publickey (s.o.) benötigt wird, muss dieser zunächst erzeugt werden. Sicherlich kann auch ein bestehender Key verwendet werden, jedoch sollte man hinsichtlich sauberer Trennung einen separaten Key erstellen.

# RSA-Schlüsselpaar erzeugen
ssh-keygen -t rsa

Installation

Zur Installation bleibt eigentlich nicht viel zu sagen. Der aktuelle Stand wird ausgecheckt und über die mitgelieferten Skripte installiert.

# aktuellen Stand klonen
git clone git://github.com/sitaramc/gitolite
# Verzeichnis für die Binaries im Benutzerverzeichnis erstellen
mkdir -p $HOME/bin
# gitolite installieren
gitolite/install -to $HOME/bin
# public-key integrieren
gitolite setup -pk git.pub

Je nach Konfiguration, kann es sein das der letzte Befehl scheitert. Warum? Ganz einfach er kann den entsprechenden Befehl nicht finden, da nicht jede Distribution per Default das bin-Verzeichnis im Home an den PATH anhängt. Schnelle Abhilfe schafft ein entsprechender export oder ein Aufruf mit vollem Pfad.

$HOME/bin/gitolite setup -pk git.pub

Soweit so gut, ist man soweit gekommen, ist eigentlich alles Nötige erledigt und gitolite funktioniert.

Abschluss

In einer lokalen Shell kann nun das Repository für die Konfiguration ausgecheckt werden und Benutzer sowie Repositories hinzugefügt werden.

git clone git@example.com:/gitolite-admin

Daraufhin erhält man einen neuen lokalen Ordner „gitolite-admin“. Darin befinden sich die Ordner keydir und conf. Möchte man einen neuen Public-Key hinzufügen, so kopiert man diesen als Datei in den Ordner keydir und für innerhalb der Konfiguration im Ordner conf die entsprechenden Einträge hinzu. Dabei sieht die Konfiguration schematisch so aus:

@entwickler = daniel felix simon
@admins = git 

repo meinprojektrepo
    RW+ = daniel
    RW = felix
    R = @entwickler

Dabei entsprechen @entwickler und @admins Gruppen, welche das hinzufügen von Benutzern recht komfortabel gestalten. Möchte man alle Nutzer hinzufügen bietet gitolite die Gruppe @all an. Die Zeile „repo meinprojektrepo“ stellt dabei ein Repository dar und definiert die Zugriffsrechte der Benutzer auf das Repository. Möchte man weitere Repositories erstellen, fügt man einfach weitere Abschnitte hinzu und gitolite wird die entfernten Repositories mit dem nächsten push erstellen und entsprechend einrichten.

# neuen Public-Key hinzufügen
git add keydir/neuer_key
# Änderungen commiten/einpflegen
git commit -am "Neuer Key von Max Mustermann"
# Änderungen an Remote-Server übertragen
git push

So das war es eigentlich. Da der Post relativ lang geworden ist, werde ich den Part über gitlist später in einem weiteren Post erläutern. Sollten Fehler oder Fragen existieren, bitte einfach melden.

Zeilenumbrüche (^M) entfernen:

:%s/^V^M//g

Wobei ^V und ^M durch gedrückt halten der Steuerungstaste (STRG/CTRL) und des jeweiligen Buchstabens gebildet werden.

N Zeilen auskommentieren:

Unter der Angabe des Bereichs mit absolutem Start- und Endwert

<Startzeile>,<Endzeile>s/^/#/

Oder unter Angabe der Startzeile und der Anzahl der Zeilen

:<Startzeile>,<+-Zeilenanzahl>s/^/#/

Dabei ist die Raute (#) das jeweilige Zeichen um einen Kommentar einzuleiten. Für Octave-Code würde man das Prozentzeichen wählen (%) oder bei C/C++-Code eben // wobei diese jedoch jeweils mit einem vorangestelltem \ versehen werden müssen. Natürlich kann man damit auch alles Andere auf die Zeilen anwenden. Entfernen kann man die Kommentare natürlich auch wieder.

:<Startzeile>,<Endzeile>s/^#//

Für die Kombination aus Start- und Endzeile, sowie für die Angabe von Startzeilen und der Anzahl der folgenden Zeilen:

:<Startzeile>,<+-Zeilenanzahl>s/^#//

KiCAD beziehen

Für die üblichen Plattformen wie Windows, Linux usw. gibt es Pakete bzw. Installationsroutinen auf der Homepage. In der Regel sind diese jedoch etwas „gesetzt“. Möchte man eine aktuelle Version des Entwicklungszweigs nutzen, bleibt daher nur das eigenhändige Kompilieren. Unter MacOSX existieren ein oder zwei verschiedene Build-Scripts, wobei der Build-Vorgang wohl mehr oder weniger erfolgreich ist. Für Ubuntu wie üblich ein PPA. Unter Arch Linux nutzt man für den aktuellsten Stand das PKGBUILD aus dem AUR. Natürlich ist bei sämtlichen Build-Skripten zu bedenken, dass das Resultat mehr oder weniger stabil ausfallen kann. Sogar für Windows-Nutzer hat sich jemand erbarmt und versucht den Build-Vorgang in ein Skript zu packen und somit die Unbekannten Gefilde vor ihm zu vestecken.

KiCAD-Videos

Klar gibt es auch Videos und einige Video-Tutorials. Playlist

KiCAD-Quellen

Da ein EDA-Programm nur so gut ist wie seine Bauteilquellen, folgen nun einige gute Quellen für ebensolche. Dabei ist jedoch auf die Lizenzen des jeweiligen Autors zu achten. Sollte jemand noch weitere Bibliotheken kennen, dann würde ich mich über eine kurze Meldung freuen.

kicadcloud (hauptsächlich Bauteile, Footprints) smisioto (Bauteile, Footprints und 3D-Modelle) Renie S. Marquet (Bauteile, Footprints und 3D-Modelle) Konvertierte EAGLE Bibliotheken (Bauteile und Footprints) saturnal.eu (Bauteile, Footprints und 3D-Modelle)

Programme wie MATLAB oder Octave sind schon recht hilfreiche Programme, wenn es darum geht Daten mathematisch auszuwerten oder zu visualisieren. Dabei ist es oftmals extrem nervig, wenn mehrere Dateien des gleichen Typs verarbeitet werden – also mittels Stapel- oder Batchverarbeitung – sollen um bspw. Trainingsdaten für einen Klassifikator zu verarbeiten etc.. Für MATLAB ist mir dazu mal eine 32-Bit-DLL untergekommen, aber leider funktioniert diese nicht unter Octave.

Oct-Files - Funktionsumfang

Daher habe ich mir ein oct-File geschrieben, welches genau diese Aufgabe übernimmt. Oct-Files sind dabei das Pendant zu den mex-Files von Matlab und stellen eine C++-API bereit um den Funktionsumfang von Octave zu erhöhen.

DEFUN_DLD ( scandir , args,  , "-*- texinfo -*-\n\
        @deftypefn {Scan Dir} {} scandir (@var{n}, @var{m})\n\
        A function that scans the passed directory for files with the given files extension.\n\
        This could be helpfull for writing applications where serveral files schould be proccessed in batchmode.\n\
        @end deftypefn" )
{
        /* return values */
        octave_value_list retval;
        /* number of input arguments */
        int nargin = args.length ();

        /* do something fancy */

        /* return results */
        return retval;
}

Dabei habe ich mir ein entsprechendes octfile geschrieben, um einen angegebenen Pfad nach Dateien einer bestimmten Endung durchsucht und eine Liste dieser Dateien als CharMatrix zurück liefert. Dabei kann die so kreierte Funktion „scandir“ – sofern im Suchpfad von Octave – wie jede andere Funktion aufgerufen werden:

[~/Dokumente/Projekte/Messdaten/Volumen]$ ls                                                                         
Tauchtechnik_Schallfeld_ZEUS  WS1232-10KK200-03.3d
[~/Dokumente/Projekte/Messdaten/Volumen]$ octave -q
octave:1> dir = pwd
dir = /home/daniel/Dokumente/Projekte/Messdaten/Volumen
octave:2> name = scandir (dir, '3d' )
name = /home/daniel/Dokumente/Projekte/Messdaten/Volumen/WS1232-10KK200-03.3d

Somit ist es möglich mehrere Dateien (plus Pfad) automatisch in einer Liste zu verwalten und ggf. an seine Octave-Skripte übergeben und somit recht viel Zeit gespart werden. Damit ist nun die Batchverarbeitung recht einfach möglich. Ich hoffe das Ganze ist für den ein oder anderen nützlich.

Octave Oct-file Scandir

Patch erstellen

git diff --no-prefix > patchfile

Patch einspielen mit patch

patch -p0 < patchfile

Sollte –no-prefix weggelassen werden, dann enthält der Patch die Prefixe a/ b/ für die Quelldateien. Mit folgender Änderung werden diese ignoriert.

patch -p1 < patchfile

Patch einspielen mit git apply

git apply --index patchfile

Beschleunigungssensoren (ADXL345) sind ja nahezu alltags-tauglich und begleiten mittlerweile fast jedermann im Smartphone oder Tablet. Interessant sind sie daher auch für eigene Spielerreien. Da ich noch ein eBay-Modul rumliegen hatte und sowohl für den Beschleunigungssensor als auch für das Raspberry Pi einen halbwegs sinnvollen Zweck finden wollte, dachte ich mir ich verheirate die beiden miteinander.

Überrascht war ich als ich sah, dass Analog Devices wohl recht aktiv in der Dokumentation und Entwicklung von Gerätetreibern unter Linux (device drivers) ist und es ein nahezu fertiges Kochrezept für das Raspberry Pi gibt.

Einrichten der Entwicklungsumgebung

# Arbeitsverzeichnis erzeugen
mkdir RaspberryPi
cd RaspberryPi
# Entwicklungstools klonen
git clone https://github.com/raspberrypi/tools.git
# Kernelquellen klonen
git clone https://github.com/raspberrypi/linux.git

Anwenden des/der Patchfiles

Leider funktionieren die Patch-Files aus dem Analog Devices-Wiki nicht mehr mit der aktuellen Version. Daher habe ich die Änderungen manuell übernommen. Zunächst benötigen wir die Änderungen, welche ich als Patch (Ausgabe von diff) zum Download bereitgestellt habe. Somit ist es nicht notwendig die Änderungen bzgl. des aktuellen Stands vom Kernel-Repository per Hand einzupflegen. Das geht natürlich auch, aber warum mehr Arbeit als nötig aufhalsen. Hat man das Repo ausgecheckt und das Patch-File im aktuellen Ordner (linux), so folgt das normale „Applying“ via Git.

git apply path/file.patch

Kompilieren des Kernels und der Module

# Exportieren der relevanten Informationen zum Übersetzen
export PATH=PFAD_ZU_TOOLS_ORDNER/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/:$PATH
export ARCH=arm
export CROSS_COMPILE=arm-linux-gnueabihf-
# Konfigurieren
make bcmrpi_defconfig
# Starten des Kompilierens
make

Übernehmen des Kernels und der Module

cp arch/arm/boot/zImage /PFAD_ZUR_FAT_PARTITION_SDKARTE/kernel.img
sudo ARCH=arm make modules_install INSTALL_MOD_PATH=/media/10b4c001-2137-4418-b29e-57b7d15a6cbc</pre>

Das Wichtigste zum Anfang ist es natürlich alle angeschlossenen Geräte – in diesem Fall USB-Geräte – ausfindig zu machen. Wie der unten stehende Code zeigt, ist dies recht schnell erledigt. Wichtig ist dabei eigentlich nur ?*INSTR, welches an jedes angeschlossene Gerät geschickt wird. Anschließend erhält man als Antwort die Identifikationsnummer. Alles Andere ist nun abhängig von den implementierten Befehlen des Geräts selber, wozu man die Dokumentation des Herstellers konsultieren sollte. PS: Die maximale Wiederholrate ist limitiert auf 50 Hz. Diese wird durch das Gerät und nicht durch die Applikation oder Qwt oder Sonstiges herabgesetzt.

#include <QtCore/QCoreApplication>
#include <visa.h> 

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

        ViUInt32 retCnt=0; 
        char buf [256] = {0}; 
        char instrDesc[100]={0}; 
        ViSession defaultRM,vi; 
        ViStatus status; 
        ViFindList find_list; 
        viOpenDefaultRM (&defaultRM); 
        status = viFindRsrc(defaultRM, "USB0::?*INSTR", &find_list, &retCnt, instrDesc); 
        status = viOpen(defaultRM,instrDesc, 
                VI_NULL,VI_NULL, &vi); 
        if (status != VI_SUCCESS)
        { 
            printf("Can not find USBTMC device!\n"); 
                viClose(vi); 
                viClose (defaultRM); 
        } else {
            printf("USBTMC device : %s\n",instrDesc); 
                viPrintf(vi,"*idn?\n"); 
                viScanf (vi, "%t", &buf); 
                printf("%s\n",buf); 
                viClose (vi); 
                viClose (defaultRM); 
        }
    return a.exec();
}

Ich muss mal schauen wo ich das Programm geparkt habe. Eventuell kann man ja doch noch etwas Sinnvolles daraus machen.

Anschließend wurde der Pegelwandler für die RS232-Schnittstelle entfernt und gegen einen Adapter in Form eines Lochrasteraufbaus ersetzt. Dieser ermöglicht die Nutzung des BTM-Mini-S-Moduls, also eines Raysons BTM-222 Bluetooth-SPP (Serial over Bluetooth) Adapters. Die Schnittstelle soll später noch einmal gegen eine USB-Serial-zu-Wlan-Bridge ausgetauscht werden (wenn die Chinapost noch ankommen sollte). Soweit so gut. Der mitgelieferte ATmega32 wurde durch einen ATmega1284P getauscht. Zwar würde der Mega32 sicher fürs Erste reichen, aber der Tatendrang will befriedigt werden.

Abschließend muss man eigentlich nur noch bemerken, dass sich Hausschuhe auf Laminat hervorragend statisch aufladen können. Die LED zu Anzeige der Akkuspannung hat es beim Anschalten nicht überlebt. Eventuell ist so ein Armbändchen doch nicht ganz verkehrt!

Die Wahl viel dabei auf eine Vernetzung von mehreren Teilkomponenten mittels TWI oder I²C. Gesagt getan, das erste Modul lief auf dem Steckbrett und funktioniert nun auch als Lochrasteraufbau,nur zur Platine hat es bisher noch nicht reichen wollen.

Für die Kommunikation mit der USI-Schnittstelle des Tinys hat sich Martin Junghans schon Gedanken gemacht. Daher war die Anpassung/Erweiterung nicht sonderlich schwierig und konnte nach kurzer Zeit mittels BusPirate getestet werden. Hinzu sind noch die Rad-Encoder für das Chassis (RP6v2-Encoder) gekommen, welche man seit einiger Zeit separat bei Conrad erstehen kann. Mittlerweile kann man nahezu alles per TWI konfigurieren und sogar im EEPROM des AVRs speichern.

Da wären :

• Tastgrad für alle PWM-Ausgänge separat variiert werden
• Vorteiler für PWM-Frequenz können paarweise gesetzt werden
• PWM-Ausgänge können komplett deaktiviert werden
• Encoderwerte können ausgelesen uns zurückgesetzt werden
• Laufrichtung für zwei (vier gingen mit Anpassungen auch) Motoren kann gesetzt und invertiert werden
• Speichern der aktuellen Einstellungen im EEPROM

Natürlich kann jeder Parameter auch gesetzt werden. Interessanter Weise ist trotz der Programmierung in C noch etwas Platz übrig.

Program Memory Usage   : 1354 bytes   66.1 % Full
Data Memory Usage      :   19 bytes   14.8 % Full
EEPROM Memory Usage    :    8 bytes    6.3 % Full

Was die Überlegung weckt die Regelung für den Geradeauslauf (wenn mal Zeit ist) noch zu integrieren.

Der Code und etwas Dokumentation ist ab sofort auf Github zu finden.

• Ab in den abgesicherten Modus und als User mit Adminrechten einloggen (auch wenn es der ist, der nicht mehr funktioniert!)
• regedit öffnen und nach : HKEY\_LOCAL\_MACHINE\SOFTWARE\MICROSOFT\WindowsNT\CurrentVersion\ProfileList gehen
• Profil suchen, welches hinten ein .bak aufweist (das sollte zweimal vorkommen!)
• das ohne .bak in Name.old umbennen und anschließend bei dem anderen das .bak entfernen
• Den Wert State auf 0 setzen
• Neustarten und freuen!

Nach ein wenig „Durchklingeln“ und Internetrecherche konnte ich die SMD-ICs mit der Aufschrift AHT als Analogschalter identifizieren. Wermutstropfen ist jedoch, dass diese nicht mehr produziert werden. Zum Glück hat aber TI, bis auf den Namen, identische im Programm welche man auch als Muster bekommen konnte.

Nach etwas Gefummel – die defekten ICs gingen schneller runter als die neuen drauf waren sie dann auch ausgetauscht. Nach einem erfolglosen Test, bemerkte ich heute eine Lötbrücke an zwei Pins, welche ich schnell entfernte. Firmware-Update mit AVRStudio 5 durchgeführt und alles war wieder in Butter. 50 € gespart und verdammt viel Glück gehabt, dass es nicht der Spannungswandler war.

Wie unter Unixoiden üblich geschieht die mittels Pipe. Da das Bootimage mit GZip komprimiert wurde, erledigt zcat das Dekomprimieren und Kopieren in einem Rutsch. Wichtig ist hier nur, dass alle Partitionen die sich auf den Stick befanden überschrieben werden.

Eine Angabe der Partitionsnummer ist auch nicht notwendig, da wir diese ja gerade erstellen wollen. Daher genügt die Angabe des entsprechenden Blockdevices, welche für unseren Stick steht.

wget ftp://ftp2.de.debian.org/debian/dists/squeeze/main/installer-i386/current/images/hd-media/boot.img.gz
zcat boot.img.gz > /dev/sdb

Der Vorgang kann, je nach USB-Stick und dessen Schreib-/Lesegeschwindigkeit etwas Zeit in Anspruch nehmen.

2. Schritt Dateien auf den Stick bringen und fertig

So der erste Schritt ist getan. Der Debian-Installer ist auf dem Stick, welcher auch bootfähig ist. Fehlt nur noch das ISO-Image der Netzwerkinstallation. Diese kann man mit folgenden 4 Zeilen schnell und bequem auf den Stick werfen und ist fertig.

mount /dev/sdb1 /mnt
cd /mnt
wget http://cdimage.debian.org/debian-cd/6.0.1a/i386/iso-cd/debian-6.0.1a-i386-netinst.iso
cd
umount /mnt

So nun haben wir einen bootfähigen Stick, welcher alles Notwendige beinhaltet um eine Installation über das Netzwerk vorzunehmen. Danach hat man eine minimale Installation und alle Pakete werden via Internet in der aktuellsten Version installiert. So spart man sich auch gleich die Update-Orgie nach der Installation.

Quellen:

• Philips/NXP Application Note AN97055
• Datenblatt PCA9306

Wobei „Punching In A Dream“ auch sehr cool ist. Aber das kann man sich bei folgender YouTube-Playlist per Auto-Replay reinpfeiffen.

Nun versuchte ich die aktuelle Version, die übrigens auf github zu finden ist, zu übersetzen und scheiterte fürs Erste. Nach kurzem Suchen im Internet, war das Problem gefunden und kurz darauf auch gefixet. Das Problem bestand darin, dass nicht gegen die Xlib-gelinkt wurde usw. usw.. Da mein Window-Manager keine dekorativen Elemente wie Kreuze zum Schließen hat, habe ich auch einen Quit-Button eingefügt, so muss der Prozess nicht jedes mal abgewürgt werden. Im Übrigen hat die Gtk einen schlechteren Ruf, als sie wirklich ist. Als Gtk-Novize war das Anpassen mit Google und der Dokumentation kein wirkliches Problem.

Patch for nitrogen Quit button and xlib

• Apple-Produkte nur wegen des Styles her
• Wenn Apfel, dann ganz Apfel

Nun ganz so ist es jedoch nicht. Durch den ganzen Kram von Uni, Arbeit und meinem privatem Elektronik-Bastel-Krams habe ich immer weniger Platz auf dem Schreibtisch. Da kommt kommt die kleine Apfel-Tastatur genau richtig, denn Sie hat einen recht schmalen Formfaktor. Da mir bisher immer noch das nötige Kleingeld fehlt um mir ein Apfel-Komplettpaket hinzustellen, wird das auch sicherlich noch eine ganze Weile auf sich warten lassen müssen. Aber zurück zur Tastatur. Diese wird via Bluetooth in das bestehende System eingebunden, wobei eigentlich keinerlei Gerätetreiber notwendig sind. Nun kommen die bisher einzigen Haken an dem Gerät.

• Zum einen ist man, wenn man ins BIOS oder bei GRUB ein anderes OS auswählen möchte komplett aufgeschmissen
• Die Funktionstasten funktionieren nicht out-of the-box
• Für knappe 70 Tacken, hält man es bei Apple nicht für nötig einen Bluetooth-Dongle oder Ähnliches beizulegen (hier wird darauf gebaut das die Mac-Hardware Bluetooth intern verbaut hat)
  Die doppelt belegten Tasten lassen sich mit den entsprechenden Bootcamp-Treibern schnell in Gang bringen und die Multimedia-Tasten kann man, wenn man möchte mit dem Tool AppleWirelessKeyboard von Codeplex mit Overlay-Grafik zur Funktion überreden. Vorausgesetzt ist natürlich, dass man einen entsprechenden Dongle in der Schublade liegen hat oder wie bei der Apple-Hardware auf internes Bluetooth setzen kann. Alles in allem funktioniert das Keyboard ausgesprochen gut. Der Tastenanschlag ist sehr angenehm und durch die geringen Maße geht das Tippen deutlich schneller von der Hand als bei meiner alten Cherry-Tastatur. Durch den leichten Neigungswinkel den die Tastatur hat, sind die Tasten sehr gut zu erreichen und es fühlt sich an, als würde ich meine M1330-Tastatur benutzen. Gewöhnungsbedürftig sind die Shotcuts für Delete, die Bildlauf-Tasten und Pos1 bzw. Ende. Allerdings muss man nun einmal damit leben, wenn man eine Winzlingtastatur kauft, dann muss der Platz schließlich irgendwo auch eingespart werden.

In dem Sinne viel Spaß beim Anschauen und eine schöne Restwoche. (Morgen ist ja schon Bergfest !!)

Download der Images

Man sucht sich einen Mirror für das Diskimage seiner Wahldistribution und lädt die 12 MB große Datei herunter:

http://mirrors.kernel.org/centos/5.5/os/i386/images/

Partition erzeugen und Kopieren auf den USB-Stick

Um die Partition zu erzeugen, gibt es wie immer viele Möglichkeiten und es zählt, was  funktioniert. Also gparted, Windows oder fdisk, Hauptsache man hat am Ende eine Partition. Anschließend wird diese noch FAT formatiert, wobei die Größe der Partition die Entscheidungshilfe für FAT16 oder FAT32 gibt. Danach kommt der finale Schritt mit dd, wo kein Weg dran vorbei führt. Als Beispiel die Prozedur unter Linux in der Shell mit fdisk :

fdisk -l /dev/sdb
mkfs -t vfat /dev/sdb1
dd if=diskboot.img of=/dev/sdb

Booten und Quelle angeben

Nun sollte der Stick seinen Weg in die USB-Buchse des Zielsystems finden und als Bootmedium der Stick gewählt werden. Ist man in der Installation bei der Wahl der Paketquellen  angekommen, so gibt man einen Mirror und den Pfad zu den Paketen an.

SVN-Repository mit git-svn auschecken

git svn clone --username user http://host/url

Updates vom SVN holen

git svn rebase

Lokale Änderungen aus dem Git-Repository ins SVN schieben

git svn dcommit

Die Infos kommen natürlich nicht von Irgendwo. Die hatte ich vor einiger Zeit auf siriux.net gefunden.

ifconfig eth0:X down
ifconfig eth0:X hw ether 00:11:22:33:44:55
ifconfig eth0:X up

Damit kann man auch gleich ganze Ranges kapern. Nur mal nebenbei gesagt, ihr alten Seebären. Da fällt mir gerade ein, noch daran zu erinnern, dass durch diese Zeilen ein MAC-Filter im WLAN-Router auch völlig unsinnig ist. Aber wen es beruhigt…