Sensor zur Erkennung des Ballaufpralls

Ich denke, Sie müssen den Sensor an ein Oszilloskop anschließen und das Spannungssignal während Handbewegungen und während des Ballaufpralls vergleichen oder Ihre ADC-Daten ausgeben und grafisch darstellen (wie von @Harry Svensson erwähnt). Wenn Sie keine guten Daten haben, raten Sie nur über den richtigen Algorithmus.

Ich denke, der Ballschlag hat eine sehr schnelle Spannungsanstiegszeit, während Handbewegungen eine langsame Anstiegszeit haben. Wenn die Daten dies bestätigen, können Sie einen als Unterscheidungsmerkmal konfigurierten Operationsverstärker vor den ADC stellen. Die Ausgabe variiert je nachdem, wie schnell sich das Piezosignal ändert, anstatt auf dem tatsächlichen Pegel zu basieren.

Das obige Diagramm stammt aus einem guten Tutorial zur Differentiator-Schaltung unter http://www.electronics-tutorials.ws/opamp/opamp_7.html

Grundsätzlich gilt: Je schneller das Piezospannungssignal ansteigt (oder abfällt), desto größer ist die Vout-Auslenkung. Ihr Code sucht dann nur nach Überschreitung eines Schwellenwerts wie Ihr aktueller Algorithmus.

Denken Sie daran, dass die höchste Spannungsauslenkung während des Ballschlags positiv oder negativ sein kann, je nachdem, wie Sie Ihr Piezo ausgerichtet haben. Ihre Analyse Ihrer Sensor-Rohdaten wird dies zeigen.

Wenn Ihre MCU schnell genug ist, könnten Sie dies sogar digital in Echtzeit tun. Im Grunde müssen Sie nur den Unterschied zwischen den Samples sehen und auslösen, wenn Sie einen großen Unterschied sehen.

Diese Art von Dingen kann mit Ereignisdiskriminierung durchgeführt werden .

Ein Ereignisdiskriminator akzeptiert Signale mit dem richtigen Amplituden- und Frequenzinhalt.

Um dies in einem einfachen Mikrocontroller mit mäßiger Leistungsfähigkeit (z. B. 16 MHz oder besser) zu erreichen:

Vergessen Sie den A2D und legen Sie Ihr Piezosignal an einen analogen Komparator an. Der Ausgang des Komparators wird dann mit einem als Interrupt konfigurierten Eingangspin verbunden.

Sobald der 1. Impuls ankommt, starten Sie einen Timer und fahren Sie fort, Eingangsimpulse zu zählen. Verlassen Sie die Schleife, sobald die gewünschte Anzahl von Impulsen erkannt wurde oder der Timer abgelaufen ist.

Wenn Sie die gewünschte Anzahl von Zählwerten erhalten und der Timer unter einem bestimmten Zählwert liegt, dann hat das Signal eine zu hohe Frequenz und kann verworfen werden.

Wenn der Timer abgelaufen ist und der Zählwert immer noch zu niedrig ist, dann hat das Signal eine zu niedrige Frequenz und kann verworfen werden.

Andernfalls kann das Signal als Ereignis gezählt werden .

Natürlich könnten Sie all dies mit Ihren A2d-Daten tun, es würde nur eine CPU mit mehr PS erfordern.

" Was sind die richtigen Einstellungen? " Betrachten Sie einen Ballsprung mit einem am Ausgang des Komparators angebrachten Zielfernrohr. Bestimmen Sie die Anzahl der Impulse, die für einen einzelnen Pong-Ball-Aufprall am häufigsten vorkommen, sowie die der Frequenz entsprechende Mindest- und Höchstzeit.

Viel Glück!

Pseudocode:

//******************************************************************************
    //
    // INTERRUPT HANDLERS
    //
    //******************************************************************************
    // Port 1 interrupt service routine
    #pragma vector=PORT1_VECTOR
    __interrupt
    void Port_1(void) {
        //Only defined interrupt should be (P1.0).  Yes, slimy cheating here to keep things fast.

        //Bit1.0 - Initial Pulse detected.  Start Discrimination.

        //Start Window timing, TA1R should already be set to 0 somewhere else.
        TA1CTL |= TIMER_A_CONTINUOUS_MODE;

        //Start Pulse counting, TA2R should already be set to 0 somewhere else.
        TA2CTL |= TIMER_A_CONTINUOUS_MODE;

        //Disable this pin input interrupt
        P1IE = 0x0; //Hard-coded and blunt-force trauma for speed.

        State = Active;
    }

    //Handle interrupts from Timer A1 ('Timer1_A'), section 0 ('0') which connects to CCR0
    //This is the Frequency Window timer.
    #pragma vector=TIMER1_A0_VECTOR
    __interrupt
    void TIMER1_A0_ISR(void){
        //if we've made it here, then we've run out of time.  Abort.  Low Frequency.

        //Turn off/reset Pulse counter
        Timer_A_stop(TIMER_A2_BASE);
        Timer_A_clearCaptureCompareInterrupt(TIMER_A2_BASE, TIMER_A_CAPTURECOMPARE_REGISTER_0);

        //Turn off/reset this (Window) counter
        Timer_A_stop(TIMER_A1_BASE);

        State = LowF;
    }
    //Handle interrupts from Timer A2 ('Timer2_A'), section 0 ('0') which connects to CCR0
    //This is the pulse counter.
    #pragma vector=TIMER2_A0_VECTOR
    __interrupt
    void TIMER2_A0_ISR(void){
        //if we've made it here, then we have enough pulses. Check for event...

        //Turn off/reset the window counter
        Timer_A_stop(TIMER_A1_BASE);
        Timer_A_clearCaptureCompareInterrupt(TIMER_A1_BASE, TIMER_A_CAPTURECOMPARE_REGISTER_0);

        //Turn off/reset this (Pulse) counter
        Timer_A_stop(TIMER_A2_BASE);

        //Verifiy timer results outside the ISR, and determine is this is really a good event
        State = Verify; 
    }