Die digital anzeigende Personenwaage SUPER-SERVAL - EMSP

Abschlußbericht Mixed Signal Baugruppen 2007/8 Digitaltechnik BACK TO THE ROOTS SUPER-SERVAL 

Die digital anzeigende Personenwaage SUPER-SERVAL 

Nachträgliche Ergänzungen zur Firmware 

Von Henry Westphal 

Seite 5- 1


Die Idee 

Im Rahmen der Lehrveranstaltung wurde aus Zeitgründen ein bereits bei Tigris vorhandener Hardware- 

Abstraction-Layer verwendet. Da dieser auch bei Kundenprojekten eingesetzt wird, kann er nicht 

veröffentlicht werden, was dem Open-Source-Gedanken dieses Projekts widerspricht. 

Weiterhin erscheint es interessant, anstelle des (intern) umfangreichen und universellen Hardware- 

Abstraction Layers, der ja in einem gewissen Sinne, eine im Sinne des Gewinnens von Erkenntnis 

eigentlich unerwünschte „Blackbox“ darstellt, eine sparsame Programmierung zu setzen, die nur das 

für den Funktionsumfang des Super-Serval Notwendige enthält. 

Dieses Programm wurde im Oktober 2008 im Rahmen einer internen Mitarbeiterfortbildung der Tigris- 

Elektronik GmbH erstellt. 

Seite 5- 2


Die verwendeten Tools 

Das Programm wurde im Rahmen einer einzigen (selbst geschriebenen) Datei realisiert. Hierzu kam 

der C-Compiler IAR Embedded Workbench EW8051 Version 7.50A zum Einsatz. Weiterhin wurde die 

Software „Windows Serial Download“ von Analog Devices verwendet, um das vom IAR-Compiler 

generierte Hex-File in den Microcontroller-Flash zu laden. Diese Software ist im Lieferumfang des 

Analog-Devices AD845 Eval-Kits enthalten. 

Mit zu diesem Kit gehört ein Download-Kabel, das hier ebenfalls verwendet wurde. Das Interface 

zwischen dem Download-Kabel und der Super-Serval-Baugruppe ist eine Tigris-spezifische 

Adapterbaugruppe, die im Folgenden dokumentiert ist: 

5-6: Emulator 

(nur für Entwicklungsstadium) 

7-8 S/W-Download Taster 

(nur für Entwicklung und Produktion) 

J6002 

CON4 

GND 

TXD 

RXD 

VDD 

1-2 RXD/TXD TTL-Pegel J6001 


CON8 

2 1 

3-4 Brücke zum Abtrennen USB 


4 3 

9-10 Resettaster 


6 

8 

10 

1 234 

5 

7 

9 

SW6003 

SW PUSHBUTTON 

SW6004 

SW PUSHBUTTON 

1 2 

J6003 

CON2 

+5V 

ADI 

EVAL-KABEL 

RESET 

DOWNLOAD 

EMULATOR 

Adapterbaugruppe, J6001 ist 1 zu 1 mit J201 auf dem Super-Serval verbunden 

Seite 5- 3


GND 

TXD 

4 

RXD 

3 

VDD 

2 

1 

Definition der Belegung des Gegensteckers zum Download-Kabel von Analog Devices 

Das Download-Kabel wird PC-seitig an den COM-Port angeschlossen. 

Seite 5- 4


Der Source-Code 

Da der Source-Code mit umfangreichen Kommentaren versehen ist, wird die voranstehende 

Beschreibung kurz gehalten. 

Die Waage wird mit zwei Tastern kalibriert. 

Bei leerem Wägeteller drückt man die Taste „0kg“. Damit wird der Nullwert erfasst und als 

Kalibrierkonstante im nichtflüchtigen Datenspeicher des AduC845 abgelegt. 

Bei mit Kalibriergewichten von insgesamt 80kg belastetem Wägeteller drückt man die Taste „80kg“. 

Damit wird der dazugehörige Ausgangscode des A/D-Umsetzers als zweiter Kalibrierwert nichtflüchtig 

abgelegt. 

Die Gewichtsanzeige entsteht dann durch Verrechnung des aktuellen Ausgangscodes des A/D- 

