Zur Darstellung des aktuellen Wattzahlen werden dabei im Arduino die Millisekunden zwischen zwei Flanken auf dem Eingang gezählt. Bei 1000 Impulsen pro kWh entsprechen 3600 Millisekunden zwischen den Flanken einem angeschlossenen Verbraucher mit 1000 Watt.

/** Hilfsprogramm zur Auswertung der Zähler
* Maximal 8 SO-Zähler können angeschlossen werden, die mit folgendem Protokoll
* an die serielle Schnittstelle ausgegeben werden:
*
* byte0  byte1     byte2     byte3      ...
* A-H    0-9       0-9       0-9        \n
* Kanal  Millis                         Newline
*
* Die Millis sind dabei die Millisekunden zwischen den letzten beiden Low-High-Flanken
* auf dem angegebenen Kanal.
*/
const byte counterPins[8] = { 2,3,4,5,6,7,8,9 };
unsigned long millisBetween[8];
unsigned long lastMillis[8];
byte lastState[8];

void setup() {
  for (byte i = 0; i < sizeof(counterPins); i++) {
     pinMode(counterPins[i], INPUT);
     digitalWrite(counterPins[i], LOW);
     millisBetween[i] = 0;
     lastMillis[i] = 0;
     lastState[i] = 0;
  }
  Serial.begin(9600);
}

void loop() {
  unsigned char bitMaskToSend = 0;
  unsigned long time = millis();
  for (byte i = 0; i < 8; i++) {
     byte val = digitalRead(counterPins[i]);
     if (val == HIGH && lastState[i] == LOW) {
       millisBetween[i] = time-lastMillis[i];
       lastMillis[i] = time;
       bitSet(bitMaskToSend, i);
     }
     lastState[i] = val;
  }
  for (byte i = 0; i < 8; i++) {
     unsigned long dataToWrite = millisBetween[i];
     if (bitRead(bitMaskToSend,i)) {
       Serial.print((char)('A'+i));
       Serial.println(dataToWrite);
     }
  }
}

Als externe Komponente ist neben dem obligatorischen Abblockkondensator nur noch der Shunt notwendig. Bis zu 16 Sensoren lassen sich gemeinsam an einem I2C-Bus betreiben: Zwei Adresseingänge, die an Vcc, Gnd, SDA oder SCL gelegt werden legen die Adresse des im kompakten SO-8 Gehäuse daherkommenden Chips fest:

Messwertaufnehmer für 4 Verbraucher mit jeweils bis zu 30A bei 12V, die über M6-Schrauben direkt an den Shunts befestigt werden

Als Shunt kommt die WSMS5515-Serie von Vishay Dale mit 500μΩ zum Einsatz, die bei 30A Last einen Spannungsabfall von 15mV liefern. Durch die Auflösung des INA219 kann diese Kombination Ströme von 1mA messen und die Leistung auf 20mW genau bei einem Maximum von 524W bestimmen.

Hier eine kleine Liste der Dinge, die bei der Serienfertigung zu beachten sind:

• Ausreichend Rand um den Nutzen für den Bestückungsautomaten
• Passermarken oder gegenüberliegende Bohrungen auf jeder Platine im Nutzen
• Koordinaten aller Bausteine immer auf die Mitte des Gehäuses beziehen
• Klare Kennzeichnung der Einheiten (mm, cm, inch, mil)
• Gerberfiles des Nutzens, Drillfile, Stückliste und Koordinaten der Bauteile für den Bestücker bereitstellen
• Eindeutige Beschriftung aller beigestellten Bauteile, bei kleinen Bauteilen (0805 und kleiner) durchaus 10% mehr bereitstellen, da der Automat auf dem Weg die Bauteile verlieren kann
• Falls Bauteile nicht bestückt werden sollen, diese trotzdem in die Stückliste als “nicht zu bestücken” aufnehmen

Bei der Bestückung gab es zwar noch einige Rückfragen (Nicht zu bestückende Pads, Koordinaten der Bohrlöcher für die Positionierung) aber nach zwei Wochen kamen die bestückten Platinen wieder in der Werkstatt an:

Die Endmontage (THT-Bauteile einlöten) wurde per Hand vorgenommen, da sich die zusätzlichen Prozessschritte bei einer so kleinen Serie nicht gerechnet hätten:

Zuletzt erfolgte die Montage in den dafür vorgesehenen Schließfächern:

