FHlogo.gif (3673 Byte)
                      Mikrocomputerlabor:
         Kapazitätsmeßung für Ni-Cad Akku´s
 
 
 

                            

1 Aufgabenstellung

2 Anforderungsliste

3 Blockschaltbild

3.1 Portbelegungsplan

4 Hardware

4.1 Schaltplan

4.2 Platinenlayout

4.3 Bauteileliste

5 Software


          

 

   Aufgabenstellung:

 

Bedienungsanleitung:

Für die Bedienung des Akkuladers dienen die drei auf der Controllerplatine

befindlichen Taster T1..T3. Für die Ausgabe stehen die Leuchtdioden L1..L3, sowie die LCD-Anzeige zur Verfügung.

Mit T1 und T2 wird das Programm ausgewählt oder z.B. der Ladestrom gesenkt bzw. erhöht. Der mittlere Taster, T2, bestätigt die jeweilige Auswahl und führt in das nächste Menu.

Abfolge der Bedienung:

Nach dem Einschalten des Akkuladers leuchtet die LED 1 und der Lader bittet nach Auswahl des Ladeprogramms: LADEN, ENTLADEN, AKKU TESTEN

Mit den Tastern T1 und T3 wird durch das Menu gescrollt, mit T2 die Auswahl bestätigt.

 

 

 

    Anforderungsliste:

Änderung/ Datum

F

W

Anforderungen für Aufgabe / Teilaufgabe: Kapazitätsmeßung Ni-Cad Akku´s

Verantwortlich

 

 

 

 

 

 

Physik.-technische Funktionen

 

 

 

Geometrie

 

31.01.00

F

Über VAG-Leiste an die Euro 535 anschließbar Reufels

31.01.00

F

Steckkarte im Euroformat (160x100) Reufels

31.01.00

F

liegend für Laborbetrieb Reufels

31.01.00

F

Programmentwicklung Remote-Debug System Assembler Reufels/Lauer

 

 

 

 

 

 

Kinematik

 

31.01.00

F

statisch Lauer

 

 

 

 

 

 

Kräfte

 

31.01.00

W

ohne äußere Belastung Lauer

 

 

 

 

 

 

Anforderungen an die Technologie

 

 

 

Gebrauch

 

31.01.00

F

Ladung – bzw. Ladekontrolle Akku Lauer

31.01.00

F

Anzeige über LCD – Display Lauer

31.01.00

F

Bedienung über die vorhandenen Taster auf der Euro 535 Lauer

 

 

 

 

 

 

Montage - Fertigung

 

31.01.00

F

Platinenlayout mit Protel Reufels

31.01.00

F

Layoutfräsung der Platine i.d. FH-Werkstatt Lauer

31.01.00

F

Prototyp – Aufbau mit Handbestückung Reufels

 

 

 

 

 

 

Kontrolle

 

31.01.00

F

Prüfprotokoll und Meßpunkte auf der Platine Reufels

 

 

 

 

 

 

Energie

 

31.01.00

F

Labor - Netzteil Lauer

 

 

 

 

F= Festdorderung W= Wunsch

 

 

    Blockschaltbild

 

Blockschaltbild.GIF (10601 Byte)

    Portbelegungsplan

Port

Verwendung

Funktion

 

 

 

1.1

Taster

Die Taster der EURO 535 – Platine werden zur Steuerung des

1.2

Taster

Vorganges bzw. Programmes verwendet

1.3

Taster

 

3.2

LED

Zusätzliche Anzeigefunktionen werden mit den vorhanden

3.3

LED

LED´s der EURO 535 realisiert

3.4

LED

 

4

Display

D0-D7 (Datenleitungen des Display´s)

5.0

Display

R/W

5.1

Display

RS

5.2

Display

_E

5.3

Analog - Schaltung

Laden

5.4

Analog - Schaltung

Entladen

AN0

Analog - Schaltung

Akku Spannung

 

Hardware

   Schaltplan

 

    Platinenlayout

 

    Bauteileliste   

 

 

Menge

Artikel

Bestellnr.

Einzelpreis

Gesamtpreis

1

VAG-Leiste (96 pin Buchse)

-

-

-

1

LCD-Display 2 zeilig, 16 Zeichen

LTN 211R-10

DM 23,319

DM 23,319

2

1N4001

1N4001

DM 0,043

DM 0,086

1

1N4148

1N4148

DM 0,035

DM 0,035

1

BY251

BY251

DM 0,158

DM 0,158

2

BC547B

BC547B

DM 0,096

DM 0,192

1

BD240

BD240

DM 0,522

DM 0,522

1

BUZ11

BUZ11

DM 1,595

DM 1,595

1

LM324

LM324 DIL

DM 0,33

DM 0,33

1

LED 20mA

CQY72

DM 0,130

