IoT – El guardian del bosque

Un dispositivo de funcionamiento solar de baja potencia que detecta la tala ilegal de madera en el borde utilizando datos acústicos

Historia

Cada año se destruyen casi 19 millones de acres de bosques, lo que equivale a 27 campos de fútbol por minuto. Los bosques sirven como hogar para miles de animales y, para muchas personas, son una fuente de alimento, agua, ropa, medicinas y refugio. Los llamados pulmones de la Tierra también mitigan el cambio climático actuando como sumideros de carbono. A medida que las ciudades se expanden con el aumento de calamidades naturales como incendios forestales a un ritmo alarmante, la necesidad de conservar el ecosistema forestal es un paso vital en nuestra lucha contra el cambio climático. Los incendios forestales no necesitan presentación. Dicho esto, más del 80% de los incendios forestales son antropogénicos (provocados por el hombre) en contraposición a los biogénicos (naturales). Estos pueden deberse a muchas razones, como la tala ilegal, los esfuerzos de deforestación. La pérdida de bosques como resultado de la tala ilegal es una amenaza para la biodiversidad en hábitats forestales. Cada vez más especies son incapaces de sobrevivir ya que la práctica niega el hábitat crucial para la interconexión natural. La extensa fragmentación y degradación del bosque ha puesto a más especies de animales y plantas al borde de la extinción. Por lo tanto, detener la tala ilegal ayudaría a restaurar la flora y la fauna y restablecer el equilibrio de la naturaleza para sostener el mundo.

Solución propuesta

La solución es construir una detección de tala ilegal basada en eventos acústicos en el borde mismo alimentada por energía solar. La mayoría de las soluciones hasta la fecha se han basado en gran medida en la nube para el posprocesamiento de los datos recopilados de los sensores, que está limitado por el ancho de banda de la red, lo que los convierte en dispositivos que consumen mucha energía. Por lo tanto, el dispositivo propuesto sería capaz de clasificar 3 clases de eventos acústicos, a saber: Normal (sonido natural del bosque), Axe (tala de árboles con Axe), motosierra (tala de árboles con motosierra) en el borde, y solo enviaría los resultados de la clasificación y el estado del dispositivo a través de una frecuencia de radio a la estación base. La estación base recibe los datos, los carga en la nube y genera una alerta por SMS a la autoridad en cuestión si se detecta un registro ilegal. Para sostener esta solución en los bosques, necesitaríamos recolectar energía solar y almacenarla en una batería. Además, para ahorrar energía, el dispositivo estaría en un ciclo continuo de dormir, despertar a la inferencia y volver a dormir.

Hardware

Nuestro primer objetivo es seleccionar componentes que sean energéticamente eficientes, ya que el dispositivo funcionaría completamente con batería y energía solar. A continuación se menciona una lista de componentes seleccionados:

1) Kit de desarrollo QuickFeather: esta placa tiene capacidad para un núcleo Arm de 80 Mhz con un eFPGA que ayuda a realizar tareas de cálculo intensivo más rápido con menos consumo de energía. La placa tiene un micrófono a bordo con un detector de sonido de baja potencia (LPSD), un NOR Flash, un cargador de batería con un conector JST que lo convierte en un candidato adecuado para nuestra aplicación.

2) Xbee S2C: este módulo de RF puede funcionar con una potencia mínima de 2 mW y con una corriente de suspensión en microamperios. Aparte de las especificaciones de potencia, la disponibilidad y el precio del módulo lo hacen destacar.

3) Placa solar Clicker: este módulo alberga un cargador y convertidor Buck BQ25570 Nano Power Boost de TI. El bajo voltaje de arranque en frío (300 mV), la corriente de salida máxima (110 mA), la fácil asignación de pines y un supercondensador de respaldo lo hicieron adecuado para nuestro proyecto.

