kevin's blog

microapl is a wrapper script for micro_evtd, which passes the corresponding hexadecimal value for setting different values of your buffalo linkstation. In my case, debian squeeze was installed onto a Buffalo LS-Pro v1.

There are two types of controlling the leds: With “mcon”, the leds are controlled by the linkstation. With “cpu”, you can set the leds by yourself.

To get all possible settings, type in:

root@box:~ microapl
option: boot_start
boot_end
power_off
shutdown_wait
shutdown_cancel
skip_standby
delay_standby
standby
reboot
temp_get
fan_set_speed [arg]
fan_get_speed
bz_on [arg]
bz_set_freq [arg]
bz_melody tempo note ...
bz_imhere tempo note ...
int_get_switch_status [arg]
led_set_bright [arg]
led_set_cpu_mcon [arg]
led_set_on_off [arg]
led_set_blink [arg]
led_set_code_error [arg]
led_set_code_information [arg]
led_set_cpu_mcon [arg]
mcon_get_status
hdd_set_power [arg]
mcon_get_version

As you see, you can do many cool stuff, for example play a melody with bz_melody, or set and get the fan speed. Just try out.

To get the current controlling type of the leds (cpu or mcon), type in:

root@box:~ microapl -a led_set_cpu_mcon
#[microapl.led_set_cpu_mcon]
led_power=mcon
led_info=mcon
led_diag=mcon
led_link=mcon

If you want to change the diag-led (error, red) by yourself, set the the led_diag value to “cpu”:

root@box:~ microapl -a led_set_cpu_mcon diag
root@box:~ microapl -a led_set_cpu_mcon
#[microapl.led_set_cpu_mcon]
led_power=mcon
led_info=mcon
led_diag=cpu
led_link=mcon

Now the value of led_diag is changed changed to “cpu”. To light up the diag-led, type in:

root@box:~ microapl -a led_set_on_off diag
root@box:~ microapl -a led_set_on_off
#[microapl.led_set_on_off]
led_power=off
led_info=off
led_diag=on
led_link=off

To change the power, link, info and diag led to cpu and light them up, type in:

root@box:~ microapl -a led_set_cpu_mcon power info diag link
root@box:~ microapl -a led_set_on_off power info diag link

To change everything back to mcon (default), just use “off” as parameter:

root@box:~ microapl -a led_set_cpu_mcon off

Have fun!

Für ein kleines Projekt möchte ich unter Python Werte vom Arduino darstellen. In Python nutze ich hierbei das pyserial Modul, welches plattformunabhängig sehr einfach eine serielle Verbindung aufbaut.

Unter Python wird eine Anfrage gestellt, die der Arduino mit Werten definierter Größe beantwortet. Unter Arduino werden die Werte je nach Größe mit den Funktionen serial_uint8 bis serial_uint32 in einzelne Bytes (little-endian) geteilt. Auf der Gegenseite unter Python wird mit dem struct-Modul das Bytearray nach einer vorgegebenem Format wieder in einzelne Bytes entteilt.

Die Python Struct-Formate findet man hier. Die PySerial Dokumentation gibt es hier.

Python-Code:

import serial
import time
import struct
 
""" setup serial for arduino """
ser = serial.Serial()
ser.port = 2
ser.baudrate = 9600
 
""" open serial port """
ser.open()
 
while 1:
 
    """ request values from arduino """    
    ser.write("s")
 
    """ wait until all bytes were read """
    while ser.inWaiting() != 0:
 
        """ unpack format, little endian """
        unpack_fmt = "<BLbHHHH"
 
        """ read bytes as described in unpack_fmt """
        val = ser.read(size=struct.calcsize(unpack_fmt))
 
        """ display values """
        print struct.unpack(unpack_fmt, val)
 
    time.sleep(1)

Arduino-Code:

void setup() {
  Serial.begin(9600);
}
 
uint8_t serial_buffer[128];
uint8_t serial_buffer_pos = 0;
 
void serial_uint8(uint8_t val) {
  serial_buffer[serial_buffer_pos++] = (val & 0xFF);
}
 
void serial_uint16(uint16_t val) {
  serial_buffer[serial_buffer_pos++] = (val & 0xFF);
  serial_buffer[serial_buffer_pos++] = (val >> 8) & 0xFF;
}
 
void serial_uint32(uint32_t val) {
  serial_buffer[serial_buffer_pos++] = (val & 0xFF);
  serial_buffer[serial_buffer_pos++] = (val >> 8) & 0xFF;
  serial_buffer[serial_buffer_pos++] = (val >> 16) & 0xFF;
  serial_buffer[serial_buffer_pos++] = (val >> 24) & 0xFF;
}
 
void serial_init() {
  serial_buffer_pos = 0;
}
 
void serial_send() {
  for (int i = 0; i < serial_buffer_pos; i++) {
    Serial.write(serial_buffer[i]);
  }
}
 
int readByte = 0;
 
void loop() {
 
  if (Serial.available() > 0) {
 
    readByte = Serial.read();
    switch (readByte) {
      case 's':
        serial_init();
        serial_uint8(1);
        serial_uint32(millis());
        serial_uint8(100);
        serial_uint16(random(8, 2200));
        serial_uint16(random(8, 2200));
        serial_uint16(random(8, 2200));
        serial_uint16(random(8, 2200));
        serial_send();
        break;
 
      case 'r':
        serial_init();
        serial_uint8(random(0, 250));
        serial_send();
        break;
    }
  }
}

Das Ergebis sieht so aus:

(1, 1375424, 100, 1463, 927, 1220, 715)
(1, 1376425, 100, 663, 1552, 470, 308)
(1, 1377426, 100, 923, 711, 1963, 571)
(1, 1378427, 100, 732, 1259, 618, 1629)
(1, 1379428, 100, 1493, 378, 396, 80)
(1, 1380429, 100, 1115, 753, 409, 1894)
(1, 1381431, 100, 1968, 1328, 287, 413)
(1, 1382431, 100, 135, 1310, 1237, 823)
(1, 1383433, 100, 794, 1352, 1923, 439)
(1, 1384433, 100, 550, 632, 116, 175)

Python:

""" two byte integer """
val = 42131 # bin: 1010 0100 1001 0011 hex: 0xa493
print hex(val)
 
byte1 = val & 0xFF # first 8 bit
byte2 = (val >> 8) & 0xFF # last 8 bit
 
print "byte1: " + hex(byte1) # result: 0x93
print "byte2: " + hex(byte2) # result: 0xa4
 
""" merge two bytes into 2-byte integer """
val_m  = (byte1 & 0xFF)
val_m |= (byte2 & 0xFF) << 8
print hex(val_m) # result: 0xa493

Nach mehreren Wochen Experimentierens konnte ich nun meine erste Platine mit Hilfe des Toner-Transferverfahrens fertigstellen. Dabei nimmt man einen Laser-Drucker (günstig von eBay, z.b. HP Laserjet 1010) und druckt sein Layout auf ein geeignetes Papier (Reicheltkatalogpapier eignet sich dafür). Danach überträgt man den Toner mittels Bügeleiesen oder Laminiermaschine auf die Kupferschicht der Platine (vorher mit Aceton reinigen). Spülwasser und ein wenig rubbeln erledigen den Rest, danach ist der Toner fast krazfest auf der Platine und kann geätzt werden.

Meine Platine für den diesjährigen Pyro-Fernzünder Empfänger hat relativ gut geklappt (nach dem dritten Anlauf):

Darauf befindet sich ein Atmega 328 mit Arduino Bootloader, ein MAX232 für die Kommunikation mit einem Handy, ein 434Mhz Funkmodul und ein ULN2803A als Relaistreiber. Auf dem Foto sehen die Leiterbahnen leicht unterbrochen aus, sind aber sehr durchgängig und mit einer breite von 36mil auch relativ groß. Zum Schutz sind die Leiterbahnen mit Plastik 70 Isolierlack besprüht. Die Bohrlöcher konnte ich mit einer großen Ständerbohrmaschine problemfrei mit 0,8mm und 1mm bohren.

Zwei kleine Fehler im Layout konnte ich durch ein Kabel am Boden und einer Drahtbrücke fixen. Nur hat blöder weiße die Maße des RF-Moduls von Sparkfun nicht gepasst, so dass ich den Antennen Pin verbiegen mußte. Aber immerhin klappt nun alles und Silvester kann kommen :)

Nach nun über 3 Stunden habe ich es endlich geschafft mein Nokia 6210 über ein DLR-3p Datenkabel (original mit FBus auf RS232-Konverter) durch einen MAX232N IC mit meinem Arduino sprechen zu lassen. Hier erstmal die Eagle-Schematik:

Benötigt wird:
1x MAX232
4x 10uF Elkos (sollte zwischen 1uF bis 22uF passen -> Datenblatt des jeweiligen ICs)
1x 100nF Keramikkondensator als ByPass
1x Male D-Sub9 Stecker

Nach einigen erfolglosen Anläufen hat mir dbzoo die Lösung gegeben: Beim D-Sub9 Stecker muss Pin 4 (DTR) auf VCC, damit der Arduino vom Datenkabel als DCE gesehen wird, da er sonst nicht will.
Edit: Man muss auch noch Pin 7 (RTS) auf VCC legen, dann empfängt man auch RX.

Zum testen habe ich folgendes einfaches Programm, welches mittels AT-Befehle ein Telefonat aufbaut:

void setup() {
  Serial.begin(9600);
}
 
void loop() {
  Serial.println("AT");
  delay(500);
  Serial.println("ATD0711123123");
  delay(5000);
}

Mit den Django Extensions lassen sich in den Modellen sehr einfach UUIDs anstelle der üblichen Autoincrement IDs nutzen.

Unter Debian installiert man hierzu das Paket python-django-extensions:

apt-get install python-django-extensions

Danach fügt man in seiner settings.py das Paket hinzu:

INSTALLED_APPS = (
    ...
    'django_extensions',
)

Die myapp/models.py kann nun wie folgt aussehen:

from django.db import models
from django_extensions.db import fields as exfields
 
class List(models.Model):
    id = exfields.UUIDField(primary_key=True)
    name = models.CharField('name of list', max_length=200)

Wer einen alternativen Titel auf WordPress-Seiten haben möchte, kann sich folgendem Hack bedienen:

<h2><?php
$custom = get_post_custom();
echo (array_key_exists("title", $custom)) ? $custom["title"][0] : the_title();
?></h2>

Diese Änderung in der index.php, single.php und page.php durch folgenden vorhandenen Teil ersetzen:

<h2><?php the_title(); ?></h2>

Standardmäßig nutzt WordPress für den Titel und Navigationslink den selben Text. Mit diesem kleinem, handlichen Hack lassen sich nun alternative Titel über ein benutzerdefiniertes Feld mit dem Wert “title” anzeigen. Zusammen mit All-in-One-Seo, welches zusätzlich den Title im Header ändern kann, hat man jegliche Titel-Freiheit.

Nach einigen Rezepten wie man den originalen Mojito herstellt, fand ich das *echt kubanische Mojito-Rezept* auf der Havana Club Website in Form eines Videos. Nach dem uns der Türsteher hereinlässt, verät uns der Barkeeper das Rezept:

• 2 Teelöffel Zucker in ein Glas geben
• Saft einer 1/2 Limette (genügend, um den Zucker zu bedecken)
• 2 frische Minzezweige und
• 9cl Mineralswasser hinzugeben
• Alles gut mischen (mit dem Stößel)
• 4,5cl Havana Club 3 Jahre
• 4 Eiswürfel dazu geben
• Gut umrühren

Wie man sieht, kommt anstelle des mir bekannten Rezeptes kein Rohrzucker und keine ganzen Limettenstücke rein. Aber am wichtigsten ist natürlich die frische Minze, welche am besten frisch vom Garten kommt. Die originale Hemminwayminze ist die Mentha species ‘Nemorosa’, es gehen aber auch andere Minzen wie z.b. die Grüne Minze.

Witzig: Das in Japan entwickelte Spiel “Puck-Man” wurde in den USA in “Pac-Man” umbenannt, da sonst Kids das Spiel mit “F” aussprechen könnten.