DM 0,130

2

Trimmer liegend (PIHER) 10k

PT 6-L 10k

DM 0,391

DM 0,782

1

10k

Metall 10k

DM 0,130

DM 0,130

1

220

Metall 220

DM 0,130

DM 0,130

1

4,7k

Metall 4,7k

DM 0,130

DM 0,130

1

100k

Metall 4,7k

DM 0,130

DM 0,130

1

0,39 /1W axial

5W axial 0.39

DM 0,509

DM 0,509

1

0,82 /1W axial

5W axial 0.82

DM 0,509

DM 0,509

1

0,51 /1W axial

5W axial 0.51

DM 0,509

DM 0,509

1

UA 7805 /1A

UA 7805

DM 0,417

DM 0,417

1

10uF

RAD 10/35

DM 0,078

DM 0,078

1

330uF

RAD 330/16

DM 0,174

DM 0,174

3

100nF

MKS-2 100n

DM 0,139

DM 0,417

Gesamtpreis

DM 29,85

zuzügl. 16 % MwSt

DM 4,78

Rechnungsbetrag

DM 34,63

 

 

 

 

 

Software

Programmablaufpan

 

 

 

 

 

 

  

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

** **

** Datei:Akku2.C **

** Das Programm bewirkt: Automatisches Akkuladen/Entladen **

** und Testen des angeschl. Akkus **

** **

** **

** Eingangsparameter: KEINE! (void) **

** **

** Ausgangsparameter: KEINE! (void) **

** **

** Rueckgabewert: KEINER! (void) **

** **

***********************************************************************

** **

** Autor: J. Reufels / B. Lauer **

** Datum: 03.01.2000 WS99/00 **

** **

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

/***************** Steueranweisungen fuer den Compiler ***************/

#pragma SMALL /* Speicherverwaltung: SMALL */

#pragma OBJECTEXTEND /* typengerechtes Programm Debug */

#pragma SYMBOLS /* alle Symbole werden aufgelistet */

#pragma CODE DEBUG /* Symbolisches Debuggen ein */

/* typedefs */

typedef enum {PIN_LADEN, PIN_ENTLADEN} PIN;

typedef enum {FULL, EMPTY, ERROR, OK } ZUSTAND;

typedef enum {LADEN, ENTLADEN, TESTEN} LADE_MODE

/* include */

#include <euro_535.h> /* Definitionen fuer EURO_535-Karte */

#include <stdio.h> /* fuer 'printf' notwendig */

#include "DISPLAY.H" /* fuer LCD-Display Ansteuerung */

/* aus Buch: 8051 Mikrocontroller */

/* Maier-Wolf Franzis Verlag */

/* ISBN 3-7723-6453-5 */

/* wegen Uhrheberrechte nicht abgedruckt*/

/* Variablendeklarationen */

/* globals */

int upper_voltage; // Vorkomma Spannungswert;

int lower_voltage; // Nachkommaanteil, 2-stellig

int akku_status = OK; // Akku-Zustand

int voltage; // Spannungswert AD-Wandler

int tmp_voltage; // Hilfsvariable

int akku_prog; /* Akku programm ( 1:laden 2:entl 3:Testen ) */

int current; /* Lade-/Entladestrom */

int akku_cap; /* voreingestellte Akku-Kapazitaet */

int high_puls_time; /* 1..100 Zeit in 0,036s */

int des_capacity; /* Solwert Kapazitaet */

unsigned int lower_capacity; /* steht fuer mAh */

unsigned int upper_capacity; /* steht fuer uAh */

unsigned char data LF_ADR; /* LCD-RAM Adresse der naechsten Zeile */

int z; /* Laufvariable */

/* Funktions-Prototypen */

void calc_val(void); /* Ladeparameter berechenen */

void akku_menu(void); /* akkumode auswahl */

void init_timer2(void); /* Timer 2 init */

void wait_t2(int portpin); /* Warteschleife Timer 2 */

void prog_control(void); /* Programmführung */

void load_akku(void); /* Akku Ladeprogramm */

void discharge_akku(void); /* Akku Entladeprogramm */

void auswahl(int wert); /* Menu Auswahl Akkuprogramm */

int read_voltage(void); /* ADDAT Register lesen */

void inc_capacity(void); /* Kapazitaet erhoehen */

int check_voltage(void); /* Spannung ueberpruefen */

 

 

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

/*

/* void main(void)

/*

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

void main(void)

{

/* Initialisieren */

/* Lade und Entladepin ruecksetzen */

CHARGE = 0;

DISCHARGE = 0;

/* Betriebsmodi EIN anzeigen */

LED1 = 0;

/*Display initialisieren */

disp_init(0x08, 0);

LF_ADR = 0x40; /* RAM-Adresse fuer zweite Zeile */

/* Display loeschen */