Encontré un módulo de iluminación solar barato en Amazon, que resultó ser un buen recinto para el proyecto, ya que el panel solar ya está conectado al recinto y también hay un soporte de batería. Como el micrófono de la tabla de empotrar rápido está orientado hacia abajo, asegúrese de que la abertura no esté bloqueada debido a la carcasa. Todos los componentes se conectaron mediante pines hembra soldados a la placa de creación de prototipos. La conexión de hardware es la siguiente:

1) La entrada del panel solar está conectada al pin de entrada del módulo de clic solar. Para habilitar el convertidor de refuerzo reductor, el pin EN del módulo del clicker solar está cortocircuitado a tierra. La tensión aumentada se conecta a su vez a la placa de conexión rápida mediante el conector justo. El XBee se alimenta a través de una salida de voltaje regulado (J3_15) en la placa de conexión rápida para mantener una comunicación de RF estable. La batería también se conecta a través del pin Vbat justo al lado del conector JST.

2) Los pines Rx y Tx del tablero de derivación rápida están conectados al pin Rx y Tx del módulo Xbee respectivamente. El pin IO_6 en la pluma rápida conectado al pin 9 del módulo Xbee controla los ciclos de suspensión del módulo Xbee. Al subirlo (3,3 V), el XBee entra en modo de suspensión y mantenerlo bajo (GND) lo activa.

Se utilizaron pequeños alambres para formar la interconexión entre los componentes. A continuación se muestran algunas instantáneas del diseño del hardware.

Recopilación de datos

SensiML proporciona una solución de software de un extremo a otro para la captura de datos, el modelado de datos y la generación de firmware para la inferencia en el dispositivo para dispositivos con recursos limitados de baja potencia. Para usar el cambio rápido con SensiML Solutions, necesitaremos actualizar el archivo bin del firmware de recolección de datos en la placa. Puede descargar el archivo bin directamente desde el sitio web de SensiML (asegúrese de descargar el archivo bin compatible con audio) y siga este tutorial para comenzar . Tenía problemas para crear un alias para el programador de Tinyfpga, sin embargo, el uso de la consola git bash me ayudó a resolver el problema con la creación de un nombre de alias “qfprog” y también para actualizar el archivo bin en la placa.

Dado que necesitaríamos escribir algo de firmware más adelante en el proyecto, sería mejor obtener algo de experiencia práctica con la generación de archivos bin utilizando el Proyecto de aplicación AI de interfaz de transmisión simple Quickfeather en eclipse ide. Aquí hay un tutorial descriptivo para configurar el proyecto de la aplicación en eclipse.

Después de configurar el proyecto en el IDE, diríjase al archivo Fw_global_config.h y realice los siguientes cambios para que el dispositivo sea detectado en el Laboratorio de captura de datos .

Seleccione la macro de audio para habilitar la transmisión de audio a través de UART. También debe habilitar la macro SENSOR_AUDIO_LIVESTREAM_ENABLED en el archivo de encabezado sensor_audio_config_user.h presente en el directorio sensor_audio del proyecto.

Presione el botón de compilación (en forma de martillo) para generar el archivo bin ubicado en el directorio GCC_Project / output / bin. Abra git bash en el mismo directorio, presione el botón de reinicio en el tablero seguido del botón de usuario antes de que el LED verde deje de parpadear, y use el siguiente comando para flashear el archivo bin.

qfprog –port <Device COM Port> –m4app <Name of the bin file>.bin –mode m4

Una vez que se muestra el programa, conecte el convertidor en serie de USB a TTL para realizar una conexión rápida de acuerdo con las siguientes conexiones:

Rx (Convertidor en serie) -> Rx (tablero quickfeather)

Tx (Convertidor en serie) -> Tx (tablero quickfeather)

Tierra (convertidor en serie) -> Tierra (tablero quickfeather)

