Pause in Picosekunden



  • Hallo zusammen.
    Ich starte grad ein neues Projekt.
    Zurzeit bin ich noch dabei zu prüfen, ob es machbar ist.

    Bei dem Projekt benötige ich einen Code,
    welcher einen 56 Bit Code Berechnet, sendet und empfängt.
    Die String länge beträgt 56x0,125us. (8 MhZ)
    Eine 0 wäre 31,25us high und 93,75us low.
    Eine 1 wäre 93,75us high und 93,75us low.

    Als Basis dachte ich an einen Raspberry PI.

    Ist es möglich mit C++ diese Pausen zu programmieren?
    delay, usleep fallen raus?

    Oder sollte ich mich lieber auf Phyton bzw Assembler konzentrieren? 😕


  • Mod

    Häh?

    Geh mal davon aus, dass niemand hier weiß, was in deinem Kopf vorgeht, außer du erklärst es uns. Wenn du ein Problem beschreibst, musst du auch den nötigen Kontext beschreiben, den man benötigt, um das Problem verstehen zu können.



  • Woher nehmen Python oder Assembler die Taktung?

    Ohne Echzeitbetriebssystem wird man das in Software wohl nicht lösen können.



  • Ich entwickel einen Controler welcher zur Steuerung von Diverser Hardware über LWL benötigt wird.

    Controler sendet definierten Datenstring mit 8Mhz über LWL an externe Hardware.

    Diese schaltet diverse Relais liest bzw schreibt Temperaturwerte. Die gelesen Werte und Statusse werden wieder in den Datenstring gepackt und per LWL wieder an den Controler zurückgesendet.

    Der Controler wertet den Datenstring wieder aus und sendet ihn wieder per LWL an die Hardware usw.

    An den Controler wird per Bluetooth ein Tablett angebunden wo über ein GUI bestimmte Werte (z.B. Temperarturen) verändert bzw. Relais geschaltet werden können. (GUI kommt nicht von mir, wird aber extra dafür geschrieben. Vermutlich Windows Basis.)

    Der Datenstring wird von der Hardware (besteht schon) mit 8 Mhz erwartet und wieder gesendet.
    Eine 0 wäre 31,25us high und 93,75us low.
    Eine 1 wäre 93,75us high und 93,75us low.

    Syncronisations Bits sind im String bereits enthalten.

    Gibt es eine möglichkeit die angegebenen Zeiten mit C++ zu programmieren?



  • Das hört sich so an, als hättest du ein Pulsweiten moduliertes Signal und willst dieses interpretieren.

    Ich denke hierfür musst du unbedingt auf die Hardware zurückgreifen. Find mal heraus welche CPU du nutzt, suche dir die Prozessorspezifikation und suche ob es auf der CPU ein entsprechendes Bauteil für deine Arbeit gibt. Wenn in der Doku die Rede von DAC, MPU und Timern die Rede ist und du sehr viele Registerbelegungen findest, bist du richtig.

    Wenn du Glück hast, ist dies schon in der Prozessor speziischen SDK enthalten. Wenn nicht musst du vermutlich das SDK der Prozessors nehmen und das HW Bauteil per Register konfigurieren.

    Schau mal beispielsweise bei http://www.keil.com/ vorbei.



  • Du kommst da ganz heftig mit den Einheiten bzw. dem Präfix durcheinander.

    Ein Puls bei 8 MHz dauert 125 Nanosekunden.
    Deine Pulse sind aber 125 bzw 187,5 Mikrosekunden lang.
    Im Titel redest du von Picosekunden.

    Der Rapberry Pi hat meist ein normales, nichtechtzeit Linux.
    D.H. dass dein Programm jederzeit unterbrochen werden kann.
    Daher sind genaue Taktfolgen eher schwierig. Mit einer Scriptsprache wie Python sogar noch mehr.

    Du wirst Hardwareunterstützung und/oder Interrupts benötigen.

    Da dein Puls/Pausenverhältnis bei 1:3 bzw 3:1 liegt, kannst du auch einen 224 Bit-Wort (56*4) erzeugen und das mit 32 MHz ausgeben.



  • Ein Puls bei 8 MHz dauert 125 Nanosekunden.
    Deine Pulse sind aber 125 bzw 187,5 Mikrosekunden lang.
    Im Titel redest du von Picosekunden.

    Mein gesammter Datenstring ist 56 *0,125 us lang. Also 56 Takte.
    Wenn ich jeden Tackt 1:3 bzw 3:1 unterteile komme ich auf
    31,25us bzw. 93,75 us.
    Der Teil hinter dem Komma sind Picosekunden. Oder habe ich da einen Denkfehler? 😕



  • Du wirst Hardwareunterstützung und/oder Interrupts benötigen.

    Ich bin da auf die Idee gekommen einen Pikosekunden Timer aufzuziehen. So was würde aber gnadenlos die CPU beanspruchen. 🙂

    Ich würde mal tippen das man einen AdC auf PWM konfigurieren kann.



  • EvilG schrieb:

    Mein gesammter Datenstring ist 56 *0,125 us lang. Also 56 Takte.
    Wenn ich jeden Tackt 1:3 bzw 3:1 unterteile komme ich auf
    31,25us bzw. 93,75 us.

    Nein. Nicht µs.

    EvilG schrieb:

    Der Teil hinter dem Komma sind Picosekunden.

    Ja.

    EvilG schrieb:

    Oder habe ich da einen Denkfehler? 😕

    Bei 32 MHz ist der Takt 31,25 ns lang. Da brauchst du keinen Picosekunden genauen Timer.

    Ob die Hardware vom Raspi das aber unterstützt, kann ich nicht sagen.



  • Mein gesammter Datenstring ist 56 *0,125 us lang. Also 56 Takte.
    Wenn ich jeden Tackt 1:3 bzw 3:1 unterteile komme ich auf
    31,25us bzw. 93,75 us.
    Nein. Nicht µs.
    

    Jo hast recht.

    Bei 32 MHz ist der Takt 31,25 ns lang. Da brauchst du keinen Picosekunden genauen Timer.

    32 Mhz = 31,25 ns. Aber wenn ich einen Timer/ Delay wie auch immer nur bis 1 ns erstellen kann, fehlen mir die 0,25 ns was ja 250 ps entspricht.
    Ob die Toleranz beim Empfänger groß genug kann ich noch nicht sagen.

    Theoretisch brauche ich einen Code welcher mir ein Delay von 31,25ns macht.
    Alternativ müsste ich mir was mit Registern und Quarz bauen.
    Dann würde ich das Projekt aber aus Zeitmangel aufgeben.



  • Worauf die Anderen vermutlich hinauswollen ist, dass du keinen Timer mit 0.25 ns, Auflösung, sondern einen Timer mit 31,25 ns Auflösung brauchst (Oder wie bereits gesagt am besten direkt ein PWM Modul).

    Du könntest den HW Timmer (falls vorhanden) so einstellen, dass er nach 31,25 ns ein Interrupt feuert.

    Alternativ kannst du es auch so realisieren, dass du so viele NOP's ausführst, bis die Zeit vergangen ist:

    for (int i = 0; i < X; i++) {
    	__asm("NOP");
            // Am besten gleich ein paar mehr NOP's hier einsetzen!
    }
    
    MAKE_HIH();
    
    for (int i = 0; i < Y; i++) {
    	__ASM("NOP");
    }
    
    MAKE_LOW();
    

    Diese Lösung wäre sehr einfach, erfordert aber ein wenig Experimentieren bis du die richtigen Werte für X und Y hast. Außerdem erfordert diese Lösung sehr deterministisches Verhalten von deinem System, d.h. diese Schleife bzw. dein Prozess darf auf keinen Fall durch das OS unterbrochen werden und der Prozessor sollte auch nicht aus irgentwelchen Gründen zwischen Turbo- und Normalbetrieb oder ähnliches umschalten.

    Mal ganz davon abgesehen, dass diese Lösung alles andere als effizient ist, aber wenn parallel eh nichts anderes bei dir Laufen soll, ist das durchaus legitim 🙂



  • Bei einem Timer werden i.A. die Grundtakte gezählt. Wenn das ein Vielfaches von 32 MHz ist, hast du die benötigte Auflösung von 31,25 µs.

    Vergiss den Versuch, das mit Bit-Banging zu realisieren, wenn du schon wegen 0,25 µs Bauchschmerzen bekommst.



  • warum nimmst du dir nicht einfach einen normalen (also kein arduino, sondern mehr was "vernünftiges") mikrocontroller? der hat nen timer und wenn der abgelaufen ist, löst er einen interrupt aus in dem du deine daten einlesen kannst.



  • Theoretisch brauche ich einen Code welcher mir ein Delay von 31,25ns macht.
    Alternativ müsste ich mir was mit Registern und Quarz bauen.
    Dann würde ich das Projekt aber aus Zeitmangel aufgeben.

    gibt es deinen fertige Komponente/Adapter der dein "Protokoll" schon spricht und dir ein API zur Verfügung stellt - absolut gar nichts - oder zu teuer?


Log in to reply