// -----------------------------------------------------------------------------
//! \brief This routine initializes the transport layer and opens the port
//! of the device.
//!
//! \param[in] tRxBuf - pointer to NPI TL Tx Buffer
//! \param[in] tTxBuf - pointer to NPI TL Rx Buffer
//! \param[in] npiCBack - NPI TL call back function to be invoked at the end of
//! a UART transaction
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITLUART_initializeTransport(Char *tRxBuf, Char *tTxBuf, npiCB_t npiCBack)
{
UART_Params params;
TransportRxBuf = tRxBuf;
TransportTxBuf = tTxBuf;
npiTransmitCB = npiCBack;
// Configure UART parameters.
UART_Params_init(¶ms);
params.baudRate = NPI_UART_BR;
params.readDataMode = UART_DATA_BINARY;
params.writeDataMode = UART_DATA_BINARY;
params.dataLength = UART_LEN_8;
params.stopBits = UART_STOP_ONE;
params.readMode = UART_MODE_CALLBACK;
params.writeMode = UART_MODE_CALLBACK;
params.readEcho = UART_ECHO_OFF;
params.readCallback = NPITLUART_readCallBack;
params.writeCallback = NPITLUART_writeCallBack;
// Open / power on the UART.
uartHandle = UART_open(Board_UART, ¶ms);
//Enable Partial Reads on all subsequent UART_read()
UART_control(uartHandle, UARTCC26XX_CMD_RETURN_PARTIAL_ENABLE, NULL);
#ifndef POWER_SAVING
// This call will start repeated Uart Reads when Power Savings is disabled
NPITLUART_readTransport();
#endif //!POWER_SAVING
return;
}
Void Task_UART(UArg arg0, UArg arg1)
{
UART_Handle uart;
UART_Params uartParams;
const char echoPrompt[] = "\fEchoing characters:\r\n";
char input;
UART_Params_init(&uartParams);
uartParams.writeMode = UART_MODE_BLOCKING;
uartParams.readMode = UART_MODE_BLOCKING;
uartParams.writeDataMode = UART_DATA_BINARY;
uartParams.readDataMode = UART_DATA_BINARY;
uartParams.readReturnMode = UART_RETURN_FULL;
uartParams.readEcho = UART_ECHO_OFF;
uartParams.baudRate = 115200;
uartParams.parityType = UART_PAR_NONE;
uartParams.dataLength = UART_LEN_8;
uartParams.stopBits = UART_STOP_ONE;
uart = UART_open(Board_UART0, &uartParams);
if (uart == NULL) {
System_abort("Error opening the UART");
}
System_printf("\nTask_UART");
UART_write(uart, echoPrompt, sizeof(echoPrompt));
// Loop forever echoing
while (1) {
UART_read(uart, &input, 1);
input++;
UART_write(uart, &input, 1);
}
}
/*********************************************************************
* @fn rpcTransportOpen
*
* @brief opens the serial port to the CC253x.
*
* @param devicePath - path to the UART device
*
* @return status
*/
int32_t rpcTransportOpen(char *_devicePath, uint32_t port)
{
UART_Params uartParams;
int32_t ret = -1;
if (uart == NULL)
{
/* Create a UART with data processing off. */
UART_Params_init(&uartParams);
uartParams.readMode = UART_MODE_BLOCKING;
uartParams.writeMode = UART_MODE_BLOCKING;
uartParams.readTimeout = BIOS_WAIT_FOREVER;
uartParams.writeTimeout = BIOS_WAIT_FOREVER;
uartParams.readCallback = NULL;
uartParams.writeCallback = NULL;
uartParams.readReturnMode = UART_RETURN_FULL;
uartParams.writeDataMode = UART_DATA_BINARY;
uartParams.readDataMode = UART_DATA_BINARY;
uartParams.readEcho = UART_ECHO_OFF;
uartParams.baudRate = 115200;
uartParams.dataLength = UART_LEN_8;
uartParams.stopBits = UART_STOP_ONE;
uartParams.parityType = UART_PAR_NONE;
// init UART driver
uart = UART_open(EK_TM4C1294XL_UART4, &uartParams);
if (uart != NULL)
{
// return success
ret = 0;
}
}
return ret;
}
// -----------------------------------------------------------------------------
//! \brief This routine initializes the transport layer and opens the port
//! of the device.
//!
//! \param[in] tRxBuf - pointer to SDI TL Tx Buffer
//! \param[in] tTxBuf - pointer to SDI TL Rx Buffer
//! \param[in] sdiCBack - SDI TL call back function to be invoked at the end of
//! a UART transaction
//!
//! \return void
// -----------------------------------------------------------------------------
void SDITLUART_initializeTransport(Char *tRxBuf, Char *tTxBuf, sdiCB_t sdiCBack)
{
// Set UART transport callbacks
TransportRxBuf = tRxBuf;
TransportTxBuf = tTxBuf;
sdiTransmitCB = sdiCBack;
// Configure UART parameters.
UART_Params_init(¶msUART);
paramsUART.baudRate = SDI_UART_BR;
paramsUART.readDataMode = UART_DATA_BINARY;
paramsUART.writeDataMode = UART_DATA_BINARY;
paramsUART.dataLength = UART_LEN_8;
paramsUART.stopBits = UART_STOP_ONE;
paramsUART.readMode = UART_MODE_CALLBACK;
paramsUART.writeMode = UART_MODE_CALLBACK;
paramsUART.readEcho = UART_ECHO_OFF;
paramsUART.readCallback = SDITLUART_readCallBack;
paramsUART.writeCallback = SDITLUART_writeCallBack;
//paramsUART.readReturnMode = UART_RETURN_FULL;
// Open / power on the UART.
uartHandle = UART_open(Board_UART, ¶msUART);
if(uartHandle != NULL)
{
//DEBUG("ERROR in UART_open");
}
//Enable Partial Reads on all subsequent UART_read()
UART_control(uartHandle, UARTCC26XX_RETURN_PARTIAL_ENABLE, NULL);
return;
}
void cmdTerp() {
UART_Handle uart;
UART_Params uartParams;
UART_Params_init(&uartParams);
uartParams.writeDataMode = UART_DATA_BINARY;
uartParams.readDataMode = UART_DATA_BINARY;
uartParams.readReturnMode = UART_RETURN_FULL;
uartParams.readEcho = UART_ECHO_OFF;
uartParams.baudRate = 9600;
uart = UART_open(Board_UART1, &uartParams);
globalUART = &uart;
if (uart == NULL) {
System_abort("Error opening the UART");
}
char input[2];
uint8_t duty;
while(1) {
UART_write(uart,">",1);
UART_read(uart,input,1);
UART_write(uart,input,1);
cmdExecute(input,duty);
}
}
/*
* ======== echoFxn ========
* Task for this function is created statically. See the project's .cfg file.
*/
Void echoFxn(UArg arg0, UArg arg1)
{
char input;
UART_Handle uart;
UART_Params uartParams;
const char echoPrompt[] = "\fEchoing characters:\r\n";
/* Create a UART with data processing off. */
UART_Params_init(&uartParams);
uartParams.writeDataMode = UART_DATA_BINARY;
uartParams.readDataMode = UART_DATA_BINARY;
uartParams.readReturnMode = UART_RETURN_FULL;
uartParams.readEcho = UART_ECHO_OFF;
uartParams.baudRate = 9600;
uart = UART_open(Board_UART0, &uartParams);
if (uart == NULL) {
System_abort("Error opening the UART");
}
UART_write(uart, echoPrompt, sizeof(echoPrompt));
/* Loop forever echoing */
while (1) {
UART_read(uart, &input, 1);
UART_write(uart, &input, 1);
}
}
/**
* @fn SBL_TL_open
*
* @brief Open device port for communication with the target device. Currently
* only supports UART
*
* @param pType - SBL_DEV_INTERFACE_[UART,SPI]
* @param pID - local serial interface ID (i.e. CC2650_UART0)
*
* @return uint8_t - SBL_SUCCESS, SBL_FAILURE
*/
uint8_t SBL_TL_open(uint8_t pType, uint8_t pID)
{
UART_Params params;
// Currently only support over UART
if (pType == SBL_DEV_INTERFACE_UART)
{
// Configure UART parameters.
// No parity bit, One stop bit set by default
UART_Params_init(¶ms);
params.baudRate = SBL_UART_BR;
params.readDataMode = UART_DATA_BINARY;
params.writeDataMode = UART_DATA_BINARY;
params.readEcho = UART_ECHO_OFF;
// Open UART port for sending SBL commands
sblUartHandle = UART_open(pID, ¶ms);
if (sblUartHandle == NULL)
{
return SBL_FAILURE;
}
// Work around for UART driver re-open bug. Sometimes there is a mystery byte already
// read prior to sending any commands to the target device
UARTCharGetNonBlocking(((UARTCC26XX_HWAttrsV1 const *)(sblUartHandle->hwAttrs))->baseAddr);
return SBL_SUCCESS;
}
return SBL_FAILURE;
}
/*********************************************************************
* @fn Board_openLCD
*
* @brief Open the UART port and initialize Log callback plugin.
*
* @param none
*
* @return void
*/
void Board_openLCD(void)
{
UART_Params uartParams;
UART_Params_init(&uartParams);
uartParams.baudRate = 115200;
UART_Handle hUart = UART_open(Board_UART, &uartParams);
UartLog_init(hUart);
}
int8_t BtStack_push(const BtStack_Frame* frame)
{
// special character declarations
const char escapedEnd[] = {SLIP_ESC, SLIP_ESC_END}; // escaped 0xC0
const char escapedEsc[] = {SLIP_ESC, SLIP_ESC_ESC}; // escaped 0xDB
char sendStream[KFP_WORST_SIZE];
uint8_t sentChar = 0;
// append start character
sendStream[0] = SLIP_END;
sentChar++;
// iterate through frame adding ESC characters where necessary
uint8_t i;
for (i=0; i<KFP_FRAME_SIZE-2; i++)
{
switch(frame->b8[i])
{
case(SLIP_END):
// escape END character
strncat(sendStream, escapedEnd, 2);
sentChar+=2;
break;
case(SLIP_ESC):
// escape ESC character
strncat(sendStream, escapedEsc, 2);
sentChar+=2;
break;
default:
sendStream[sentChar] = frame->b8[i];
sentChar++;
}
}
// append end character
sendStream[sentChar] = SLIP_END;
sentChar++;
// prepare UART socket
UART_Handle s;
UART_Params params;
UART_Params_init(¶ms);
params.baudRate = uartBaud;
params.writeMode = UART_MODE_BLOCKING;
params.writeDataMode = UART_DATA_BINARY;
params.readDataMode = UART_DATA_BINARY;
params.readReturnMode = UART_RETURN_FULL;
params.readEcho = UART_ECHO_OFF;
s = UART_open(Board_BT1, ¶ms);
// write to socket and close once complete
int8_t ret = UART_write(s, sendStream, sentChar);
UART_close(s);
return ret;
}
/*******************************************************************************
* @fn Main
*
* @brief Application Main
*
* input parameters
*
* @param None.
*
* output parameters
*
* @param None.
*
* @return None.
*/
int main()
{
#ifdef CACHE_AS_RAM
// Invalidate cache
VIMSModeSet( VIMS_BASE, VIMS_MODE_DISABLED );
// Wait for disabling to be complete
while ( VIMSModeGet( VIMS_BASE ) != VIMS_MODE_DISABLED );
// retain cache during standby
Power_setConstraint(PowerCC26XX_SB_VIMS_CACHE_RETAIN);
#endif
RegisterAssertCback(AssertHandler);
PIN_init(BoardGpioInitTable);
#ifndef POWER_SAVING
/* Set constraints for Standby, powerdown and idle mode */
Power_setConstraint(PowerCC26XX_SB_DISALLOW);
Power_setConstraint(PowerCC26XX_IDLE_PD_DISALLOW);
#endif //POWER_SAVING
#ifdef PRINTF_ENABLED
// Enable System_printf(..) UART output
UART_Params uartParams;
UART_Params_init(&uartParams);
uartParams.baudRate = 1000000;
UartPrintf_init(UART_open(Board_UART, &uartParams));
System_printf("Printf enabled\r\n");
#endif
/* Initialize ICall module */
ICall_init();
/* Start tasks of external images - Priority 5 */
ICall_createRemoteTasks();
/* Kick off profile - Priority 3 */
GAPRole_createTask();
Keys_createTask();
/* Kick off application - Priority 1 */
SimpleTopology_createTask();
/* enable interrupts and start SYS/BIOS */
BIOS_start();
return 0;
}
/*
* ======== main ========
*/
int main()
{
PIN_init(BoardGpioInitTable);
#ifndef POWER_SAVING
/* Set constraints for Standby, powerdown and idle mode */
Power_setConstraint(Power_SB_DISALLOW);
Power_setConstraint(Power_IDLE_PD_DISALLOW);
#endif // POWER_SAVING
/* Initialize ICall module */
ICall_init();
/* Start tasks of external images - Priority 5 */
ICall_createRemoteTasks();
#ifdef PRINTF_ENABLED
// Enable System_printf(..) UART output
UART_Params uartParams;
UART_Params_init(&uartParams);
uartParams.baudRate = 921600;
UartPrintf_init(UART_open(Board_UART, &uartParams));
#endif
/* Kick off profile - Priority 3 */
GAPRole_createTask();
SimpleBLEPeripheral_createTask();
#ifdef FEATURE_OAD
{
uint8_t counter;
uint32_t *vectorTable = (uint32_t*) 0x20000000;
#if defined(__IAR_SYSTEMS_ICC__)
uint32_t *flashVectors = &__vector_table;
#elif defined(__TI_COMPILER_VERSION__)
uint32_t *flashVectors = &ti_sysbios_family_arm_m3_Hwi_resetVectors;
#endif //Compiler.
// Write image specific interrupt vectors into RAM vector table.
for(counter = 0; counter < 15; ++counter)
{
*vectorTable++ = *flashVectors++;
}
}
#endif //FEATURE_OAD
/* enable interrupts and start SYS/BIOS */
BIOS_start();
return 0;
}
/**
* usage: this method does the work, checkes the queue, writes to the UART and post's
* the Event
* @method uart_method
* @author: patrik.szabo
* @param arg0 - not used param for the task
* @return *none*
*/
void uart_method(UArg arg0) {
// char input;
UART_Handle uart;
UART_Params uartParams;
/* Create a UART with data processing off. */
UART_Params_init(&uartParams);
uartParams.writeDataMode = UART_DATA_BINARY;
uartParams.readDataMode = UART_DATA_BINARY;
uartParams.readReturnMode = UART_RETURN_FULL;
uartParams.readEcho = UART_ECHO_OFF;
uartParams.baudRate = 9600;
uart = UART_open(Board_UART0, &uartParams);
if (uart == NULL) {
System_abort("Error opening the UART");
}
QueueObject* queueObjectPointer;
char altData[22] = "";
char pressData[16] = "";
char tempData[18] = "";
while (1) {
while (!Queue_empty(uartQueue)) {
queueObjectPointer = Queue_dequeue(uartQueue);
sprintf(altData, "Altitude: %d | ",
(int) queueObjectPointer->myInformationPointer->alt);
System_printf("%s", altData);
UART_write(uart, altData, sizeof(altData));
sprintf(pressData, "Pressure: %d | ",
queueObjectPointer->myInformationPointer->press);
System_printf("%s", pressData);
UART_write(uart, pressData, sizeof(pressData));
sprintf(tempData, "Temparature: %d\n\r",
queueObjectPointer->myInformationPointer->temp);
System_printf("%s", tempData);
UART_write(uart, tempData, sizeof(tempData));
Event_post(uartReadyEvent, Event_Id_02);
}
Task_sleep(500);
}
}
int rs485_init()
{
UART_Params_init(&uartParams);
uartParams.writeDataMode = UART_DATA_BINARY ;
uartParams.readDataMode = UART_DATA_BINARY ;
uartParams.readReturnMode = UART_RETURN_FULL;
uartParams.readEcho = UART_ECHO_OFF;
uartParams.baudRate = rs485_baudRate;
uartParams.readTimeout = rs485_timeout;
uart2 = UART_open(Board_UART2, &uartParams);
if (uart2 == NULL ) {
System_abort("Error opening the UART2");
return 1;
}
return 0;
}
/*!
* @brief Opens the UART console
*
* @param binary Open the UART in binary mode
* @return UART_Handle to the opened UART
*/
UART_Handle UARTConsole_open(bool binary)
{
UART_Params uartParams;
/* Create a UART with the parameters below. */
UART_Params_init(&uartParams);
if (binary == true)
{
uartParams.readEcho = UART_ECHO_OFF;
uartParams.writeDataMode = UART_DATA_BINARY;
}
else
{
uartParams.baudRate = 115200;
}
handle = UART_open(Board_UART0, &uartParams);
return (handle);
}
/*
* ======== openHandle ========
* The UART driver will return NULL if there was an error creating a UART
*
* @param index Index into the ports array of UARTPorts
* @param binary Open the UART in binary mode
* @return UART_Handle to the opened UART
*/
static UART_Handle openHandle(Int index, Bool binary)
{
UART_Params uartParams;
/* Only UART 0 is supported in this example. */
if (index >= NUM_PORTS) {
System_printf("UART index %d not supported, valid range is 0-%d", index, (NUM_PORTS - 1));
return (NULL);
}
/* The UART driver only allows creating once, return if its already open. */
if (ports[index].open) {
/* Make sure the index is not already opened in the wrong mode */
if (binary != ports[index].binary) {
return (NULL);
}
ports[index].open++;
return (ports[index].handle);
}
/* Create a UART with the parameters below. */
UART_Params_init(&uartParams);
if (binary == TRUE) {
uartParams.readEcho = UART_ECHO_OFF;
uartParams.writeDataMode = UART_DATA_BINARY;
ports[index].binary = TRUE;
}
else {
ports[index].binary = FALSE;
uartParams.baudRate = 115200;
}
ports[index].handle = UART_open(ports[index].base, &uartParams);
if (ports[index].handle != NULL) {
ports[index].open = 1;
}
return (ports[index].handle);
}
static void cli_uart_init(UART_SerialDevice *dev) {
static UART_Params uartParams;
if(uart == NULL)
{
/* Create a UART with data processing off. */
UART_Params_init(&uartParams);
uartParams.writeDataMode = UART_DATA_BINARY;
uartParams.readDataMode = UART_DATA_BINARY;
uartParams.readReturnMode = UART_RETURN_FULL;
uartParams.writeMode = UART_MODE_BLOCKING;
uartParams.readEcho = UART_ECHO_OFF;
uartParams.baudRate = 57600;
uart = UART_open(CLI_UART, &uartParams);
if (uart == NULL) {
System_abort("Error opening the UART");
}
dev->fntab = &UART_SerialDevice_fntab;
dev->uart = uart;
}
}
int sim800_open(){
UART_Params_init(&uartParams);
uartParams.writeDataMode = UART_DATA_BINARY;
uartParams.readDataMode = UART_DATA_BINARY;
uartParams.readReturnMode = UART_RETURN_FULL;
uartParams.readTimeout = SIM800_READ_TIMEOUT;
uartParams.readEcho = UART_ECHO_OFF;
uartParams.baudRate = SIM800_BAUD_RATE;
uart = UART_open(Board_UART2_COMM, &uartParams);
if (uart == NULL) {
//debug
GPIO_toggle(Board_LED_GREEN);
Task_sleep(300);
GPIO_toggle(Board_LED_GREEN);
return 0;
}else{
return 1;
}
}
//taskFxn
void taskFxn(UArg a0, UArg a1) {
Hwi_Params hwiParams;
Hwi_Params_init(&hwiParams);
hwiParams.enableInt = true;
Hwi_construct(&hwi, INT_AUX_ADC, adcIsr, &hwiParams, NULL);
UART_Params uParams;
// Initialize default values
UART_Params_init(&uParams);
// Configure custom data, don't care about read params as not used
// 115.2kBaud, Text, blocking mode
uHandle = UART_open(Board_UART,&uParams);
// Set up pins
pinHandle = PIN_open(&pinState, alsPins);
// Enable clock for ADC digital and analog interface (not currently enabled in driver)
AUXWUCClockEnable(AUX_WUC_MODCLKEN0_SOC_M|AUX_WUC_MODCLKEN0_AUX_ADI4_M);
// Connect AUX IO7 (DIO23) as analog input. Light sensor on SmartRF06EB
AUXADCSelectInput(ADC_COMPB_IN_AUXIO7);
// Set up ADC
AUXADCEnableSync(AUXADC_REF_FIXED, AUXADC_SAMPLE_TIME_2P7_US, AUXADC_TRIGGER_MANUAL);
// Disallow STANDBY mode while using the ADC.
Power_setConstraint(Power_SB_DISALLOW);
while(1) {
//Sleep 100ms in IDLE mode
//Task_sleep(100 * 1000 / Clock_tickPeriod);
// Trigger ADC sampling
AUXADCGenManualTrigger();
// Wait in IDLE until done
Semaphore_pend(hSem, BIOS_WAIT_FOREVER );
//System_printf("ADC: %d\r\n", singleSample);
//printf ("ADC: %d\r\n");
//printf ("ADC\r\n");
}
/*
// Disable ADC
AUXADCDisable();
// Allow STANDBY mode again
Power_releaseConstraint(Power_SB_DISALLOW);
// Restore pins to values in BoardGpioTable
PIN_close(pinHandle);
// Log data through UART
UART_write(uHandle, &adcSamples[1], SAMPLESIZE);
// Goto STANDBY forever
Task_sleep(BIOS_WAIT_FOREVER);
*/
}
void rxFxn(UArg param0, UArg param1)
{
// Declare state variables
Bool inFrame = FALSE;
uint8_t frIndex = 0;
// Buffers
char tempRx[1];
BtStack_Frame tempFr;
while(TRUE)
{
// open socket
UART_Handle s;
UART_Params params;
UART_Params_init(¶ms);
params.baudRate = uartBaud;
params.writeDataMode = UART_DATA_BINARY;
params.readMode = UART_MODE_BLOCKING;
params.readDataMode = UART_DATA_BINARY;
params.readReturnMode = UART_RETURN_FULL;
params.readEcho = UART_ECHO_OFF;
s = UART_open(Board_BT1, ¶ms);
// read UART buffer and decode
UART_read(s, tempRx, 1);
switch(tempRx[0])
{
case(SLIP_END):
if (inFrame)
{
if (frIndex == (KFP_FRAME_SIZE-2))
{
// end of frame, call callback to interpret it
if (rxCallback != NULL)
{
rxCallback(&tempFr);
}
}
// ignore corrupt frames
frIndex = 0;
inFrame = FALSE;
break;
}
else
{
inFrame = TRUE; // start new frame
frIndex = 0;
break;
}
case(SLIP_ESC):
if (inFrame)
{
UART_read(s, tempRx, 1);
switch(tempRx[0])
{
case(SLIP_ESC_END):
tempFr.b8[frIndex] = SLIP_END;
frIndex++;
break;
case(SLIP_ESC_ESC):
tempFr.b8[frIndex] = SLIP_ESC;
frIndex++;
break;
default:
break; // invalid post ESC character
}
break;
}
else
{
break; // ignore corrupt frames
}
default:
if (inFrame)
{
// standard character store
tempFr.b8[frIndex] = tempRx[0];
frIndex++;
break;
}
}
}
}
Void uartFxn(UArg arg0, UArg arg1)
{
int8_t input[] = " ";
LcdObj lcd_message;
int index = 0;
for(index = 0; index < 15; index++) {
lcd_message.buffer[index] = ' ';
}
lcd_message.position = 1;
UART_Handle uart;
UART_Params uartParams;
/* Create a UART with data processing off. */
UART_Params_init(&uartParams);
uartParams.writeDataMode = UART_DATA_BINARY;
uartParams.readDataMode = UART_DATA_BINARY;
uartParams.readReturnMode = UART_RETURN_FULL;
uartParams.readEcho = UART_ECHO_OFF;
uartParams.baudRate = 9600;
uart = UART_open(Board_UART0, &uartParams);
if (uart == NULL) {
System_abort("Error opening the UART");
}
Semaphore_pend(start_data_semaphore, BIOS_WAIT_FOREVER); // wait on button semaphore
//send this char for handshaking with PC
int8_t prompt = 65;
UART_write(uart, &prompt, 1);
int total_x = 0;
int total_y = 0;
int total_z = 0;
int average_x = 0;
int average_y = 0;
int average_z = 0;
int counter = 0;
int rx = 0;
while (1) {
UART_read(uart, &input, 2);
if(input[0] == '$' && input[1] == '$') {
P2OUT &= ~BIT1;
P1OUT |= BIT0;
BIOS_exit(1);
}
rx = (int)input[1];
if(input[0] == '-') {
rx = 0 - rx;
}
total_x = total_x + rx;
UART_read(uart, &input, 2);
if(input[0] == '$' && input[1] == '$') {
P2OUT &= ~BIT1;
P1OUT |= BIT0;
BIOS_exit(1);
}
rx = (int)input[1];
if(input[0] == '-') {
rx = 0 - rx;
}
total_y = total_y + rx;
UART_read(uart, &input, 2);
if(input[0] == '$' && input[1] == '$') {
P2OUT &= ~BIT1;
P1OUT |= BIT0;
BIOS_exit(1);
}
rx = (int)input[1];
if(input[0] == '-') {
rx = 0 - rx;
}
total_z = total_z + rx;
/*
if((counter % 3) == 0) {
total_x = total_x + rx;
} else if ((counter % 3) == 1) {
total_y = total_y + rx;
} else {
total_z = total_z + rx;
}*/
counter++;
if(counter > 50) {
average_x = total_x/counter;
average_y = total_y/counter;
average_z = total_z/counter;
combine_ints_to_string(average_x, average_y, average_z, 15,lcd_message.buffer);
counter = 0;
total_x = 0;
total_y = 0;
total_z = 0;
lcd_message.position = 1;
Mailbox_post(LCD_Mbx, &lcd_message, BIOS_WAIT_FOREVER);
}
MAP_Interrupt_enableInterrupt(INT_ADC14);
}
}
/*
* ======== echoFxn ========
* Task for this function is created statically. See the project's .cfg file.
*/
Void echoFxn(UArg arg0, UArg arg1)
{
char input;
UART_Params uartPCParams;
UART_Params uartGSMParams;
UART_Params uartXBEEParams;
const char echoPrompt[] = "\fEchoing characters:\r\n";
// Create a UART for PC
UART_Params_init(&uartPCParams);
uartPCParams.readMode = UART_MODE_CALLBACK;
uartPCParams.writeMode = UART_MODE_CALLBACK;
uartPCParams.readCallback = &pcReadUARTCallback;
uartPCParams.writeCallback = &pcWriteUARTCallback;
uartPCParams.writeDataMode = UART_DATA_BINARY;
uartPCParams.readDataMode = UART_DATA_BINARY;
uartPCParams.readReturnMode = UART_RETURN_NEWLINE;
uartPCParams.readEcho = UART_ECHO_OFF;
uartPCParams.baudRate = 115200;
uartPC = UART_open(Board_UART0, &uartPCParams);
if (uartPC == NULL) {
System_abort("Error opening the UART");
}
// Create a UART for GSM
UART_Params_init(&uartGSMParams);
uartGSMParams.readMode = UART_MODE_CALLBACK;
uartGSMParams.writeMode = UART_MODE_CALLBACK;
uartGSMParams.readCallback = &gsmReadUARTCallback;
uartGSMParams.writeCallback = &gsmWriteUARTCallback;
uartGSMParams.writeDataMode = UART_DATA_BINARY;
uartGSMParams.readDataMode = UART_DATA_BINARY;
uartGSMParams.readReturnMode = UART_RETURN_NEWLINE;
uartGSMParams.baudRate = 115200;
uartGSM = UART_open(Board_UART1, &uartGSMParams);
if (uartGSM == NULL) {
System_abort("Error opening the GSM UART");
}
// Create a UART for GSM
UART_Params_init(&uartXBEEParams);
uartXBEEParams.readMode = UART_MODE_CALLBACK;
uartXBEEParams.writeMode = UART_MODE_CALLBACK;
uartXBEEParams.readCallback = &xbeeReadUARTCallback;
uartXBEEParams.writeCallback = &xbeeWriteUARTCallback;
uartXBEEParams.writeDataMode = UART_DATA_BINARY;
uartXBEEParams.readDataMode = UART_DATA_BINARY;
uartXBEEParams.readReturnMode = UART_RETURN_NEWLINE;
uartXBEEParams.baudRate = 115200;
uartXBEE = UART_open(Board_UART3, &uartXBEEParams);
if (uartXBEE == NULL) {
System_abort("Error opening the GSM UART");
}
UART_write(uartPC, echoPrompt, sizeof(echoPrompt));
while (1) {
// Read from all the UARTS
UART_read(uartPC, &input, 1);
UART_read(uartGSM, &input, 1);
UART_read(uartXBEE, &input, 1);
}
}
/**
* /fn TransferFunction
* /brief Functions transfers read values from altitude/thermo click via uart7.
*
* /param arg0 not used.
* /param arg1 not used.
* /return void.
*/
static void TransferFunction(UArg arg0, UArg arg1) {
TransferMessageType message;
UInt firedEvents;
UART_Handle uart7;
UART_Params uart7Params;
int length;
int precision;
int width;
float value;
bool convert;
int len;
PositionType* position;
DateTimeType* dateTime;
char* destination;
UART_Params_init(&uart7Params);
uart7Params.writeDataMode = UART_DATA_BINARY;
uart7Params.readDataMode = UART_DATA_BINARY;
uart7Params.readReturnMode = UART_RETURN_FULL;
uart7Params.readEcho = UART_ECHO_OFF;
uart7Params.baudRate = 9600;
uart7 = UART_open(Board_UART3, &uart7Params);
if (uart7 == NULL) {
System_abort("Error opening the UART");
}
while (true) {
firedEvents = Event_pend(transferEvent, Event_Id_NONE,
TRANSFER_MESSAGE_EVENT,
BIOS_WAIT_FOREVER);
if (firedEvents & TRANSFER_MESSAGE_EVENT) {
// Get the posted message.
// Mailbox_pend() will not block since Event_pend()
// has guaranteed that a message is available.
Mailbox_pend(transferMailbox, &message, BIOS_NO_WAIT);
convert = true;
switch (message.kind) {
case TRANSFER_PRESSURE:
result[0] = ID_PRESSURE;
value = message.value / 100; /* hPa */
width = 1;
precision = PRESSURE_PRECISION;
if (PRESSURE_PRECISION > 0) {
width = 3;
}
break;
case TRANSFER_ALTITUDE:
result[0] = ID_ALTITUDE;
value = message.value;
precision = ALTITUDE_PRECISION;
if (ALTITUDE_PRECISION > 0) {
width = 3;
}
break;
case TRANSFER_GPS_LOCATION:
result[0] = ID_LOCATION;
convert = false;
position = message.data;
len = strlen(position->latitude);
memcpy(&result[1], position->latitude, len);
destination = result + 1 + len;
len = strlen(position->longitude);
memcpy(destination, position->longitude, len);
destination += len;
*destination = '\0';
break;
case TRANSFER_DATE_TIME:
result[0] = ID_DATE_TIME;
convert = false;
dateTime = message.data;
len = sizeof(dateTime->dateTimeString);
memcpy(&result[1], dateTime->dateTimeString, len);
break;
default:
System_printf(
"Error TransferFunction: Received unknown message %d.\n",
message.kind);
System_flush();
// unknown, nothing special
continue; /* no break, would be unreachable code */
}
if (convert) {
(void) snprintf(&result[1], 20, "%*.*f", width, precision,
value);
} else {
length = strlen(result) + 1;
}
length = strlen(result) + 1;
UART_write(uart7, &result[0], length);
#ifdef DEBUG
System_printf("%s transferred.\n", result);
System_flush();
#endif // DEBUG
}
}
}
//must be called from within a task - this function will block!
//returns 1 if modem responds with OK
int hm10_begin(){
memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer));
UART_Params_init(&uartParams);
uartParams.writeDataMode = UART_DATA_BINARY;
uartParams.readMode = UART_MODE_BLOCKING;
uartParams.readTimeout = HM10_READ_TIMEOUT;
uartParams.readDataMode = UART_DATA_BINARY;
uartParams.readReturnMode = UART_RETURN_FULL;
uartParams.readEcho = UART_ECHO_OFF;
uartParams.baudRate = HM10_BAUD_RATE;
uart = UART_open(Board_UART2_COMM, &uartParams);
if (uart == NULL) {
//debug
GPIO_toggle(Board_LED_GREEN);
Task_sleep(300);
GPIO_toggle(Board_LED_GREEN);
return 0;
}
else
{
Task_sleep(1000);
UART_write(uart, hm10_at_wakestring, strlen(hm10_at_wakestring));
UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer));
serial_printf(cli_stdout, "%s\n", hm10_rxBuffer);
memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer));
UART_write(uart, hm10_at_pwrm1, strlen(hm10_at_pwrm1));
UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer));
serial_printf(cli_stdout, "%s\n", hm10_rxBuffer);
memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer));
Task_sleep(1000);
UART_write(uart, hm10_at_clear, strlen(hm10_at_clear));
UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer));
serial_printf(cli_stdout, "%s\n", hm10_rxBuffer);
memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer));
Task_sleep(500);
UART_write(uart, hm10_at_imme1, strlen(hm10_at_imme1));
UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer));
serial_printf(cli_stdout, "%s\n", hm10_rxBuffer);
memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer));
Task_sleep(1000);
UART_write(uart, hm10_at_name, strlen(hm10_at_name));
UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer));
serial_printf(cli_stdout, "%s\n", hm10_rxBuffer);
memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer));
Task_sleep(1000);
UART_write(uart, hm10_at, strlen(hm10_at));
UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer));
serial_printf(cli_stdout, "%s\n", hm10_rxBuffer);
if(!strcmp("OK", hm10_rxBuffer)){
UART_write(uart, hm10_at_start, strlen(hm10_at_start));
hm10_end(); // Close UART port to configure Text mode to callback @ newline + CR
uartParams.writeDataMode = UART_DATA_BINARY;
/* Experimental: use callback mode such that the comm task is not blocked
* while waiting for incoming commands.
*
* Note: think about using void UART_readCancel ( UART_Handle handle )
* WARNING: It is STRONGLY discouraged to call UART_read from its own callback function (UART_MODE_CALLBACK).
*/
uartParams.readMode = UART_MODE_CALLBACK;
uartParams.readCallback = hm10_read_callback;
uartParams.readTimeout = UART_WAIT_FOREVER; //HM10_READ_TIMEOUT;
uartParams.readDataMode = UART_DATA_TEXT;
uartParams.readReturnMode = UART_RETURN_NEWLINE;
uart = UART_open(Board_UART2_COMM, &uartParams);
if (uart == NULL)
{
//debug
GPIO_toggle(Board_LED_GREEN);
Task_sleep(300);
GPIO_toggle(Board_LED_GREEN);
return 0;
}
else
{
hm10_initialised = 1;
// directly be receptive for commands
hm10_callback = 0;
UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer));
return 1; //modem can now communicate with us
}
}
else
{
return 0;
}
}
}
