Ich wollte mal testen, wie brauchbar die Java Virtual Machine auf der ARM Architektur läuft. Hierzu habe ich mir einen Rasperry Pi 3 bestellt und Netbeans installiert. Die Entwicklungsumgebung läuft dort mit akzeptabler Geschwindigkeit. Ein paar erste Tests zeigen, wie schnell man auf die Port-Pins zugreifen kann.
Heute habe ich mich mal hingesetzt um den Schaltplan und die Funktionsweise der Counter Teils aufzuzeichnen.
Die Funktionsweise ist eigentlich einfach. Wenn man einfach nur die Signalimpulse über einen definierten Zeitraum (der Torzeit) zählen würde, wäre es praktisch nicht möglich bei niedrigen Frequenzen eine vernünftige Auflösung zu bekommen. Für eine 6-stellige Anzeige benötigt man 1 Millionen Takte. Bei 100 Hertz wäre dafür eine Torzeit von 10.000 Sekunden nötig – rund 3 Stunden.
Alternativ dazu kann man die Periode messen. Dazu gibt das Messsignal die Torzeit vor und man zählt, wie viele Takte das Referenzsignal in dieser Zeit abgibt. Das ist bei 100 Hertz gut machbar, bei 1 MHz wiederum kaum mit guter Genauigkeit möglich.
Das hier verwendete Messprinzip ist im Wesentlichen eine Kombination der beiden Messmethoden. Bei einer Messung werden gleich zwei Zähler aktiv. Über den Zeitraum der Torzeit zählt ein Counter die Takte der Referenzfrequenz und ein weiterer die Takte der Signalfrequenz. Über das D FlipFlop wird sicher gestellt, dass die tatsächliche Torzeit immer nur ganze Perioden der Signalfrequenz beträgt. Andernfalls würde man bei niedrigen Frequenzen einen erheblichen Messfehler bekommen.
Das Diagramm zeigt ein Eingangssignal von 12,5 MHz an Pin A.
Wenn der Microcontroller eine neue Messsequenz einleiten will, setzt er Pin B auf 1. Da das D FlipFlop ein invertiertes Signal bekommt, wird mit der nächsten fallenden Signalflanke die Torzeit beginnen, der Ausgang Q des FlipFlop springt dann auf 1 (Pin C)
Mit dem Beginn der Torzeit werden über die beiden UND Gatter die beiden Counter für Signal- und Referenzfrequenz freigeschaltet und zählen nun hoch (Pin D und E an Pin 2 und 4 des Microcontrollers).
Der Microcontroller kann den Beginn der Torzeit über seinen Input – Pin C (an Pin 3 des PIC) lesen. Jetzt wartet er die gewünschte Zeit ab (z.B. ca. eine Sekunde) und setzt den Pin B wieder auf 0 zurück. Die genaue Zeit ist hier nicht wichtig, sie geht nicht in das Messergebnis ein solange sie ausreichend groß für die gewünschte Auflösung ist.
Das Tor bleibt jetzt aber noch offen – bis zur nächsten fallenden Flanke des Signals. Damit ist sicher gestellt, dass nur ganze Signalperioden gelesen werden. Wenn der Microcontroller feststellt, dass am Pin C wieder 0 anliegt, weiß er, dass eine Messperiode abgeschlossen ist. Nun kann er die Counter einlesen und das Ergebnis berechnen.
Im Bild sieht man die (viel zu kurze) Torzeit des Microcontrollers am Pin B von 200 nS (5 Referenz-Takte). Durch die Synchronisierung mit dem Signal wird die tatsächliche Torzeit auf 6 Takte gedehnt (Pin C). In dieser Zeit werden 3 steigende Flanken des Signals gezählt und 6 steigende Flanken der Referenz.
Aus diesen Werten kann nun die tatsächliche Signalfrequenz ermittelt werden:
Signalfrequenz = Signal-Takte * Referenzfrequenz / Referenz-Takte = 3 * 25000000 / 6 = 12500000
Natürlich ist die Torzeit in der Zeichnung viel zu kurz. Tatsächlich würde man hier eher eine Torzeit von ca. einer halben Sekunde wählen. Das kann ich nur nicht vernünftig Zeichnen. In diesem Fall würde die Rechnung vielleicht so aussehen ( bei einer Torzeit 0,51 Sekunden):
Signalfrequenz = Signal-Takte * Referenzfrequenz / Referenz-Takte = 6375000 * 25000000 / 12750000 = 12500000
Heute bin ich dazu gekommen den internen Oszillator einzubauen. Ich habe dafür einen TCXO mit 25 MHz bestellt – in der Hoffnung, dass ich damit eine gute Stabilität erreiche. Laut Datenblatt sollte die Genauigkeit im Bereich 50ppm liegen. Zur Messung steht mir nur mein Rigol DG1062 zur Verfügung. Ich weiß nicht sicher, wie genau dieses Gerät ist, aber da es recht teuer war, hoffe ich auf gute Eigenschaften. Mein TCXO liegt 23ppm neben der Nomialfrequenz. Im Laufe der letzten Stunde hat die Anzeige meines Frequenzmessers nur um 4 Digits auf der 8. Stelle geschwankt. Das akzeptiere ich mal als sehr gutes Ergebnis.
Aufgrund des Messprinzips kann man sehr niedrige Frequenzen messen. Ich bin mir nicht sicher, ob ich die Originalschaltung falsch gelesen habe oder ob sie tatsächlich eine Race Condition enthält – bei mir hat das dazu geführt, dass ich mit ca. 50%er Wahrscheinlichkeit einen Takt zu viel gezählt habe. Bei 20 MHz und einem Messintervall von 1 Sekunde ist das kein Problem. Bei 1 Hertz gibt das völlig falsche Ergebnisse. Ich habe die Schaltung deshalb so abgeändert, dass das Gate mit fallenden Takt statt mit steigenden Takt geschaltet wird. Bei steigenden Takt zählt der Zähler hoch, so dass ich eine halbe Taktperiode Zeit zwischen den beiden wichtigen Ereignissen bekomme. Nach dieser Änderung steht die Anzeige auch bei sehr niedrigen Frequenzen exakt.
Bei sehr niedrigen Frequenzen unter 2 Hertz verlängert sich das Messintervall, im Durchschnitt auf das 2-fache der Periodendauer. Unter 100 Millihertz bekomme ich aber auch keine sinnvolle Anzeige mehr. Das ist aber auch nicht wichtig, es liegt weiter außerhalb des angepeilten Messbereichs. Nach oben komme ich bis 24 MHz, darüber gibt es ebenfalls erhebliche Messfehler.
Jetzt fehlt noch eine verbesserte Software mit Anzeige des Messbereichs (Hertz, Kilohertz, Megahertz), das Netzteil und das Gehäuse.
Nach einigen Fehlversuchen bin ich nun wieder einen Schritt weiter. Geplant war es eigentlich, dass ich mit einen Referenztakt von 25 MHz arbeite. Bei meinem aktuellen Aufbau komme ich aber nicht zuverlässig über 10 MHz. Allerdings habe ich noch viele lang frei fliegende Leitungen.
Bei einem Referenztakt von 10 MHz und einem Signal von 1,234567 MHz komme ich auf eine Anzeige, die zwischen 1,234567 und 1,234568 pendelt. Besser kann ich es nicht erwarten. Meine Messperiode liegt bei ziemlich genau einer Sekunde.
Meine Hand liegt nicht zufällig links neben dem Zählermodul auf dem Kabel der Spannungsversorgung. Sie dient als Filter damit ich nicht über dieses Kabel erhebliche Störungen einfange. Ohne diesen Filter sind meine Messwerte immer ca. ein Promille zu hoch.
Die nächsten Schritte bestehen darin, dass ich den externen Referenztakt von meinem Funktionsgenerator auf den internen Oszillator umstelle. Dabei werde ich dann nochmal versuchen auf 25 MHz zu gehen und die Messperiode auf eine halbe Sekunde verkürzen. Falls das nicht klappt, bleibe ich eben bei 10 MHz.
Bei meinen ersten Schritten mit dem PIC32 habe ich natürlich mit dem „Hello World“ der embedded Welt begonnen: ein Port Bit wird ein- und ausgeschaltet. Das hat auf Anhieb funktioniert.
Als nächstes stellt sich dann die Frage: wie schnell kann man einen Port ein- und ausschalten. Hier bin ich auf ca. 400 nS gekommen, eigentlich zu langsam für so einen schnellen Prozessor. Unglücklicherweise habe ich das Ergebnis einfach so hingenommen, da es schnell genug für meine Aufgaben war.
Hätte ich mich damals um eine Klärung bemüht, wären mir gestern mehrere Stunden Fehlersuche erspart geblieben. Mein Frequenzzählerprojekt kommt nicht so schnell voran wie erhofft (das liegt zum einen an der verfügbaren Zeit aber noch mehr daran, dass ich mehr lernen muss als ich vorher gedacht hätte) – aber es macht Fortschritte. Mittlerweile haben ich das Anzeigemodul und einen einfachen durchlaufenden Zähler. Als ich gestern meinen Referenztakt von 25 MHz auf den Zähler gegeben habe, hat sich gezeigt, dass der Zähltakt unter einem MHz lief. Der Oszillator war unschuldig, das Oszilloskop hat ordentliche 25 MHz angezeigt.
Die Fehlersuche hat sich etwas mühsam gestaltet, da ich gleich zwei Fehler in der Prozessorkonfiguration hatte. Diese hatte ich einfach aus einem Beispiel übernommen, welches offensichtlich für eine andere Prozessorversion war.
Zum einen wurde der Takt für die externen Komponenten durch den Wert 8 geteilt. Wenn man die kryptischen Kurznamen der Konfiguration verinnerlicht hat, ist das offensichtlich. Mir ist es aber vorher nicht aufgefallen.
Der größere Fehler bestand aber darin, dass die Konfiguration für einen externen 8 MHz Quarzoszillator eingestellt war. Ich habe aber keinen Quarz in meiner Schaltung (der Prozessortakt geht nicht in die Messgenauigkeit ein). Irgendwie lief der Prozessor aber trotzdem, vermutlich blieb er auf einem langsamen internen Oszillator für den Start hängen.
Nachdem ich die Konfiguration in Ordnung gebracht hatte (interner schneller RC Oszillator mit 8 MHz, PLL auf 64 MHz), lief mein Zähler problemlos mit den 25 MHZ (da der Zähler intern synchronisiert wird, ist die Zählertaktrate durch den Prozessortakt beschränkt).
#pragma config FPLLIDIV = DIV_2 // PLL Input Divider (2x Divider)
#pragma config FPLLMUL = MUL_16 // PLL Multiplier (16x Multiplier)
#pragma config FPLLODIV = DIV_1 // System PLL Output Clock Divider (PLL Divide by 1)
#pragma config FWDTEN = OFF
#pragma config FNOSC = FRCPLL // Oscillator Selection Bits (Fast RC Osc with PLL)
#pragma config FSOSCEN = OFF // Secondary Oscillator Enable (Disabled)
#pragma config IESO = OFF // Internal/External Switch Over (Disabled)
#pragma config POSCMOD = OFF // Primary Oscillator Configuration (Primary osc disabled)
#pragma config OSCIOFNC = OFF // CLKO Output Signal Active on the OSCO Pin (Disabled)
#pragma config FPBDIV = DIV_1 // Peripheral Clock Divisor (Pb_Clk is Sys_Clk/1)
#pragma config FCKSM = CSDCMD // Clock Switching and Monitor Selection (Clock Switch Disable, FSCM Disabled)
Als nächstes habe ich nun noch mal mein Blinky Programm korrigiert. Jetzt komme ich auf eine Periode von ca. 100 nS für ein Bit Setzen und Zurücksetzen – also ca. 50 nS für eine Portausgabe. Das ist schon viel näher an den erwarteten Werten.
Als nächstes benötige ich die Zähler für das Eingangssignal. Praktischerweise besitzt der PIC32 neben dem Timer1, den ich für die Anzeige verwende, noch vier weitere 16 Bit Zähler, die sich zu zwei 32 Bit Zählern zusammenschalten lassen. Heute habe ich mich darum gekümmert, die Timer 2 und 3 als 32 Bit Zähler zu verwenden.
In einem ersten Schritt habe ich mich auf die Zusammenschaltung konzentriert und mit dem internen Takt wie beim Timer1 gearbeitet. Das geht relativ einfach und ist nach einem kurzen Blick in das Datenbuch leicht zu erledigen.
OpenTimer23(T23_ON | T23_SOURCE_INT | T23_PS_1_1, 0xffffffff);
Statt Timer1 wird nun die Kombination aus Timer2 und Timer3 verwendet. Die vordefinierten Hilfsfunktionen und Konstanten sind erfreulicherweise dafür vorbereitet. Der Prescaler wird auf 1 gesetzt, der maximale Timerwert auf volle 32 Bit (die aber nicht komplett benötigen werde).
In der Hauptschleife warte ich nun immer rund eine halbe Sekunde, lese den Timer23 aus und übertrage den aktuellen Wert in den Bildspeicher.
while(1) {
int del;
// wait for 500 milliseconds
for (del = 0; del < 80000; del++);
setInt(ReadTimer23());
};
Das war der einfache Teil, da es im Internet eine Vielzahl von Beispielen gibt, wie man einen Timer mit einem internen Takt verwendet. Für einen Frequenzzähler benötige aber einen Zähler für einen externen Takt. An dieser Stelle habe ich erst mal einen Schreck bekommen, da mir klar wurde, dass ich die Pins für die Ausgangssignale ohne Rücksicht darauf verteilt habe, ob sie eventuell auch von den Timern benötigt werden. Aber ich hatte Glück – das Timer2 Clock Signal, welches auch Eingang für den kombinierten Timer 2 + 3 ist, hat als Eingang einen programmierbaren Pin (PPS). Da ich auf Anhieb kein Beispiel dafür im Internet gefunden habe, musste ich mich jetzt also erst mal mit der Programmierung der Pinbelegung auseinandersetzen. Erfreulicherweise ist es dann aber doch recht einfach. Es gibt zu jedem Eingang eines Funktionsbausteins eine Liste mit den möglichen Pins. Aus dieser Liste muss man einen passenden Pin auswählen, den Mapping-Wert auslesen und in ein Register eintragen. Das war alles – wenn man es erst mal verstanden hat ist es ganz simpel: T3CKRbits.T3CKR = 0;.
void startCounter() {
OpenTimer23(T23_ON | T23_SOURCE_EXT | T23_PS_1_1, 0xffffffff);
T3CKRbits.T3CKR = 0; // RA0
}
Wie man im Video sieht, habe ich mittlerweile auch das im Teil 3 beschriebene Übersprechen zwischen den Anzeigestellen in Griff. Das Flackern kommt durch eine Überlagerung der Kamerafrequenz mit der Anzeigefrequenz, es ist im Original nicht sichtbar. Die Wiederholfrequenz liegt bei ca. 90 Hertz.
Aktueller Software Stand:
/*
* File: main.c
* Author: Matthias Thiele
*
* Created on 23. Januar 2015, 21:08
*/
#include <stdio.h>
#include <stdlib.h>
#include <plib.h>
// Configuration Bit settings
// SYSCLK = 80 MHz (8MHz Crystal/ FPLLIDIV * FPLLMUL / FPLLODIV)
// PBCLK = 40 MHz
// Primary Osc w/PLL (XT+,HS+,EC+PLL)
// WDT OFF
// Other options are don't care
//
#pragma config FPLLMUL = MUL_20, FPLLIDIV = DIV_2, FPLLODIV = DIV_1, FWDTEN = OFF
#pragma config POSCMOD = HS, FNOSC = PRIPLL, FPBDIV = DIV_8
#pragma config OSCIOFNC = OFF // CLKO Output Signal Active on the OSCO disabled
#pragma config JTAGEN = OFF // JTAG Enable (JTAG Disabled)
#define SYS_FREQ (80000000L)
static int digits[9];
static int dark[9];
// Ermittelt das Port B Bitmuster für einen Wert
// an einer Position im Bildspeicher
int calcPattern(int pos, int value) {
int hexDigit = (value & 0xf) << 7;
int position = ((pos & 1) << 11) | ((pos & 0xe) << 12);
int comma = (pos == 1) ? 0x20 : 0;
return hexDigit | position | comma;
}
// Schreibt eine Ziffer an eine Position im Bildspeicher
void setDigit(int pos, int value) {
int pattern = calcPattern(pos, value);
digits[pos] = pattern;
}
// Schreibt einen Integer Wert in den Bildspeicher
void setInt(int value) {
int i, j;
for (i = 8; i >= 0; i--) {
int part = value % 10;
setDigit(i, part);
value = value / 10;
if (value == 0) {
// clear leading digits
for (j = i - 1; j >= 0; j--) {
setDigit(j, 0xf);
}
break;
}
}
}
// Zeigt in einer Schleife die 9 Stellen des
// Displays an. Wird aus dem Heartbeat Interrupt
// ca. 1000 mal pro Sekunde aufgerufen.
void displayTick() {
static int pos = 0;
// dunkel schalten
mPORTBWrite(dark[pos]);
int delay;
for (delay = 0; delay < 3; delay++);
// neuen Wert eintragen
mPORTBWrite(digits[pos]);
// nächste Stelle ermitteln (round robin)
pos++;
if (pos > 8) {
pos = 0;
}
}
// Interrupt Service Routine für Timer1
void __ISR(_TIMER_1_VECTOR, ipl2) Timer1Handler(void) {
displayTick();
mT1ClearIntFlag();
}
// Initialisert das Display
void initDisplay() {
int i;
for (i = 0; i < 9; i++) {
dark[i] = calcPattern(i, 0xf);
}
}
// Initialisiert und startet den Heartbeat Timer
void startHeartbeat() {
OpenTimer1(T1_ON | T1_SOURCE_INT | T1_PS_1_256, 4);
INTEnableSystemMultiVectoredInt();
ConfigIntTimer1(T1_INT_ON | T1_INT_PRIOR_2);
mT1ClearIntFlag();
}
// Initialisiert und startet die Zähler Timer
void startCounter() {
OpenTimer23(T23_ON | T23_SOURCE_EXT | T23_PS_1_1, 0xffffffff);
T3CKRbits.T3CKR = 0; // RA0
}
int main(void)
{
SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
mJTAGPortEnable(DEBUG_JTAGPORT_OFF);
ANSELA = 0;
ANSELB = 0;
CM1CON = 0;
CM2CON = 0;
CM3CON = 0;
mPORTBSetPinsDigitalOut( 0xfffc );
mPORTASetPinsDigitalIn( 0x3 );
initDisplay();
startHeartbeat();
startCounter();
while(1) {
int del;
// wait for 500 milliseconds
for (del = 0; del < 80000; del++);
setInt(ReadTimer23());
};
}
An diesem Wochenende hatte ich ein paar Stunden Zeit um mich um die Anzeigeroutine zu kümmern. Ziel war es, dass die Anzeige Interruptgesteuert aus einem Bildspeicher heraus erfolgt.
Da die Anzeige 9-stellig ist und ich über eine 10. Stelle noch ein paar externe LEDs ansteuern möchte, brauche ich für eine Wiederholrate von 100 Hertz eine Interruptrate von 1 kHz. Diese Frequenz wird intern über den Timer1 erzeugt.
OpenTimer1(T1_ON | T1_SOURCE_INT | T1_PS_1_256, 4);
Die Teilerfaktoren habe ich experimentell ermittelt, sie unterscheiden sich fast um den Faktor 10 von den theoretisch notwendigen Werten. Ich habe den Verdacht, dass mein PIC im Augenblick nicht mit der vollen Taktrate läuft. Das muss ich bei Gelegenheit mal genauer untersuchen, im Augenblick stört es mich aber nicht.
Als nächstes benötige ich eine Interrupt Service Routine (ISR), welche bei jedem Timer-Überlauf aufgerufen wird. Dazu muss die Routine definiert werden und der Timer-Interrupt aktiviert werden.
void __ISR(_TIMER_1_VECTOR, ipl2) Timer1Handler(void) {
displayTick();
mT1ClearIntFlag();
}
Die Funktion meldet sich als ISR für den Timer1 an. Bei jedem Aufruf wird die nächste Stelle angezeigt, das ganze immer im Kreis. Am Ende der Routine wird das Interrupt Flag zurückgesetzt damit sie im nächsten Intervall wieder aufgerufen wird. Später wird diese Routine auch noch die Abfrage der Eingabetaster durchführen.
void startHeartbeat() {
OpenTimer1(T1_ON | T1_SOURCE_INT | T1_PS_1_256, 4);
INTEnableSystemMultiVectoredInt();
ConfigIntTimer1(T1_INT_ON | T1_INT_PRIOR_2);
mT1ClearIntFlag();
}
Hier nun die komplette Timer-Initialisierung. Nach der Programmierung der Teilerfaktoren wird der Interrupt eingeschaltet und konfiguriert. Das war schon alles. Jetzt wird die Funktion Timer1Handler rund 1000 mal pro Sekunde aufgerufen.
Als nächstes kommt dann die eigentliche Anzeige in der Funktion displayTick(). Sie müsste eigentlich die aktuelle Ziffer aus dem Bildspeicher auslesen, das dafür benötigte Bitmuster für den Ausgabeport ermitteln (jeweils 4 Bit für die Siebensegmentanzeige und den Multiplexer für die Stellenauswahl) und dieses Muster auf den Port B ausgeben. Es ist aber verschenkte Zeit, das Bitmuster 1000 mal pro Sekunde ständig neu zu errechnen, deshalb wird es beim Füllen des Bildspeichers errechnet und statt einfach nur der Ziffer wird das Bitmuster dort abgelegt. Die Ausgaberoutine muss also immer nur die nächste Stelle aus dem Bildspeicher auslesen und auf den Port ausgeben. Die Position des Ausgabecursors wird in der lokalen Variablen pos gespeichert.
static int digits[9];
void displayTick() {
static int pos = 0;
mPORTBWrite(digits[pos]);
pos++;
if (pos > 8) {
pos = 0;
}
}
Nun fehlt noch eine Möglichkeit, den Bildspeicher zu füllen. Als low level Funktion gibt es einen Aufruf, der die Position und einen Wert enthält. Diese Funktion errechnet daraus das Bitmuster für den Port B.
void setDigit(int pos, int value) {
int hexDigit = (value & 0xf) << 7;
int position = ((pos & 1) << 11) | ((pos & 0xe) << 12);
int pattern = hexDigit | position;
digits[pos] = pattern;
}
Darauf aufbauend gibt es nun eine Funktion, die einen 32 Bit Integer Wert in den Bildspeicher einträgt.
void setInt(int value) {
int i, j;
for (i = 8; i >= 0; i–) {
int part = value % 10;
setDigit(i, part);
value = value / 10;
if (value == 0) {
// clear leading digits
for (j = i – 1; j >= 0; j–) {
setDigit(j, 0xf);
}
break;
}
}
}
Beim Betrachten der Bilder ist mir aufgefallen, dass es ein sichtbares Übersprechen zwischen den einzelnen Stellen gibt. Ich vermute, dass die Abschaltung der Stelle nicht schnell genug ist und jede Stelle deshalb ein paar Mikrosekunden lang noch aktiv ist, während bereits die nächste Stelle angezeigt wird.
[Edit] Das habe ich mir mittlerweile mal genauer angesehen. Man bekommt den Effekt leicht per Software weg, indem man vor dem Wechsel der Stelle den Wert 0xf (alles dunkel) ausgibt und ein paar Mikrosekunden wartet. Ich vermute, dass der PNP Darlington Transistor nicht besonders schnell schaltet. Da er einen großen Vorwiderstand hat, dauert es vermutlich mehrere Mikrosekunden bis er abschaltet.
Da ich am Wochenende im Augenblick stark in die Vereinsarbeit (wsb-calw.de) eingebunden bin, geht es mit meinem kleinen Projekt nicht so schnell voran wie gewünscht. Ich habe in dieser Woche aber doch ein paar weitere Schritte geschafft.
Die erste Hürde lag darin, dass ich nicht den kompletten Microstick einbauen wollte. Zum einen ist es zu teuer, für jedes kleine Bastelprojekt ca. 40 EUR auszugeben. Zum anderen wollte ich ein echtes Microcontrollerprojekt haben und nicht einfach nur eine fertige Modulplatine einbauen.
Eigentlich ist es auch nicht kompliziert. Für die Programmierung und das Debugging sind 5 Leitungen vorgesehen: GND und +3.3V, Daten und Takt sowie Reset. Also habe ich den PIC aus dem Microstick herausgenommen und auf meine Platine gesetzt. Die 5 Leitungen habe ich von der Platine mit dem Adaptersockel auf der Unterseite verbunden. Et voià – der PIC wurde von der Entwicklungsumgebung nicht gefunden. An dieser Stelle hätte ich mir eine Stunde Fehlersuche ersparen können, wenn ich mir den Schaltplan des Microstick richtig angesehen hätte. Dort kann man nämlich genau sehen, dass einige Prozessorpins nicht mit dem Adaptersockel verbunden sind. Unter anderem Reset und +3.3V.
Nachdem ich die Verbindung vom Adaptersockel entfernt und direkt in PIC Fassung eingesteckt hatte, lief die Kontaktaufnahme problemlos. Nun hatte ich den Stand, dass ich einen externen PIC32 programmieren und debuggen konnte.
Der nächste Schritt war dann Fleißarbeit: den Siebensegmentdecoder und den 1 aus 16 Demultiplexer vom Steckbrett auf meine Lochrasterplatine versetzen. Das wäre eigentlich einfach gewesen. Unglücklicherweise habe ich für die Verbindungen einen Draht mit einer extrem weichen und wärmeempfindlichen Isolierung verwendet. Und mir dabei gleich einen Kurzschluss zwischen zwei Datenleitungen eingebaut.
Um es noch etwas komplizierter zu machen, habe ich an dem Multiplexer auch noch den Enabled Eingang offen gelassen. Da ein offener CMOS Eingang auf irgend einem Pegel hängt, bekommt man eine extrem unzuverlässige Schaltung. Bei mir blieb das Display dunkel – bis ich mit dem Finger in die Nähe des ICs gekommen bin. Alleine die Nähe hat ausgereicht, dass der Pin mit 50 Hertz Netzfrequenz ein- und ausgeschaltet hat. Wieder ein Abend verloren, bis ich das gefunden hatte.
Der nächste Abend ging dafür drauf, die 9 PNP Transistoren für den Multiplexer auf der Anodenseite einzulöten und Basiswiederständen zu versehen. Dabei hatte ich im Vorfeld den benötigten Platz etwas knapp kalkuliert. Es hat zwar alles gepasst, ist aber etwas gedrängt und schief. Nun ja – später ist es in einem Gehäuse und man sieht es nicht mehr.
Jetzt läuft aber alles und der nächste Schritt besteht darin, eine interruptgesteuerte Anzeigeroutine für den Multiplexer zu schreiben. Der Lötkolben kann ein paar Tage ausruhen.
Im Internet hatte ich vor ein paar Wochen ein Verfahren gefunden, wie man einen Frequenzzähler mit guter Genauigkeit und Messauflösung aufbauen kann. Das Original wurde mit einem AVR Prozessor aufgebaut. Da ich ein PIC32 Projekt durchführen wollte, habe ich diesen Prozessor gewählt, auch wenn ein einfacheres Modell gereicht hätte.
Bei ebay konnte ich für wenige Euro 9-stellige blaue Siebensegment Displays erwerben. Da mein PIC32 Modell nicht gerade üppig mit Pins bestückt ist, habe ich einen normalen Siebensegment Decoder 7447 verwendet. Das hat auch den angenehmen Vorteil, dass ich gleich eine Open Collector Ansteuerung für die LEDs habe. Den Dezimalpunkt kann ich im Augenblick noch nicht ansteuern, dafür werde ich noch ein Port-Pin spendieren müssen.
Zum Multiplexen der einzelnen Stellen habe ich einen 1 aus 16 Decoder 74154 verwendet. Ich hatte auch überlegt, einen 1 aus 8 Decoder (74138) zu verwenden und die neunte Stelle dann direkt anzusteuern. Das hätte die Schaltung aber umfangreicher gemacht und bringt kaum eine Einsparung. Dann sind eben 7 Schaltzustände ungenutzt. Das kann ich später dazu verwenden um zusätzliche LEDs zur Statusanzeige anzusteuern.
Da ich die Segmente mit mindestens 30 mA ansteuern möchte (laut Datenblatt sind 30 mA erlaubt, deshalb wird das Display es auch überleben, wenn der Multiplexer mal stehen bleibt), kann ich die Stellenumschaltung nicht direkt vom IC aus ansteuern. Es müssen bei der Anzeige der Ziffer 8 ca. 240 Milliampere geliefert werden. Also erfolgt die Ansteuerung über einen PNP Darlington Transistor der mit dem Emitter an Plus liegt. Der Decoder zieht den ausgewählten Kanal freundlicherweise auf 0 – genau passend zur Ansteuerung des Transistors, natürlich mit einem Vorwiderstand. Vermutlich hätte hier statt eines Darlingtons auch ein normaler PNP Transistor gereicht.
Die TTL ICs betreibe ich mit den vorgeschriebenen 5 Volt, den PIC mit 3,3 Volt. Der High Level des PIC hat aber auch bei nur 3,3 Volt einen ausreichend hohen Pegel um von den TTL ICs als High erkannt zu werden.
Für den Prototypen auf dem Steckbrett habe ich nur 3 Stellen verkabelt. Der nächste Schritt besteht darin, das Ganze dann vollständig auf einer Platine aufzubauen. Sobald die Anzeige dann steht, geht es an den Zählerteil.
Etwas zum Nörgeln habe ich zum Schluss aber noch: die Port-Pin Verteilung bei den 28 Pin PIC32 ist übel. Vom Port A stehen prinzipiell die ersten 5 Bit zur Verfügung – die Einschränkung deshalb, weil ich nur PA0 und PA1 tatsächlich zu einer Ausgabe überreden konnte. PA2 und PA3 gehören scheinbar dem Programmieradapter. Die Verwendbarkeit von PA4 habe ich nicht überprüft.
Beim Port B ist es auch nicht toll. Er ist auf den ersten Blick vollständig – aber nein: die Bits 6 und 12 fehlen ganz. Zwei weitere Bits sind durch den Oszillator belegt und ich habe noch nicht herausgefunden, wie man sie als Ausgang verwenden kann. Da ist es schon mühsam, vier zusammenhängende Bits als Bus zu finden. Das hätte man vielleicht auch sinnvoller aufteilen können.
Gestern ist die neue Hardware gekommen. Auch hier habe ich als erstes mal Blinky ausprobiert.
Die erste Hürde lag in den Projekteinstellungen. Dort kann man den Microstick direkt auswählen. Dann wird er aber nicht erkannt. Statt dessen muss man „Starter Kits (PKOB)“ auswählen. Zum Glück wird man durch den grünen Punkt in die richtige Richtung geleitet.
Nachtrag: wer lesen kann, ist im Vorteil. Die Selektion heißt MICROSTICK – ich habe aber einen Microstick II, das Nachfolgemodell.
Ein erster Test mit dem Oszilloskop zeigt nur mittelprächtige Werte. Knapp 400 nS für ein Bit setzen oder zurücksetzen, das ist nicht toll für 12,5 nS Taktrate. Ich komme auf 30 Takte. Vermutlich ist das dem Compiler geschuldet, der in der kostenlosen Version keine Optimierungen bietet. Falls ich damit Probleme bekomme, werde ich es mal mit Assembler versuchen. Im Augenblick werde ich erst mal die Hardware erforschen.
Der Neugierde halber habe ich mir doch mal den erzeugten Assembler Code angesehen. In den Projekteigenschaften kann man einstellen, dass die temporären Dateien nicht gelöscht werden. So ganz klar ist mir noch nicht, wo da die 30 Takte bleiben, das werde ich in den nächsten Tagen mal genauer untersuchen.
Ich habe dem Prozessor unrecht getan. Durch eine Konfigurationsfehler lief er nur mit etwa einem Achtel des möglichen Takts. In der verbesserten Konfiguration komme ich auf etwa 50 nS.
Wenn ich das zu diesem Zeitpunkt genauer untersucht hätte, wären mir einige Probleme in dem Folgeprojekt erspart geblieben.