Study of animal movement: equipment design and development

#jupyter nbextension enable --py widgetsnbextension 
import platform #to get my operative system
import plotly.graph_objects as go
import serial #pip install pyserial
import struct #to unfold a C struct into other types of data
import numpy as np
import math

import threading           
import time                #to implement delays
import plotlydash as dplot

import datetime            #to get time
import webbrowser #for opening a webbroser when running scrips
import dash
from dash import dcc, html
from dash.dependencies import Input, Output

#from varname import nameof #for getting name of var #pip3 install varname
#define constants
def constant(f):
    def fset(self, value):raise TypeError
    def fget(self):return f()
    return property(fget, fset)
class _Const(object):
  @constant
  def DATA_RX_FORMAT_HEADER():   return 'f'
  @constant
  def DATA_RX_FORMAT_DATA():     return 'fffffffffffff'
  @constant
  def DATA_RX_FORMAT():          return('ffffffffffffff') #(DATA_RX_FORMAT_HEADER+DATA_RX_FORMAT_DATA)
  @constant
  def DATA_RX_SIZE():            return 56 #(DATA_RX_FORMAT_HEADER+DATA_RX_FORMAT_DATA)
  @constant
  def DATA_RX_HEADER_VALUE():    return 1.000102902456799e-37# in hex: 0x02082080 #in float: 1.000102902456799e-37
  @constant
  def SERIAL_PORT_ID_WIN():      return 'COM18'  ##in float: 1.000102902456799e-37 in hex: 0x02082080
  @constant
  def SERIAL_PORT_ID_LINUX():    return '/dev/ttyACM0'  ##in float: 1.000102902456799e-37 in hex: 0x02082080
  @constant
  def SERIAL_PORT_ID_RASPBIAN(): return '/dev/ttyS0'#serial 0:'/dev/ttyS0',serial 1:'/dev/ttyAMA0' 
  @constant
  def SERIAL_UPDATE_MS():        return 110 #150 also works
  @constant
  def WEB_TITLE():               return 'FiEstIn - Instituto Balseiro'  ##in float: 1.000102902456799e-37 in hex: 0x02082080
#create the constant class
CONST = _Const()
#declare global variables
global serial_port
# to apply an adaptative filter 
global anglex,angley,anglez 
#------------------------------------------------------------------------------
#Create the plot
#----------------------------------------------------------------------------------
# generate data
x = np.outer(np.linspace(-1.4, 1.4, 20), np.ones(20)) 
y = x.copy().T 
z = np.cos(x ** 2 + y ** 2) 
#create figure
fig = go.FigureWidget(go.Figure(data=go.Surface(x=x, y=y, z=z, showscale=False,colorscale ='viridis')))
                   #colors: blugrn, #ylgn #viridis more beautiful
camera = dict(up=dict(x=0,   y=0,   z=0),#esto controla el giro
          center=dict(x=0,   y=0,   z=0),#controls camera center
            eye=dict( x=1.2, y=1.2, z=1.2)) #control the zoom out position
fig.update_layout(scene_camera=camera,template='plotly_dark',font_size=14)
fig.update_layout(title='Awaiting for data')
#----------------------------------------------------------------------------------
#Proceed to open and init serial port
#-----------------------------------------------------------------------------------
anglex,angley,anglez=-1,-1,-1 #init as -1
opertative_system=platform.system()
if opertative_system=='Raspbian': serial_port_id=CONST.SERIAL_PORT_ID_RASPBIAN
if opertative_system=='Linux':    serial_port_id=CONST.SERIAL_PORT_ID_LINUX
if opertative_system=='Windows':  serial_port_id=CONST.SERIAL_PORT_ID_WIN
try :   serial_port.close() #will try to close port if already opened, this is a secutiry meassure
except: pass #DO NOT COMMENT if we can't close, we don't do anything
finally:serial_port = serial.Serial(serial_port_id,115200,timeout=1)#timeout must be passed in seconds
print('Serial port',serial_port) #to know the serial port used
#---------------------------------------------------------------------------------------
#Proceed to create the dash web structure
#----------------------------------------------------------------------------------
graph_plots=[]#list of dash graph plots we want to add. makes easier to have multiple plots
graph_plots.append(dcc.Graph(id='graph1',figure=fig,style={'width': '75vw', 'height': '75vh'}))  
row = html.H1(children=graph_plots)
#we add the element with the desired tittle
header = html.H1(children=CONST.WEB_TITLE,style={'color':'#7FDBFF','font_size': '130%'})
subheader = html.H2(children='\U0001F422 \U0001F422 \U0001F422 Grupo de Fsica Estadstica e Interdisciplinaria '
                    +'\U0001F422 \U0001F422 \U0001F422',style={'color':'#57F287'})                                                 