Alle Tests waren erfolgreich und das Projekt konnte seine Feuertaufe auf dem Melt!-Festival bestehen:

Layout erstellen

Das Layout wird mit EAGLE erstellt und gegen die eigenen Design-Regeln geprüft (Ausgehend von den pcb-pool Regeln: Minimale Leiterbreite 6 mil, minmaler Abstand 6 mil, Bohrungen mindestens 0,5mm):

Layout drucken

Statt das Layout jedes Mal mit eigenen Einstellungen mit dem CAM-Prozessor zu erstellen hilft ein kleines Skript diese zu erzeugen (kein Füllen der Bohrlöcher, richtige Spiegelung für den Ausdruck, Layer fest vorgegeben):

#!/bin/bash
# Skript: eagle-to-pdf.sh
infile=`basename "$1" .brd`
BRD="${1}"
out_file_prefix=${TMPDIR}/printjob-$$
EAGLE=/Applications/EAGLE/EAGLE.app/Contents/MacOS/EAGLE
${EAGLE} -dEPS -X -f- -m -c+ -s1 -o"${out_file_prefix}-top.ps" "${BRD}" 1 17 18 20 105  > /dev/null
${EAGLE} -dEPS -X -m -c+ -s1 -o"${out_file_prefix}-top-mask.ps" "${BRD}" 20 29  > /dev/null
${EAGLE} -dEPS -X -f- -c+ -s1 -o"${out_file_prefix}-bottom.ps" "${BRD}" 16 17 18 20 106  > /dev/null
${EAGLE} -dEPS -X -c+ -s1 -o"${out_file_prefix}-bottom-mask.ps" "${BRD}" 20 30  > /dev/null

ps2pdf14 -dEPSCrop "${out_file_prefix}-top.ps" "${infile}-top.pdf"
ps2pdf14 -dEPSCrop "${out_file_prefix}-top-mask.ps" "${infile}-top-mask.pdf"
ps2pdf14 -dEPSCrop "${out_file_prefix}-bottom.ps" "${infile}-bottom.pdf"
ps2pdf14 -dEPSCrop "${out_file_prefix}-bottom-mask.ps" "${infile}-bottom-mask.pdf"

rm "${out_file_prefix}-top.ps" "${out_file_prefix}-top-mask.ps" "${out_file_prefix}-bottom.ps" "${out_file_prefix}-bottom-mask.ps"

Das Skript wird mit der brd-Datei als Argument aufgerufen und erstellt im aktuellen Verzeichnis vier PDF-Dateien für die unterschiedlichen Masken.

Um Papier zu sparen werden die vier PDFs mit ein wenig Rand (ca. 1,5 cm) auf einer Seite positioniert, z.B. mit Pages. Dabei unbedingt darauf achten, dass die Größe nicht verändert wird.

Der Druck selbst erfolgt mit dem Laserdrucker auf Transparentpapier (Diamant Extra Spezial, billiger als Overheadfolie und bessere Schwärzung). Je nach Drucker sollten folgende Einstellungen vorgenommen werden: Druck auf dickes Papier (sorgt für erhöhten Tonerauftrag), keine Rasterung, s/w-Druck:

Den Ausdruck ab jetzt vorsichtig behandeln, ansonsten kann Toner abgerieben werden. Die einzelnen Masken aus dem Papier ausschneiden und jeweils die Top- und Bottom-Seite mit den Tonerschichten aufeinanderlegen, ausrichten und mit einem Streifen Klebeband an einem Rand fixieren.

Nun die fotopositiv beschichtete Platine (Bungard FR4, selber beschichten lohnt nicht), die an einer Seite einen Rand von mindestens 1 cm haben sollte, zwischen die beiden Masken legen und die Maske auf der Platine fixieren:

Belichten

Die Belichtung erfolgt mit einem umgebauten Gesichtsbräuner, der – wie die Profigeräte – mit vier 15-Watt UV-Röhren bestückt ist. Da die UV-Röhren einige Minuten für das Aufwärmen brauchen, sollte der Belichter schon vorher eingeschaltet sein.
Für Bungard Positiv-Material hat sich bei der Kombination Laserausdruck auf Transparentpapier eine Belichtungszeit von 140 Sekunden pro Seite bewährt. Die nicht zu belichtende Seite sollte dabei abgedeckt und leicht beschwert werden:

Platine entwickeln

