Physikalische Vorgänge in C

Beginner

Saturday, February 4th 2012, 11:36pm

Hallo liebe Programmier/C-Profis.
ich schätze mal, dass ich mit meiner Frage wohl eher die Profis unter euch ansprechen werde.
Es geht um folgendes. ich möchte einen Druck- und einen Beschleunigungssensor simulieren und das ganze per microController realisieren.
der Ablauf soll zeitlich plausibel also immer vorhersehbar bzw beeinflussbar sein.
Der Drucksensor liefert zur zeit x einen gewissen promillewert also den Differentiellen Druckanstieg gemessen zum Vorwert (Normdruck).
Während der Druckanstieg zur zeit x genau oder mehr als 100 Promille beträgt, soll der beschleunigungswert ausgegeben werden. Die zeitliche differenz darf 30milliSekunden nicht überschreiten da das Signal vom auswertenden Steuergerät als unplausible aberkannt wird.
Ziel ist die Grundlage in C zu schaffen um, jetzt kommts, einen Crash zu simulieren un damit dem steuergerät FeuerFrei zu ermöglichen.

Ich hoffe ich hab den Grundgedanken etwas vermitteln können und auf rege Beteiligung.

bcc-fan

Professional

Posts: 384

2

Sunday, February 5th 2012, 9:42am

Oh ha, C ist nur ein ganz kleiner Teil deines Projektes.

Wie klein sollen/dürfen die Zeitintervalle sein? Dürfen die weitgehend unabhängig von deinem C-Programm bezüglich der Zeitintervalle vom Betriebssystem beeinflusst werden?

Soll das Programm nur simuliert werden oder real auf einem Micro-Controller laufen?
Wenn das real laufen soll, würde ich mich mit den hartwarespezifischen Möglichkeiten des Controllers auseinandersetzen.
Was hat das Teil schon alles an Bord: Timer, AD-Wandler oder andere Messwertaufnehmer? Gibt es vom Controller-Anbieter schon Treiber?

Es kann sein das sich hier Programmierer tummeln, die von so etwas einen Plan haben. Aber in einem speziellen Micro-Controllerforum, sollten die da täglich mit befasst sein.

Meist werden für Micro-Controller für den jeweiligen Controller optimierte Compiler, für das was du vorhast, genutzt. Z.B. speziell für deinen Controler optimiert Varianten des GCC. Falls du dich da tummelst, die Software-Anforderungen des Controllers genau beachten.

Wenn es dann an den C-Quelltext geht, kannst du hier mit Beispielen fragen. Erstens sehen wir dann besser ob wir dir helfen können. Und zweitens hast du uns immer noch nicht dein Controller-Modell verraten?

Viel Spass damit
bcc-fan

Rushh0ur

Professional

Posts: 228

3

Sunday, February 5th 2012, 3:19pm

Im Prinzip sollte dein vorhaben gar nicht so schwer sein, vorraussetzung ist halt das du die Datenblätter der Sensoren hast um das ganze dem Test- bzw. Zielsystem verständlich zu übermitteln.

Hast du schon irgentwelche Ansätze? Welcher µC soll verwendet werden?
Wenn nicht würde ich als µC die ATmegas von der Firma Atmel empfehlen, sehr Einsteigerfreundlich und sollte für dein Vorhaben ausreichen.

Mfg Rushh0ur

Quizzer11

Beginner

Posts: 4

4

Sunday, February 5th 2012, 4:40pm

Hallo Danke für die ersten Antworten.

Also der Controller könnte ein ATMega 328 sein. was dafür am besten taugt bin ich für ratschläge gerne bereit.
die Datenblätter/Lastenhefte zu den Sensoren liegen vor.

Im prinzip läuft das so ab, das der Drucksensor eine Initialisierungsphase durchläuft und aller 228µs seinen Statuswert mitteilt. die Wordlänge beträgt dabei 104µs und umfasst 13Bits. Also Paritybit, Datenword und zwei startbits.

die initialisierungskette muss ich am testfahrzeug noch aufnehmen. Die werte vom beschleunigungssensor werden fasst auf die selbe weise generiert.

Also meine hardware umfasst momentan ein Atmel evaluationsboard, aber ich würde mich auch von anderer Hardware überzeugen lassen.

meine C-kenntnisse sind auf Basis eines Einsteigers. Ich habe jedoch schon erfahrung auf Ti´s T320F28335 DSP gesammelt. Also sind Registerprogrammierungen nix neues. Mir fehlt bloss grade der zündende Gedanke.

Rushh0ur

Professional

Posts: 228

5

Sunday, February 5th 2012, 7:34pm

Der 328 wird für die Sache locker ausreichen.

Quoted from "Quizzer11"

