Hallo im Forum !

Heute möchte ich euch mein kleines Bastelprojekt mit dem Mikrokontroller vorstellen. Nachdem
nun schon viele interessante Projekte hier im Forum vorgestellt wurden, folgt nun meine Bastelei: Ein Messwagen für Märklin HO.


Zum Hintergrund: Märklin hatte in der Vergangenheit einen Messwagen 49960 herausgegeben, dieser diente mir bei meinem Projekt als Vorbild. Natürlich hätte man auch einen einfachen Fahrradtacho nehmen können, doch ich wollte eine Art Komplettlösung, so wie es sie von Märklin gab.

In meinem Messwagen kommt ein Atmel Mega16A zum Einsatz. Programmiert wurde in C, AVR Studio5. Als Basis dient ein n-Wagen Märklin 4259. Der Sourcecode für den Mikrokontroller befindet sich am Ende des Posts.

Hier die ausführliche Dokumentation des Messwagens:
[attachment=0]Messwagen_Dokumentation.pdf[/attachment]

Fangen wir an: Welche Funktionen soll der Messwagen haben, und wie steuere ich diesen an?
Folgende Funktionen sind implementiert:
- aktuelle Geschwindigkeit
- maximale Geschwindigkeit
- gefahrene Strecke
- Fahrzeit
- Umgebungstemperatur
- Reset
- aus

Umgebungstemperatur? Ja, richtig gelesen, ich habe ebenfalls eine Temperaturmessung vorgesehen.

Dazu später mehr. Um zwischen diese einzelnen Funktionen schalten zu können, wird ein handelüblicher Funktionsdekoder verwendet, deren Ausgänge über einen Optokoppler mit dem Mikrokontroller verbunden sind. Um die anderen Messdaten zu erfassen, wird ein Radsensor in Form von einem Hallsensor eingesetzt.

Hier der gesamte Schaltplan:


Damit die gesamte Schaltung in den Wagenkasten passt, habe ich die Schaltung in verschiedene Teilschaltungen zerteilt.
Fangen wir mit der Spannungsversorgung an.