footprint = html.H3(children="\U0001F98E Andrs Oliva Trevisan, Nicols Catalano, Laila D. Kazimierski, Erika Kubisch, Karina Laneri \U0001F98E ",style={'color':'#0092CC','text-align': 'right'})                                                
#we add the element with the timer
graph_timer= dcc.Interval(id='timer_graph_update',interval=CONST.SERIAL_UPDATE_MS # in milliseconds
                                              ,n_intervals=0) #initial value of intervals
#create an object to chare ,json compatilble data between elements of the web site or external one
data_to_share=dcc.Store(id='data_to_transfer', storage_type='local')
#-----------------------------------------------------------------------------------
#we create the app layout adding all the objsects ---------------------------------
app_layout = html.Div(children=[header,subheader, row, graph_timer,data_to_share,footprint], style={
"text-align": "center", "justifyContent":"center",'backgroundColor':"#111111"})
#-----------------------------------------------------------------------------------
#Define dash callback function to update plot.
#-----Must be defined here because 'serial_port' var has to be initialized before define
#---------------------------------------------------------------------------------
app = dash.Dash(__name__)
app.layout=app_layout
#------callback function to read data from spi and store it
#---this callback is triggred by the periodic timer    
@app.callback(Output('data_to_transfer',  'data'), #must be named data, otherwise raise error
              Input('timer_graph_update', 'n_intervals')
              )
def function_rx_serial_port(n_intervals):
#print(n_intervals) #n_intervals=amounts of time the callbnack has been called since start
          rx_data=[]#init data buffer
          bytes_rx=serial_port.read(CONST.DATA_RX_SIZE)
          if len(bytes_rx)>=CONST.DATA_RX_SIZE: #Double check: crucial is serial timout=!0 
             floats=struct.unpack(CONST.DATA_RX_FORMAT, bytes_rx) #convert bytes to floats
             if floats[0]==CONST.DATA_RX_HEADER_VALUE:#verified the packet header is the correct
                rx_data=floats
          return(rx_data)      
#------callback function to read data that has been stores and then update the plot 
#-------this callback is triggred each time the 'data_to_transfer': 'data' object
         # is returned (or maybe changed, you fill have to figure it out!)         
@app.callback(Output('graph1', 'figure'),#figure MUST be an output to store the modified version
              Input('data_to_transfer', 'data'), #must be named data, otherwise raise error
              Input('graph1', 'figure') #figure MUST be an input in order to be modified
              )
def function_update_plot(rx_data,figure):
         if len(rx_data)>0:#verified the packet header is the correct
            #verified the packet header->store the variables
            temp_mcu,temp_imu=rx_data[1],rx_data[2]
            ax,ay,az=rx_data[3],rx_data[4],rx_data[5]
            gx,gy,gz=rx_data[6],rx_data[7],rx_data[8]
            mx,my,mz=rx_data[9],rx_data[10],rx_data[11]
            #anglex=0.98*(anglex+gx)+0.02*(ax)
            #angley=0.98*(angley+gy)+0.02*(ay)
            #anglez=0.98*(anglez+gz)+0.02*(az)
            mdirx=math.atan2(mz, my)#/math.pi
            mdiry=math.atan2(mx, mz)#/math.pi
            mdirz=math.atan2(my, mx)#/math.pi
            #print('angle val:',anglex,angley,anglez)
            #print('Mag val:',mx,my,mz)
            print('Mag dir :',mdirx,mdiry,mdirz)
            figure['layout']['title'] ='Temperatura Tortuga: '+str(temp_imu)+' C'+ f'<br><sup> Gravedad terrestre:{az:.3f} m/s<br> </sup>';
            figure['layout']['scene']['camera']['up']=dict(x=mdirx-0.6, y=mdiry, z=mdirz )#esto controla el giro    
         return(figure)                               #near computer (x=my, y=mz, z=-mx ) 
                            #(x=my, y=mx, z=mz )    #dict(x=mz+my, y=mx+mz, z=-mx-my)
                               #x=mx, y=my, z=mz     #dict(x=1.5+my, y=1.5+my, z=0.5+mz)
