Physikalische Vorgänge in C

  • Physikalische Vorgänge in C

    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.

  • 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

  • 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

  • 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.

  • Der 328 wird für die Sache locker ausreichen.

    Quizzer11 schrieb:


    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 IDE hast du schon.

    Mfg Rushh0ur

  • @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

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Quizzer11 ()

  • 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:
    me-systeme.de/canbus.html
    Genauere Bezeichnung: PCA82C250

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

    Quellcode

    1. #define F_CPU 20000000UL // 20MHz
    3. #include <avr/io.h>
    4. #include <avr/interrupt.h>
    5. #include <util/delay.h>
    7. /*********************************************************/
    8. /* entry point */
    9. /*********************************************************/
    10. int main(void)
    11. {
    12. /// Enable 8 Bit Timer0
    13. LM_TCCR0 = (1<<CS00); // PRESCALE = 1
    14. // Intervall = (1 / (F_CPU/PRESCALE)) * 256 = 12,8us
    15. LM_TIMSK |= (1<<TOIE0); // time overflow interrupt enable
    17. /// Enable Output Pins PD5..PD7
    18. DDRD |= 0b11100000;
    20. /// enable interrupts
    21. sei();
    23. /// main loop
    24. while(1)
    25. {
    26. }
    27. }
    29. /*********************************************************/
    30. /* timer1 ovferflow interrupt handler */
    31. /*********************************************************/
    32. ISR(TIMER0_OVF_vect)
    33. {
    34. // send something
    35. // wird alle 12,8us aufgerufen bei 20Mhz Taktfrequenz des µC
    36. return;
    37. }
    Alles anzeigen


    Mfg Rushh0ur