void GPSline(void) {
char buffer[128];
int lenght;
int k;
int i;
lenght = sprintf (buffer, "$PSRF103,00,01,00,01*25");
for(k=0;k<lenght;k++)
{
uart0_putchar(buffer[k]);
Delay(1);
}
uart0_putchar(0x0D); //CR
uart0_putchar(0x0a); //LF
count += 1;
while(!uart0_getchar_present());
while(uart0_getchar() != '$');// wait for the start of a line
for(i=0;i<256;i++)
{
while(!uart0_getchar_present());
gpsbuffer[i] = uart0_getchar();
// uart0_putchar(gpsbuffer[i]);
if(gpsbuffer[i] == '\r') {
gpsbuffer[i] = 0;
while(uart0_getchar_present()) uart0_getchar();
return;
}
}
}
int main(void)
{
int c;
uart0_init();
set_mcu_speed();
eint();
led_state = 1;
LED_DIR = 0xff;
LED_OUT = 0xff;
printf("Timer test program ready.\n");
printf("10Hz\n");
timerA3_start(20);
delay(4000);
timerA3_stop();
timerA3_start(10);
while (1)
{
LPM3;
while ((c = uart0_getchar()))
{
printf("%c",c);
}
}
return 0;
}
/*-----------------------------------------------------------------------------
* SER_GetChar: Read a character from the Serial Port
*----------------------------------------------------------------------------*/
int32_t SER_GetChar (void) {
#ifdef __DBG_ITM
if (ITM_CheckChar())
return ITM_ReceiveChar();
#else
// if (UART1_S1 & UART_S1_RDRF_MASK) {
//while (!(UART1_S1 & UART_S1_RDRF_MASK));
//return (UART1_D);
// Wait until character has been received //
//while (!(UART_S1_REG(TERM_PORT) & UART_S1_RDRF_MASK));
// Return the 8-bit data from the receiver //
//return UART_D_REG(TERM_PORT);
if (TERM_PORT_NUM == 0)
return uart0_getchar(UART0_BASE_PTR);
else if (TERM_PORT_NUM == 1)
return uart_getchar(UART1_BASE_PTR);
else
return uart_getchar(UART2_BASE_PTR);
#endif
return (-1);
}
int uart0_recv(DynamixelPacket *pktRecv) {
int c; // needs to be int, not char, for EOF processing
int npkt = 0;
c = uart0_getchar();
while (c != EOF) {
// Process char from RS485 input
npkt = dynamixel_input(pktRecv, c, npkt);
if (npkt == -1) {
return 1;
}
c = uart0_getchar();
if (c == EOF) {
// Delay and try last time
_delay_us(100);
c = uart0_getchar();
}
}
return 0;
}
char
in_char (void)
{
if (TERM_PORT_NUM == 0)
return uart0_getchar(UART0_BASE_PTR);
else if (TERM_PORT_NUM == 1)
return uart_getchar(UART1_BASE_PTR);
else
return uart_getchar(UART2_BASE_PTR);
}
void get_serial(void)
{
int i;
int j;
char buffer[9];
for(i=0;i<3;i++)
{
while(!uart0_getchar_present());
buffer[i] = uart0_getchar();
uart0_putchar('G');
}
}
char * mygets(char *s)
{
char ch;
while((ch = uart0_getchar()) != '\r')
{
*s = ch;
s++;
uart0_putchar(ch);
}
*s++ = '\r';
*s++ = '\n';
*s = '\0';
return s;
}
/*!
* Get character from uart0
*/
static int uart0_recv ( void *data, size_t size, uint flags, device_t *dev )
{
int c;
if ( !data || size < 1 )
return -1;
c = uart0_getchar ();
if ( c == -1 ) /* no new data */
return 0;
*( (uint *) data ) = c;
return 1;
}
static void uart_echo ()
{
uart0_putchar ( uart0_getchar() );
}
static int __getchar(char *buf)
{
uart0_getchar(buf);
}
int main(void) {
init();
//******
//TEST 1
//******
#if _TEST == 1
bool toggle = false;
uint8_t packet_pos = 0;
char c;
DDRD |= (1 << PD6);
init();
while(true) {
c = uart0_getchar();
if (c == 'y') {
toggle = false;
uart0_putchar('y');
}
if (c == 'n') {
toggle = true;
uart0_putchar('n');
}
if (toggle)
PORTD |= (1 << PD6);
else
PORTD &= ~(1 << PD6);
}
//******
//TEST 2
//******
#elif _TEST == 2
char c;
DDRD |= (1 << PD6) // set outputs in PORTD
| (1 << PD5)
| (1 << PD4);
TCCR1A = 0x00; // clear all current timer 1 settings
TCCR1B = 0x00;
TCCR1B |= (1 << WGM12); // turn on CTC mode:
// Clear Timer on Compare Match
TIMSK1 = (1 << TOIE1); // enable global and timer overflow interrupt
TCCR1B |= (1 << CS10);
while(true) {
c = uart0_getchar();
if (c != EOF) {
if (c == 'f')
servoTurn(0);
if (c == 'g')
servoTurn(90);
if (c == 'h')
servoTurn(180);
}
}
//******
v //TEST 3
//******
#elif _TEST == 3
Packet host_packet;
PacketInit(&host_packet);
int len = 0;
char c;
DDRD |= (1 << PD6);
while(1) {
c = uart0_getchar();
if (c != EOF)
len = PacketProcessChar(&host_packet, c);
if (len > 0)
uart0_printstr("got a packet!\r\n");
}
//******
//TEST 4
//******
#elif _TEST == 4
uint8_t messageBuf[4];
uint8_t TWI_slaveAddress = 0x10;
DDRD |= (1 << PD5) | (1 << PD6);
TWIInit();
sei();
while(1) {
PORTD ^= (1 << PD5) | (1 << PD6);
TWIStart();
//TWIStop();
_delay_ms(500);
}
#elif _TEST == 5
Packet host_packet;
PacketInit(&host_packet);
int len = 0;
char c;
DDRD |= (1 << PD5);
uint8_t message_buf[] = {0xFE, 0xFE, 0x01, 0x04, 0x02, 0x2B, 0x01, 0xCC};
int i;
while(1) {
c = uart0_getchar();
if (c != EOF) {
len = PacketProcessChar(&host_packet, c);
}
if (len > 0) {
PORTD ^= (1 << PD5);
len = 0;
}
//for (i = 0; i < 8; i++)
// uart0_putchar(message_buf[i]);
//uart0_putchar(0xFD);
//uart0_putchar(0xFF);
//c = uart0_getchar();
//if (c != EOF) {
// len = PacketProcessChar(&host_packet, c);
//PORTD ^= (1 << PD5);
//}
//if (len > 0)
//PORTD ^= (1 << PD5);
//_delay_ms(1000);
}
/*
DDRD |= (1 << PD5);
char c;
while(1) {
c = uart0_getchar();
if (c != EOF) {
uart0_putchar(c);
PORTD ^= (1 << PD5);
//_delay_ms(500);
}
}*/
#endif // _TEST
return 0;
}
void checkForCommands (void) {
char c;
char tmpStr[commandBufferLen];
while (uart0_char_waiting_in()) {
c = uart0_getchar();
if (c == 0x08) { // backspace
if (commandBufferPtr > commandBuffer) { // if there is anything to backspace
commandBufferPtr--;
}
}
if (c == 0x0d) // if carriage-return
c = 0x0a; // substitute linefeed
if (c == 0x0a) { // if linefeed, attempt to parse the command
stayRoused(120); // keep system roused
*commandBufferPtr++ = '\0'; // null terminate
switch (commandBuffer[0]) { // command is 1st char in buffer
case '$': { // an NMEA string from the GPS
// outputStringToUART1("\r\n NMEA from GPS \r\n");
strcpy(tmpStr, commandBuffer + 1);
if (!strncmp(tmpStr,"GPRMC",5)) {
outputStringToUART1(tmpStr);
outputStringToUART1("\r\n");
}
break;
}
case 'V': case 'v': { // show firmware version
outputStringToBothUARTs(versionString);
break;
}
case 'T': case 't': { // set time
// get info from commandBuffer before any UART output,
// because in some configurations any Tx feeds back to Rx
strcpy(tmpStr, commandBuffer + 1);
if (!isValidDateTime(tmpStr)) {
outputStringToUART0("\r\n Invalid timestamp\r\n");
break;
}
if (!isValidTimezone(tmpStr + 20)) {
outputStringToUART0("\r\n Invalid hour offset\r\n");
break;
}
outputStringToUART0("\r\n Time changed from ");
strcat(strJSON, "\r\n{\"timechange\":{\"from\":\"");
intTmp1 = rtc_readTime(&dt_RTC);
datetime_getstring(datetime_string, &dt_RTC);
strcat(strJSON, datetime_string);
outputStringToUART0(datetime_string);
datetime_getFromUnixString(&dt_tmp, tmpStr, 0);
rtc_setTime(&dt_tmp);
strcat(strJSON, "\",\"to\":\"");
outputStringToUART0(" to ");
datetime_getstring(datetime_string, &dt_tmp);
strcat(strJSON, datetime_string);
outputStringToUART0(datetime_string);
strcat(strJSON, "\",\"by\":\"hand\"}}\r\n");
outputStringToUART0("\r\n");
stateFlags1 |= (1<<writeJSONMsg); // log JSON message on next SD card write
stateFlags1 |= (1<<writeDataHeaders); // log data column headers on next SD card write
rtcStatus = rtcTimeManuallySet;
outputStringToUART0(strHdr);
intTmp1 = rtc_setupNextAlarm(&dt_CurAlarm);
timeZoneOffset = dt_tmp.houroffset;
timeFlags &= ~(1<<timeZoneWritten); // flag that time zone needs to be written
syncTimeZone(); // attempt to write the time zone; will retry later if e.g. power too low
//
/*
startTimer1ToRunThisManySeconds(30); // keep system Roused
*/
break;
}
case 'L': case 'l':
{ // experimenting with the accelerometer Leveling functions
uint8_t rs, val;
// outputStringToUART0("\r\n about to initialize ADXL345\r\n");
// rs = initializeADXL345();
// if (rs) {
// len = sprintf(str, "\n\r initialize failed: %d\n\r", rs);
// outputStringToUART0(str);
// break;
// }
// outputStringToUART0("\r\n ADXL345 initialized\r\n");
// bring out of low power mode
// use 100Hz for now ; bit 4 set = reduced power, higher noise
rs = setADXL345Register(ADXL345_REG_BW_RATE, 0x0a);
if (rs) {
len = sprintf(str, "\n\r could not set ADXL345_REG_BW_RATE: %d\n\r", rs);
outputStringToUART0(str);
break;
}
// for (iTmp = 1; iTmp < 6; iTmp++) { // try reading bit 7, INT_SOURCE.DATA_READY
// rs = readADXL345Register(ADXL345_REG_INT_SOURCE, &val);
// if (rs) {
// len = sprintf(str, "\n\r could not read ADXL345_REG_INT_SOURCE: %d\n\r", rs);
// outputStringToUART0(str);
// break;
// }
// if (val & (1 << 7)) {
// len = sprintf(str, "\n\r INT_SOURCE.DATA_READY set: 0x%x\n\r", val);
// } else {
// len = sprintf(str, "\n\r INT_SOURCE.DATA_READY clear: 0x%x\n\r", val);
// }
// outputStringToUART0(str);
// }
// outputStringToUART0("\r\n set ADXL345_REG_BW_RATE, 0x0a \r\n");
if (readADXL345Axes (&accelData)) {
outputStringToUART0("\r\n could not get ADXL345 data\r\n");
break;
}
// set low power bit (4) and 25Hz sampling rate, for 40uA current
rs = setADXL345Register(ADXL345_REG_BW_RATE, 0x18);
if (rs) {
len = sprintf(str, "\n\r could not set ADXL345_REG_BW_RATE: %d\n\r", rs);
outputStringToUART0(str);
break;
}
// len = sprintf(str, "\n\r X = %i, Y = %i, Z = %i\n\r", (unsigned int)((int)x1 << 8 | (int)x0),
// (unsigned int)((int)y1 << 8 | (int)y0), (unsigned int)((int)z1 << 8 | (int)z0));
len = sprintf(str, "\n\r X = %i, Y = %i, Z = %i\n\r", accelData.xWholeWord,
accelData.yWholeWord, accelData.zWholeWord);
outputStringToUART0(str);
break;
}
case 'C': case 'c':
{
len = sprintf(str, "\n\r test write to SD card 0x%x\n\r", (disk_initialize(0)));
intTmp1 = writeCharsToSDCard(str, len);
// sd card diagnostics
outputStringToUART0("\r\n test write to SD card\r\n");
// len = sprintf(str, "\n\r PINB: 0x%x\n\r", (PINB));
// send_cmd(CMD0, 0)
// len = sprintf(str, "\n\r CMD0: 0x%x\n\r", (send_cmd(CMD0, 0)));
break;
}
case 'P': case 'p':
{ // force SD card power off
outputStringToUART0("\r\n turning SD card power off\r\n");
turnSDCardPowerOff();
outputStringToUART0("\r\n SD card power turned off\r\n");
break;
}
case 'A': case 'a':
{
findADXL345();
break;
}
case 'F': case 'f':
{ // experimenting with temperature functions
if (!temperature_InitOneShotReading()) {
// temperature conversion time, typically 30ms
for (Timer2 = 4; Timer2; ); // Wait for 40ms to be sure
if (!temperature_GetReading(&temperatureReading)) {
len = sprintf(str, "\n\r Temperature: %d degrees C\n\r", (temperatureReading.tmprHiByte));
outputStringToUART0(str);
}
}
break;
}
//case 'I': case 'i':
//{ // experimenting with irradiance functions
//uint8_t result;
//result = getIrrReading(TSL2561_UpLooking, TSL2561_CHANNEL_BROADBAND, &irrReadings[0]);
//if (!result) {
//len = sprintf(str, "\n\r Val: %lu; Mult: %lu; Irr: %lu \n\r",
//(unsigned long)irrReadings[0].irrWholeWord, (unsigned long)irrReadings[0].irrMultiplier,
//(unsigned long)((unsigned long)irrReadings[0].irrWholeWord * (unsigned long)irrReadings[0].irrMultiplier));
//} else {
//len = sprintf(str, "\n\r Could not get irradiance, err code: %d", result);
//}
//outputStringToUART0(str);
//break;
//}
//
//case 'B': case 'b':
//{ // experimenting with reading the battery voltage using the Analog to Digital converter
//len = sprintf(str, "\n\r Hi byte: %d \n\r", readCellVoltage(&cellVoltageReading));
//outputStringToUART0(str);
//len = sprintf(str, "\n\r 16bit value: %d \n\r", cellVoltageReading.adcWholeWord);
//outputStringToUART0(str);
//
//
//break;
//}
//
//
case 'D': case 'd':
{ // output file 'D'ata (or 'D'ump)
outputStringToUART0("\r\n (data dump only works from Bluetooth)\r\n");
break;
}
// put other commands here
default:
{ // if no valid command, echo back the input
outputStringToUART0("\r\n> ");
outputStringToUART0(commandBuffer);
outputStringToUART0("\r\n");
// startTimer1ToRunThisManySeconds(30); // keep system Roused another two minutes
break;
}
} // switch (commandBuffer[0])
commandBuffer[0] = '\0';
commandBufferPtr = commandBuffer; // "empty" the command buffer
} else { // some other character
// ignore repeated linefeed (or linefeed following carriage return) or carriage return
if (!((c == 0x0a) || (c == 0x0a))) {
if (commandBufferPtr < (commandBuffer + commandBufferLen - 1)) // if there is room
*commandBufferPtr++ = c; // append char to the command buffer
}
} // done parsing character
} // while (1)
} // end of checkForCommands
int
main(int argc, char **argv)
{
bool flip_flop = false;
asm ("di");
/* Setup clocks */
CMC = 0x11U; /* Enable XT1, disable X1 */
CSC = 0x80U; /* Start XT1 and HOCO, stop X1 */
CKC = 0x00U;
delay_1sec();
OSMC = 0x00; /* Supply fsub to peripherals, including Interval Timer */
uart0_init();
#if __GNUC__
/* Force linking of custom write() function: */
write(1, NULL, 0);
#endif
/* Setup 12-bit interval timer */
RTCEN = 1; /* Enable 12-bit interval timer and RTC */
ITMK = 1; /* Disable IT interrupt */
ITPR0 = 0; /* Set interrupt priority - highest */
ITPR1 = 0;
ITMC = 0x8FFFU; /* Set maximum period 4096/32768Hz = 1/8 s, and start timer */
ITIF = 0; /* Clear interrupt request flag */
ITMK = 0; /* Enable IT interrupt */
/* asm ("ei"); / * Enable interrupts * / */
/* Disable analog inputs because they can conflict with the SPI buses: */
ADPC = 0x01; /* Configure all analog pins as digital I/O. */
PMC0 &= 0xF0; /* Disable analog inputs. */
clock_init();
/* Initialize Joystick Inputs: */
PM5 |= BIT(5) | BIT(4) | BIT(3) | BIT(2) | BIT(1); /* Set pins as inputs. */
PU5 |= BIT(5) | BIT(4) | BIT(3) | BIT(2) | BIT(1); /* Enable internal pull-up resistors. */
/* Initialize LED outputs: */
#define BIT(n) (1 << (n))
PM12 &= ~BIT(0); /* LED1 */
PM4 &= ~BIT(3); /* LED2 */
PM1 &= ~BIT(6); /* LED3 */
PM1 &= ~BIT(5); /* LED4 */
PM0 &= ~BIT(6); /* LED5 */
PM0 &= ~BIT(5); /* LED6 */
PM3 &= ~BIT(0); /* LED7 */
PM5 &= ~BIT(0); /* LED8 */
#if UIP_CONF_IPV6
#if UIP_CONF_IPV6_RPL
printf(CONTIKI_VERSION_STRING " started with IPV6, RPL" NEWLINE);
#else
printf(CONTIKI_VERSION_STRING " started with IPV6" NEWLINE);
#endif
#else
printf(CONTIKI_VERSION_STRING " started" NEWLINE);
#endif
/* crappy way of remembering and accessing argc/v */
contiki_argc = argc;
contiki_argv = argv;
process_init();
process_start(&etimer_process, NULL);
ctimer_init();
set_rime_addr();
queuebuf_init();
netstack_init();
printf("MAC %s RDC %s NETWORK %s" NEWLINE, NETSTACK_MAC.name, NETSTACK_RDC.name, NETSTACK_NETWORK.name);
#if WITH_UIP6
memcpy(&uip_lladdr.addr, serial_id, sizeof(uip_lladdr.addr));
process_start(&tcpip_process, NULL);
printf("Tentative link-local IPv6 address ");
{
uip_ds6_addr_t *lladdr;
int i;
lladdr = uip_ds6_get_link_local(-1);
for(i = 0; i < 7; ++i) {
printf("%02x%02x:", lladdr->ipaddr.u8[i * 2],
lladdr->ipaddr.u8[i * 2 + 1]);
}
/* make it hardcoded... */
lladdr->state = ADDR_AUTOCONF;
printf("%02x%02x" NEWLINE, lladdr->ipaddr.u8[14], lladdr->ipaddr.u8[15]);
}
#else
process_start(&tcpip_process, NULL);
#endif
serial_line_init();
autostart_start(autostart_processes);
while(1) {
watchdog_periodic();
if(NETSTACK_RADIO.pending_packet()) {
int len;
packetbuf_clear();
len = NETSTACK_RADIO.read(packetbuf_dataptr(), PACKETBUF_SIZE);
if(len > 0) {
packetbuf_set_datalen(len);
NETSTACK_RDC.input();
}
}
while(uart0_can_getchar()) {
char c;
UART_RX_LED = 1;
c = uart0_getchar();
if(uart0_input_handler) {
uart0_input_handler(c);
}
}
UART_RX_LED = 0;
process_run();
etimer_request_poll();
HEARTBEAT_LED1 = flip_flop;
flip_flop = !flip_flop;
HEARTBEAT_LED2 = flip_flop;
}
return 0;
}
char
in_char (void)
{
return uart0_getchar(LPUART0_BASE_PTR);
}
int fgetc(FILE *f)
{
return (uart0_getchar());
}
/**
* @brief tries receive a char via xbee. Non-Blocking function.
* @return a received char or zero if no char was received
*/
uint8_t niboCom_getchar(){
if(uart0_rxempty()==false) return uart0_getchar();
return 0;
}