#--------------------------------------------------------------
# Clean serial port by reading, Open web browser and start dash server
#--------------------------------------------------------------
webbrowser.open_new("http://127.0.0.1:8050/")
print(serial_port.read(CONST.DATA_RX_SIZE*20))#read all it can before time out, allow us to clean the buffer
serial_port.timeout=0; #remove timeout to avoid SYNC issues
app.run_server(debug=False)
#--------------------------------------------------------------
# End of program: this point is reach when dash server is shutted down
#--------------------------------------------------------------
serial_port.close() #we close the opeened serial port top free it for other app
print('End of program: Serial port was closed')

/*
 * Copyright (c) 2017-2018, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 *  ======== rfEasyLinkEchoRx.c ========
 */
/* Standard C Libraries */
#include <stdlib.h>

/* XDCtools Header files */
#include <xdc/std.h>
#include <xdc/runtime/Assert.h>
#include <xdc/runtime/Error.h>
#include <xdc/runtime/System.h>

/* BIOS Header files */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
#include <ti/sysbios/knl/Semaphore.h>
#include <ti/sysbios/knl/Clock.h>

/* TI-RTOS Header files */
#include <ti/drivers/GPIO.h>
#include <ti/drivers/UART2.h>
/* Board Header files */
#include "ti_drivers_config.h"

/* Application Header files */
#include <ti_radio_config.h>

/* EasyLink API Header files */
#include "easylink/EasyLink.h"

/* Undefine to not use async mode */
#define RFEASYLINKECHO_ASYNC

#define RFEASYLINKECHO_TASK_STACK_SIZE    4046
#define RFEASYLINKECHO_TASK_PRIORITY      2

#define RFEASYLINKECHO_PAYLOAD_LENGTH     52

Task_Struct echoTask;    /* not static so you can see in ROV */
static Task_Params echoTaskParams;
static uint8_t echoTaskStack[RFEASYLINKECHO_TASK_STACK_SIZE];

#ifdef RFEASYLINKECHO_ASYNC
static Semaphore_Handle echoDoneSem;
#endif //RFEASYLINKECHO_ASYNC

static bool bBlockTransmit = false;
static UART2_Handle uart;
EasyLink_TxPacket txPacket = {{0}, 0, 0, {0}};
#define UART_MESSAGE_SIZE RFEASYLINKECHO_PAYLOAD_LENGTH+4
char message_to_uart[UART_MESSAGE_SIZE];//CHECKED: SAME IF ITS CHAR OR ARRAY
#ifdef RFEASYLINKECHO_ASYNC

void echoRxDoneCb(EasyLink_RxPacket * rxPacket, EasyLink_Status status)
{
    if (status == EasyLink_Status_Success)
    {
        /* Toggle RLED to indicate RX, clear GLED */
        GPIO_toggle(CONFIG_GPIO_RLED);
        GPIO_write(CONFIG_GPIO_GLED, CONFIG_GPIO_LED_OFF);
        /* Copy contents of RX packet to TX packet */
        //4 bytes to identify the first part of the package
        message_to_uart[0]=0x80;message_to_uart[1]=0x20;message_to_uart[2]=0x08;message_to_uart[3]=0x02;
        memcpy(&(message_to_uart[4]), rxPacket->payload,RFEASYLINKECHO_PAYLOAD_LENGTH);
        //UART2_write(uart, (rxPacket->payload), RFEASYLINKECHO_PAYLOAD_LENGTH, NULL);

        // UART2_write(uart, "\r\n rx:\r\n", 5, NULL);
        //copy the payload to UART
        /* Permit echo transmission */
        bBlockTransmit = false;
    }
    else
    {
        /* Set GLED and clear RLED to indicate error */
        GPIO_write(CONFIG_GPIO_GLED, CONFIG_GPIO_LED_ON);
        GPIO_write(CONFIG_GPIO_RLED, CONFIG_GPIO_LED_OFF);
        /* Block echo transmission */
        bBlockTransmit = true;
    }
    Semaphore_post(echoDoneSem);
}
#endif //RFEASYLINKECHO_ASYNC