Para comenzar, cree una nueva cuenta y descargue el software DCL, e inicie sesión. Una vez que la conexión esté lista, abra el Laboratorio de captura de datos, cree un nuevo proyecto dándole un nombre y guárdelo en algún lugar. Luego cambie del modo ‘Explorador de etiquetas’ al modo ‘Captura’. El DCL utiliza complementos en forma de archivos SSF que le indican cómo comunicarse con los dispositivos. Descargue el de QuickFeather aquí (asegúrese de elegir el de Transmisión simple) y agréguelo usando Editar-> Importar complemento de dispositivo y seleccionando el archivo SSF recién descargado. En la esquina superior derecha verá que la Configuración del sensor está vacía, así que haga clic en el botón Agregar nuevo sensor, seleccione el complemento QuickFeather Simple Stream, use la fuente de captura ‘Audio’, una frecuencia de muestreo de 16000 muestras por segundo y asegúrese de que “Micrófono” esté marcado. Continúe y guárdelo con el nombre que desee.

Con la placa configurada, siga adelante y haga clic en “Conectar” dentro del DCL después de encontrar el puerto serie correcto (¡el del convertidor serie USB a TTL!) Con el botón “Escanear dispositivos”. Si no funciona inicialmente, intente desenchufar el convertidor, volver a enchufarlo o desconectarlo y volverlo a conectar. Justo debajo de ese panel, hay una sección para agregar etiquetas y metadatos. He añadido tres etiquetas: normal, hacha y motosierra. Presione el botón de grabación cuando esté listo.

Una vez que se completa la grabación, necesitamos limpiar los datos de audio ya que no queremos que fragmentos de audio no deseados ingresen al modelo de entrenamiento. Esto se puede lograr yendo a la pestaña Explorador de proyectos en la parte superior izquierda y haciendo doble clic en la captura que desea modificar. Luego, podemos agregar segmentos arrastrando el mouse mientras se mantiene presionado el botón derecho sobre las áreas que desea conservar. Puede verlos en el área superior derecha. Esto también nos permite capturar diferentes etiquetas dentro de la misma captura creando segmentos para cada una de ellas y cambiando las etiquetas. También puede utilizar Detectar segmentosopción en la parte inferior para detectar automáticamente segmentos en los datos y hacer todo el trabajo repetitivo por usted. Asegúrese de crear la misma cantidad de segmentos para cada clase, ya que esto equilibraría el modelo y evitaría que se ajuste de forma inadecuada o excesiva. También puede agregar un video de los datos para correlacionarlo con el evento de audio.

 

Después de dirigirse a Archivo-> Cerrar archivo, es hora de usar Analytics Studio para generar un modelo a partir de los datos capturados. Recuerde que los datos guardados dentro del DCL se cargan y almacenan automáticamente en la nube, aunque puede tomar unos minutos para que se actualicen y aparezcan.

Entrenamiento de datos:

SensiML proporciona un plan de suscripción de Community Edition que ofrece la mayoría de las funciones de Analytics Toolkit sin costo alguno. Una gran oferta para los creadores que quieran experimentar.

Inicie sesión en Analytics Studio en un navegador web y seleccione el proyecto que se creó en el DCL.

 

Para entrenar un modelo, primero debemos informar a Analytics Studio de los datos que queremos usar en un formulario de Consulta. Esto se puede hacer haciendo clic en la Prepare Datapestaña e ingresando un nombre, sesión, etiqueta, metadatos relevantes, los sensores y cómo trazarlos. Después de guardar, el conjunto de datos debería aparecer a la derecha y podemos ver cuántos segmentos hay en cada etiqueta.

 

Una canalización es un contenedor para una serie de pasos de procesamiento de datos. El objeto de canalización le permite obtener una canalización existente o crear una nueva con un nombre determinado. Puede establecer fuentes de datos de entrada con el objeto creado, agregar transformaciones, generadores de características, selectores de características, transformaciones de características y clasificadores. Podemos crear un pipeline haciendo clic en la Build Modelpestaña e ingresando los siguientes detalles:

1) Nombre de la canalización:

2) Seleccione la consulta que acaba de crear,

3) Tamaño de la ventana: corresponde al número de muestras que se almacenan en búfer para cada evento. Esto puede tener un efecto notable en el modelo y el tamaño del modelo. Por lo tanto, establezca esto sabiamente.

4) Métricas de optimización: elija su prioridad entre Precisión, Puntuación F1, Sensibilidad.

5) Tamaño del clasificador: esto limita el tamaño del modelo, ideal para cargar en chips con restricciones de ROM.

Al hacer clic, Optimizese ejecutará y se creará el modelo. Haga clic en la barra Mostrar configuración avanzada para revelar las opciones. Me gusta este conjunto de opciones ya que proporciona más flexibilidad y control sobre el proceso de construcción del modelo. Una de las opciones que elegí fue “Balance de datos”, que iguala los datos de cada clase para el entrenamiento. Siéntase libre de jugar con estas configuraciones, ya que Pipeline Log es bastante inteligente, ya que sugiere al usuario que cambie un cierto parámetro en caso de falla de compilación.

 

SensiML ofrece más opciones para investigar el modelo generado. Cambie a la pestaña Explorar modelo en el lado izquierdo para revelar todos los detalles relacionados con el modelo, como Visualización del modelo, Matriz de confusión, Resumen de funciones y Resumen del paquete de conocimientos. Si desea optimizar y ajustar el algoritmo subyacente, visite el tutorial avanzado de creación de modelos.

 

Puede continuar y descargar el modelo / conocimiento haciendo clic en la opción Descargar modelo en el menú desplegable de la izquierda. SensiMl admite una gran variedad de tablas, una que debemos seleccionar es la tabla de plumas rápidas. Incluso si su placa no es compatible, puede seleccionar ARM GCC Generic, que descargaría la biblioteca estática junto con un código de ejemplo para usar con cualquier placa habilitada para ARM. A continuación, se mencionan las opciones en las que debemos centrarnos antes de descargar el paquete de conocimientos:

1) Opción flotante: esto generaría un objetivo de instrucciones de punto flotante para convenciones específicas de punto flotante

2) Formato: tenemos tres opciones aquí (Binario, Biblioteca, Fuente). El código fuente solo está disponible para la versión paga. Si desea flashearlo directamente en la placa, descargue el binario seleccionado. Para nuestro proyecto, necesitaríamos el formato de biblioteca para una integración perfecta en el firmware.

3) Aplicación: seleccione la opción de transmisión simple, ya que habíamos utilizado el Uart para la recopilación de datos en lugar de la placa WIFI.

4) Depuración: en la pestaña Configuración avanzada, asegúrese de establecer esto en verdadero , ya que los problemas relacionados con los resultados de reconocimiento que no se muestran en la Terminal Uart se han informado en el foro de lógica rápida .

 

Desarrollo de firmware:

El primer paso del desarrollo del firmware es integrar el paquete de conocimientos generado en el proyecto qf_ssi_ai_app. A continuación se mencionan algunos enlaces que lo ayudarían a lograr lo mismo:

Compilación de la biblioteca SensiML en el documento QuickLogic QuickFeather

La pregunta aquí es desarrollar firmware que realice la inferencia de audio durante una duración particular, ingrese al modo de suspensión para ahorrar energía durante un período de tiempo fijo y se reactive nuevamente para reanudar el ciclo. El proyecto qf_ssi_ai_app utiliza Audio DataBlock Processor Threads para recopilar los datos de audio, los introduce en el modelo y envía los resultados del reconocimiento a la consola. Si pudiéramos suspender este hilo, el dispositivo entraría automáticamente en el estado ideal ya que no hay más tareas que ejecutar.

La guía paso a paso para el desarrollo de código es la siguiente:

1) Habilite el modo de reconocimiento en el archivo sensor_audio_config_user.h:

#define SENSOR_AUDIO_RECOG_ENABLED (1)    // Change it to 1
#define SENSOR_AUDIO_LIVESTREAM_ENABLED (0)
#define SENSOR_AUDIO_DATASAVE_ENABLED (0)

2) Agregue los siguientes archivos de encabezado al archivo main.c

#include “ql_audio.h”
#include “sml_output.h”

3) Cree un identificador para adjuntarlo al hilo del procesador Audio DataBlock y la definición de extern, facilita la vida del compilador. Cree controles de temporizador para controlar la duración de la actividad y los ciclos de sueño del dispositivo.

extern TaskHandle_t xTobeParsed;
TickType_t xTimestart;
TimerHandle_t idealtimer;
TimerHandle_t worktimer;
#define IDEAL_TIMER_PERIOD    10000
#define WORK_TIMER_PERIOD     2000

4) Ahora adjunte la tarea al hilo haciendo los cambios en los siguientes archivos:

  • c:

// Add this at the top of file
TaskHandle_t   xTobeParsed;

// Pass the address of the task handle in the last parameter
datablk_processor_params_t audio_datablk_processor_params[] = {
{ AUDIO_DBP_THREAD_PRIORITY,
&audio_dbp_thread_q,
sizeof(audio_datablk_pe_descr)/sizeof(audio_datablk_pe_descr[0]),
audio_datablk_pe_descr,
256,
“AUDIO_DBP_THREAD”,
&xTobeParsed                   /****** Edited here ********/
}
};

  • h:

// As we are passing the address of the task handle, we need to change type of the
// datablk_pe_handle to pointer.

typedef struct st_datablk_processor_params
{
int                      dbp_task_priority;  ///< desired task priority
QueueHandle_t           *p_dbp_task_inQ;     ///< input queue handle
int                      num_pes;         ///< number of PEs for this thread
datablk_pe_descriptor_t  *p_descr;        ///< array of thread PE configurations
int                      stack_depth;     ///< depth of stack needed for this thread
char                    *dbp_task_name;    ///< datablock processor task name string
xTaskHandle             *datablk_pe_handle;  /****** Edited here ********/
} datablk_processor_params_t ;

  • c:

// Remove the Ampersand sign in order be compatible with the pointer operator.
xTaskCreate ( datablk_processor_task,
p_dbp_params->dbp_task_name,
p_dbp_params->stack_depth,
p_dbp_params,
p_dbp_params->dbp_task_priority,
p_dbp_params->datablk_pe_handle   /****** Edited here ********/
);

4) Agregue funciones para las siguientes tareas:

  • Inicializar temporizadores:

void timer_init(void)
{
if (!idealtimer) {
idealtimer = xTimerCreate
(
“idealTimer”,
IDEAL_TIMER_PERIOD, // 10 ticks = ~10ms
pdTRUE,            // auto-reload when the timer expires
(void *)0,
idealTimer_Callback
);
}
if (!worktimer) {
worktimer = xTimerCreate
(
“workTimer”,
WORK_TIMER_PERIOD, // 10 ticks = ~10ms
pdTRUE,            // auto-reload when the timer expires
(void *)0,
workTimer_Callback
);
}
}

  • Funciones de devolución de llamada a las que se llamará después de que expire cada temporizador:

void workTimer_Callback (TimerHandle_t timHandle)
{
max_class_print();
vTaskSuspend(xTobeParsed);
TimerStart(1);
uart_tx_raw_buf(UART_ID_SSI,”\r\nSleeping”,10);
Xbee_Sleep_Config(1);
TimerStop(0);
}

void idealTimer_Callback(TimerHandle_t timHandle)
{
vTaskResume(xTobeParsed);
TimerStart(0); //work start
Xbee_Sleep_Config(0);
TimerStop(1);  // ideal stop
HAL_DelayUSec(1000);
uart_tx_raw_buf(UART_ID_SSI,”\r\nInferencing”,13);
}

  • Funciones para iniciar y detener los temporizadores:

void TimerStart(bool timer_select)
{
BaseType_t  status;
if (timer_select)  {
status = xTimerStart (idealtimer, 0);                // start timer
if (status != pdPASS)  {
// Timer could not be started
uart_tx_raw_buf(UART_ID_SSI, “\r\n start ideal timer failed\r\n”, 30);
}
}
else
{
status = xTimerStart (worktimer, 0);                // start timer
if (status != pdPASS)  {
// Timer could not be started
uart_tx_raw_buf(UART_ID_SSI, “\r\n start work timer failed\r\n”, 30);
}
}
}

void TimerStop(bool timer_select)
{
if (timer_select) {
xTimerStop(idealtimer, 0);
}
else {
xTimerStop(worktimer, 0);
}
}

  • Configurar el modo de suspensión de Xbee:

void Xbee_Sleep_Config(bool enable_sleep) {
IO_MUX->PAD_6_CTRL = 0x103;
// Pull the Pin 6 to 3.3v, which is
// connected o PIN9 on Xbee
if(enable_sleep)
HAL_GPIO_Write(GPIO_0, 1);
else
HAL_GPIO_Write(GPIO_0, 0);
}

Necesitamos hacer coincidir la velocidad en baudios del dispositivo con la del módulo XBee para establecer la comunicación a través de UART. Visite el siguiente enlace para configurar el módulo XBee y cambiar el parámetro brate en la función uart_setup () presente en el archivo App / src / qf_hardwaresetup.c . El código fuente completo del proyecto está disponible en github, aquí está el enlace:

https://github.com/Pratyush-Mallick/qorc-sdk.git

Optimización de baja potencia:

El modo de bajo consumo en el QORC SDK se logra aprovechando la técnica de ahorro de energía de FreeRTOS tickless IDLE. Cuando no hay tareas activas en FreeRTOS, solo la tarea IDLE está activa y hace que la CPU entre en suspensión. Quicklogic tiene un documento bien guiado sobre este tema. La página se puede encontrar aquí.

Medir el consumo de energía de un sistema integrado es una tarea cada vez más difícil; sin embargo, el kit de perfilador de energía de Nordic Semiconductor II (PPK2) lo convierte en una experiencia perfecta. Medimos el consumo de corriente de nuestro sistema en el modo de fuente, es decir, el dispositivo bajo prueba (DUT) recibe energía del PPK2. Instale la aplicación Power Profiler, conecte el VOUT en el PPK2 al VBAT en la tabla de derivación rápida, conecte ambos a tierra y estará listo para comenzar.