Umsetzers mit den gespeicherten Kalibrierdaten. 

Nach dem Laden der Kalibrierkonstanten und der Initialisierung des A/D-Umsetzers gelangt das 

Programm in eine Endlosschleife, in der laufend das Gewicht gemessen und angezeigt wird. In 

dieser Schleife werden zudem die Kalibriertaster abgefragt, wird ein Tastendruck erkannt wird, erfolgt 

eine Aktualisierung des gewählten Kalibrierwertes sowie dessen nichtflüchtige Speicherung. 

/******************************************************* 

* 

* Firmware Personenwaage SUPER-SERVAL 

* 

* Version 1.00 29.10.2008 

* 

* 31.10.2008 Gleitender Mittelwert hinzugefügt 

* 

* (c) TIGRIS Elektronik GmbH 

* 

* Hinweis: dieses Programm wurde nur zu Demonstrations- Lehr- und 

* Ausbildungszwecken erstellt. Es entspricht nicht in allen Details den 

* Anforderungen, die an die Qualität eines kommerziellen Programms zum 

* professionellen Einsatz gestellt werden 

* 

*******************************************************/ 

/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 

* 

* Bitte unbedingt beachten: 

* 

* Man muß beim WSD-Downloader "Erase Code only" einstellen, unter 

* "Configuration". In der Default-Einstellung wird auch der 

* Datenspeicherbereich gelöscht, womit die Kalibrierdaten gelöscht werden. 

* 

* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ 

// Registerdefinitionen für ADuC845, im Lieferumfang von IAR enthalten 

#include "ioADUC845.h" 

Seite 5- 5


/********************************************************* 

* 

* Tigris-interne Standard-Typdefinitionen 

* 

**********************************************************/ 

typedef unsigned char int8u; 

typedef unsigned int int16u; 

typedef unsigned long int32u; 

typedef signed char int8s; 

typedef signed int int16s; 

typedef signed long int32s; 

typedef float flt32; 

typedef double flt64; 

typedef int8u bool; 

#define true (bool)1 

#define false (bool)0 

/********************************************************* 

* Delay-Routine 

* 

* Verzögerung um die übergebene Zeit delay_time, Wert der 

* Variablen multipliziert mit etwa 4 us 

* 

**********************************************************/ 

void delay (int32u delay_time) 

{ 

int32u volatile actual_time; 

} 

actual_time = 0; 

while (actual_time < delay_time) 

{ 

actual_time ++; 

} 

Seite 5- 6


/********************************************************* 

* Initialisierung des A/D-Wandlers 

* 

* kontinuierliche Wandlung im Bereich 320mV mit vorheriger Kalibrierung 

* Eingangsbuffer überbrückt! 

* 

**********************************************************/ 

void adc_setup( void) 