static void rfEasyLinkEchoRxFnx(UArg arg0, UArg arg1)
{
    uint32_t absTime;
	  UART2_Params uartParams;
    /* Create a UART in CALLBACK read mode */
       UART2_Params_init(&uartParams);
       uartParams.writeMode     = UART2_Mode_BLOCKING;
       uartParams.baudRate     = 115200;
       uart = UART2_open(CONFIG_UART2_0, &uartParams);
       //
       if (uart == NULL)
       {while (1) {}} //OPEN FAILED
      UART2_write(uart, "\r\n Start task:\r\n", 10, NULL);
#ifdef RFEASYLINKECHO_ASYNC
    /* Create a semaphore for Async */
    Semaphore_Params params;
    Error_Block      eb;

    /* Init params */
    Semaphore_Params_init(&params);
    Error_init(&eb);

    /* Create semaphore instance */
    echoDoneSem = Semaphore_create(0, &params, &eb);
    if(echoDoneSem == NULL)
    {
        System_abort("Semaphore creation failed");
    }

#else
    EasyLink_RxPacket rxPacket = {{0}, 0, 0, 0, 0, {0}};
#endif //RFEASYLINKECHO_ASYNC

    // Initialize the EasyLink parameters to their default values
    EasyLink_Params easyLink_params;
    EasyLink_Params_init(&easyLink_params);

    /*
     * Initialize EasyLink with the settings found in ti_easylink_config.h
     * Modify EASYLINK_PARAM_CONFIG in ti_easylink_config.h to change the default
     * PHY
     */
    if(EasyLink_init(&easyLink_params) != EasyLink_Status_Success)
    {
        System_abort("EasyLink_init failed");
    }

    while(1) {
        // Wait to receive a packet
        //UART2_write(uart, "\r\n Wait to ress:\r\n", 15, NULL);
        EasyLink_receiveAsync(echoRxDoneCb, 0);
        //GPIO_write(CONFIG_GPIO_GLED, CONFIG_GPIO_LED_ON);
        /* Wait indefinitely for Rx */
        Semaphore_pend(echoDoneSem, BIOS_WAIT_FOREVER);
        UART2_write(uart, (message_to_uart), UART_MESSAGE_SIZE, NULL);

}
}

void echoTask_init() {

    Task_Params_init(&echoTaskParams);
    echoTaskParams.stackSize = RFEASYLINKECHO_TASK_STACK_SIZE;
    echoTaskParams.priority = RFEASYLINKECHO_TASK_PRIORITY;
    echoTaskParams.stack = &echoTaskStack;
    echoTaskParams.arg0 = (UInt)1000000;

    Task_construct(&echoTask, rfEasyLinkEchoRxFnx, &echoTaskParams, NULL);
}

/*
 *  ======== main ========
 */
int main(void)
{
	  UART2_Params uartParams;
    /* Call driver init functions. */
    Board_initGeneral();
    GPIO_init();

    GPIO_setConfig(CONFIG_GPIO_RLED, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);
    GPIO_setConfig(CONFIG_GPIO_GLED, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);

    GPIO_write(CONFIG_GPIO_RLED, CONFIG_GPIO_LED_OFF);
    GPIO_write(CONFIG_GPIO_GLED, CONFIG_GPIO_LED_OFF);

      echoTask_init();
    /* Start BIOS */
    BIOS_start();

    return (0);
}