Sensor para detectar el impacto de la bola

Creo que necesitas conectar el sensor a un osciloscopio y comparar la señal de voltaje durante los movimientos de las manos y durante el impacto de la bola, o descargar tus datos de ADC y trazarlos (como lo mencionó @Harry Svensson). Si no tiene buenos datos, entonces solo está adivinando el algoritmo correcto.

Creo que el golpe de bola tendrá un tiempo de aumento de voltaje muy rápido, mientras que los movimientos de la mano serán lentos. Si los datos lo confirman, entonces puede colocar un opamp configurado como diferenciador antes del ADC. Su salida variará según la rapidez con la que cambie la señal piezoeléctrica, en lugar de basarse en el nivel real.

Eldiagramaanterioresdeunbuentutorialsobreelcircuitodeldiferenciadoren enlace

Básicamente, cuanto más rápido aumente (o disminuya) la señal de voltaje piezoeléctrico, mayor será la excursión Vout. Su código luego buscará exceder un umbral como su algoritmo actual.

Tenga en cuenta que la excursión de mayor voltaje puede ser positiva o negativa durante el golpe de pelota, según la manera en que haya orientado su piezo. Su análisis de los datos sin procesar de su sensor revelará esto.

Si su MCU es lo suficientemente rápido, incluso podría hacerlo digitalmente en tiempo real. Básicamente, solo necesitas ver la diferencia entre muestras y disparadores cuando veas una gran diferencia.

Este tipo de cosas se puede hacer con discriminación de eventos .

Un discriminador de eventos acepta señales con el contenido adecuado de amplitud y frecuencia.

Para lograr esto en un simple microcontrolador de capacidad moderada (por ejemplo, 16 MHz o mejor):

Olvide el A2D y aplique su señal piezoeléctrica a un comparador analógico. La salida del comparador luego se conecta a un pin de entrada configurado como una interrupción.

Una vez que llegue el primer pulso, inicie un temporizador y continúe contando los pulsos de entrada. Una vez que se detecte el número deseado de pulsos, o se haya agotado el temporizador, salga del bucle.

Si obtiene el número de conteos deseado y el temporizador está por debajo de algún conteo, entonces la señal tiene una frecuencia demasiado alta y se puede descartar.

Si el temporizador ha caducado y el recuento sigue siendo demasiado bajo, la señal tiene una frecuencia demasiado baja y se puede descartar.

De lo contrario, la señal se puede contar como un evento .

Por supuesto que podrías hacer todo esto con tus datos A2d, solo tomaría una CPU con más potencia.

" ¿Cuáles son los ajustes adecuados? " Observe un rebote de pelota con un alcance unido a la salida del comparador. Determine el número de pulsos que son los más comunes para un solo rebote de la bola pong, así como el tiempo mínimo y máximo correspondiente a la frecuencia.

¡Buena suerte!

Pseudo Código:

//******************************************************************************
    //
    // 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; 
    }