Commit e65cb06c authored by leoXtr3m's avatar leoXtr3m
Browse files

se agrega el codigo de round robin para la captura de datos y el codigo I2C...

se agrega el codigo de round robin para la captura de datos y el codigo I2C par la comunicacion con el sensor
parent e423d750
/**********************************************************
* @file main.c
*
* Proyecto final
* Modulo Round Robin OBTENER DATOS POR UART
*
* Este modulo agrupa las funciones de manejo del timer
*
* @version 1.0
* @author Leoncio Rios, Jesus Calixto
* Version inicial
* @date 20 de Mayo 2022
*
**********************************************************/
#ifndef INCLUDE_I2C_H_
#define INCLUDE_I2C_H_
#include <msp430.h>
#include <stdint.h>
/**
* @brief Buffer de recepción i2c
*/
#define I2C_RX_BUFFER_SIZE 6
/**
* @brief Buffer de transmisión i2c
*/
#define I2C_TX_BUFFER_SIZE 6
/**
* @brief Estructura que representa datos crudos de aceleración en x,y,z
*/
struct acc_raw
{
/*! X-axis sensor data */
int16_t x;
/*! Y-axis sensor data */
int16_t y;
/*! Z-axis sensor data */
int16_t z;
};
/**
* @brief Tipo que envuelve a la estructura acc_raw
*/
typedef struct acc_raw acc_raw_t;
/**
* @brief Configura el módulo USCI_B0 para funcionar en modo I2C.
* @details Inicializa el módulo como "I2C master" con direcciones de
* 7 bits. Divide la fuente SMCLK entre 12 para generar la señal de reloj.
* SCL = ~100kHz @ 1.1MHz
*/
void initI2C();
/**
* @brief Recibe la dirección de la bandera a utilizar.
* @param uint8_t* flag: bandera a encender cuando haya una cadena de
* caracteres lista en el buffer de recepción.
*
*/
void setI2Cflag(uint8_t* flag);
/**
* @brief Envía un arreglo de bytes a la dirección del registro del esclavo
* objetivo.
* @param uint8_t slave_address: dirección del esclavo.
* @param uint8_t reg: dirección del registro a escribir.
* @param uint8_t* msg: dirección del mensaje a enviar.
* @param uint8_t msg_size: cantidad de bytes a enviar.
*/
void sendI2C(uint8_t slave_address, uint8_t reg, uint8_t *msg, uint8_t msg_size);
/**
* @brief Recibe un arreglo de bytes desde el registro del esclavo
* objetivo e indica el fin de la recepción a través de una bandera.
* @param uint8_t slave_address: dirección del esclavo.
* @param uint8_t reg: dirección del registro a leer.
* @param uint8_t* msg: dirección donde guardar el mensaje recibido.
* @param uint8_t msg_size: cantidad de bytes a recibir.
*/
void readI2C(uint8_t slave_address, uint8_t reg, uint8_t* msg, uint8_t msg_size);
/**
* @brief Traduce los bytes recibidos a un vector de aceleraciones en enteros
* @param uint8_t* msg: mensaje recibido del BMI160
* @param acc_raw_t* accel: vector de datos crudos donde se guarda el resultado
*/
void asignarAccel(uint8_t* msg, acc_raw_t* accel);
#endif /* INCLUDE_I2C_H_ */
/**********************************************************
* @file main.c
*
* Proyecto final
* Modulo Round Robin OBTENER DATOS POR UART
*
* Este modulo agrupa las funciones de manejo del timer
*
* @version 1.0
* @author Leoncio Rios, Jesus Calixto
* Version inicial
* @date 20 de Mayo 2022
*
**********************************************************/
#ifndef INCLUDE_IMU_H_
#define INCLUDE_IMU_H_
#include <msp430.h>
#include <stdint.h>
#include "i2c.h"
/**
* @brief Dirección del registro de comandos del BMI160
*/
#define CMD_REG 0x7E
/**
* @brief Dirección del registro de configuración del BMI160
*/
#define ACC_CONF_REG 0x40
/**
* @brief Dirección del registro de seteo de rangos del BMI160
*/
#define ACC_RANGE_REG 0x41
/**
* @brief Dirección del registro de salida del acelerómetro del BMI160
*/
#define ACC_DATA_REG 0x12
/**
* @brief Dirección del registro de estado del BMI160
*/
#define PMU_STATUS_REG 0x03
/**
* @brief Valor para definir modo normal de funcionamiento del acelerómetro en el BMI160
*/
#define NORMAL_MODE_VALUE 0x11
/**
* @brief Valor para configurar adquisicion a 50Hz en el acelerómetro del BMI160
*/
#define ACC_CONF_VALUE 0x27 //(00100111b)
/**
* @brief Valor para definir un rango de 8g del acelerómetro en el BMI160
*/
#define ACC_RANGE_VALUE 0x08 //(00001000b)
/**
* @brief Dirección i2c esclavo del BMI160
*/
#define ACCEL_ADDRESS 0x69
/**
* @brief Configura el sensor BMI160 según los parámetros definidos en el módulo y comienza la adquisición de datos.
*
*/
void initIMU();
#endif /* INCLUDE_IMU_H_ */
/**********************************************************
* @file main.c
*
* Proyecto final
* Modulo Round Robin OBTENER DATOS POR UART
*
* Este modulo agrupa las funciones de manejo del timer
*
* @version 1.0
* @author Leoncio Rios, Jesus Calixto
* Version inicial
* @date 20 de Mayo 2022
*
**********************************************************/
#ifndef INCLUDE_TIMER_HW_H_
#define INCLUDE_TIMER_HW_H_
//Rutina de inicializacion del timer hardware usando el crystal
void config_timer_crystal(void);
//Rutina de inicializacion del timer hardware usando el VLO
void config_timer_VLO(void);
//Rutina de inicializacion del timer A
void vInitTimerA(void);
void setFlagTimer(unsigned int* flag_timer, int* tiks_new);
#endif /* INCLUDE_TIMER_HW_H_ */
/**********************************************************
* @file main.c
*
* Proyecto final
* Modulo Round Robin OBTENER DATOS POR UART
*
* Este modulo agrupa las funciones de manejo del timer
*
* @version 1.0
* @author Leoncio Rios, Jesus Calixto
* Version inicial
* @date 20 de Mayo 2022
*
**********************************************************/
#ifndef INCLUDE_UART_H_
#define INCLUDE_UART_H_
//#include<stdint.h>
#define BUFF 21 // tamaño de los buffers
static char buffer_TX[BUFF]; // se les pasa el tamaño a todos por igual
static char buffer_RX[BUFF];
static char buffer_ext[BUFF];
static char buffer_temp[BUFF];
/**
* @brief funcion que inicializa UART
*/
void uart_init(unsigned int* pt_fin);
/**
* @brief funcion que para transmitir. Copia en el buffer de transmicion el mensaje a enviar y habilita interrupcion de registro vacio.
* @param char* mensaje: puntero a el mensaje a transmitir.
*
*/
void transmitir_TX(char* mensaje);
/**
* @brief funcion que copia el buffer de recepcion a buffer externo.
* @param char* buff_ext: puntero al buffer externo.
*/
void copiar_ext(char* buff_ext);
////////////////////////////////////////////////////////
/**
* @brief funcion que añade temperatura y la hora actual al buffer temp
* @param int* temp: puntero con la temperatura actual.
* @param int* horas: puntero con la hora actual.
* @param int* minutos: puntero con la minutos actuales.
* @param int* segundos: puntero con la segundos actuales.
*
*/
void add_XYZ(int* accelX,int* accelY,int* accelZ);
/**
* @brief funcion que copia el buffer de temperatura
* @param char* buff_temp: puntero al buffer temperatura.
*/
void copiar_temp(char* buff_temp); //Copia la temperatura al buffer
/**
* @brief funcion que evalua los parametros que entran por consola a la UART
* @param int* tiksXX: puntero de salida de los tiks ingresados en WP XX.
* @param int* tiks_actual: puntero de entrada de los tiks actuales .
* @param int* temp_actual: puntero de entrada de la temeperatura actual.
*/
#endif /* INCLUDE_UART_H_ */
/**********************************************************
* @file main.c
*
* Proyecto final
* Modulo Round Robin OBTENER DATOS POR UART
*
* Este modulo agrupa las funciones de manejo del timer
*
* @version 1.0
* @author Leoncio Rios, Jesus Calixto
* Version inicial
* @date 20 de Mayo 2022
*
**********************************************************/
#ifndef UTILS_H_INCLUDED
#define UTILS_H_INCLUDED
//#include "timer.h"
/**
* Convierte un entero a ASCII
* @param int value: valor entero a covertir
* @param char* str: puntero a char donde guardar el resultado
*/
void itoa(int value, char* str);
/**
* Convierte un entero de 1 o dos digitos en dos ASCII - 00 01 02 03 10 11 12
*/
void intTOchar(int value, char* str1, char* str2, char* str3, char* str4, char* str5);
#endif // UTILS_H_INCLUDED
/**********************************************************
* @file main.c
*
* Proyecto final
* Modulo Round Robin OBTENER DATOS POR UART
*
* Este modulo agrupa las funciones de manejo del timer
*
* @version 1.0
* @author Leoncio Rios, Jesus Calixto
* Version inicial
* @date 20 de Mayo 2022
*
**********************************************************/
#include <i2c.h>
#include <msp430.h>
#include <stdint.h>
static uint8_t* flagI2C;
void setI2Cflag(uint8_t* flag) {
flagI2C = flag;
}
void initI2C(){
UCB0CTL1 |= UCSWRST; // Se habilita el reset de software pag. 430 Familia
UCB0CTL1 |= UCSSEL_2; // Se se lecciona el reloj SMCLK
UCB0CTL0 &= ~UCSLA10; // Direccion de esclavo con 7 bits de direccion
UCB0CTL0 = UCMST + UCMODE_3 + UCSYNC; // I2C Master, Modo de I2C, Modo sincrono pag. 468 familia
UCB0BR0 = 12; // fSCL = SMCLK/12 = ~100kHz
UCB0BR1 = 0;
P1SEL |= BIT6 + BIT7; // Asigna los pines del I2C a USCI_B0, P1.7 = SDA
P1SEL2|= BIT6 + BIT7; // Asigna los pines del I2C a USCI_B0, P1.6 = SCL
UCB0CTL1 &= ~UCSWRST; // Restablecimiento de USCI liberado para la operacin.
IE2 &= ~(UCB0RXIE + UCB0TXIE); // Se desactivan las interrupciones RX y TX
}
void sendI2C(uint8_t slave_address, uint8_t reg, uint8_t *msg, uint8_t msg_size){
UCB0I2CSA = slave_address;
/*
* Send at most I2C_TX_BUFFER_SIZE
* */
int j, tope;
if (msg_size < (I2C_TX_BUFFER_SIZE - 1) ){
tope = msg_size;
}
else {
tope = I2C_TX_BUFFER_SIZE - 1;
}
while (UCB0CTL1 & UCTXSTP); // Ensure previous stop condition got sent
UCB0CTL1 &= ~UCB0TXIFG; // Clear TX interrupt flag
UCB0CTL1 |= UCTR + UCTXSTT; // I2C TX, start condition
// while (UCB0CTL1 & UCTXSTT); // Wait for start condition to be sent
while (!(IFG2 & UCB0TXIFG)); // Wait for previous byte to be loaded into shift register
UCB0TXBUF = reg; // Send slave register address
for (j=0; j < tope; j++){ // Send Message
while (!(IFG2 & UCB0TXIFG)); // Wait for previous byte to be loaded into shift register
UCB0TXBUF = msg[j];
}
while (!(IFG2 & UCB0TXIFG)); // Wait for previous byte to be loaded into shift register
IFG2 &= ~UCB0TXIFG; // Turn off TX Interrupt Flag
UCB0CTL1 |= UCTXSTP; // Generate stop condition
while (UCB0CTL1 & UCTXSTP); // Wait for stop condition to be sent
}
void readI2C(uint8_t slave_address, uint8_t reg, uint8_t* msg, uint8_t msg_size){
UCB0I2CSA = slave_address;
while (UCB0CTL1 & UCTXSTP); // Ensure previous stop condition got sent
UCB0CTL1 |= UCTR + UCTXSTT; // I2C TX, start condition
while (!(IFG2 & UCB0TXIFG)); // Wait for slave address to be loaded into shift register
UCB0TXBUF = reg; // Send slave register address
while (!(IFG2 & UCB0TXIFG)); // Wait for previous byte to be loaded into shift register
IFG2 &= ~UCB0TXIFG; // Turn off TX Interrupt Flag
IFG2 &= ~UCB0RXIFG; // Clear RX Interrupt Flag
UCB0CTL1 &= ~UCTR; // Receiver mode
UCB0CTL1 |= UCTXSTT; // Generate restart condition
while (UCB0CTL1 & UCTXSTT); // Wait for restart condition to be sent
int j;
for (j = 0; j < msg_size; j++) {
if ( (msg_size - j) == 1) {
UCB0CTL1 |= UCTXSTP;
}
while (!(IFG2 & UCB0RXIFG)); // Wait for new byte
msg[j] = UCB0RXBUF;
}
while (UCB0CTL1 & UCTXSTP); // wait for stop condition to be sent
*flagI2C = 1;
}
///PROCESAMIENTO
void asignarAccel(uint8_t* msg, acc_raw_t* accel){
uint8_t idx = 0;
uint8_t lsb;
uint8_t msb;
int16_t msblsb;
lsb = msg[idx++];
msb = msg[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
if (msblsb < 0) msblsb = - msblsb;
accel->x = msblsb;
lsb = msg[idx++];
msb = msg[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
if (msblsb < 0) msblsb = - msblsb;
accel->y = msblsb;
lsb = msg[idx++];
msb = msg[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
if (msblsb < 0) msblsb = - msblsb;
accel->z = msblsb;
}
/**********************************************************
* @file main.c
*
* Proyecto final
* Modulo Round Robin OBTENER DATOS POR UART
*
* Este modulo agrupa las funciones de manejo del timer
*
* @version 1.0
* @author Leoncio Rios, Jesus Calixto
* Version inicial
* @date 20 de Mayo 2022
*
**********************************************************/
#include <i2c.h>
#include <msp430.h>
#include <stdint.h>
#include "imu.h"
void initIMU(){
while ( UCB0STAT & UCBBUSY ); // espero a que el bus este libre
uint8_t msg = 0xB6; // Soft reset
sendI2C(ACCEL_ADDRESS, CMD_REG, &msg, 1);
__delay_cycles(5000);
msg = NORMAL_MODE_VALUE; // Pasar acelerometro a normal mode (low-power es 0x12)
sendI2C(ACCEL_ADDRESS, CMD_REG, &msg, 1);
__delay_cycles(5000);
msg = ACC_CONF_VALUE; // Setear frecuencia
sendI2C(ACCEL_ADDRESS, ACC_CONF_REG, &msg, 1);
__delay_cycles(5000);
msg = ACC_RANGE_VALUE; // Setear rango
sendI2C(ACCEL_ADDRESS, ACC_RANGE_REG, &msg, 1);
__delay_cycles(5000);
}
/**********************************************************
* @file main.c
*
* Proyecto final
* Modulo Round Robin OBTENER DATOS POR UART
*
* Este modulo agrupa las funciones de manejo del timer
*
* @version 1.0
* @author Leoncio Rios, Jesus Calixto
* Version inicial
* @date 20 de Mayo 2022
*
**********************************************************/
#include <stdint.h>
#include <msp430.h>
#include <timer_hw.h>
unsigned int tiks;
unsigned int numm;
unsigned int contTimer;
unsigned int* Tflag;
unsigned int SEL_tiks;
void vInitTimerA(void)
{
// Configuracion Pag. 355 de la familia
//inicializacion pag. 358 de la familia
TACCR0 = 0; //Inicialmente parar el timer
TACCTL0 |= CCIE; //Habilitar la interrupcion para CCR0. -Pag.372 de la familia
TACTL = TASSEL_1 + ID_0 + MC_1; //Selecciono ACLK, divisor 1, y Modo UP (timer)
TACCR0 = tiks; /// Valor a cargar en TACCR0, segun el oscilador seleccionado, para dar interrupcion cada 250ms.
}
void setFlagTimer(unsigned int* flag_timer, int * tiks_new){
/*Set flag*/
Tflag = flag_timer; /// variable de seteo de tiks
SEL_tiks = tiks_new; /// variable para modificar los tiks
contTimer=0;
}
//Timer ISR
#pragma vector = TIMER0_A0_VECTOR
__interrupt void vTimerAInterrupt(void)
{
//inc_time(250);
numm++;
contTimer++;
*Tflag = 1;
//if(contTimer >= SEL_tiks){
// *Tflag = 1;
// contTimer = 0;
// LPM3_EXIT;
//}
// Conmuto el led
P1OUT ^= BIT0;
} //Timer ISR
//Rutina de inicializacion del timer hardware usando el cristal como fuente de reloj.
void config_timer_crystal(void)
{
// slau144j.pdf, p280
//The LFXT1 oscillator supports ultra-low current consumption using a 32768-Hz watch crystal in LF mode (XTS = 0)
// XTS = 0
BCSCTL1 &= ~(XTS);