Added accelerometer-triggered sleep

 -switchable at compile time with CONFIG_ACCEL_SLEEP flag
- maintain ring buffer of 3d acceleration readings (10 samples)
- compute RMS difference between last acceleration sample and buffered
readings (10 samples, 10 seconds)
- if difference is below a preset threshold for more than 5 minutes,
send the tag to sleep
- sleep is like hibernation, except we keep reading accelerometer
- if RMS difference exceeds threshold, wake up tag
- added sleep status to the flags field of the status packet

Author: ccattuto

firmware/nRF51/tag-proximity/inc/acc.h

@@ -74,6 +74,6 @@ extern uint8_t acc_init(void);
 extern void acc_write(uint8_t cmd, uint8_t data);
 extern void acc_read(uint8_t cmd, uint8_t len, uint8_t *data);
 extern void acc_sample(void);
-extern int16_t tag_acc(uint8_t axis);
+extern int16_t acc_get(uint8_t axis);
 
 #endif/*__ACC_H__*/

firmware/nRF51/tag-proximity/inc/config.h

@@ -28,6 +28,9 @@
 /* log to flash */
 #define CONFIG_FLASH_LOGGING        1
 
+/* accelerometer-based sleep */
+#define CONFIG_ACCEL_SLEEP          1
+
 /* blink on receiving a proximity packet */
 #define CONFIG_PROXIMITY_BLINK      0
 

firmware/nRF51/tag-proximity/inc/main.h

@@ -31,6 +31,10 @@ extern uint8_t status_flags;
 extern uint8_t boot_count;
 extern uint32_t reset_reason;
 
+#if CONFIG_ACCEL_SLEEP
+extern uint8_t sleep;
+#endif
+
 extern void blink(uint8_t times);
 extern void blink_fast(uint8_t times);
 extern uint16_t blink_wait_release(void);

firmware/nRF51/tag-proximity/inc/openbeacon-proto.h

@@ -41,7 +41,7 @@
 
 #define FLAG_BOOT               (1 << 0)
 #define FLAG_TIME_RESET         (1 << 1)
-#define FLAG_HIBERNATE			(1 << 2)
+#define FLAG_SLEEP              (1 << 2)
 #define FLAG_LOG_STOPPED        (1 << 3)
 #define ERROR_FLASH_WRITE       (1 << 4)
 #define ERROR_LOG_BUF_OVERRUN   (1 << 5)

firmware/nRF51/tag-proximity/src/acc.c

@@ -24,6 +24,7 @@
 
 */
 #include <openbeacon.h>
+#include <main.h>
 #include <acc.h>
 #include <timer.h>
 