Während die Platine belichtet wird, kann der Entwickler für den Fotopositiv-Lack angesetzt werden. Statt den üblichen Entwickler zu kaufen, kann auch normaler, pulverförmiger, Abflussreiniger verwendet werden, dieser enthält auch nur Natriumhydroxid. Da der Entwickler relativ schnell unbrauchbar wird, sollte er jedes Mal erneut angesetzt werden. Etwa 3g auf 250 ml warmes Wasser (25-28 ºC) reichen dafür aus, trotz der geringen Menge NaOH sollte jeglicher Kontakt mit dem Entwickler vermieden werden!

Nach Ablauf der Belichtungszeit werden die Masken von der Platine entfernt und die Leiterbahnen sollten sich leicht gelblich von den freizuätzenden Stellen abheben.

Die Platine nun in den Entwickler legen und mit einer Kunststoffpinzette an dem freien Rand im Entwickler bewegen, die belichteten Stellen verfärben sich lila und lösen sich auf. Nach etwa 30-60 Sekunden, wenn keine lila Reste mehr an den Kanten der Leiterbahnen sichtbar sind, sollte die Entwicklung abgeschlossen sein und die Platine kann unter fließendem Wasser gespült werden:

Unterbelichtungen mit Cutter/Skalpell korrigieren

Sollten zwischen dicht beieinander liegenden Leiterbahnen noch Fotolackreste sein, können diese vor dem Ätzen mit einem Skalpell beseitigt werden.
Ursache hierfür können sein: Luft zwischen Maske und Platine, Dreck auf der Glasplatte des Belichters, zu kurze Belichtungszeit, Abstand zwischen UV-Röhren und Platine zu groß, zu kalter Entwickler, zu wenig NaOH im Entwickler.

Ätzen

Zum Ätzen gibt es verschiedene Möglichkeiten, von Eisen-(III)-Chlorid möchte ich jedoch abraten. Vernünftig geht es entweder mit Natriumpersulfat (250g pro Liter, 40 ºC Ätztemperatur) oder mit Salzsäure/Wasserstoffperoxid (375ml Wasser, 375ml Wasserstoffperoxid 10%, 250ml Salzsäure 33% langsam hinzugeben, Temperatur zwischen 10 und 30 ºC). Egal welches Ätzmittel verwendet wird, die entsprechenden Sicherheitsvorkehrungen (Belüftung, Schutz der Augen, Wasser zum Spülen in der Nähe,… ) sind auf jeden Fall zu beachten! Die Lösung ätzt nicht nur sehr schnell sondern bleicht auch alles, was mit ihr in Berührung kommt:

Der Vorteil bei der Salzsäure/Wasserstoffperoxid Kombination ist, dass sich das Ätzmittel nicht wirklich verbraucht, das Kupfer wird mit dem durch die Salzsäure entstandene Kupferchlorid geätzt. Nur bei Verfärbung ins bräunliche kann die Lösung durch Zugabe von wenig Salzsäure und Sauerstoff in Form von H₂O₂ wieder aufgefrischt werden, Details zu dem Verfahren unter http://members.optusnet.com.au/~eseychell/PCB/etching_CuCl/index.html.

Resist entfernen/reinigen

Die Reste des Fotolacks müssen für die nächsten Schritte entfernt werden, dies geschieht entweder mit Aceton (Achtung, hoch entzündlich) oder mit feinem Scheuermittel. Soll die Platine im Anschluss verzinnt werden, darf das freiliegende Kupfer nach der Reinigung nicht mehr berührt werden und sollte nicht lange der Luft ausgesetzt sein.

Verzinnen

Zum Verzinnen gibt es unterschiedliche Varianten, statt jedoch mit Lötlampe und Fittingslot zu arbeiten, ist die chemische Variante (z.B. SurTin) die einfachere und schnellere: Die angesetzte SurTin-Lösung in eine Entwicklerwanne geben, Platine rein, zwei Minuten leicht bewegen, fertig. Das chemisch Zinn hält sich ohne Probleme ein halbes Jahr, sofern es dunkel und kühl gelagert wird und hält für mindestens 50 Europlatinen. Falls die Lösung länger steht, kann es zu Kristallbildungen kommen, die vor dem Einsatz durch Erwärmen aufgelöst werden müssen.