Aquí hay observaciones de consumo de energía promedio (1 min) a 3.3 voltios con un ciclo de suspensión de 10 segundos y reconocimiento de 2 segundos:

  • Solo Quickfeather: 6mA
  • Solo Quickfeather (DFS): 7mA (la escala de frecuencia dinámica se puede habilitar configurando #define CONST_FREQ en 1 en el archivo Fw_global_config.h)
  • Solo Xbee (sin dormir): 31mA
  • Solo Xbee (suspensión habilitada): 1.97 mA (esta guía puede ayudarlo a configurar los modos de suspensión de XBee)
  • Quickfeather + Xbee (sin dormir): 36mA
  • Quickfeather (DFS) + Xbee (suspensión): 7mA

 

Podría lograr un mínimo de 3 mA incorporando los siguientes cambios en el lado del firmware configurando el reloj del nodo de la política de suspensión a 256 kHz en el archivo s3x_pwrcfg.c.

 

Quería llevar el consumo de energía al mínimo, por lo tanto, contacté al equipo de Quicklogic y SensiML. Aquí está lo que tenían que decir:

“Reducir el consumo de energía mientras se mantiene un rendimiento óptimo requiere mucho desarrollo y ajuste. Es difícil determinar si la corriente máxima de 2 mA para la EOS S3 se puede lograr sin una comprensión clara del tamaño del modelo, Sensor ODR (solo IMU o también Audio ), etc. Para reducir aún más el consumo de energía, FW debe poner todos los componentes no utilizados (específicos del caso de uso) en el modo de menor consumo de energía. Esto no está siendo abordado por el FW actual “.

Sin embargo, me proporcionaron la siguiente guía que incorporaría en el desarrollo futuro:

  • En la aplicación SimpleStreaming actual, CONST_FREQ está configurado para proporcionar el máximo rendimiento. En este caso, hay dos modos de energía: Inactivo y Activo. El estado de suspensión es cuando el S3 M4 ingresa al modo WFI mientras el S3 IP recopila datos del sensor en el búfer. El estado activo es cuando M4 está ejecutando algo o configura HW para transferir datos. El tiempo activo de M4 depende en parte de los datos del paquete de conocimientos.
  • Para Active, el núcleo S3 consume ~ 5.67mW (@ 1.8V); el # no incluye el consumo de S3 IO ni los sensores.
  • Para WFI, el núcleo S3 consume ~ 0.370uW (@ 1.8V); el # no incluye el consumo de S3 IO ni los sensores.
  • Para EOS S3, al cambiar la frecuencia de HOSC, es necesario reconfigurar todos los divisores de redes de reloj y actualizarlos para obtener la frecuencia de reloj de salida correcta.

Aquí hay algunas fotos y videos durante las pruebas al aire libre.

 

Alerta de puerta de enlace en la nube y SMS:

Nuestra puerta de enlace en la nube consta de una computadora personal conectada a Internet y un coordinador Xbee conectado a una PC a través de UART. Un script de Python que se ejecuta en la PC obtiene los datos del Coordinador de Xbee a través de UART, los procesa y luego los reenvía a la nube ThingSpeak para su posterior visualización y análisis. Puedes seguir este video en youtube para comenzar con thingspeak.

Una vez que comencemos a recibir datos con éxito en la nube, necesitaríamos un mecanismo de activación para enviar SMS de alerta si se detecta la tala ilegal de madera. Afortunadamente, Thingspeak tiene una aplicación ThingHTTP que permite la comunicación entre dispositivos, sitios web y servicios web sin tener que implementar el protocolo en el nivel del dispositivo. Usaremos esta aplicación para activar las API de Twilio que pueden enviar correos electrónicos y SMS automáticos. Como ThingSpeak se basa en Matlab, necesitaríamos codificar este proceso en Matlab. Visite los siguientes enlaces para comenzar con ThingHTTP y Twilio Account. He adjuntado el código de Python y Matlab al final de este blog.

Aquí está el enlace al canal público que muestra el estado de suspensión rápida, la clase de reconocimiento y la ubicación del dispositivo: https://thingspeak.com/channels/1370213

 

Alcance futuro:

Aquí hay una lista de tareas que planeo lograr en la próxima revisión (cualquier tipo de ayuda es muy apreciada):

  • Reducir el consumo de corriente en el modo de suspensión en el rango de microamperios.
  • Agregue la funcionalidad de monitoreo del nivel de batería aprovechando el pin ADC conectado al pin VBAT.
  • Agregue también un sensor de gas para la detección de incendios forestales.
  • Un mejor panel solar como el de epshine powerfilm .
  • Un mejor convertidor de impulso, ya sea de e-peas o de industrias matrices

Código fuente: https://github.com/Pratyush-Mallick

Acerca de Pratyush Mallick 1 Article
Soy ingeniero de firmware de profesión y modificador de memoria. La mayor parte de mi tiempo libre la dedico a desarrollar sistemas que puedan actuar como diseños de referencia para resolver problemas del mundo real.

Be the first to comment

Leave a Reply

Tu dirección de correo no será publicada.


*