clrscr();

printf("uC-Labor WS99/00\n");

printf("Lauer / Reufels");

wait(60000);

clrscr();

/* Akku-Betriesmodi waehlen */

akku_menu();

/* zugehoerige Ladeparameter berechnen */

calc_val();

/* Timer initialisiern */

init_timer2();

/* Ladeprogramm aufrufen */

prog_control();

}

 

 

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

/*

/* readvoltage

/*

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

int read_voltage(void)

{

/* AD-Wandler AN0 lesen mit Bereich 0,00..5,00V */

ADCON |= 0x80; /* Kanal AN0 selektieren */

DAPR = 0x00; /* Wandlung starten */

while(BSY);

return (int) ADDAT;

}

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

/*

/* check_voltage

/*

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

int check_voltage()

{

int u_voltage; // aktueller Spannungswert

/* ADDAT in Integer-Wert wandlen */

u_voltage = (int) read_voltage();

/* Akkuspannung: Vor- und Nachkommastelle berechnen */

tmp_voltage = u_voltage * 100 / 51;

upper_voltage = u_voltage / 51;

lower_voltage = tmp_voltage - upper_voltage * 100;

voltage = upper_voltage * 100 + lower_voltage;

/* Akku-Status auf OK setzen */

akku_status = OK;

/* pruefen, ob Akku voll oder defekt ist */

if (voltage <= 50 || voltage > 150)

{

akku_status = ERROR;

clrscr();

printf("Akku defekt ");

LED1=1;

wait(60000);

}

/* Pruefen, ob Akku entladen ist */

if (akku_prog != LADEN && voltage <= 80) // also AKKU entladen o. lADEN

{ akku_status = EMPTY;

printf("Akku leer");

}

/* Pruefen, ob Akku voll geladen ist */

if (akku_prog == LADEN && voltage >= 126) // nur bei AKKU laden

{ akku_status = FULL;

printf("akku voll");

}

/* wenn Akku-Status weiterhin ok */

if (akku_status == OK)

{

/* Cursor positionieren und Spannung ausgeben */

printf("U = %d,", upper_voltage);

if (lower_voltage < 10) printf("0%d[V]", lower_voltage);

else printf("%d[V]", lower_voltage);

}

/* Akku-Status zurueckgeben */

return akku_status;

}

 

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

/*

/* void auswahl(int wert)

/*

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

void auswahl(int wert)

{

switch (wert)

{

case 0 : printf("LADEN ");

break;

case 1 : printf("ENTLADEN ");

break;

case 2 : printf("Akku Test ");

break;

default: printf("ERROR ");

break;

}

}

 

 

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

/*

/* void akku_menu(void)

/*

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

void akku_menu(void)

{

clrscr();

printf("Akkulader \n");

printf("Lademodi waehlen");

wait(60000);

wait(60000);

/* Programm auswaelen mit < ok > Taste */

akku_prog = 0;

do

{

wait(2000); /* Tastenentprellung */

clrscr();

printf("Auswahl < ok >\n");

auswahl(akku_prog);

if (!Button_3)

{

if (akku_prog==0) akku_prog = 2;

else akku_prog = akku_prog - 1;

}

 

if (!Button_1)

{

if (akku_prog==2) akku_prog = 0;

else akku_prog = akku_prog + 1;

}

}

while (Button_2);

wait(500);

while (!Button_2);

wait(2000);

/* Akkukapazitaet einstellen */

des_capacity = 600;

do

{

wait(500); /* Tastenentprellung */

clrscr();

printf("Kapazitaet\n");

printf("I = %d[mAh]", des_capacity);

if (!Button_3)

{ /* Dekrementiere um 10, Untergrenze ist 10 */

if (des_capacity <= 10) des_capacity = 10;

else des_capacity = des_capacity - 10;

}

if (!Button_1)

{ /* Inkrementiere um 10, Obergrenze ist 1000 */

if (des_capacity >= 1000) des_capacity = 1000;

else des_capacity = des_capacity + 10;

}

}

while (Button_2); /* Tastenentprelölung */

wait(500);

while (!Button_2);

/* Akkustrom einstellen */

current = 50; /* default current */

do

{

wait(2000); /* Tastenentprellung */

/* Display loeschen */

clrscr();

printf("Stromwahl\n");

printf("I = %d[mA]", current);

if (!Button_3)

{ /* Dekrementiere um 10, Untergrenze ist 10 */

if (current <= 10) current =10;

else current = current - 10;

}

 

if (!Button_1)

{ /* Inkrementiere um 10, Obergrenze ist 1000 */

if (current >= 1000) current = 1000;

else current = current + 10;

}

}

while (Button_2);

wait(500);

while (!Button_2);

} // end of menu

 

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