Da ein wesentlicher Bestandteil von SurTin konzentrierte Schwefelsäure ist, sind auch hier die Angaben der Sicherheitsdatenblätter zu beachten. Auch ist für eine ausreichende Lüftung zu sorgen, da die Lösung Schwefelwasserstoff ausdünsten kann (riecht dann nach verfaulten Eiern).

Nach dem Abtropfen und Spülen mit klarem Wasser, kann die Oberfläche noch mit Küchenpapier abgerieben werden um ein wenig Glanz auf das Zinn zu bekommen:

Lötstopp laminieren

Wenn die Platine noch einen Lötstopp bekommen soll, sollte sie einige Male durch den Laminator laufen um die Feuchtigkeit rauszubekommen. Aus diesem Grund sollte auch kein Pertinax als Platinenmaterial genommen werden, dies muss wesentlich länger getrocknet werden und kann sich dabei verziehen.

Lötstopp gibt es z.B. bei Octamex als A4-Folie (Bungard Dynamask), die sehr lichtempfindlich gegenüber UV-Licht ist. Sämtliche Verarbeitungsschritte sollten daher bei gedämpfter Beleuchtung (kein Tageslicht, keine Neon-Röhren) stattfinden.

Von der Folie passende Stücke für die Platine abschneiden, der eigentliche Resist ist hierbei zwischen zwei Schutzfolien eingebettet. Dynamask hat eine matte und eine glänzende Seite, die matte Schutzfolie lässt sich mit zwei Streifen Klebeband die von beiden Seiten auf die Folie geklebt werden an einer Ecke abziehen. Der nun freigelegte Film ist ziemlich klebrig und wird nun auf die Platine laminiert:

Als Laminator eignen sich die Olympus Geräte (z.B. A-290) recht gut, da diese auch mit den 1,5mm dicken Platinen zurechtkommen, ohne dass der Dremel am Gehäuse angesetzt werden muss.

Belichten

Analog zur Belichtung für die Ätzmasken wird auch hier wieder eine Tasche für die Vorder- und Rückseite geklebt und auf der Platine passgenau auf die Lötpads fixiert. Die Belichtungszeit ist allerdings deutlich kürzer, 70 Sekunden sind ausreichend. Nach der eigentlichen Belichtung muss der Lötstopp eine halbe bis eine Stunde lang ruhen (natürlich im Dunkeln).

Lötstopp entwickeln

Der Entwickler für die Lötstoppmasken besteht aus Natriumcarbonat, 10g pro Liter, Temperatur sollte 30 ºC betragen. Vor dem Entwickeln muss die zweite Schutzfolie noch von den Platinen entfernt werden.
Bei leichtem Schwenken der Lösung löst der Entwickler an den nicht belichteten Stellen den Lötstopp nach 3-5 Minuten ab. Falls einzelne Stellen sich nicht lösen (zu lange belichtet oder zu geringe Schwärzung?), hilft leichtes Kratzen mit einem weichem Gegenstand:

Härten

Der Lötstopp muss nun noch gehärtet werden, hierfür kann die Platine zwischen Transparentpapier einige Male durch den Laminator geschoben werden. Danach sollte sie eine Stunde lang von beiden Seiten mit UV-Licht belichtet werden:

Bohren und Bestücken

Sollte es sich nicht um eine einseitige SMD-Bestückung handeln, können nun die Bohrungen gesetzt werden. Danach kann die Platine bestückt und im Anschluss von den Lötmittelresten (sofern kein NoClean-Lötzinn verwendet wird) befreit werden:

Die Gesamtdauer für die Herstellung einer solchen Platine liegt (inkl. der Zeit für das Ruhen und Härten des Lötstopps, die ja auch anderweitig genutzt werden kann) bei 2,5 Stunden.

Hier noch die Einkaufsliste, falls jemand in die Platinenherstellung einsteigen möchte:

Zum Aufbau: das Pult ist in zwei Teile, jeweils 19-Zoll/5HE, aufgeteilt. Beide Hälften verfügen über eigenständige A/D-Wandler (MCP3208) für die 100mm Fader und Digital-Inputs (74HC165) für die Encoder und Taster. Diese geben Ihre Daten auf einen zentralen Bus, der von dem Microcontroller auf MIDI umgesetzt wird.

