Obtención de entradas válidas desde el buscador de rango ultrasónico

Navega tus respuestas
0

(Estoy publicando esta pregunta aquí porque siento que el problema es una parte de mi falta de comprensión de la electrónica y no a)

Estoy tratando de monitorear la tolva de alimentación para mi horno de pellets. Tuve un Buscador de rango ultrasónico Seed Studio por ahí

Utilicé una secuencia de comandos de ejemplo para comenzar, y configuré algunas "correcciones de errores" simples antes de configurarlo en la tolva.

Todo funciona generalmente como debería. Sin embargo, me estoy topando con dos problemas;

  1. Necesito apuntar el sensor ultrasónico hacia la tolva de manera que el cono vea los lados de la tolva lo menos posible.

  2. Tengo picos mucho más grandes en mis datos (un factor de 1000 más grande) después de montar el sensor que mientras lo probaba en mi oficina. ¿Cómo puedo solucionar esto? ¿Necesito otro sensor, o debo filtrarlo en el código como lecturas erróneas?

Preguntas adicionales: Soy consciente de que los ultrasonidos pueden verse afectados por las partículas en el aire y la temperatura. ¿Debo considerar otro sensor?

Datos de muestra: 

* = potentially a hit on another surface than the pellets in the hopper

44              2018-10-17 11:08:39
33              2018-10-17 11:24:40 *
41              2018-10-17 11:25:00
49              2018-10-17 12:01:03
42              2018-10-17 12:01:23
36              2018-10-17 13:41:49 *
340376          2018-10-17 13:43:09 ???
40              2018-10-17 13:43:29
33              2018-10-17 14:06:50 *
40              2018-10-17 14:07:10
32              2018-10-17 14:56:13 *
40              2018-10-17 14:56:33
30              2018-10-17 15:24:35 *
39              2018-10-17 15:24:55
32              2018-10-17 15:56:57 *
41              2018-10-17 15:57:17
35              2018-10-17 16:34:59 *
41              2018-10-17 16:35:39
33              2018-10-17 17:33:42 *
41              2018-10-17 17:34:02
49              2018-10-17 18:00:44
41              2018-10-17 18:04:44
49              2018-10-17 18:11:25
42              2018-10-17 18:12:25
52              2018-10-17 18:39:46
44              2018-10-17 18:40:06
36              2018-10-17 18:57:48 *
42              2018-10-17 18:58:08
69              2018-10-17 19:39:10
41              2018-10-17 19:39:30
68              2018-10-17 19:41:10
41              2018-10-17 19:41:30
48              2018-10-17 21:22:16
41              2018-10-17 21:27:56
48              2018-10-17 23:55:45
340385          2018-10-18 00:00:26 ???
45              2018-10-18 00:00:46
36              2018-10-18 00:31:48 *
44              2018-10-18 00:32:08
36              2018-10-18 01:02:49 *
44              2018-10-18 01:03:09
52              2018-10-18 06:28:29
44              2018-10-18 06:35:09
37              2018-10-18 07:48:54 *
44              2018-10-18 07:49:34
340395          2018-10-18 08:13:15 ???
46              2018-10-18 08:13:35

Aquí está la parte esencial de mi código ( Código completo en Github ): 

#function to calculate deviation between current and previously read value
def deviation(x,y):
    diff = abs(float(x)-float(y))
    avg = (float(x)+float(y))/2
    return (diff/avg)

distance = int(round(duration*34000/2))
            if (distance != lastread):
                dev = deviation(lastread,distance)
            if (dev > allowableError):
                #save last entry, only if deviation is big enough.
                lastread = distance
                saveData(distance)
                print str(distance) + "\t\t" + str(datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S'))
    
pregunta Jonas Stumph Stevnsvig

1 respuesta

2

Es probable que esté relacionado con la latencia general del sistema.

El problema es que en una frambuesa o en un sistema Linux similar (y también se aplica a la plataforma con un sistema operativo), tienes un kernel que programa las tareas (todos los demás programas que se ejecutan).

Si bien parece que su programa se ejecuta continuamente en su while (1), el sistema realmente necesita ejecutar otras tareas y puede en cualquier momento bloquear su programa.

Los programas de espacio de usuario suelen tener la prioridad más baja, a menos que se especifique lo contrario.

Lo que sucede es que, a veces, su programa no se ejecuta con la suficiente rapidez, ya que el sistema está ocupado manejando otras cosas, y así pasa el tiempo entre el momento en que el pin se establece en 1 y el programa lo verificará.

Hay alguna forma de evitar este problema, pero requiere un controlador de nivel de kernel que pueda controlar y leer los pines con menor latencia pero es bastante (muy) complejo de hacer para algún programador de controladores que no sea del kernel.

Para mitigar el problema, puede intentar ejecutar el programa con una prioridad de ejecución . Probablemente esto ayude, pero puede que no resuelva totalmente el problema.

También puede agregar un filtro de software para ignorar los problemas erróneos.

Otra opción, quizás la mejor, si tu frambuesa tiene varios CPU Core, sería reserve un núcleo solo para su programa , para que no se interrumpa

En general, la mejor solución sería utilizar un dispositivo similar a Arduino para controlar el sensor y luego comunicarse con la frambuesa a través de SPI o I2C. Como el Arduino no tiene un kernel o la necesidad de ejecutar tareas, tendrá mediciones mucho más precisas en los tiempos.

    
respondido por el Damien

Lea otras preguntas en las etiquetas

¿Cómo se calcula el cambio de fase de un amplificador operacional utilizando coordenadas polares? ¿Se supone que la corriente nominal varía según el voltaje?