@@ -40,6 +41,19 @@ static const uint8_t g_acc_init[][2] = {
 /* most recent acceleration measurement */
 static int16_t acc[3];
 
+#if CONFIG_ACCEL_SLEEP
+#define ACC_BUFFER_LEN   10
+#define ACC_DELTA_THRES  100000L
+#define ACC_SLEEP_THRES  300
+
+static int16_t acc_buffer[ACC_BUFFER_LEN][3];
+static int32_t acc_avg[3];
+static uint8_t acc_buffer_index;
+static uint8_t acc_buffer_full;
+static uint16_t sleep_counter;
+static uint8_t moving;
+#endif /* CONFIG_ACCEL_SLEEP */
+
 
 void acc_write(uint8_t cmd, uint8_t data)
 {
@@ -88,17 +102,70 @@ void acc_read(uint8_t cmd, uint8_t len, uint8_t *data)
 }
 
 
+#if CONFIG_ACCEL_SLEEP
+static void acc_process_sample(void)
+{
+	int16_t acc_delta;
+    uint32_t acc_delta_norm = 0;
+    uint8_t i, j;
+
+	if (acc_buffer_full)
+	{
+		acc_delta_norm = 0;
+
+		for (i=0; i<3; i++)
+		{
+			acc_avg[i] = 0;
+			for (j=0; j<ACC_BUFFER_LEN; j++)
+				acc_avg[i] += acc_buffer[j][i];
+			acc_avg[i] /= ACC_BUFFER_LEN;
+
+			acc_delta = acc[i] - acc_avg[i];
+			acc_delta_norm += acc_delta * acc_delta;
+		}
+
+		if (acc_delta_norm < ACC_DELTA_THRES)
+ 		{
+			moving = 0;
+			if (!sleep && ++sleep_counter > ACC_SLEEP_THRES)
+				sleep = 1;
+		} else {
+			moving = 1;
+			sleep = 0;
+			sleep_counter = 0;
+			acc_buffer_index = 0;
+			acc_buffer_full = 0;
+		} 
+	}
+
+	for (i=0; i<3; i++)
+		acc_buffer[acc_buffer_index][i] = acc[i];
+
+	acc_buffer_index++;
+	if (acc_buffer_index == ACC_BUFFER_LEN)
+		acc_buffer_index = 0;
+
+	if (!acc_buffer_full && !acc_buffer_index)
+		acc_buffer_full = 1;
+}
+#endif /* CONFIG_ACCEL_SLEEP */
+
+
 void acc_sample(void)
 {
 	/* briefly turn on accelerometer */
 	acc_write(ACC_REG_CTRL_REG1, 0x97);
 	timer_wait(MILLISECONDS(2));
 	acc_read(ACC_REG_OUT_X, sizeof(acc), (uint8_t*)&acc);
 	acc_write(ACC_REG_CTRL_REG1, 0x00);
+
+#if CONFIG_ACCEL_SLEEP
+	acc_process_sample();
+#endif
 }
 
 
-inline int16_t tag_acc(uint8_t axis)
+inline int16_t acc_get(uint8_t axis)
 {
 	return acc[axis];
 }
@@ -147,6 +214,14 @@ uint8_t acc_init(void)
 	for(i=0; i<ACC_INIT_COUNT; i++)
 		acc_write(g_acc_init[i][0], g_acc_init[i][1]);
 
+#if CONFIG_ACCEL_SLEEP
+	acc_buffer_index = 0;
+	acc_buffer_full = 0;
+	moving = 1;
+	sleep = 0;
+	sleep_counter = 0;
+#endif /* CONFIG_ACCEL_SLEEP */
+
 	/* make first measurement */
 	acc_sample();
 

firmware/nRF51/tag-proximity/src/main.c

@@ -34,6 +34,10 @@
 #include <log.h>
 #endif
 
+#if CONFIG_ACCEL_SLEEP
+uint8_t sleep = 0;
+#endif
+
 uint8_t hibernate = 0;
 uint8_t status_flags = 0;
 uint8_t boot_count;

firmware/nRF51/tag-proximity/src/radio.c

@@ -133,7 +133,11 @@ void RTC0_IRQ_Handler(void)
 		/* increment time */
 		g_time++;
 
+#if !CONFIG_ACCEL_SLEEP
 		if (!hibernate)
+#else
+		if (!hibernate && !sleep)
+#endif
 		{
 			/* schedule tracker TX */
 			if(!g_request_tx)
@@ -157,7 +161,11 @@ void RTC0_IRQ_Handler(void)
 			rng(CONFIG_PROX_SPACING_RNG_BITS);
 		NRF_RTC0->CC[1] = NRF_RTC0->COUNTER + delta_t;
 
+#if !CONFIG_ACCEL_SLEEP
 		if (!hibernate)
+#else
+		if (!hibernate && !sleep)
+#endif	
 		{
 			/* start HF crystal oscillator */
 			NRF_CLOCK->TASKS_HFCLKSTART = 1;
@@ -391,25 +399,34 @@ void RADIO_IRQ_Handler(void)
 						g_pkt_tracker.p.status.rx_loss = (int16_t)((RX_LOSS*100)+0.5);
 						g_pkt_tracker.p.status.tx_loss = (int16_t)((TX_LOSS*100)+0.5);
 						g_pkt_tracker.p.status.ticks = NRF_RTC0->COUNTER + g_ticks_offset + g_pkt_tracker_ticks;
-						g_pkt_tracker.p.status.acc_x = tag_acc(0);
-						g_pkt_tracker.p.status.acc_y = tag_acc(1);
-						g_pkt_tracker.p.status.acc_z = tag_acc(2);
+						g_pkt_tracker.p.status.acc_x = acc_get(0);
+						g_pkt_tracker.p.status.acc_y = acc_get(1);
+						g_pkt_tracker.p.status.acc_z = acc_get(2);
 						g_pkt_tracker.p.status.voltage = adc_bat();
 						g_pkt_tracker.p.status.boot_count = boot_count;
 
 						g_pkt_tracker.p.status.info = 0;
 						if (status_flags & FLAG_BOOT)
 							g_pkt_tracker.p.status.info = (uint8_t) ( (reset_reason & 0x0F) | ((reset_reason >> 12) & 0x07) );
 
+						g_pkt_tracker.p.status.flags = status_flags;
+
 #if CONFIG_FLASH_LOGGING
 						g_pkt_tracker.p.status.flash_log_free_blocks = flash_log_free_blocks();
-						g_pkt_tracker.p.status.flags = status_flags | (flash_log_running() ? 0 : FLAG_LOG_STOPPED);
-#else /* CONFIG_FLASH_LOGGING */
+						if (!flash_log_running())
+							g_pkt_tracker.p.status.flags |= FLAG_LOG_STOPPED;
+#endif /* CONFIG_FLASH_LOGGING */
+
+#if CONFIG_ACCEL_SLEEP
+						if (sleep)
+							g_pkt_tracker.p.status.flags |= FLAG_SLEEP;
+#endif /* CONFIG_ACCEL_SLEEP */
+
+#if !CONFIG_FLASH_LOGGING
 /* if we do not log to flash, reset status flags here.
    otherwise only reset when we log a status packet to flash */
-						g_pkt_tracker.p.status.flags = status_flags;
 						status_flags = 0;
-#endif /* CONFIG_FLASH_LOGGING */
+#endif /* !CONFIG_FLASH_LOGGING */
 
 						g_time_status_reported = g_time;
 					}