Ein Brückengleichrichter richtet die Digitalspannnung gleich, ein Pufferkondensator glättet die
Spannung. Der Linearspannungsregler stellt die nötigen 5V Versorgungsspannung der gesammten Schaltung zur Verfügung. Die LED dient als Kontrolle, das Spannnung anliegt.
Im Langzeittest wird der Linearregler relativ warm, einen Kühlkörper kann aufgrund der engen
Platzverhätnissen nicht eingebaut werden. Eine mögliche Alternative wäre ein DC/DC Wandler;
dieser hat dann einen deutlich besseren Wirkungsgrad (rund 70 bis 80%). Ein Schleifer und ein Messingbech aus der früheren Innenbeleuchtung (Märklin #7330) stellt den Kontakt zur Schiene her.

Dann folgt die Anzeige:

Bitte nicht erschrecken

Die 7 Segmentanzeigen werden vom Mikrokontroller durch Multiplexen angesteuert.

Zum Schluss noch der eigentliche Mikrokontroller mit dem Optokoppler, einem Zählbaustein 4024 und dem Thermistor für die Temperaturmessung (Mikrokontroller und 4024 jetzt nicht eingesteckt).



Der Optokoppler sorgt dafür, dass der Funktionsdekoder galvanisch von dem Rest der Schaltung entkopplet ist.
WICHTIG: Die Ausgänge des Funktionsdekoders müssen erst gedimmt werden, da sonst durch die hohe Spannung des Dekoderts der Optokoppler zerstört wird. Alternativ kann auch ein passender Widerstand zwischen Decoder fx und Optokopplereingang eingebaut werden.
Wie werden denn nun Geschwindigkeit und Strecke gemessen?
Der Hallsensor erfasst die Achsumdrehungen mittels eines kleinen Neodym-Bohr-Magneten. Der Zähler 4024 erfasst diese Impulse und der Mikrokontroller ließt den Zählerstand aus. Dieses passiert in einem Zeitfenster von 1 Sekunde. Anschließend kann mit der Anzahl der Impulsen und des Raddurchmessers die Strecke und die Geschwindigkeit ermittelt werden.
ich habe einen bipolaren Hallsensor verwendet. Daher müssen tatsächlich zwei Magnete an der Achse befestigt werden.

Die Temperatur wird über einem Widerstandsteiler ermittelt und mittels ADC-Port des Mikrokontrollers eingelesen.

Nachdem nun alles Aufgebaut ist, folgt die Preparierung des Wagen. Dafür muss der Wagenboden isoliert werden und ein Schleifer sowie eine Masseplatte in die Drehgestelle installiert werden (Teile stammen wie oben schon erwähnt von der ehemals eingebauten Innenbeleuchtung).


Platzieren der Platinen:



Hier der Sourcecode:

-Hauptfunktion

// Messwagen für Maerklin
 
/*
PIN Belegung
 
PortC0 - 3: Kathode 7LED
PortC5: Reset 4024
PortD: Anode 7LED
PortA1 - 3: fx Decoder
PortA0: ADC
PortB0 -5: Einlesen 4024
*/
 
#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "routines.h"
 
ISR(TIMER0_OVF_vect)
{
	task_segments();
}
 
ISR(TIMER1_COMPA_vect)
{
	gettime();
	uint32_t impulse=getimpulse();	
	PORTC |= (1<<PC5); //RESET4024
	getpath(impulse);
	getspeed(impulse);
	PORTC &= ~(1<<PC5);
}
 

int main(void)
{
	init();
	_delay_ms(1000); //start-up tine
	sei();
		while(1) 
		{
			getswitch();
		}
}
 
 

-benutzte Funktionen:

#define raddurchmesser 10.3
 
 
//Initialisierung ADC/Timer/Reset4024
void init( void );
 
//Initialisierung Timer0
void timer_enable0(void);
 
//Initialisierung Timer1
void timer_enable1(void);
 
//Initialisierung ADC
void adc_init(void);
 
//Einlesen der Switches von Multidecoder
void getswitch(void);
 
//Berechnung Temperatur
int64_t gettemperature(void);
 
//Ausgabe Temperatur
void set_segments(int64_t val);
 
//Ausgabe Impulse
uint32_t getimpulse(void);
 
//Multiplexen der Anzeige
void task_segments(void);
 
//Berechnung Fahrstrecke
void getpath(uint32_t val);
 
//Berechnung Gesschwindigkeit
void getspeed(uint32_t val);
 
//Berechnung Zeit
void gettime(void);
 
 

-Implementierung der Funktionen

#include <avr/io.h>
#include <util/delay.h>
#include "routines.h"
 
uint8_t pos = 0;
uint16_t zeit=0;
uint64_t strecke=0;
uint16_t geschwindigkeit=0;
uint16_t maxgeschwindigkeit=0;
int64_t temperatur =0;
uint8_t i =0;
uint16_t summe =0;
 
//Speicherarry für "Bilder" der 7-Segment Anzeigen 
uint8_t display[]= { 0, 0, 0, 0, 0b00000000};
	
//Speicherarray für grafische Umsetzung der Zahlen
const uint8_t segments[] = { 0b01110111, 0b00010100, 0b10110011, 0b10110110,0b11010100, 0b11100110, 0b11100111, 0b00110100, 0b11110111, 0b11110110, 0b01111111, 0b00011100, 0b10111011, 0b10111110,0b11011100, 0b11101110, 0b11101111, 0b00111100, 0b11111111, 0b11111110 };
 

void init(void)
{
DDRA=0x00;
DDRB=0b00000000;
DDRC=0xFF;
DDRD=0xFF;
 
PORTC |= (1<<PC5);
_delay_ms(100);
PORTC &= ~(1<<PC5);
 
timer_enable0();
timer_enable1();
adc_init();
}
 
void timer_enable0(void)
{	
TCCR0=2; //activate Timer0 with CPU-clock / 8
TCNT0=0; //reset Timer0 
TIMSK|=(1<<TOIE0); // Timer Overflow Interrupt enable
}
 

void timer_enable1(void)
{	
TCCR1B |= (1 << WGM12); // Configure timer 1 for CTC mode
TIMSK |= (1 << OCIE1A); // Enable CTC interrupt
OCR1A   = 15624; // Set CTC compare value to 1Hz at 4MHz AVR clock
TCCR1B |=  (1 << CS12); // Start timer at Fcpu/256 
}
 
void adc_init(void)
{
ADCSRA |= (1<<ADEN) | (1<<ADATE) | (1<<ADPS2) | (0<<ADPS1) | (1<<ADPS0) | (1<<ADSC);
ADMUX|= (1<<REFS0) | (0<<REFS1)| (0<<ADLAR) ; // AVcc Volt als Referenz 
SFIOR|= (0<< ADTS2)| (0<<ADTS1)| (0<<ADTS0); // free running
ADMUX|= (0<<MUX0) | (0<<MUX1) | (0<<MUX2) | (0<<MUX3)| (0<<MUX4) ; // choose Port PA0 for ADC
}
 

void getswitch(void)  // get switches from Multidecoder
{
uint8_t fxdecoder=PINA;
fxdecoder = fxdecoder & 0b00001110;
 
if (fxdecoder==14) // off 
{
	display[0]=0x00;
	display[1]=0x00;
	display[2]=0x00;
	display[3]=0x00;
}
 
else if (fxdecoder==12) // Geschwindigkeit f1
{
	uint16_t temp = geschwindigkeit*3.132;
	
	uint8_t tausend = temp/1000;
	uint8_t hundert = (temp%1000)/100;
	uint8_t zehner = (temp%100)/10;
	uint8_t einer = (temp%10);
	
	display[0]=segments[einer];
	display[1]=segments[zehner+10];
	display[2]=segments[hundert];
	display[3]=segments[tausend];
}
 
else if (fxdecoder==10) // Strecke f2
{
	uint16_t streckeraw = strecke*0.01; 
	uint8_t hundert = streckeraw/1000;
	uint8_t zehner = (streckeraw%1000)/100;
	uint8_t einer = (streckeraw%100)/10;
	uint8_t komma = (streckeraw%10);
	
	display[0]=segments[komma];
	display[1]=segments[einer+10];
	display[2]=segments[zehner];
	display[3]=segments[hundert];	
}
 
else if (fxdecoder==6) // Fahrzeit f3
{
	uint16_t minutenraw=zeit/60; 
	uint8_t stunden1 = (minutenraw/60);
	uint8_t minuten2 = (minutenraw%60)/10;
	uint8_t minuten1 = (minutenraw%10);
	
	display[0]=segments[minuten1];
	display[1]=segments[minuten2];
	display[2]=segments[stunden1+10];
	display[3]=0b00000000;
}
 

else if (fxdecoder==8) //Vmax f1 + f2
{
	uint16_t temp = maxgeschwindigkeit*3.132;
	
	uint8_t tausend = temp/1000;
	uint8_t hundert = (temp%1000)/100;
	uint8_t zehner = (temp%100)/10;
	uint8_t einer = (temp%10);
	
	display[0]=segments[einer];
	display[1]=segments[zehner+10];
	display[2]=segments[hundert];
	display[3]=segments[tausend];
}
 

else if (fxdecoder==4) //Temperatur  f1 + f3
{
	set_segments(gettemperature());
}
 
else if (fxdecoder==0) // RESET  f1 + f2 + f3
{
	zeit=0;
	strecke=0;
	geschwindigkeit=0;
	maxgeschwindigkeit=0;
 
	display[0]=0b10000000;
	display[1]=0b10000000;
	display[2]=0b10000000;
	display[3]=0b10000000;
}
 
else
{
	// display error
	display[0]=0b00000000;
	display[1]=0b10000001;
	display[2]=0b10000001;
	display[3]=0b11100011;
}
	
}
 

int64_t gettemperature(void)
{
	int64_t temp_raw =0;
	float  hilf =0;
	int16_t i;
	int64_t temp1=0;
	int64_t temp2=0;
	int64_t temp3=0;
 
		for(i = 0; i<1000 ; i++)
		{
			temp_raw +=ADC;
			_delay_ms(5);
		} 
	temp_raw=temp_raw*0.01;
	hilf = (0.0002*5000*temp_raw*4.8828125)/(50000-(temp_raw*4.8828125));//0.2=1000/5000 
 
	temp1=hilf*hilf*hilf*2854;
	temp2=hilf*hilf*15850;
	temp3=hilf*47480;
 
	temperatur=temp1-temp2+temp3-31985; // Kennlinie des PTC
	temperatur-=130;//Kalibrierung um 1.3 Grad
	return temperatur; 
}
 

void task_segments(void) 
{
	switch(pos)
	{ 
		case 0: PORTD=display[4]; PORTC &= ~(1<<PC3);_delay_ms(1); PORTC |= (1<<PC0); PORTD=display[pos]; pos++; break;
		case 1: PORTD=display[4]; PORTC &= ~(1<<PC0); _delay_ms(1);PORTC |= (1<<PC1); PORTD=display[pos]; pos++; break;
		case 2: PORTD=display[4]; PORTC &= ~(1<<PC1); _delay_ms(1);PORTC |= (1<<PC2); PORTD=display[pos]; pos++; break;
		case 3: PORTD=display[4]; PORTC &= ~(1<<PC2); _delay_ms(1);PORTC |= (1<<PC3); PORTD=display[pos]; pos=0; break;
	}
}
 

 uint32_t getimpulse(void)
{
	uint32_t zaehler=PINB;
	zaehler= zaehler & 0b00011111;
	return zaehler;
}
 
void set_segments(int64_t val)
{
	
if(val<(-9999)) // return Error E1  
{
	display[0]=0b00000000;
	display[1]=0b00000000;
	display[3]=0b11100011;
	display[2]=0b00010100;
	return;
}
 

if(val>9999) // return Error E2
{
	display[0]=0b00000000;
	display[1]=0b00000000;
	display[3]=0b11100011;
	display[2]=0b10110011;	
	return;
}
 
// Ausgabe Temperatur
 
if(val>=0)
{
	uint8_t tausend = (val%10000)*0.001; 
	uint8_t hundert = (val%1000)*0.01;
	uint8_t zehner = (val%100)*0.1;
 
	if(tausend==0)
	{
		display[2]=0b00000000;	
	}
 
	else
	{
		display[2]=segments[tausend];
	}
 
	display[1]=segments[hundert+10];
	display[0]=segments[zehner];
	display[3]=0b00000000;
}
 
	if(val<0)
	{
	val=-val;
	uint8_t hundert = (val%1000)*0.01;
	uint8_t zehner = (val%100)*0.1;
	display[2]=0b10000000; // minus
	display[1]=segments[hundert+10];
	display[0]=segments[zehner];
	display[3]=0b00000000; 
	}
}
 
void getpath(uint32_t val)
{
	strecke= strecke+(val*raddurchmesser*3.14);
}
 
void getspeed(uint32_t val)
{
	uint16_t wert = val*raddurchmesser*3.14; // mm pro sec
	summe+=wert;
	i++;
	if (i==5)
	{
		geschwindigkeit=summe*0.2;
		i=0;
		summe=0;
	}	
		
	 if (geschwindigkeit>maxgeschwindigkeit)
	 {
		 maxgeschwindigkeit=geschwindigkeit;
	 }		 
}
 
void gettime(void)
{
	zeit++;
}	
 
 

Gruß
Oliver

Ein toller Beitrag, schön, sowas hier zu finden!

Gruß,
Moritz

Hallo Oliver,
bitzsaubere Lösung und ihre Beschreibung - gratuliere zu der Arbeit (und Ausführung)

Hallo Oliver,

ich verstehe zwar nichts (Programmierung), aber es sieht toll aus, was Du geschaffen hast...
Ein weiterer Höhepunkt Deines Beitrages wäre ein Video des Wagens in Aktion....


Viele Grüße von Harald

Guten Abend,

Danke für die Komplimente. Ganz fertig ist der Wagen allerdings noch nicht, es fehlt noch der Einbau des Funktionsdekoders. Bisher habe ich die Funktionen durch Drahtbrücken ausgelöst.
Ebenfalls soll noch eine schwarze Pappe im Bereich der 7 Segmentanzeigen die Lücken füllen, denn die beiden Fenster links und rechts der 4 Anzeigefenster sind noch komplett leer.

Falls gewünscht, kann ich noch eine Auflistung mit den Bauteilen (Widerstände, Dioden,...) in das Forum einstellen.

@ Harald:
Eine gute Idee mit dem Video, das werde ich in den nächsten Tagen noch machen

Gruß
Oliver

Hi Oliver,

klasse Idee, klasse Umsetzung, klasse Bericht!!!



Nochmal Klasse, wenn Du soetwas wie eine "Bauanleitung", mit Stückliste nachreichst



Viele Grüße, Michael

Hallo klasse Bericht

Danke

Gruß Ralf

Hallo Oliver,

fesche Sache!
Ich hatte eine ähnliche Idee, hätte mir allerdings einen Wagen zu einem "richtigen" Messwagen wie sie auch die Bahn hat, umgebaut, allerdings nicht mit einer Anzeige sondern mit einer Kamera (habe ein Kamera-Modul aus einem alten Siemens-Handy, welches sich recht gut per µC ansteuern und auswerten lassen soll), sowie einem Gyrosensor um ein ausgiebiges Streckenprofil aufzeichnen zu können (mit Steigungen, maximalen Querbeschleunigungen, Unregelmäßigkeiten bei der Gleisverlegung usw. ). Basis wäre wohl ein Arduino, es gibt ja sogar solch kleine Chips dass sie in einen H0-Wagen passen würden. Je nach Hardware-Aufwand würde es sich dann aber fast schon lohnen, sich Platinen fertigen zu lassen (ein Kommilitone fräst Platinen auf einer selbstgebauten Portalfräse).

Ist aber bislang nur ein Hirngespinst, seitens des Lastenhefts aber schon ein recht ausgefeiltes!

Hallo Oliver,
klasse Projekt. Vor allem freut mich, dass hier einer mal was vorstellt, dass direkt in AVR-Studio programmiert ist. Ich programmiere meine Controller auch direkt, verwende aber noch Studio 4.
Was benutzt Du zum programmieren des AtMega? ( ich habe mir einen AVR-Dragon zugelegt )

Da ich noch analog fahre, kann ich deine Anleitung zwar nicht direkt verwenden, finde es aber trotzdem sehr interessant.

Noch ein Tip: Damit der Drahtverhau unter der Platine nicht so voluminös wird verwende ich zum Verdrahten auf der Platine Kupferlackdraht (Fädeldraht). Z.B. so wie hier: http://www.abload.de/image.php?img=servo...-untenx8old.jpg

Hallo Oliver,

toller Messwagen!
Sauber aufgebaut und dokumentiert, wie es sein soll.
Von dem Code in C verstehe ich allerdings nicht viel, die Sprache habe ich nie lernen dürfen flaster:

Wird man den Wagen mal in Aktion erleben können?

Grüße,
Moritz

Hallo zusammen,

wie gewünscht, habe ich eine Auflistung der eingesetzten Bauteile erstellt (siehe Bauteile.xls).

@Franz-Peter: Gute Idee mit dem Lackdracht, das würde die Sache doch deutlich übersichtlicher gestalten. Ich habe meinen Programmer aus der Bucht erstanden: http://www.ebay.de/itm/AVR-USB-ISP-Progr...=item5642ecc35f. Dieser ist sehr kostengünstig und arbeitet sehr zuverlässig unter AVR Studio5.
Theroretisch kann man den Messwagen auch analog einsetzen; man müsste nur den Optokoppler samt Funktionsdekoder durch SMD-DIPschalter ersetzen und diese auf der Wagenkastenunterseite installieren und schon kann dieser Wagen auch auf analogen/delta Modellbahnen fahren.

@Moritz: Natürlich werde ich den Messwagen zum Stammtisch nächste Woche mitbringen. Wäre toll, wenn bis dahin auch die Lichtschranke von Sebastian funktioniert, dann kann man gut vergleichen, ob die Messergebnisse auch alle so stimmig sind

@Niklas: Also eine genaue Auswertung des Streckenprofils. Damit ließe sich ja zum Beispiel gut erfassen, ob die Kurvenüberhöhung in Bögenvorbildgerecht ist. Wie groß ist denn so ein Gyrosensor? Ich habe damit noch nie gearbeitet, wäre aber eine wirklich interessante Idee! Natürlich ist eine Platinenlösung immer die saubere und professionellere Lösung. Sollte der Wagen die nächsten Tests (Wärmeentwicklung Linearregler, Pufferung der Schaltung bei schlechter Masserückführung, insbesondere bei schmutzigen Gleisen oder Weichen,...) gut bestehen, dann werde ich vielleicht mal ein paar Platinen fertigen lassen.

Gruß
Oliver

Hallo Oliver,

um die Größe zu demonstrieren, bemühe ich mal wieder ein Foto eines Arduino-Projekts aus der Uni:



Gelb eingekreist ist der Gyrosensor auf einem sog. Breakout-Board, welches den Anschluss des Chips mit manuellen Mitteln ermöglicht (Lötpunkte für Buchsenleiste). Als Größenreferenz diene die Platine unterhalb, welche die Größe des Arduinos hat. Der Chip selber passt auf jeden Fall in einen H0-Waggon (hat denke ich ugf. die Größe eines N-Dekoders).

Hallo Oliver,
ja, so ähnliche Geräte hatte ich mir damals auch angeschaut. Das ist natürlich schon ein ordentliches Stück günstiger als der AVR-Dragon. Was mich an den Geräten nur stört ist, dass man damit nicht debuggen kann.

Hallo Oliver!

Ein schönes Stück was du da konstruiert hast!
Jetzt hast du mich angesteckt, und ich würde mir auch gern so einen Wagen bauen.

Wärs vielleicht möglich einen fertigprogrammierten Atmel-Chip von dir zu erstehen? Von sowas habe ich nämlich nur sehr wenig Ahnung, da wäre eine vorgefertigte Lösung optimal.

Was hat denn die gesamte Elektronik zusammen ungefähr gekostet?

Hallo Georg,

die Stückliste habe ich im Thread als Download hochgeladen. Die Bauteilkosten lagen bei ca. 30 Euro inklusive Mikrokontroller. Hast du denn schon einmal in C programmiert? Natürlich kann ich dir auch einen Atmel programmieren und dir diesen zuschicken. Allerdings befindet sich der Messwagen noch in der Testphase; bei dem nächsten Stammtisch wird der Wagen ausgiebig getestet. Bis dahin kann sich das Programm noch geringfügig ändern.

Es lohnt sich auf jeden Fall, sich näher mit einem Mikrokontroller zu befassen. Alles was du bruchst, ist ein Mikrokontroller, die Programmierumgebung und einen Programmieradapter. Die Programmierumgebung (AVR Studio) gibt es sogar kostenlos von Atmel. Im Internet gibt es viele Tutorials zum Thema Einstieg mit Mikrokontroller, empfehlenswert ist Folgendes: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial.

Hier eine weitere Bastelei mit Mikrokontroller aus dem Forum:
http://archiv.stummiforum.de/viewtopic.p...=92344&start=75.

Gruß
Oliver

Supertoll.

Will auch schon lange einen haben, aber die Dinger gehen auf ebay weg für 80 Euro gut bespielt.

Also die 30€ inkl. Atmel finde ich echt preiswert. Soweit ich das mit meinem Bastelkollegen durchbesprochen habe, würde ich die Schaltung wahrscheinlich in SMD Bauform aufbauen. Vielleicht wird auch eine Platine selbstgeätzt, mal sehen.

Vom Programmieren von Microprozessoren habe ich leider echt null Plan. Und mein Freund kennt sich nur ein wenig mit PIC-Programmierung aus. Die Atmels spielen da schon in einer anderen Liga.
Werd mal schauen ob ich Zeit habe mich da einzulesen.

Und Eile hat das ganze Projekt ohnehin nicht, vorher brauche ich auch mal einen oder zwei günstige Spenderwagen.
Bei mir soll im Endeffekt so einer entstehen: http://www.railfaneurope.net/pix/at/work...90_000-3_G2.jpg
Die Fensteranordnung auf der Wagenseite macht mir derzeit noch planerische Probleme.

Hallo zusammen,

bisher fehlt immernoch der Funktionsdekoder, um die anderen Funktionen, wie zum Beispiel Fahrzeit und Strecke anzeigen zu können.
Deshalb habe ich als Übergangslösung vorerst einen 4poligen DIP-Schalter eingebaut:



Nun kann ich laut Tabelle folgende Funtionen schalten:

Geschwindigkeit: 1 ON
max. Geschwindigkeit: 1 und 2 ON
Strecke: 2 ON
Fahrzeit: 3 ON
Temperatur: 1 und 3 ON
Reset: alle ON
aus: alle OFF

Die Messergebnisse sind hinreichend genau; dies wurde auf dem letzten Stammtisch Heinsberg/Düren ausführlich geprüft.

Somit sollte der Code für den Atmel so gut wie fertig sein.

@ Georg: Falls Interese besteht, dann schicke ich dir in den nächsten Tagen mal eine PN.

Gruß
Oliver

Ja mach das bitte, Oliver!

Hallo zusammen,

nochmals ein kleines Update von mir:

Auf Nachfragen von mehreren Stummis habe ich hier noch die Pinbelegung des Ports D zu den Pins der 7 Segmentanzeigen:

PD0 - E
PD1 - D
PD2 - C
PD3 - DP
PD4 - B
PD5 - A
PD6 - F
PD7 - G

Außerdem habe ich den Schaltplan im ersten Post aktualisiert, dieser stammte noch aus der Planungsphase.

Ich würd mich freuen, wenn der eine oder andere Stummi seine Version des Messwagens hier präsentiert, ich bin neugierig

Gruß
Oliver

Also mein Messwagen wird wohl doch auf einem PIC-Prozessor basieren und ausser Geschwindigkeit messen nichts können. Dafür komme ich mit dem PIC-Programmieren besser zurecht.
Bis der allerdings herzeigbar ist, wirds sicher noch ein Weilchen dauern. Der Bauteilhaufen liegt schon bereit, aber der Wagen braucht noch einiges an Umbauten, die Platinen wollen noch geätzt werden (ein Layout dafür gibts auch noch nicht), und die Firmware für den Prozessor muss ich noch anpassen an meine Bedürfnisse.
Ich rechne mit Fertigstellung in frühestens einem Jahr. Immerhin soll mein Messwagen auch komplett neu lackiert werden, und Airbrusherfahrung habe ich auch noch genau Null... Ein ehrgeiziges Projekt. ^^*

Sobalds was gibt, werde ich mich aber sicher wieder melden.

Hallo Georg,

da drück ich dir die Daumen. Ich bin gespannt auf das Ergebnis gespannt

Gruß
Oliver

Moin,

Ich habe die Messung der Temperatur noch nicht ganz verstanden, ist einer der Widerstände ein NTC?


Gruß Lars

Hallo Lars,

der Sensor ist ein PTC. Der andere Widerstand ist ein normaler Widerstand; zusammen bilden sie einen Spannungsteiler. Je nachdem, welche Umgebungstemperatur vorliegt, ändert sich der eine Widerstand des PTC Elements. Das hat zur Folge, dass sich das Potential zwischen den beiden Widerständen ändert. Diese Spannungsänderung wird vom µC über einen ADC (Analog Digital Wandler) registriert und dann gemäß der Spanungs/Temperaturkennlinie des PTCs in die passende Temperatur umgerechnet.

Gruß
Oliver

EDIT: Die Exceltabelle mit den Bauteilen wurde aktualisiert, nun lassen sich alle Bauteile zur Schaltung zuordnen

Cool danke für die Schnelleantwort, NTC und PTC unterscheiden sich ja nicht so stark

Edit: man hätte ja auch einfach im Quellcode lesen können ... ops: