Sensor para detectar impacto de pelota

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

Creo que el golpe de la pelota tendrá un tiempo de aumento de voltaje muy rápido, mientras que los movimientos de la mano tendrán un tiempo de aumento lento. Si los datos lo confirman, entonces podría 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.

El diagrama anterior es de un buen tutorial sobre el circuito diferenciador en http://www.electronics-tutorials.ws/opamp/opamp_7.html

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

Tenga en cuenta que la excursión de voltaje más alta puede ser positiva o negativa durante el golpe de la pelota, dependiendo de la forma en que haya orientado su piezoeléctrico. Su análisis de los datos sin procesar de su sensor lo revelará.

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

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

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

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

Olvídese del 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 tiempo, salga del bucle.

Si obtiene el número deseado de conteos 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 expirado y el conteo sigue siendo demasiado bajo, entonces 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, podría hacer todo esto con sus datos A2d, solo necesitaría una CPU con más potencia.

" ¿Cuáles son los ajustes correctos? " Mire el rebote de una pelota con un visor conectado a la salida del comparador. Determine el número de pulsos que son los más comunes para un solo rebote de una pelota de ping pong, así como el tiempo mínimo y máximo correspondiente a la frecuencia.

¡Buena suerte!

Pseudocó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; 
    }