{ 

int mode0; 

int mode1; 

int mode2; 

int mode3; 

int mode4; 

int mode5; 

int mode6; 

int mode7; 

// Register ADCMODE 

mode7 = 0; 

mode6 = 1; // Notch-Filter 50/60 Hz aktiv 

mode5 = 1; // Primary ADC eingeschaltet 

mode4 = 1; // Auxiliary ADC eingeschaltet 

mode3 = 0; // Chop aktiv, da Bit negiert 

mode2 = 0; // idle 

mode1 = 0; 

mode0 = 1; 

ADCMODE = ( mode0 // kein sequentieller, bitweiser Zugriff 

+ (mode1


// Register SF 

SF = 246; // ca. 5 Wandlungen pro Sekunde. Bessere 

// Performance als "255", wurde durch Tigris- 

// interne Tests festgestellt 

// Auch wenn zu einem späteren Zeitpunkt eine Kalibrierung auf Systemebene 

// stattfindet, wird sicherheitshalber die im Datenblatt vorgeschlagene 

// Kalibriersequenz ausgeführt 

// interner Nullpunktabgleich im Bereich 2,56V 

// Register ADC0CON1 

ADC0CON1_bit.RN0 = 1; // Eingangsspannungsbereich 2,56V 

ADC0CON1_bit.RN1 = 1; 



mode7 = 0; 





mode2 = 1; // internal zero calibration 

mode1 = 0; 

mode0 = 0; 

ADCMODE = ( mode0 

+ (mode1


// interner Fullscale-Abgleich im Bereich 2,56V 

// Register ADC0CON1 

ADC0CON1_bit.RN0 = 1; // Eingangsspannungsbereich 2,56V*/ 




mode7 = 0; 





mode2 = 1; // internal full scale calibration 

mode1 = 0; 

mode0 = 1; 


+ (mode1


// "continuous conversion" für den weiteren Betrieb einstellen 

} 


mode7 = 0; 





mode2 = 0; // Continous Conversion 

mode1 = 1; 

mode0 = 1; 


+ (mode1


/********************************************************* 

* Auslesen des A/D-Wandlers 

* 

* Es wird ein 24-Bit-Wert aus dem ADC ausgelesen 

* 

* 0xffffff = positive full scale voltage 

* 0x800000 = zero voltage 

* 0x000000 = negative full scale voltage 

* 

* Bei erfolgreichem Erkennen des READY-Flags wird die 

* grüne LED gepulst 

* 

**********************************************************/ 

int32u adc_readout (void) 

{ 

int32u volatile ready; 

int32u value; 

int32u volatile low_byte; 

int32u volatile mid_byte; 

int32u volatile high_byte; 

} 

ready = 0; 

value = 0; 

while ( ready == 0) // Ready-Flag des ADC pollen 

{ 

ready = ADCSTAT_bit.RDY0; 

} 

if (ready == 1) 

{ 

P2_bit.P20 = 0; // Pulsen der grünen LED bei 

delay(5); // Erkennen des Abschlusses 

P2_bit.P20 = 1; // der A/D-Wandlung 

} 

low_byte = ADC0L; 

mid_byte = ADC0M; 

high_byte = ADC0H; 

value = low_byte + (mid_byte


/********************************************************* 

* Einlesen der Taster 

* 

* Die Taste wird als gedrückt interpretiert, 

* wenn 90% der übergebenen "debounce time" ein Low-Pegel 

* erkannt wurde 

* 

* Rückgabe 

* 0 = keine Taste gedrückt 

* 1 = nur "0kg"-Taste gedrückt 

* 2 = nur "80kg"-Taste gedrückt 

* 3 = Taste "0kg" und Taste "80kg" gedrückt 

* 

**********************************************************/ 

int scan_switches (int32u debounce_time) 

{ 

} 

int32u volatile time; 

int32u volatile sum_P22; 

int32u volatile sum_P23; 

int32u switch_state; 

int32u volatile P22; 

int32u volatile P23; 

time = 0; 

sum_P22 = 0; 

sum_P23 = 0; 

P22 = 0; 

P23 = 0; 

while ( time < debounce_time ) // Abfrage und Summierung der 

// Tastenzustände über die 

// Entprellzeit 

{ 

if (P2_bit.P22 == 0) // Abfragen Taste "0kg" 

{ 

sum_P22 ++; 

} 

} 

if (P2_bit.P23 == 0) // Abfragen Taste "80kg" 

{ 

sum_P23 ++; 

} 

time ++; 

if ( sum_P22 > ( debounce_time * 0.9)) // Vergleich mit 90% Kriterium 

{ 

P22 = 1; 

} 

if ( sum_P23 > ( debounce_time * 0.9)) // Vergleich mit 90% Kriterium 

{ 

P23 = 1; 

} 

switch_state = P22; // Bildung des Rückgabewertes 

switch_state = switch_state + ( P23 * 2 ); // mit gewichteter Summierung 

return switch_state; 

Seite 5- 12


/********************************************************* 

* Anzeige einer HEX-Zahl 

* 

* Nur zum Debuggen 

* 

* Anzeige einer vierstelligen Zahl auf den LED-Displays im 

* HEX-Format 

* 

**********************************************************/ 

void display_hex( int32u value) 

{ 

} 

P0_bit.P04 = 1; // Alle Latch-Eingänge 

P0_bit.P05 = 1; // der Displays werden 

P0_bit.P06 = 1; // in den inaktiven 

P0_bit.P07 = 1; // Zustand (high) 

// gebracht 

// Schreiben des ersten Digits von rechts 

P0_bit.P04 = 0; // Latch-Signal auf low 

P3 = ( (value & ( 0x0f 0 ) 4 ) 8 )


/********************************************************* 

* Anzeige einer Dezimalzahl 

* 

* 

* Anzeige einer vierstelligen Zahl auf den LED-Displays im 

* Dezimal-Format 

* 

**********************************************************/ 

void display_dec( int32u value) 

{ 

} 

int digit0; // Hilfsvariablen für die einzelnen 

int digit1; // 4 Digits 

int digit2; 

int digit3; 

digit0 = (value / 1 ) % 10; // Umwandlung Hex zu BCD 

digit1 = (value / 10 ) % 10; // erst Teilen, dann den "Rest" 

digit2 = (value / 100 ) % 10; // (mit "%") bestimmen 

digit3 = (value / 1000 ) % 10; // Beispiel: Anzeigen der zweiten 

// Stelle von 1234 d, intern hexadezimal 

// abgelegt 1234 geteilt durch 100 ist 

// 12,3412,34 % 10 ist 2,34 

// angezeigt wird dann "2" 

P0_bit.P04 = 1; // Alle Latch-Eingänge der Displays 

P0_bit.P05 = 1; // werden in den inaktiven Zustand 

P0_bit.P06 = 1; // (high) gebracht 

P0_bit.P07 = 1; 

// Schreiben des ersten Digits von rechts 

P0_bit.P04 = 0; // Latch-Signal auf low 

P3 = digit0


/********************************************************* 

* Schreiben in den nichtflüchtigen Speicherbereich des AduC845 

* 

* Es wird eine 32 bit-Zahl "data" übergeben, die in der 

* ebenfalls übergebenen Adresse "page_address" gespeichert wird 

* 

* Bei erfolgreichem Verify wird die grüne LED gepulst 

* 

**********************************************************/ 

void write_nv( int16u page_address, int32u data) 

{ 

EADRL = page_address & 0x00FF; // Page-Address in Adress- 

EADRH = (page_address & 0xFF00) >> 8; // register schreiben 

} 

EDATA1 = data & 0x000000FFul; // Daten in Datenregister 

EDATA2 = (data & 0x0000FF00ul) >> 8; // schreiben 

EDATA3 = (data & 0x00FF0000ul) >> 16; // "Verteilung" auf die 

EDATA4 = (data & 0xFF000000ul) >> 24; // 4 Byte einer Page 

ECON = 0x05; // Page (4 Byte) löschen 

ECON = 0x02; // Inhalt der Datenreister 

// in EEPROM übertragen 

ECON = 0x04; // Verify durchführen 

if (ECON == 0) // Wenn Verify OK, dann 

{ // grüne LED pulsen 

P2_bit.P20 = 0; 

delay(2000); 

P2_bit.P20 = 1; 

} 

else // Wenn Fehler, dann rote LED 

{ // pulsen 

P2_bit.P21 = 0; 

delay(2000); 

P2_bit.P21 = 1; 

} 

Seite 5- 15


/********************************************************* 

* Lesen aus dem nichtflüchtigen Speicherbereich des AduC845 

* 

* Es wird eine 32 bit-Zahl "data" zurückgegeben, die aus der 

* übergebenen Adresse "page_address" ausgelesen wird 

* 

**********************************************************/ 

int32u read_nv( int16u page_address) 

{ 

int32u data; // Rückgabewert 32bit 

int32u byte1; // Hilfsvariable 




} 

EADRL = page_address & 0x00FF; // Page-Address in Adressregister 

EADRH = (page_address & 0xFF00) >> 8; // schreiben 

ECON = 0x01; // Daten aus EEPROM-Zellen in 

// Datenregister übertragen 

// 4 Bytes einer Page werden 

// gleichzeitig übertragen 

byte1 = EDATA1; // Die Inhalte der Datenregister 

byte2 = EDATA2; // werden in Hilfsvariablen 

byte3 = EDATA3; // übertragen Damit werden 

byte4 = EDATA4; // Typenkompatibilitätsprobleme 

// umgangen 

data = byte1; // gewichtete Addition der 

data = data + ( byte2


/********************************************************* 

* Hauptprogramm 

* 

* Ablauf: 

* Initialisieren 

* Holen der Kalibrierwerte aus dem EEPROM 

* Endlosschleife mit laufender Gewichtsanzeige 

* und Abfrage der Taster 

* Bei Erkennen gedrückter Kalibriertaster 

* Aktualisierung der Kalibrierdaten im EEPROM 

* 

* Zum Kalibrieren bei leerem Wägeteller die Taste "0kg" drücken, 

* bis die grüne LED für ca. 1/4 s dauerhaft aufleuchtet. 

* Bei mit 80kg belastetem Wägeteller die Taste "80kg" drücken, 

* bis die grüne LED für ca. 1/4 s dauerhaft aufleuchtet. 

* 

**********************************************************/ 

int main(void) 

{ 

int32u debounce_time; // Entprellzeit Taster 

double filtered_value; // Zwischenwert zu Aufsummierung Mittelwert 

double ref0kg; // Kalibrierwert Nullpunkt (ADC-Wert 0kg) 

double ref80kg; // Kalibrierert Steigung (ADC-Wert 80kg) 

double gewichtkg; // errechnetes Gweicht in kg 

debounce_time = 20; // Entprellzeit Taster 

int32u ADC_wert_1; 




/* Initialisierung */ 

delay (10000); 

adc_setup(); // ADC initialisieren 

ref80kg = read_nv(2); // Laden der Kalibrierkonstanten 

ref0kg = read_nv(1); // aus internem EEPROM 

/* Programmablauf */ 

while(1) // Endlosschleife 

{ 

// Bildung des gleitenden Mittelwerts über 4 A/D-Wandlungen 

ADC_wert_4 = ADC_wert_3; 



ADC_wert_1 = adc_readout(); 

filtered_value = ( ADC_wert_1 

+ ADC_wert_2 

+ ADC_wert_3 

+ ADC_wert_4 ) / 4 ; 

Seite 5- 17


// Bildung des Gewichts in kg aus A/D-Wandlungsergebnis und Kalibrierdaten 

} 

gewichtkg = ( ( filtered_value - ref0kg)/ (ref80kg - ref0kg) )* 80 * 100; 

// Gewicht anzeigen 

if (gewichtkg < 0) 

{ 

gewichtkg = gewichtkg * (-1); 

P2_bit.P21 = 0; // rote LED leuchtet bei negativen Werten 

} 

else 

{ 

P2_bit.P21 = 1; 

} 

display_dec( ((int32u)gewichtkg)); 

// Kalibrieren (nur wenn entsprechende Taste gedrückt) 

} 

if ( scan_switches(debounce_time) == 1) // Wenn Taste "0kg" gedrückt 

{ 

ref0kg = filtered_value; // ADC-Wert in EEPROM schreiben 

write_nv(1,(int32u)ref0kg); 

} 

if ( scan_switches(debounce_time) == 2) // Wenn Taste "80kg" gedrückt 

{ 

ref80kg = filtered_value; // ADC-Wert in EEPROM schreiben 

write_nv(2, (int32u)ref80kg); 

} 

Seite 5- 18


Die Handhabung der Tools 

Die Installationen. 

Analog-Devices-Tools: 

Hier gibt es keinerlei Besonderheiten, es muß lediglich die angezeigte Installer-Sequenz abgearbeitet 

werden. 

IAR-EW8051: 

Man installiert von der mitgelieferten CD, exakt nach der Installer-Sequenz. (Von einem Image der CD 

ist keine Installation möglich). Hierbei arbeitet man mit dem Startup-Freigabecode, der 30 Tage gilt. 

Man registriert das Produkt und erhält per E-Mail einen Dauer-Code zurück, der dann, nach Anleitung 

in der E-Mail eingegeben werden muß. 

Seite 5- 19


Die grundlegenden Schritte mit dem IAR-EW8051 und dem AD- 

WSD. 

Vorbemerkung 

Hier sind bewußt nur rudimentäre Bedienvorgänge auf Anfänger-Niveau beschrieben. Die 

Möglichkeiten des Programms sind hierbei wahrscheinlich nicht mal im einstelligen Prozentbereich 

genutzt. Diese Schritte, die in wenigen Minuten erlernbar sind, reichen aber schon aus, um ein 

Programm in der Komplexität der Super-Serval-Firmware erfolgreich zu realisieren! 

Neues Projekt anlegen 

Verzeichnis mit Windows-Explorer anlegen 

Seite 5- 20


IAR-EW8051 starten 

Start => Programme => Entwicklung => IAR Embedded Workbench 

(Pfad ist rechnerspezifisch) 

Es erscheint folgendes Fenster: 

Seite 5- 21


File => New => Workspace 

Seite 5- 22


Project => create new Project 

Tool chain => 8051 auswählen 

Seite 5- 23


Device specific project templates => Analog Devices auswählen: 

Baustein AduC845 auswählen und mit OK bestätigen: 

Seite 5- 24


„Speichern unter“ in das zuvor für dieses Projekt erstellte Verzeichnis 

Einen Namen für das Project festlegen und Box dann mit „speichern“ verlassen. 

Seite 5- 25


Damit ist automatisch ein „Rumpf-File“ ad845.c angelegt. 

Seite 5- 26


Man kann entweder mit dem vorhandenen Rumpf-File AD845.c manuell weiterarbeiten, also dort 

seinen neuen Source-Code erstellen... 

Seite 5- 27


...oder dieses löschen und ein bereits vorhandenes File einbinden, mit dem man weiterarbeiten will. 

Hierzu das vorhandene File, mit dem man weiterarbeiten will, mit dem Explorer in das zuvor erstellte 

Projekt-Hauptverzeichnis kopieren und als „AD845.C“ benennen. Zuvor das „Rumpf-File“ im Project- 

Fenster schließen. 

Seite 5- 28


Nach Abschluß erscheint das gewünschte File im Project-Fenster, wenn man „ad845.c“ wieder 

öffnet. 

Nun kann man mit diesem File weiterarbeiten und es verändern oder ergänzen. 

Seite 5- 29


„Wiederfinden“ eines Projekts 

Der einfachste Weg ist der „Shortcut“ über „Recent Workspaces“: 

Seite 5- 30


Wenn man auf den entsprechenden Workspace clict, öffnet sich das Projekt: 

Seite 5- 31


Wenn der „Shortcut“ nicht verfügbar ist, dann kann man den Workspace auch „ganz normal“ öffnen: 

File => Open => Workspace 

Seite 5- 32


Das *.eww-File auswählen: 

Dann öffnet sich das Projekt: 

Seite 5- 33


Compilieren und Downloaden 

Zum Compilieren F7 drücken. 

Beim ersten Compilieren kommt zunächst die folgende Meldung 

Nun muß man einen Namen für die Workspace festlegen und eingeben 

Dann die Box mit „Speichern“ verlassen. 

Seite 5- 34


Danach erfolgt die Compilierung: 

Am unteren Rand des Bildschirms erscheinen Warnungen, Fehlermeldungen und Statusmeldungen. 

Bei allen weiteren Compileraufrufen mit F7 geschieht die Compilierung sofort. 

Zum Download das Programms in den ADuC 845-Baustein den „Windows Serial Downloader“ (WSD) 

von AD starten: 

Start => Programme => ADuC => WSD 

(Pfad ist rechnerspezifisch) 

Seite 5- 35


Es erscheint folgendes Fenster: 

Seite 5- 36


Zunächst das „Configuration“-Fenster öffnen und sicherstellen, daß „Erase the CODE ONLY“ gewählt 

ist, sonst werden bei jedem Download die Kalibrierdaten gelöscht! 

Dann das „Configuration“-Fenster mit OK verlassen und im Hauptfenster auf „Download“ clicen. 

Hier dann das herunterzuladende Hex-File auswählen: 

Es heißt „ADuC845.hex“ und befindet sich im Unterverzeichnis ...\Debug \Exe 

Seite 5- 37


Zur Verdeutlichung die entstandene Verzeichnisstruktur als Explorer-Darstellung: 

Auf dem Adapterboard die Reset-Taste drücken und gedrückt halten. 

Dann die Download Taste drücken. 

Die Reset-Taste loslassen. 

Dann erst die Download-Taste loslassen 

Nun durch clicen auf „Öffnen“ den Download starten. 

Seite 5- 38


Der Download startet, es öffnet sich das folgende Fenster: 

Der Download schließt mit der Meldung „Sucess“ ab. 

Was tun, wenn der Download fehlschlägt? 

Die häufigsten Gründe dafür sind: 

- Der COM-Port ist nicht richtig zugewiesen, dies kann unter „Configuration“ korrigiert werden 

- Bei USB-COM-Port-Adaptern tritt dieser Fehler sehr häufig auf. Siehe hierzu den Anhang „USB- 

Portzuteilung“ 

- Die Tastensequenz wurde nicht ganz korrekt ausgeführt 

- Eventuell sind die Taster durch häufige Benutzung verschlissen, womit sich unsauberes Schalten 

ergibt, dann muß die Schaltsequenz mit besonderer Präzision ausgeführt werden. 

- Die Kabelverbindungen sind nicht korrekt 

Dann Reset-Taste drücken 

Das heruntergeladene Programm beginnt abzulaufen. 

Seite 5- 39


Besonderheiten bezüglich des Programmcodes 

Es muß ein Bezug zwischen der Hardware des Bausteins ADuC845 und dem Programmcode 

hergestellt werden. Hierzu dient die Datei ioADuC845.h, die bei der Anlage eines neuen Projekts 

automatisch eingebunden wird. 

Die Vorgehensweise wird beispielhaft anhand von Port 0 gezeigt: 

Bytweise Ausgabe: P0 = variable 

Byteweises Einlesen: variable = P0 

Bitweise Ausgabe auf P1.0: P0_bit.P01 = variable (nur die Werte 1 oder 0 möglich) 

Bitweise Eingabe von P1.0: variable = P0_bit.P01 (nur die Werte 1 oder 0 möglich) 

Achtung: Nicht alle Bezeichnungen in dieser Datei entsprechen exakt den Bezeichnungen im 

Datenblatt. Das SF-Register des A/D-Umsetzers finden man nicht in dem dazugehörigen Abschnitt, 

sondern unter „System Management“. 

Seite 5- 40


Anhang: USB-Portzuteilung 

Wenn sich bei dem Downloadprogramm Schwierigkeiten mit der Portzuteilung in Verbindung mit 

einem USB-Adapter ergeben, dann können diese nach dem folgenden Lösungsweg behoben 

werden: 

Zunächst gilt es herauszufinden, wie das Betriebssystem den USB-Port als virtuellen COM-Port mit den 

im Betriebssystem angelegten COM-Ports verknüpft hat. 

Zunächst USB-zu Seriell-Adapter mit dem Rechner verbinden 

Dann: Start => Einstellungen => Systemsteuerung => Verwaltung => Copmputerverwaltung => 

Gerätemanager => Anschlüsse (COM und LPT) 

Man sieht hier im Beispiel, daß der virtuelle USB-COM-Port auf COM8 gelegt wurde. 

Abschließend den vorhin gesehenen / geänderten COM-Port dort auswählen/einstellen (unter 

„Configuration“ beim AD-Downloadprogramm. 

Für das Download-Programm von AD besteht jedoch die Notwendigkeit, sich auf die COM-Ports 

COM1 bis COM4 zu beschränken. 

Wenn dies durch die automatische Zuteilung nicht erfüllt wird, dann existiert der folgende 

Lösungsweg: 

Seite 5- 41


Durch Doppelclicen auf das im Beispiel blau markierte Feld „USB Seriel Port (COM8) geht ein Fenster 

mit den Eigenschaften des virtuellen COM-Ports auf: 

Registerkarte „Port Settings“ wählen 

Seite 5- 42


Dann auf „Advanced“ gehen. 

Seite 5- 43


Dort einen anderen, zulässigen COM-Port wählen: 

Dann das AD-Downloadprogramm starten. 

Abschließend den vorhin gesehenen / geänderten COM-Port dort auswählen/einstellen (unter 

„Configuration“ beim AD-Downloadprogramm. 

Seite 5- 44

Die digital anzeigende Personenwaage SUPER-SERVAL - EMSP

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?