void UART_init(void)
{
FIFO_Init(&tx_fifo, tx_buf_gs, TX_BUFFER_MAX_SIZE);
FIFO_Init(&rx_fifo, rx_buf_gs, RX_BUFFER_MAX_SIZE);
/** @snippet [Configure UART RX and TX pin] */
nrf_gpio_cfg_output(TX_PIN_NUM);
nrf_gpio_cfg_input(RX_PIN_NUM, NRF_GPIO_PIN_NOPULL);
NRF_UART0->PSELTXD = TX_PIN_NUM;
NRF_UART0->PSELRXD = RX_PIN_NUM;
NRF_UART0->BAUDRATE = (UART_BAUDRATE_BAUDRATE_Baud38400 << UART_BAUDRATE_BAUDRATE_Pos);
NRF_UART0->EVENTS_RXDRDY = 0;
NRF_UART0->EVENTS_TXDRDY = 0;
NRF_UART0->TASKS_STARTTX = 1;
NRF_UART0->TASKS_STARTRX = 1;
NRF_UART0->INTENSET = UART_INTENSET_RXDRDY_Enabled << UART_INTENSET_RXDRDY_Pos;
NRF_UART0->INTENSET |= UART_INTENSET_TXDRDY_Enabled << UART_INTENSET_TXDRDY_Pos;
// enable interrupt;
NVIC_SetPriority(UART0_IRQn, APP_IRQ_PRIORITY_LOW);
NVIC_EnableIRQ(UART0_IRQn);
NRF_UART0->ENABLE = (UART_ENABLE_ENABLE_Enabled << UART_ENABLE_ENABLE_Pos);
}
/****************************************************************************
* DESCRIPTION: Initializes the data and the port
* RETURN: none
* ALGORITHM: none
* NOTES: none
*****************************************************************************/
void RS485_Initialize(
void)
{
/* Init the Rs485 buffers */
FIFO_Init(&FIFO_Rx, RS485_Rx_Buffer, sizeof(RS485_Rx_Buffer));
FIFO_Init(&FIFO_Tx, RS485_Tx_Buffer, sizeof(RS485_Tx_Buffer));
/* FIXME: read the stored baud rate */
/* I2C_Read_Block(
EEPROM_DEVICE_ADDRESS,
(char *)&RS485_Baud_Rate,
sizeof(RS485_Baud_Rate),
EEPROM_MSTP_BAUD_RATE_ADDR); */
RS485_Initialize_Port();
}
uint8_t module_system_init()
{
FIFO_Init (&s_at_fifo);
//ATE0, set no echo.
add_send_at_command("ATE", "ATE0\r\n");
//AT+IFC=0, set no flow control.
add_send_at_command("AT+IFC", "AT+IFC=0\r\n");
//AT+CPIN, query .....
add_send_at_command("AT+CPIN", "AT+CPIN?\r\n");
//AT+CSQ
add_send_at_command("AT+CSQ", "AT+CSQ\r\n");
//AT+GSN request for the IMEI of the module.;
add_send_at_command("AT+GSN", "AT+GSN\r\n");
// AT+CGSOCKCONT
add_send_at_command("AT+CGSOCKCONT", "AT+CGSOCKCONT=1,\"IP\",\"CMNET\"\r\n");
//AT+CIPMODE
add_send_at_command("AT+CIPMODE", "AT+CIPMODE=0\r\n");
//AT+NETOPEN
add_send_at_command("AT+NETOPEN", "AT+NETOPEN\r\n");
s_module_status = MODULE_INIT;
return s_module_status;
}
int main2(void){
FIFO_Init(); // initializes a FIFO that holds 6 elements
for(;;){
Status[0] = FIFO_Get(&GetData[0]); // should fail, empty
Status[1] = FIFO_Put(1); // should succeed, 1
Status[2] = FIFO_Put(2); // should succeed, 1 2
Status[3] = FIFO_Put(3); // should succeed, 1 2 3
Status[4] = FIFO_Put(4); // should succeed, 1 2 3 4
Status[5] = FIFO_Put(5); // should succeed, 1 2 3 4 5
Status[6] = FIFO_Put(6); // should succeed, 1 2 3 4 5 6
Status[7] = FIFO_Put(7); // should fail, 1 2 3 4 5 6
Status[8] = FIFO_Get(&GetData[1]); // should succeed, 2 3 4 5 6
Status[9] = FIFO_Get(&GetData[2]); // should succeed, 3 4 5 6
Status[10] = FIFO_Put(7); // should succeed, 3 4 5 6 7
Status[11] = FIFO_Put(8); // should succeed, 3 4 5 6 7 8
Status[12] = FIFO_Put(9); // should fail, 3 4 5 6 7 8
Status[13] = FIFO_Get(&GetData[3]); // should succeed, 4 5 6 7 8
Status[14] = FIFO_Get(&GetData[4]); // should succeed, 5 6 7 8
Status[15] = FIFO_Get(&GetData[5]); // should succeed, 6 7 8
Status[16] = FIFO_Get(&GetData[6]); // should succeed, 7 8
Status[17] = FIFO_Get(&GetData[7]); // should succeed, 8
Status[18] = FIFO_Get(&GetData[8]); // should succeed, empty
Status[19] = FIFO_Get(&GetData[9]); // should fail, empty
}
}
static void TestCase_StaticMemory(void)
{
FIFO_t MyFifo;
int ret = 0;
T MyT_A, MyT_B, MyT_C;
T MyT;
MyT.sex = 0;
MyT.addr = 0;
MyT.tel = 0;
MyT_A.sex = 1;
MyT_A.addr = 1;
MyT_A.tel = 1;
MyT_B.sex = 2;
MyT_B.addr = 2;
MyT_B.tel = 2;
MyT_C.sex = 3;
MyT_C.addr = 3;
MyT_C.tel = 3;
FIFO_Init(&MyFifo, FIFO_Pool, sizeof(T), ELE_CNT);
ret = FIFO_IsEmpty(&MyFifo);
ret = FIFO_IsFull(&MyFifo);
ret = FIFO_CountFree(&MyFifo);
ret = FIFO_CountUsed(&MyFifo);
FIFO_Put(&MyFifo, &MyT_A);
FIFO_Put(&MyFifo, &MyT_B);
FIFO_Put(&MyFifo, &MyT_C);
ret = FIFO_IsEmpty(&MyFifo);
ret = FIFO_IsFull(&MyFifo);
ret = FIFO_CountFree(&MyFifo);
ret = FIFO_CountUsed(&MyFifo);
FIFO_Get(&MyFifo, &MyT);
FIFO_Get(&MyFifo, &MyT);
FIFO_Get(&MyFifo, &MyT);
ret = FIFO_IsEmpty(&MyFifo);
ret = FIFO_IsFull(&MyFifo);
ret = FIFO_CountFree(&MyFifo);
ret = FIFO_CountUsed(&MyFifo);
FIFO_Put(&MyFifo, &MyT_A);
FIFO_Put(&MyFifo, &MyT_B);
FIFO_Put(&MyFifo, &MyT_C);
ret = FIFO_Flush(&MyFifo);
ret = FIFO_IsEmpty(&MyFifo);
ret = FIFO_IsFull(&MyFifo);
ret = FIFO_CountFree(&MyFifo);
ret = FIFO_CountUsed(&MyFifo);
}
VOID ITaskQ_Init (ITaskQ *pThis, String pSigName, String pSemName, UINT16 nNumQNodes)
{
Signal_Init(&pThis->oWrite, pSigName);
Mutex_Init(&pThis->oLock, pSemName, 1);
FIFO_Init(&pThis->oQ, nNumQNodes);
pThis->pRead = &pThis->oWrite;
}
void rs485_init(
void)
{
FIFO_Init(&Receive_Buffer, &Receive_Buffer_Data[0],
(unsigned) sizeof(Receive_Buffer_Data));
rs485_rts_init();
rs485_usart_init();
rs485_init_nvdata();
rs485_receiver_enable();
rs485_rts_enable(false);
}
/*************************************************************************
* Description: Initialize the room network USART
* Returns: nothing
* Notes: none
**************************************************************************/
void rs485_init(
void)
{
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
GPIO_StructInit(&GPIO_InitStructure);
/* Configure USARTx Rx as input floating */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure USARTx Tx as alternate function push-pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure the Request To Send (RTS) aka Transmit Enable pin */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Enable USARTx Clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
/*RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);*/
/* Enable GPIO Clock */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
/* Enable the USART Pins Software Remapping for this pair
of pins and peripheral functions:
USART3 Full remap (TX/PD8, RX/PD9, CK/PD10, CTS/PD11, RTS/PD12) */
/*GPIO_PinRemapConfig(GPIO_FullRemap_USART3, ENABLE);*/
/* Configure the NVIC Preemption Priority Bits */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
/* Enable the USARTx Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* enable the USART to generate interrupts */
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
rs485_baud_rate_set(Baud_Rate);
USART_Cmd(USART2, ENABLE);
FIFO_Init(&Receive_Buffer, &Receive_Buffer_Data[0],
(unsigned) sizeof(Receive_Buffer_Data));
timer_elapsed_start(&Silence_Timer);
}
// Initialization function
void IV_Init(void)
{
// Initializes point delay in ms
iv_tracer.point_delay_ms = IV_DEFAULT_POINT_DELAY;
// Initializes FIFO
FIFO_Init(&iv_tracer.events.super,
&iv_tracer.events.list ,
IV_EVENT_LIST_SIZE,
sizeof(IV_EVENT_T));
// FSM Constructor
FSM_Ctor(&iv_tracer.super,IV_HAND_INITIAL);
// FSM Init
FSM_Init(&iv_tracer.super);
}
// Idle, waiting timeout to get the next IV Curve
FSM_State IV_HAND_IDLE(IV_TRACER_T *me, FSM_Event *e)
{
switch (e->signal)
{
case FSM_ENTRY_SIGNAL:
return FSM_HANDLED();
case IV_START_NEW_CURVE:
return FSM_TRAN(me,IV_HAND_OPER);
case FSM_EXIT_SIGNAL:
// Inits Curve FIFO
FIFO_Init(&me->curve.super, &me->curve.points, IV_CURVE_SIZE, sizeof(IV_POINT_T));
return FSM_HANDLED();
}
// Default: Handled
return FSM_HANDLED();
}
void UART_Init(void){
// int i;
// SYSCTL_RCGC1_R |= SYSCTL_RCGC1_UART1; // activate UART1
// i=i;
// SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOD; // activate port D
// i = i;
// UART1_CTL_R &= ~0x1; // disable UART
// i=i;
// UART1_IBRD_R = 31; // IBRD = int(50,000,000 / (16 * 100000)) = int(31.25)
// UART1_FBRD_R = 16; // FBRD = int(0.1267 * 64 + 0.5) = 16.5
// // 8 bit word length (no parity bits, one stop bit, FIFOs)
// //UART1_CTL_R &= UART_CTL_UARTEN;
// I put this in. Reenable UART?
// UART1_LCRH_R = (UART_LCRH_WLEN_8|UART_LCRH_FEN);
// UART1_CTL_R |= UART_CTL_UARTEN; // enable UART
// i=i;
// UART1_LCRH_R |= 0x0070;
// UART1_CTL_R |= 0x0301; // enables RXE, TXE, and UART
// GPIO_PORTD_AFSEL_R |= 0x03; // enable alt funct on PD1-0
// GPIO_PORTD_DEN_R |= 0x03; // enable digital I/O on PD1-0
int i;
SYSCTL_RCGC1_R |= 0x2; //activate UART1
i=0;
i=1;
SYSCTL_RCGC2_R |= 0x08; //activate PortD
i=0;
i=1;
UART1_CTL_R &= ~0x01; //disable UART
UART1_IBRD_R = 31; //15.625 31
UART1_FBRD_R = 6; //0.625*64 = 40 16
UART1_LCRH_R = 0x0070;
UART1_CTL_R = 0x0301; // enables RXE, TXE, and UART
UART1_IM_R |= 0x10; // something from slides I'm not sure the effect of
NVIC_EN0_R |= 0x40; // enable "interrupt 6"
UART1_IFLS_R = (UART1_IFLS_R & ~0x38)|0x12; // enables interrupts for 1/2 full, etc?
GPIO_PORTD_AFSEL_R |= 0x0C; //enable alt function on PD2,3
GPIO_PORTD_DEN_R |= 0x0C; //enable digital I/O on PD2,3
FIFO_Init();
errorcount =0;
}
int main(){
FIFO_Init(&fifo);
configureDBGU((unsigned int) DGBU_INT_handler);
DBGU_sendString((char*)"Welcome to DBGU have fun and good luck!\r\n");
sendStringUsingFIFO((char*)"Hello world\r\n");
sendStringUsingFIFO((char*)"Hello world once again\r\n");
sendStringUsingFIFO((char*)"Goodbye world\r\n");
sendStringUsingFIFO((char*)"Hello world\r\n");
sendStringUsingFIFO((char*)"Hello world once again\r\n");
sendStringUsingFIFO((char*)"Goodbye world\r\n");
sendStringUsingFIFO((char*)"Hello world\r\n");
sendStringUsingFIFO((char*)"Hello world once again\r\n");
sendStringUsingFIFO((char*)"Goodbye world\r\n");
while(1){
}
}
/*!
* This function takes care of everyting required to display and operate
* a dialog box, represented as a prepared form object. If registers its own
* joystick event handler and handles the dialog box until the DIALOG_OnClickInModal
* callback is called by an element. E.g. a static text widget having this function
* registered as its OnClick callback.
*
* This function restores the joystick event handler when it exits, but leaves the
* form graphics untouched in the LCD.
*
* \param form The form to show and operate as a modal dialog box.
*
* \return The custom ID provided by the element that called the OnClickInModal callback.
*/
WIDGETS_id_t DIALOG_RunModal( FORMS_form_t * form )
{
// Save old state without being disturbed by interrupts.
uint8_t savedSREG = SREG;
CAL_disable_interrupt();
JOYSTICK_EventHandler_t oldJoystickHandler = JOYSTICK_GetEventHandler();
// Set new state and draw form.
DIALOG_currentModalForm = form;
FORMS_Draw( form );
FIFO_Init( &DIALOG_eventFifo, DIALOG_eventFifoBuf, DIALOG_EVENTFIFOSIZE * sizeof(DIALOG_event_t) );
JOYSTICK_SetEventHandler( DIALOG_JoystickHandler );
// Enable interrupts and wait for modal form to exit.
CAL_enable_interrupt();
DIALOG_modalClicked = false;
do {
while (FIFO_HasData( &DIALOG_eventFifo, JOYSTICK_event_t ) == false) {
POWER_EnterIdleSleepMode();
}
JOYSTICK_event_t event;
FIFO_GetData( &DIALOG_eventFifo, &event );
FORMS_OnJoystick( DIALOG_currentModalForm, &event );
} while (DIALOG_modalClicked == false);
// Wait for all joystick buttons to be released.
do {} while (JOYSTICK_GetState() != 0x00);
// Normalize LCD hardware scrolling before releasing control to other parts.
FORMS_NormalizeLCDScroll( form );
// Restore old state without being disturbed by interrupts.
CAL_disable_interrupt();
JOYSTICK_SetEventHandler( oldJoystickHandler );
SREG = savedSREG;
// Then we can return the userId from one of the form elements.
return DIALOG_modalId;
}
int main(void){
TExaS_Init();
ADC_Init(); // turn on ADC, set channel to 1
ST7735_InitR(INITR_REDTAB);
PortF_Init();
SysTick_Init(); // This makes things work
UART1_Init();
FIFO_Init();
unsigned char data;
while(1){
while(data != 0x02){
FIFO_Get(&data); // Look for new data byte
}
ST7735_SetCursor(0,0);
for(int i = 0; i<5; i++){ // Print next 5 elements
FIFO_Get(&data);
ST7735_OutChar(data);
}
ST7735_OutString(" cm"); // Print units
}
}
/****************************************************************************
* DESCRIPTION: Initializes the RS485 hardware and variables, and starts in
* receive mode.
* RETURN: none
* ALGORITHM: none
* NOTES: none
*****************************************************************************/
void Recievebuf_Initialize()
{
FIFO_Init(&Receive_Buffer0, &USART_RX_BUF[0],
sizeof(USART_RX_BUF));
}
void Slideshow( void )
{
LCD_SetScreen( 0x00 );
FIFO_data_t * fifoBuffer = MEM_ALLOC_ARRAY( Slideshow_event_t, SLIDESHOW_MAXEVENTS );
if (fifoBuffer == NULL) {
POPUP_MsgBox( 10, 2, 6, "Not enough\r\nmemory!", NULL );
} else {
TIMING_event_t timerEvent;
FIFO_handle_t fifo;
// Init FIFO.
Slideshow_eventFifo = &fifo;
FIFO_Init( &fifo, fifoBuffer, SLIDESHOW_MAXEVENTS );
// Init slideshow data and state.
static uint8_t const CAL_PGM_DEF(* const pictures[SLIDESHOW_MAXPICS]) = {
FLASHPICS_ECARS_DEMO_0,
FLASHPICS_ECARS_DEMO_1,
FLASHPICS_ECARS_DEMO_2,
FLASHPICS_ECARS_DEMO_3,
FLASHPICS_ECARS_DEMO_4,
FLASHPICS_ECARS_DEMO_5,
FLASHPICS_ECARS_DEMO_6,
FLASHPICS_ECARS_DEMO_7,
FLASHPICS_ECARS_DEMO_8,
FLASHPICS_ECARS_DEMO_9
};
int8_t picIdx = 0;
int8_t direction = 1;
// Install joystick handler.
CAL_disable_interrupt();
JOYSTICK_EventHandler_t oldHandler = JOYSTICK_GetEventHandler();
JOYSTICK_SetEventHandler( Slideshow_JoystickCallback );
CAL_enable_interrupt();
// Run main slideshow loop.
bool exit = false;
do {
// Show current picture.
PICTURE_CopyFullscreenFlashToLcd( CAL_pgm_read_puint8(&pictures[picIdx]) );
// Register timer event.
TIMING_RemoveEvent( &timerEvent );
TIMING_AddCallbackEventAfter( RTC_TICKS_PER_SECOND * SLIDESHOW_DELAYSECONDS,
Slideshow_TimerCallback,
&timerEvent );
// Wait for event from timer or joystick.
Slideshow_event_t event;
while (FIFO_HasData( &fifo, Slideshow_event_t ) == false) {
POWER_EnterIdleSleepMode();
}
FIFO_GetData( &fifo, &event );
// Process event.
switch (event) {
case SLIDESHOW_EXIT : exit = true; break;
case SLIDESHOW_TIMER :
Slideshow_UpdateIndex( &picIdx, direction );
break;
case SLIDESHOW_NEXT :
direction = 1;
Slideshow_UpdateIndex( &picIdx, direction );
break;
case SLIDESHOW_PREV :
direction = -1;
Slideshow_UpdateIndex( &picIdx, direction );
break;
default : break;
}
} while (exit == false);
// Clean up.
CAL_disable_interrupt();
TIMING_RemoveEvent( &timerEvent );
JOYSTICK_SetEventHandler( oldHandler );
CAL_enable_interrupt();
MEM_FREE( fifoBuffer );
}
}
/*----------------------------------------------------------------------------
** Define public functions
*/
void SOCKETFIFO_Init (FIFO_t *fifo, void *elements, uint32_t maxcount) {
// Initialize global data
socketfifo = fifo;
socketfifo->pvElements = elements;
FIFO_Init (socketfifo, maxcount, socketfifo_Push, socketfifo_Pop);
}