/*

/* void prog_control(void) Ladeprogrammüberwachung

/*

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

void prog_control(void)

{

if (akku_prog == LADEN) /* Akku laden */

{ /* Ladeprogramm aufrufen */

load_akku();

/* nach Abschluss laden */

clrscr();

printf("Akku geladen \n");

printf("Reset: Neustart");

while(1);

}

else if (akku_prog == ENTLADEN) /* Akku entladen */

{ discharge_akku();

/* nach Abschluss entladen */

do

{

DISCHARGE = 0; /* Portpin Entladen zurücksetzen */

home();

clrscr();

printf("Akku entladen\n");

printf("Reset: Neustart");

wait(60000);

clrscr();

printf("Akku Kapazitaet\n");

printf("C = %d[mAh]", upper_capacity);

wait(60000);

} while(1);

}

else if (akku_prog == TESTEN) /* Akku laden/entladen */

{

/* Testen: erst LADEN, dann ENTLADEN */

akku_prog = LADEN;

load_akku();

akku_prog = TESTEN;

discharge_akku();

/* nacch Abschluss */

do

{

CHARGE = 0; /* Portpin Laden zurücksetzen */

clrscr();

printf("Akku getestet\n");

printf("Reset: Neustart");

wait(60000);

clrscr();

printf("Akku Kapazitaet\n");

printf("C = %d[mAh]", upper_capacity);

wait(60000);

} while(1);

}

}

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

/*

/* void init_timer2(void) Initialisierung Timer 2 (Grundtakt =0.036s)

/*

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

void init_timer2(void)

{

CRCH=0x73; /* entspricht Takt von 0.0036s */

CRCL=0x5F;

T2R1=1; /* Automatisches Wiederladen */

T2I0=0; /* Zeitgeberbetrieb */

T2PS=0; /* Frequenz = 1/12 */

}

 

 

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

/*

/* void wait_t2(int portpin) PWM-Signal mit Periodenzeit 3,6s

/*

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

void wait_t2(int portpin)

{

for (z=0; z<100; z++)

{ /* LED's zuruecksetzen */

LED2=1;

LED3=1;

/* Lade und Entladepin zuruecksetzen */

CHARGE =0;

DISCHARGE =0;

/* High-Puls ab berechneter High-Puls-Time setzen */

if (z >= high_puls_time)

{ /* im Lademodus PIN_LADEN auf High setzen */

if (portpin == PIN_LADEN)

{

LED2=0;

CHARGE =1;

}

else if (portpin == PIN_ENTLADEN)

{ /* im Entlademodus Pin_ENTLADEN auf High setzen */

LED3=0;

DISCHARGE =1;

}

}

T2I0 = 1; /* Zaeler starten */

while(!TF2); /* Warten bis Timerueberlauf (0.036s) */

CHARGE = 0; /* Portpins zuruecksetzen */

DISCHARGE = 0;

TF2 = 0; /* Ueberlauf zuruecksetzen */

}

T2I0 = 0; /* Timer 2 stoppen */

}

 

 

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

/*

/* void load_akku(void) Ladeprogramm

/*

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

void load_akku(void)

{

clrscr();

printf("Akku anklemmen \n");

printf("und OK druecken ");

while(Button_2);

wait(1000);

while(!Button_2);

check_voltage();

while (akku_status == OK)

{ /* solange Akku nicht voll */

clrscr();

printf("Akku laden...\n");

check_voltage();

wait_t2(PIN_LADEN); /* Portpin Laden */

}

}

 

 

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

/*

/* void discharge_akku(void) Entladeprogramm

/*

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

void discharge_akku(void)

{

lower_capacity = 0;

upper_capacity = 0;

if (akku_prog == ENTLADEN) /* Testen */

{

clrscr();

printf("Akku anklemmen \n");

printf("und OK druecken ");

while(Button_2);

wait(1000);

while(!Button_2);

}

check_voltage();

while (akku_status == OK) /* solange Akku nicht voll */

{

/* Kapazitaet anzeigen */

/* nur ganze mAh ausgeben */

clrscr();

printf("C = %d[mAh]\n", upper_capacity);

akku_status = check_voltage();

wait_t2(PIN_ENTLADEN); /* Portpin ENTLADEN */

/* Kapazitaet berechnen */

lower_capacity = lower_capacity + current;

if (lower_capacity >= 1000)

{

upper_capacity++;

lower_capacity = lower_capacity - 1000;

}

}

}

 

 

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

/*

/* void calc_val(void) Puls-/Pausenverhältnis berechnen

/*

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

void calc_val(void)

{

/* ab hig_puls_time startet Lade/Entladevorgang */

high_puls_time = 100 - current / 10;

}

 

 
Februar 2000 - Bernd Lauer, Jörg Reufels
Betreuender Dozent: Prof. Dipl-Ing. J. Walter