Im prinzip läuft das so ab, das der Drucksensor eine Initialisierungsphase durchläuft und aller 228µs seinen Statuswert mitteilt. die Wordlänge beträgt dabei 104µs und umfasst 13Bits. Also Paritybit, Datenword und zwei startbits.

Hört sich nach einer Serielen übertragung an. Der ATmega unterstützt Hardwäremässig UART.
Musst halt mal Prüfen ob das für dich passt, ansonsten muss man das Signal "manuel" nach konstruieren.

Für die Intervalle würde ich nen Timer verwenden und die Benutzerdaten dann Periodisch raushauen.

Ich nehme mal an einen Compiler (WinAVR) und ne passende [lexicon]IDE[/lexicon] hast du schon.

Mfg Rushh0ur

Quizzer11

Beginner

Posts: 4

6

Monday, February 6th 2012, 2:12pm

@Rushh0ur

Als Compiler nutze ich Momentan Visual Studio X und Ti`s Compiler mit dem ich auf dem: Ti Delfino programieren kann (C2000er Serie)

Wie würde in AVR so ein Quelltext etwa aussehen, wenn ihrs machen würdet?
Sinngemäß soll ja so ablaufen:

Also der drucksensor arbeitet auf dem Manchestercodeprinzip.
dieser sendet aller 228µs ein 108µs langes datenpaket zu einer Länge von
13bits. 2 Startbits 10datenbits und ein Paritätsbit.

Bei Zündung ein (ach ja es ist auf dem CANbus laufendes Signal) wird der
Sensor initialisiert und sendet nach dem ersten zustandsinfos seine
istdaten aller 228µs.
Diese Daten gilt es zu simulieren und ggf zu verfälschen. Quasi wie eine
Restbussimulation.

Wenn der Sensor seine Werte (jetzt liegt ein Crash vor) an das
Steuergerät leitet, erwartet dieses außerdem eine Erschütterung (hier
kommt der Beschleunigungssensor zum tragen) und zwar in einem
vordefiniereten mindestabstand. Ist der mindestabstand der Signale zu
groß (radfahrer fährt gegen die Tür) soll das SG folglich nicht
auslösen.

ich glaube das Prozedere sollte soweit klar sein

Eine Frage steht noch im Raum: Wenn der µC die ganze Bitfolge in Spannungspegel ausgibt, wie bekomme ich das in für das Steuergerät verständlichen Strompegel gewandelt? Ich nehme mal an Signale über nem Widerstand abgreifen?

Danke

This post has been edited 1 times, last edit by "Quizzer11" (Feb 6th 2012, 2:23pm)

Rushh0ur

Professional

Posts: 228

7

Monday, February 6th 2012, 4:34pm

Das ganze Läuft über einen CAN-Bus?
So was ich gelesen habe wirds mit ein paar Wiederständen nix, dafür brauchst dann Wohl noch nen CAN-Controller mit dem du die Daten vom µC(0V/5V ö.ä) "konventieren" kannst.

Ein möglicher CAN-Controller wird hier vorgestellt:
http://www.me-systeme.de/canbus.html
Genauere Bezeichnung: PCA82C250

Code, hab mal schnell was Zussamenkopiert aus meinen alten Projekten:

C/C++ Quellcode

#define F_CPU 20000000UL	// 20MHz
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
 
/*********************************************************/
/* entry point						                     */
/*********************************************************/
int main(void)
{
    /// Enable 8 Bit Timer0
    LM_TCCR0  = (1<<CS00);     // PRESCALE = 1
							   // Intervall = (1 / (F_CPU/PRESCALE)) * 256 = 12,8us
    LM_TIMSK |= (1<<TOIE0);    // time overflow interrupt enable
 
    /// Enable Output Pins PD5..PD7
    DDRD  |= 0b11100000;
 
    /// enable interrupts
    sei();
 
    /// main loop
    while(1)
    {
	}
}
 
/*********************************************************/
/* timer1 ovferflow interrupt handler                    */
/*********************************************************/
ISR(TIMER0_OVF_vect)
{
	// send something
	// wird alle 12,8us aufgerufen bei 20Mhz Taktfrequenz des µC
    return;
}

Mfg Rushh0ur

Quizzer11

Beginner

Posts: 4

8

Monday, February 6th 2012, 6:38pm

Danke rushh0ur

welches Board / Controller hast du dazu genutzt?

Rushh0ur

Professional

Posts: 228

9

Tuesday, February 7th 2012, 1:59pm

Ich verwende als Programmer mySmartUSB MK2.

Der obige Code, zumindest dieser Teilabschnitt, wurde für die Steuerung einer High Power RGB Led verwendet, Controller war nen ATmega8.
Der Code sollte einfach auf andere Controllertypen der Reihe portierbar sein.

Mfg Rushh0ur

Coder Forum