Bei der Wahl des Prozessors standen die üblichen Verdächtigen zur Auswahl (PIC, Atmel und MSP), es ist aber – trotz der anhaltenden Lieferengpässe bei Atmel – ein Atmega328 geworden. Nachdem die Software recht schnell auf dem Arduino lauffähig war, ging es an die Code-Optimierung. Sobald ein wenig mehr IO-Leistung gebraucht wird (für die Encoder werden insgesamt 256 Bit über den Bus geschoben), sollte auf digitalRead und digitalWrite verzichtet werden. Die Umstellung von digitalRead(10) auf ((PINB & 0×04) >>2) brachte Faktor 40, so dass nun auch schnelle Drehungen ohne Verlust von Schritten erfasst werden. Das war dann auch der Abschied von Arduino.App und der Beginn der Umstellung auf Eclipse-CDT, das auch unter MacOS eine gute Unterstützung der kompletten AVR-Suite bietet.

Da das Pult länger halten und angenehm zu bedienen sein sollte, kommen die edlen ALPS-Produkte zum Einsatz, die in Stückzahlen auch bezahlbar sind. Die Encoder stammen aus der Automotive Serie, sind staubdicht und auf 500.000 Zyklen ausgelegt.

Momentan sind die Platinen in der Produktion bei pcb-pool, die Frontplatte wird von Schaeffer-AG hergestellt.  Sobald es an den Zusammenbau geht, folgen weitere Bilder.

Update 1:

Mittlerweile gibt es die ersten Bilder von pcb-pool:

Jetzt bleibt nur zu hoffen, dass die Stencils für die richtige Seite angefertigt werden.

Schaeffer hat die Frontplatten bereits gefräst, da der Versand für den 01.10. geplant ist, müssten diese also zusammen mit den Platinen am Samstag in der Post sein.

Update 2:

Es wurde dann doch Montag, aber sowohl die Platinen als auch die Frontplatten waren heute in der Post. Da die Encoder erst am 18.10. geliefert werden, konnten die Frontplatten schon teilweise bestückt werden:

Morgen geht es, sofern die Zeit es zulässt an die Bestückung der Platinen:

Update 3:

Die SMD-Bestückung der kleinen Platinen ist erledigt, nur für die Wandlerplatinen reichte die Lötpaste dann doch nicht mehr. Am Wochenende wird das Gehäuse gesägt und der Aufbau getestet.

Update 4:

Das Gehäuse war dann recht schnell gesägt, die Bestückung erledigt, alle Stecker (68 Stück für die Flachbandkabel im Inneren) verpresst. Der erste Test verlieft fast gut, aber drei Lessons Learned gab es dann doch noch bei dem Projekt:

• Niemals mit 100 nF X7R Abblockkondensatoren geizen
• Einen A/D Wandler immer nur mit einer Taktfrequenz betreiben, die tatsächlich kleiner ist als die maximal zulässige (der Atmel war dann doch schneller als erwartet)
• Traue niemals einem Datenstrom, der seriell übertragen wurde (es kann tatsächlich mal ein Byte fehlen)

Aber nun ist das Pult fertig und konnte erfolgreich am MOTU-828MK2 MIDI-Port betrieben werden, alle 160 Midi-Signale werden einwandfrei übermittelt, in dem zugehörigen Live-Set konnten allerdings auf Grund der Ableton-Einschränkung nur jeweils 128 gleichzeitig getestet werden.

Zum Abschluss noch ein paar Bilder vom fertigen Gerät:

Für den Hobbybastler ohne Lötstoppmaske leider nicht gut zu verarbeiten: Entweder im 16-poligen TQFN (0,5 mm Pinabstand) oder QSOP Gehäuse (0,635 mm Pinabstand). Zudem sind zwei Stromversorgungen einzuplanen: Einmal die 3,3 Volt Logiklevel und eine zweite für die LEDs (sollte mindestens 1 Volt über der Vorwärtsspannung liegen). Bei meinen bevorzugten Cree CLV1A-FKB LEDs also mindestens 4,2 Volt.

Da die Ausgänge aber auch parallel geschaltet werden können, sind auch 50 mA LEDs (wie z.B. OVSTRGBBCR8 v0n Optek) direkt ansteuerbar.

Installation:

• Download Ableton Live (Demo Version) from ableton.com.
• Download Vuvuzero.als.zip decompress and open the file with Ableton.

Usage:

Put channel 1 into record mode (by clicking the small circle below the “S” in the first track). Connect your satellite receiver to the line in of your PC/Mac and the line out to your amplifier.

Enjoy the games.

Statt I2C wird in dem PIC ein 24-Bit Schieberegister mit Latch realisiert. Nach dem Latch liegen dann die drei Software PWMs. Da links und rechts auch noch Lötpads hinmüssen, ist die Platine mit 10mmx17mm dann doch größer geworden als ursprünglich geplant, aber immer noch kleiner und deutlich günstiger.

Der PIC-Code samt Arduino-Library folgt sobald die ersten Tests erfolgreich waren.

Update 1:

Die Platinen sind zwar noch unterwegs, aber der PIC-Code ist mittlerweile fertig. Vorerst nur mit einem 8-Bit PWM, später folgt vielleicht ein Upgrade auf 10-Bit.

Ursprünglich sollte der Latch über den Watchdog-Timer erfolgen (wenn 18ms lang kein Taktsignal vorliegt, werden die Daten aus dem Schieberegister in die PWM-Register kopiert). Da unter den einzelnen Prozessoren der WDT-Timer aber schwanken kann (laut Datenblatt zwischen 9ms und 30ms) erfolgt jetzt die Übernahme über den integrierten Timer nach 10ms.

Update 2:Von pcb-pool kam jetzt das erste Bild vom Produktionsprozess. So wie es ausschaut, wird am Wochenende alles zusammengebaut.

Update 3:Alle Platinen sind nun bestückt und verlötet, morgen erfolgt der Upload des PIC-Codes:

Update 4:Die LEDs sind jetzt auch alle verbaut, fehlt nur noch der Funktionstest.

;; PWM-Code fuer RGB-Dot
;; Copyright 2010 Wolfgang Jung (w@elektrowolle.de)
    list     p=12f508
    #include p12f508.inc

    __CONFIG   _MCLRE_OFF & _CP_OFF & _WDT_OFF & _IntRC_OSC
;; Register
REG_B_RED    EQU   0x08
REG_B_GREEN  EQU   0x09
REG_B_BLUE   EQU   0x0A
REG_C_RED    EQU   0x0B
REG_C_GREEN  EQU   0x0C
REG_C_BLUE   EQU   0x0D
REG_LCLK     EQU   0x0E
REG_OVERFLOW EQU   0x0F
REG_PWMCNT   EQU   0x10
REG_WORK     EQU   0x11
;; Pinassignments
PIN_RED      EQU  H'0'
PIN_GREEN    EQU  H'1'
PIN_BLUE     EQU  H'2'
PIN_SDIN     EQU  H'3'
PIN_SDOUT    EQU  H'5'
PIN_SCLK     EQU  H'4'
;; Konstanten
DEF_OPTION  EQU 0xC7 ; Kein Wakeup, Kein Pull-Up, TOCS=fOSC/4, TOSE=1, PSA=TMR0, Prescale=256
DEF_TIMEOUT EQU 39   ; Bei 4 MHz und Prescale=256 -> etwa 10ms

    ORG 0x000
;; startup
    MOVLW    DEF_OPTION
    OPTION
;; Port-Config OIIOOO
    MOVLW   0x18
    TRIS    GPIO
L_MAIN
    MOVF    GPIO, W                ; Lade Port nach W
    XORWF   REG_LCLK, W            ; XOR mit letztem CLK
    MOVWF   REG_WORK
    BTFSS   REG_WORK, PIN_SCLK    ; Flanke von SCLK?
    GOTO    L_NO_EDGE
L_EDGE_DETECTED:
    BTFSC   REG_LCLK, PIN_SCLK
    GOTO    L_FALLING_EDGE
L_RISING_EDGE:
    ;; steigende Flanke -> SDIN auswerten
    CLRF    REG_OVERFLOW
    BCF     STATUS, C            ; clear CARRY-Flag
    BTFSC   GPIO, PIN_SDIN
    BSF     STATUS, C            ; CARRY-Flag enthaelt nun SDIN, nun das Bit durch die 24-Bit schieben
    RLF     REG_B_RED, 1
    RLF     REG_B_GREEN, 1
    RLF     REG_B_BLUE, 1
    ;; letztes Bit merken fuer das naechste Modul
    BTFSC   STATUS, C
    BSF     REG_OVERFLOW, 0
    GOTO    L_CLR_WDT
L_FALLING_EDGE:
    ;; Fallende Flanke -> letztes Bit wieder auf SDOUT schreiben
    BCF     GPIO, PIN_SDOUT
    BTFSC   REG_OVERFLOW, 0
    BSF     GPIO, PIN_SDOUT
L_CLR_WDT:
    ;; Timer0 zuruecksetzen, Prescaler muss danach angepasst werden
    MOVLW   0
    MOVWF   TMR0
    MOVLW   DEF_OPTION
    OPTION
    ;; letzten Input merken
    MOVF    GPIO, W
    MOVWF   REG_LCLK
L_NO_EDGE:
    ;; Keine Flanke seit DEF_TIMEOUT timer0
    MOVLW   DEF_TIMEOUT
    SUBWF   TMR0, W
    ;; Prescaler muss angepasst werden
    MOVLW   DEF_OPTION
    OPTION
    ;; Skip, wenn tmr0 < DEF_TIMEOUT
    BTFSS   STATUS, C
    GOTO    L_DO_PWM
L_COPY_BUFFER_TO_PWM:
    ;; Daten aus Schieberegister in PWM-Register
    MOVF    REG_B_RED, W
    MOVWF   REG_C_RED
    MOVF    REG_B_GREEN, W
    MOVWF   REG_C_GREEN
    MOVF    REG_B_BLUE, W
    MOVWF   REG_C_BLUE
L_DO_PWM:
    DECF    REG_PWMCNT, F          ; Ist pwmCnt == 0?
    BTFSS   STATUS, Z
    GOTO    L_PWM_RED
    ;;; PWMCnt == 0 -> Also alle Pins auf high
    BSF     GPIO, PIN_RED
    BSF     GPIO, PIN_GREEN
    BSF     GPIO, PIN_BLUE
L_PWM_RED:
    MOVF    REG_PWMCNT, W
    SUBWF   REG_C_RED, W
    BTFSS   STATUS, Z            ; Skip, wenn pwmCnt > red
    GOTO    L_PWM_GREEN
    MOVF    REG_C_RED, W         ; Wenn red==0, dann niemals an
    BTFSS   STATUS, Z
    BCF     GPIO, PIN_RED
L_PWM_GREEN:
    MOVF    REG_PWMCNT, W
    SUBWF   REG_C_GREEN, W
    BTFSS   STATUS, Z
    GOTO    L_PWM_BLUE
    MOVF    REG_C_GREEN, W
    BTFSS   STATUS, Z
    BCF     GPIO, PIN_GREEN
L_PWM_BLUE:
    MOVF    REG_PWMCNT, W
    SUBWF   REG_C_BLUE, W
    BTFSS   STATUS, Z
    GOTO    L_MAIN                ; Zurueck zum Anfang
    MOVF    REG_C_BLUE, W
    BTFSS   STATUS, Z
    BCF     GPIO, PIN_BLUE

Preislich sind beide auf dem gleichen Niveau (Einzelpreis 48,80€ bei Farnell) und durchaus eine Alternative zu einem Arduino, da beide doch um einiges leistungsfähiger sind. Hier der Auszug aus dem Datenblatt:

• 100 MHz operation
• 512 KB of Flash memory
• 64KB of SRAM
• 10/100 Ethernet MAC
• USB 2.0 full-speed device/Host/ OTG controller with on-chip PHY
• Four UARTs with fractional baud rate generation, RS-48, modem control, and IrDA
• Two CAN 2.0B controllers
• Three SSP/SPI controllers
• Three I2C-bus interfaces with one supporting Fast Mode Plus (1-Mbit/s data rates)
• I2S interface for digital audio

Einen konkrete Anwendung schwebt mit zwar noch nicht vor, aber das wird sich bestimmt noch ergeben.
Einzige Minuspunkte, die ich bislang finden konnte sind der nur einfach vorhandene 12-Bit DAC und das sämtlicher Code auf den NXP-Servern liegt.

Falls doch mehr DAC-Kanäle benötigt werden, scheint ein TLV5628, TLV5608, TLV5610 oder ähnliches ganz brauchbar zu sein (8-Fach, 8/10/12-Bit DAC über SPI).

Wichtiger Hinweis am Rande: Sämtliche Digital-IOs sind zwar 3,3V aber 5V tolerant.

Die Ausgänge sind in der Lage 25 mA dauerhaft gegen Masse zu schalten, für LEDs also ausreichend.

Sobald die Bestellung da ist, wird an dieser Stelle die dazu passende Arduino Bibliothek veröffentlicht.