PROCESS_THREAD(rtc_test, ev, data) {
PROCESS_BEGIN();
leds_off(LEDS_ALL);
etimer_set(&periodic_timer_rtc, CLOCK_SECOND*5);
while(1) {
PROCESS_YIELD();
if (etimer_expired(&periodic_timer_rtc)) {
rv3049_read_time(&rtctime);
if (rtctime.seconds - 3 > last_seconds) {
leds_toggle(LEDS_BLUE);
leds_off(LEDS_RED);
} else {
leds_toggle(LEDS_RED);
leds_off(LEDS_BLUE);
}
last_seconds = rtctime.seconds;
etimer_restart(&periodic_timer_rtc);
}
}
PROCESS_END();
}
PROCESS_THREAD(button_process, ev, data)
{
static struct etimer etimer;
PROCESS_EXITHANDLER(goto exit);
PROCESS_BEGIN();
printf("button_process starting\n");
while(1) {
PROCESS_WAIT_EVENT();
if(ev == PROCESS_EVENT_MSG && data != NULL
&& ((struct button_msg *)data)->type == BUTTON_MSG_TYPE) {
printf("button press\n");
leds_toggle(LEDS_ALL);
etimer_set(&etimer, CLOCK_SECOND);
PROCESS_WAIT_UNTIL(etimer_expired(&etimer));
leds_toggle(LEDS_ALL);
}
}
exit:
printf("button_process exiting\n");
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
static void
recv_uc(struct unicast_conn *c, const linkaddr_t *from)
{
struct measure_message msg;
// Check if the message length corresponds to the used struct
if (packetbuf_datalen() == sizeof(struct measure_message)){
packetbuf_copyto(&msg);
// printf("unicast message received from %d.%d: \n",
// from->u8[0], from->u8[1]);
printf("seq %lu", msg.seq);
printf(" bat %ld.%03d V\n",
(long) msg.bat_voltage,
(unsigned) ((msg.bat_voltage - floor(msg.bat_voltage)) * 1000)
);
leds_toggle(LEDS_GREEN);
} else {
// Wrong message sizes
printf("Got invalid message\n");
leds_toggle(LEDS_RED);
}
}
static void leds_pattern_toggle(uint8_t pattern)
{
if (pattern & 0x1) leds_toggle(0);
if (pattern & 0x2) leds_toggle(1);
if (pattern & 0x4) leds_toggle(2);
if (pattern & 0x8) leds_toggle(3);
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(interrupt_sample_process, ev, data)
{
/* Any process must start with this. */
PROCESS_BEGIN();
interrupt_init(1, 1, 1, 1);
interrupt_enable(INT0);
interrupt_enable(INT1);
/* Register current process with INT0 & INT1*/
interrupt_register(INT0);
interrupt_register(INT1);
while(1) {
/* Wait for an event. */
PROCESS_WAIT_EVENT();
/* Got the interrupt event~ */
if (ev == PROCESS_EVENT_INTERRUPT) {
/* Check for the int_vect. */
if (INT0 == ((struct interrupt *)data)->int_vect) {
/* Got an INT0 interrupt. */
leds_toggle(LEDS_RED);
}
else if (INT1 == ((struct interrupt *)data)->int_vect) {
/* Got an INT1 interrupt. */
leds_toggle(LEDS_YELLOW);
interrupt_disable(INT0);
}
}
} // while (1)
/* Any process must end with this, even if it is never reached. */
PROCESS_END();
}
/*-------------------------------------------------------------------*/
PROCESS_THREAD(blink_leds_proc, ev, data)
{
static struct etimer timer1;
static struct etimer timer2;
static struct etimer timer3;
PROCESS_BEGIN();
etimer_set(&timer1, INTERVAL1);
etimer_set(&timer2, INTERVAL2);
etimer_set(&timer3, INTERVAL3);
while(1) {
PROCESS_WAIT_EVENT();
if(ev == PROCESS_EVENT_TIMER && data == &timer1) {
etimer_reset(&timer1);
leds_toggle(LEDS_RED);
} else if(ev == PROCESS_EVENT_TIMER && data == &timer2) {
etimer_reset(&timer2);
leds_toggle(LEDS_GREEN);
} else if(ev == PROCESS_EVENT_TIMER && data == &timer3) {
etimer_reset(&timer3);
leds_toggle(LEDS_YELLOW);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(unicast_sender_process, ev, data)
{
static struct etimer periodic_timer;
static struct etimer send_timer;
uip_ipaddr_t *addr;
PROCESS_BEGIN();
SENSORS_ACTIVATE(button_sensor);
// SENSORS_ACTIVATE(light_sensor);
servreg_hack_init();
set_global_address();
simple_udp_register(&unicast_connection, UDP_PORT,
NULL, UDP_PORT, receiver);
//etimer_set(&periodic_timer, SEND_INTERVAL);
while(1) {
// PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&periodic_timer));
PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor);
// etimer_reset(&periodic_timer);
etimer_set(&send_timer, SEND_TIME);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&send_timer));
addr = servreg_hack_lookup(SERVICE_ID);
if(addr != NULL) {
static unsigned int button_number;
char buf[50];
if(button_number == 0) {
button_number = 1;
leds_toggle(LEDS_ALL);
} else {
button_number = 0;
leds_toggle(LEDS_ALL);
}
printf("Sending unicast to ");
uip_debug_ipaddr_print(addr);
printf("\n");
//sprintf(buf, "Occupancy Detector: %d, Luminaire Illuminance: %d", button_number, LUMINAIRE_ILLUMINANCE);
sprintf(buf, "Occupancy Detector: %d, Luminaire Illuminance: %d", button_number, (int)(410 ));
simple_udp_sendto(&unicast_connection, buf, strlen(buf) + 1, addr);
} else {
printf("Service %d not found\n", SERVICE_ID);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(test_remote_zonik_process, ev, data)
{
static int16_t zonik_val;
static uint8_t i;
PROCESS_BEGIN();
printf("Initial status of sensor is: 0x%04X\n",
zonik.status(SENSORS_ACTIVE));
while(1) {
/* Configure Zonik and activate the internal process readings */
SENSORS_ACTIVATE(zonik);
printf("Initialized. Sensor status: 0x%04X\n",
zonik.status(SENSORS_ACTIVE));
/* Read sensor value dBA multiple times */
for(i=0; i<MAX_VALID_READINGS; i++) {
/* Wait a bit */
etimer_set(&et, CLOCK_SECOND);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
/* Get data from sensor */
zonik_val = zonik.value(ZONIK_DBA_LEQ_VALUE);
leds_toggle(LEDS_GREEN);
printf("Value (dBA): %d\n", zonik_val);
}
printf("Sensor status is: 0x%04X\n",
zonik.status(SENSORS_ACTIVE));
/* Disable Zonik sensor */
SENSORS_DEACTIVATE(zonik);
printf("Process Stopped: 0x%04X\n", zonik.status(SENSORS_ACTIVE));
for(i=0; i<MAX_INVALID_READINGS; i++) {
/* Wait a bit */
etimer_set(&et, CLOCK_SECOND);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
/* Get data from sensor */
zonik_val = zonik.value(ZONIK_DBA_LEQ_VALUE);
leds_toggle(LEDS_GREEN);
printf("Value (dBA): %d\n", zonik_val);
}
etimer_set(&et, CLOCK_SECOND);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
}
PROCESS_END();
}
static void
timeout_handler(void)
{
if (!connected) {
INFO("waiting for socket connection...");
return;
}
if (sending) {
printf(".");
return;
}
buf[0]++;
leds_toggle(LEDS_GREEN);
#if SEND_TOO_LARGE_PACKET_TO_TEST_FRAGMENTATION
tcp_socket_send(&socket, (const uint8_t *)buf, UIP_APPDATA_SIZE);
#else /* SEND_TOO_LARGE_PACKET_TO_TEST_FRAGMENTATION */
tcp_socket_send(&socket, (const uint8_t *)buf, packet_length);//(random_rand() % MAX_PAYLOAD_LEN) + 1);
#endif /* SEND_TOO_LARGE_PACKET_TO_TEST_FRAGMENTATION */
sending = 1;
// INFO("START tcp send");
}
/*---------------------------------------------------------------------------*/
static void
broadcast_recv(struct broadcast_conn *c, const linkaddr_t *from)
{
leds_toggle(LEDS_RF_RX);
printf("*** Received %u bytes from %u:%u: '0x%04x'\n", packetbuf_datalen(),
from->u8[0], from->u8[1], *(uint16_t *)packetbuf_dataptr());
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(hello_world_process, ev, data)
{
PROCESS_BEGIN();
static struct etimer myTimer;
printf("Hello, world\n");
leds_init();
//PORTR_OUT = 0x3;
etimer_set(&myTimer, CLOCK_SECOND);
while(1)
{
PROCESS_WAIT_EVENT();
// PORTR.OUTTGL = 0x3;
leds_toggle(0x3);
printf("Toggle LED0 from process: %10d: %X\n", i++, leds_get());
etimer_restart(&myTimer);
}
PROCESS_END();
}
void tmr3_isr(void) {
if(bit_is_set(*TMR(3,CSCTRL),TCF1)) {
current_clock++;
if((current_clock % CLOCK_CONF_SECOND) == 0) {
seconds++;
#if BLINK_SECONDS
leds_toggle(LEDS_GREEN);
#endif
}
if(etimer_pending() &&
(etimer_next_expiration_time() - current_clock - 1) > MAX_TICKS) {
etimer_request_poll();
}
/* clear the compare flags */
clear_bit(*TMR(3,SCTRL),TCF);
clear_bit(*TMR(3,CSCTRL),TCF1);
clear_bit(*TMR(3,CSCTRL),TCF2);
return;
} else {
/* this timer didn't create an interrupt condition */
return;
}
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(test_button_process, ev, data)
{
/* static struct etimer et; */
PROCESS_BEGIN();
SENSORS_ACTIVATE(phidgets);
SENSORS_ACTIVATE(button_sensor);
while(1) {
printf("Please press the User Button\n");
PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event &&
data == &button_sensor);
leds_toggle(LEDS_GREEN);
printf("Phidget 5V 1:%d\n", phidgets.value(PHIDGET5V_1));
printf("Phidget 5V 2:%d\n", phidgets.value(PHIDGET5V_2));
printf("Phidget 3V 1:%d\n", phidgets.value(PHIDGET3V_1));
printf("Phidget 3V 2:%d\n", phidgets.value(PHIDGET3V_2));
if(phidgets.value(PHIDGET3V_1) < 100) {
leds_on(LEDS_RED);
} else {
leds_off(LEDS_RED);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(rx_process, ev, data)
{
PROCESS_BEGIN();
arduino_spi_init();
status_led_init();
lora_radio_driver.init();
// Start infinite RX
lora_radio_driver.on();
// Print CPU serial
printf("CPU serial nb: %08x, %08x, %08x, %08x\n",(unsigned int) U_ID->UI_0,(unsigned int) U_ID->UI_1, (unsigned int) U_ID->UI_2,(unsigned int) U_ID->UI_3);
etimer_set(&rx_timer, 10 * CLOCK_SECOND);
while( 1 )
{
PROCESS_WAIT_EVENT();
if(ev == PROCESS_EVENT_TIMER) {
leds_toggle(LEDS_ALL);
printf( "Alive %d\n\r", counter++);
etimer_reset(&rx_timer);
}
}
PROCESS_END();
}
int main()
{
// Initialize the platform
platform_init();
printf("SysTick test program\n");
// Set initial values
leds_on(LED_0);
leds_off(LED_1);
// Enable the SysTick, 100Hz
nvic_enable_systick(100, alarm, 0);
while (1)
{
int i;
for (i = 0; i < 0x80000; i++)
{
__asm__("nop");
}
leds_toggle(LED_1);
}
return 0;
}
/*---------------------------------------------------------------------------*/
static void
recv( const struct mac_driver *c)
{
packetbuf_set_attr(PACKETBUF_ATTR_CHANNEL, 34);
int len = c->read();
char cleanString [128];
int cleanLen = 0;
int i;
char* in= (char*)packetbuf_dataptr();
for ( i = 0; i < len; i++)
{
if ( ( in[i] >= ' ' && in[i] <= 'z' ))
{
cleanString[cleanLen] = in[i];
cleanLen++;
}
}
cleanString[cleanLen] = '\0';
cleanLen++;
printf("message received, len = %d, '%s'\n", cleanLen, cleanString);
//printf("message received, len = %d, '%s'\n", len, (char *)packetbuf_dataptr());
leds_toggle(LEDS_GREEN);
//packetbuf_clear();
//packetbuf_attr_clear();
}
PROCESS_THREAD(gpio_process, ev, data)
{
PROCESS_BEGIN();
leds_toggle(LEDS_RED);
configGPIOInterrupt();
// configGPIOOuput();
// etimer_set(&gpioOut, CLOCK_SECOND);
while(1) {
PROCESS_YIELD();
// if (etimer_expired(&gpioOut)) {
// if(raiseHigh){
// GPIO_SET_PIN(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(1));
// raiseHigh = 0;
// }
// else{
// GPIO_CLR_PIN(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(1));
// raiseHigh = 1;
// }
// etimer_restart(&gpioOut);
// }
}
PROCESS_END();
}
void ui_leds_handler(void)
/*
Handles the updating of all button LEDs.
If a button's value is 0xFF, it is on, and
if it's 0, it's off. Otherwise the value is the
current value of a counter which is used to blink
the LEDs.
*/
{
static uint8_t counter;
for (uint8_t i = 0; i < 24; i++) {
if (button_led_get(i) == 0)
leds_off(i);
else if (button_led_get(i) == 1)
leds_on(i);
else {
if (counter == BLINK_CNT) {
leds_toggle(i);
}
}
}
if (counter++ == BLINK_CNT)
counter = 0;
}
void
camera_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset)
{
const char *temp;
uint8_t buff[1024];
camera_size_t camera_size = CAMERA_SIZE_1;
u16_t count;
u32_t size;
int index = 0, len = 0, tries = 10;
if (0 == *offset) {
/* Determine the size of picture. 1 for the smallest and 3 for the largest. */
if (!REST.get_query_variable(request, "size", &temp)) {
REST.get_post_variable(request, "size", &temp);
}
if (temp) {
camera_size = camera_parse_size(temp[0]);
}
leds_toggle(LEDS_GREEN);
camera_take_picture(camera_size, preferred_size, &size, &count);
}
index = *offset / preferred_size + 1;
count = camera_get_packet_count();
len = camera_try_get_packet(index, buff, tries);
*offset += len;
if (index >= count) {
*offset = -1;
}
REST.set_header_content_type(response, REST.type.IMAGE_JPEG);
REST.set_response_payload(response, buff, len);
}
static void kbd_task(void *pvParameters)
{
uint8_t idx = 0;
bool last_state = false;
char hikob[] = "-- HiKoB --";
while (1)
{
/* LED used to indicate if the device is set up */
if(kbd_get_state())
leds_off(LED_1);
last_state = false;
leds_toggle(LED_0);
vTaskDelay(configTICK_RATE_HZ/10);
if(!button_state() && !last_state){ //if the button is pushed
kbd_send(hikob[idx]);
idx ++;
last_state = true;
}
else{
kbd_send(NO_CHAR);
last_state = false;
}
if(idx > sizeof(hikob))
idx = 0;
}
}
/*---------------------------------------------------------------------------*/
static int
detect_ack(void)
{
#define INTER_PACKET_INTERVAL RTIMER_ARCH_SECOND / 5000
#define ACK_LEN 3
#define AFTER_ACK_DETECTECT_WAIT_TIME RTIMER_ARCH_SECOND / 1000
rtimer_clock_t wt;
uint8_t ack_received = 0;
wt = RTIMER_NOW();
leds_on(LEDS_GREEN);
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { }
leds_off(LEDS_GREEN);
/* Check for incoming ACK. */
if((NETSTACK_RADIO.receiving_packet() ||
NETSTACK_RADIO.pending_packet() ||
NETSTACK_RADIO.channel_clear() == 0)) {
int len;
uint8_t ackbuf[ACK_LEN + 2];
wt = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + AFTER_ACK_DETECTECT_WAIT_TIME)) { }
len = NETSTACK_RADIO.read(ackbuf, ACK_LEN);
if(len == ACK_LEN) {
ack_received = 1;
}
}
if(ack_received) {
leds_toggle(LEDS_RED);
}
return ack_received;
}
PROCESS_THREAD(rtctest_process, ev, data)
{
static struct etimer et;
PROCESS_BEGIN();
printf("RTC init\r\n");
rtc_init();
//Alarm counter
rtc_set_alarm(200);
while(1) {
etimer_set(&et, CLOCK_SECOND);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
if (rtc_read() > 100 && rtc_read() < 150) {
leds_off(LEDS_ALL);
pm_stop_mode(0);
}
if (rtc_read() > 200) {
leds_toggle(LEDS_ALL);
}
rtc_sync();
printf("1s tick.. %d rtc alarm flag %d\r\n", rtc_read(), (RTC->CRL & RTC_CRL_ALRF));
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(test_pm10_sensor_process, ev, data)
{
PROCESS_BEGIN();
static uint16_t pm10_value;
/* Use pin number not mask, for uart_demo if using the PA5 pin then use 2 */
pm10.configure(SENSORS_ACTIVE, ADC_PIN);
/* And periodically poll the sensor */
while(1) {
etimer_set(&et, SENSOR_READ_INTERVAL);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
leds_toggle(LEDS_GREEN);
pm10_value = pm10.value(1);
if(pm10_value != ADC_WRAPPER_ERROR) {
printf("PM10 value = %u ppm\n", pm10_value);
} else {
printf("Error, enable the DEBUG flag in adc-wrapper.c for info\n");
PROCESS_EXIT();
}
}
PROCESS_END();
}
void gp_int() {
etimer_set(&periodic_timer_gpio, CLOCK_SECOND/10);
unsigned int i;
for(i = 0;i<100000000;i++)
leds_toggle(LEDS_BLUE);
printf("@@@@@@@@@@@@@@\n");
etimer_restart(&periodic_timer_gpio);
}
/*---------------------------------------------------------------------------*/
static void
udp_appcall(void *arg)
{
struct data *d;
/* char buf[50];*/
d = (struct data *)uip_appdata;
if(uip_newdata()) {
leds_toggle(LEDS_YELLOW);
/* beep();*/
/* if(uip_htons(d->seqno) != last_seqno + 1) {
leds_toggle(LEDS_RED);
beep_quick(2);
}*/
/* last_seqno = uip_htons(d->seqno);*/
/* uip_udp_send(sizeof(struct data));*/
/* snprintf(buf, sizeof(buf), "Packet received id %d signal %u\n",
d->id, tr1001_sstrength());
rs232_print(buf);*/
/* if(d->pingpong == PING) {
d->pingpong = PONG;
} else {
d->pingpong = PING;
d->seqno = uip_htons(uip_htons(d->seqno) + 1);
}*/
/* uip_udp_send(sizeof(struct data));
timer_restart(&timer);*/
} else if(uip_poll()) {
if(pingeron && etimer_expired(&etimer) && packet_count > 0) {
--packet_count;
d->id = place_id;
d->pingpong = PING;
d->seqno = uip_htons(sent_seqno);
++sent_seqno;
uip_udp_send(sizeof(struct data));
etimer_reset(&etimer);
leds_toggle(LEDS_GREEN);
}
if(packet_count == 0) {
pingeron = 0;
}
}
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(borderest_process, ev, data)
{
static struct etimer et;
PROCESS_BEGIN();
/* While waiting for the prefix to be sent through the SLIP connection, the future
* border router can join an existing DAG as a parent or child, or acquire a default
* router that will later take precedence over the SLIP fallback interface.
* Prevent that by turning the radio off until we are initialized as a DAG root.
*/
prefix_set = 0;
NETSTACK_MAC.off(0);
PROCESS_PAUSE();
SENSORS_ACTIVATE(button_sensor);
PRINTF("RPL-Border router started\n");
#if 0
/* The border router runs with a 100% duty cycle in order to ensure high
packet reception rates.
Note if the MAC RDC is not turned off now, aggressive power management of the
cpu will interfere with establishing the SLIP connection */
NETSTACK_MAC.off(1);
#endif
/* Request prefix until it has been received */
while(!prefix_set) {
etimer_set(&et, CLOCK_SECOND);
request_prefix();
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
}
/* Now turn the radio on, but disable radio duty cycling.
* Since we are the DAG root, reception delays would constrain mesh throughbut.
*/
NETSTACK_MAC.off(1);
#if DEBUG || 1
print_local_addresses();
#endif
rest_init_engine();
activate_coap_resources();
leds_init();
while(1) {
PROCESS_YIELD();
if (ev == sensors_event && data == &button_sensor) {
PRINTF("Initiating global repair\n");
rpl_repair_root(RPL_DEFAULT_INSTANCE);
leds_toggle(LEDS_ALL);
}
}
PROCESS_END();
}
// Task that blinks LED at 1Hz
static void vLEDTask(void *pvParameters)
{
while (1)
{
vTaskDelay(configTICK_RATE_HZ);
leds_toggle(LED_0);
}
}
int exec_alarm(void) {
leds_toggle(LED_RED);
alarm.date = rtc_time() + 5;
alarm.exec_cb = exec_alarm;
rtc_set_alarm(&alarm);
return 0;
}
// define
PROCESS_THREAD(p_hello_led, ev, data) {
PROCESS_BEGIN();
printf("Hello led !!!");
while(1) {
PROCESS_WAIT_EVENT();
leds_toggle(LEDS_ALL);
}
PROCESS_BEGIN();
}
/*---------------------------------------------------------------------------*/
static void
recv(const struct mac_driver *c)
{
printf("message received '%s'\n", (char *)packetbuf_dataptr());
leds_toggle(LEDS_GREEN);
packetbuf_clear();
packetbuf_attr_clear();
}
