示例#1
0
/** \brief Light & proximity sensor demo application entry
 *
 * After initializing the Xplained platform and sensor boards, this application
 * attaches descriptors to the ambient light and proximity sensor devices on
 * an Xplained inertial sensor board.  The sensor data, which is formatted and
 * printed via printf() after being read, can be viewed with a serial terminal
 * application on a machine attached to the USB interface on the Xplained
 * board.
 */
int main(void)
{
	sensor_t light_dev;     /* Light sensor device descriptor */
	sensor_t prox_dev;      /* Proximity sensor device descriptor */

	/* Initialize the board (Xplained UC3 or XMEGA & Xplained Sensor boards)
	 * I/O pin mappings and any other configurable resources selected in
	 * the build configuration.
	 */
	sensor_platform_init();

	/* Attach descriptors to the defined sensor devices. */
	sensor_attach(&light_dev, SENSOR_TYPE_LIGHT, 0, 0);
	sensor_attach(&prox_dev, SENSOR_TYPE_PROXIMITY, 0, 0);

	if (light_dev.err || prox_dev.err) {
		puts("\rSensor initialization error.");

		while (true) {
			/* Error occurred, loop forever */
		}
	}

	/* Print sensor information */
	if (PRINT_BANNER) {
		static const char *const banner_format
			= "%s\r\nID = 0x%02x ver. 0x%02x\r\n"
				"Bandwidth = %d Hz  Range = +/- %d\r\n\n";

		uint32_t id;
		uint8_t version;
		int16_t freq, range;

		sensor_device_id(&light_dev, &id, &version);
		sensor_get_bandwidth(&light_dev, &freq);
		sensor_get_range(&light_dev, &range);

		printf(banner_format, light_dev.drv->caps.name,
				(unsigned)id, (unsigned)version, freq, range);

		sensor_device_id(&prox_dev, &id, &version);
		sensor_get_bandwidth(&prox_dev, &freq);
		sensor_get_range(&prox_dev, &range);

		printf(banner_format, prox_dev.drv->caps.name,
				(unsigned)id, (unsigned)version, freq, range);

		delay_ms(500);
	}

	/* Set sample interval for the light sensor */
	if (sensor_set_sample_rate(&light_dev, LIGHT_SAMPLE_RATE) != true) {
		printf("Error setting light sensor sample rate.\r\n");
	}

	/* Set sample interval for the proximity sensor */
	if (sensor_set_sample_rate(&prox_dev, PROX_SAMPLE_RATE) != true) {
		printf("Error setting proximity sensor sample rate.\r\n");
	}

	/* Select all proximity sensor channels */
	sensor_set_channel(&prox_dev, SENSOR_CHANNEL_ALL);

#if (SET_PROX_THRESHOLD == true)
	/* Manually set proximity threshold values for each channel */
	/* Otherwise, sensor will use values previously stored in nvram. */
	sensor_set_threshold(&prox_dev, SENSOR_THRESHOLD_NEAR_PROXIMITY,
			PROX_THRESHOLD);
#endif

#if (SET_PROX_CURRENT == true)
	/* Manually set LED current value for each channel */
	/* Otherwise, sensor will use default values. */
	sensor_set_current(&prox_dev, PROX_CURRENT_mA);
#endif

	/* Initialize sensor data descriptors for scaled vs. raw data. */
	static sensor_data_t light_data = {.scaled = SCALED_DATA};
	static sensor_data_t prox_data  = {.scaled = SCALED_DATA};

	while (true) {
		LED_Toggle(ACTIVITY_LED);

		/* Read sensor values */
		sensor_get_light(&light_dev, &light_data);
		sensor_get_proximity(&prox_dev, &prox_data);

		/* Print sensor values */
		if (SCALED_DATA) {
			printf("light = [%5d]\r\n",
					(int16_t)light_data.light.value);

			printf("prox  = 1:%s 2:%s 3:%s\r\n",
					prox_labels[prox_data.proximity.value[0]],
					prox_labels[prox_data.proximity.value[1]],
					prox_labels[prox_data.proximity.value[2]]);
		} else {
			printf("light = [%5d]\r\n",
					(int16_t)light_data.light.value);

			printf("prox = [%.5x, %.5x, %.5x]\r\n",
					(int16_t)prox_data.proximity.value[0],
					(int16_t)prox_data.proximity.value[1],
					(int16_t)prox_data.proximity.value[2]);
		}

		delay_ms(500);
	}

	return 0;
}
示例#2
0
/** \brief Inertial sensor demo application entry
 *
 * After initializing the Xplained platform and sensor boards, this application
 * attaches descriptors to the accelerometer and gyroscope devices on
 * an Xplained inertial sensor board.  The sensor data, which is formatted and
 * printed via printf() after being read, can be viewed with a serial terminal
 * application on a machine attached to the USB interface on the Xplained
 * board.
 */
int main(void)
{
	/* Initialize the Xplained (UC3 or XMEGA) platform & sensor boards. */
	sensor_platform_init();

	LED_On(ACTIVITY_LED);

	/* Initialize the MCU sleep manager API and specify a sleep mode. */
	sleepmgr_init();
	sleepmgr_lock_mode(SLEEP_MODE);

#if (USE_ACCEL == true)
	/* Attach accelerometer */
	sensor_attach(&accelerometer, SENSOR_TYPE_ACCELEROMETER, 0, 0);

	if (accelerometer.err) {
		puts("\r\nAccelerometer initialization error.");

		while (true) {
			/* Error occurred, loop forever */
		}
	}

	/* Enable motion event */
	sensor_set_threshold(&accelerometer, SENSOR_THRESHOLD_MOTION,
			ACCEL_MOT_THRESH);

	sensor_add_event(&accelerometer, SENSOR_EVENT_MOTION,
			acceleration_event, 0, true);

	/* Put the accelerometer into a low-power mode (if available) */
	sensor_set_state(&accelerometer, SENSOR_STATE_LOW_POWER);
#endif

#if (USE_GYRO == true)
	/* Attach gyroscope */
	sensor_attach(&gyroscope, SENSOR_TYPE_GYROSCOPE, 0, 0);

	if (gyroscope.err) {
		puts("\r\nGyroscope initialization error.");

		while (true) {
			/* Error occurred, loop forever */
		}
	}

	sensor_set_sample_rate(&gyroscope, GYRO_SAMPLE_RATE);

#  if (GYRO_WAKE == true)
	/* Enable gyroscope new data event for wakeup */
	sensor_add_event(&gyroscope, SENSOR_EVENT_NEW_DATA,
			rotation_event, 0, true);
#  elif (GYRO_SLEEP == true)
	/* Put gyro in low-power sleep mode until accelerometer wakes system up */
	sensor_set_state(&gyroscope, SENSOR_STATE_SLEEP);
#  endif
#endif

	while (true) {
		LED_Off(ACTIVITY_LED);/* turn off while asleep */

		/* Put device in low power sleep mode until woken up by an interrupt */
		sleepmgr_enter_sleep(); /* enter specified sleep mode */

		/* Device has woken up */
		LED_On(ACTIVITY_LED);             /* turn on while awake */

#if ((USE_GYRO == true) && (GYRO_WAKE == false))
#  if (GYRO_SLEEP == true)
		/* Wake up gyroscope, wait for device to settle */
		sensor_set_state(&gyroscope, SENSOR_STATE_NORMAL);
		delay_ms(GYRO_RESTART_DELAY);

		/* Read gyroscope and put it back to sleep */
		sensor_get_rotation(&gyroscope, &rotation);
		sensor_set_state(&gyroscope, SENSOR_STATE_SLEEP);
#  else
		/* Read gyro in response to accelerometer wake */
		sensor_get_rotation(&gyroscope, &rotation); /* read gyro now */
#  endif
#endif

#if (USE_PRINTF == true)
		const char *const format = SCALED_DATA ?
				"acc = [%5d, %5d, %5d]  rot = [%5d, %5d, %5d]\r\n"
				:
				"acc = [%.5x, %.5x, %.5x]  rot = [%.5x, %.5x, %.5x]\r\n";

		/* Print accelerometer & gyroscope values */
		printf(format,
				/* data from motion event handler */
				(int16_t)acceleration.axis.x,
				(int16_t)acceleration.axis.y,
				(int16_t)acceleration.axis.z,
				
				/* data from sensor_get_rotation() (if GYRO_WAKE==false), or 
				 * from the gyro new data event handler */
				(int16_t)rotation.axis.x,
				(int16_t)rotation.axis.y,
				(int16_t)rotation.axis.z
		);
#endif

		/* Minimum active time is 100 msec */
		delay_ms(100);
	}

	return 0;
}
示例#3
0
文件: main.c 项目: InSoonPark/asf
/** \brief Proximity Sensor gesture recognition demo application entry
 *
 * This application uses a 3-channel proximity sensor to recognize simple
 * gestures.  When a proximity event occurs, the routine will wake up from
 * a low-power sleep mode and begin repeatedly sampling the proximity
 * sensor, until the proximity of the object is no longer detected.  Then
 * the beginning and ending sensor readings are compared, and the overall
 * direction of the object's movement is determined based on a lookup table.
 *
 * Once the direction is determined, it is indicate by turning on one of the
 * LEDs on the controller board and (optionally) by serial output to a
 * terminal device.  If the direction cannot be determined, all indicator
 * LEDs will be blinked rapidly.
 *
 * The application then resets by returning to a low-power sleep mode until
 * the next proximity event is detected.
 */
int main(void)
{
	uint8_t start_channels;    /* First channels detecting proximity */
	uint8_t current_channels;  /* Current channels detecting proximity */
	uint8_t end_channels;      /* Final channels detecting proximity */
	direction_t direction;     /* Calculated gesture direction */
	int i;

	/* Initialize the board (Xplained UC3 or XMEGA & Xplained Sensor boards)
	 * I/O pin mappings and any other configurable resources selected in
	 * the build configuration.
	 */
	sensor_platform_init();

	/* Turn on LEDs while initialization completes */
	LED_On(UP_LED);
	LED_On(DOWN_LED);
	LED_On(LEFT_LED);
	LED_On(RIGHT_LED);

	/* Initialize the MCU sleep manager API and specify a sleep mode. */
	sleepmgr_init();
	sleepmgr_lock_mode(SLEEP_MODE);

	/* Attach and initialize proximity sensor */
	sensor_attach(&prox_dev, SENSOR_TYPE_PROXIMITY, 0, 0);

	if (prox_dev.err) {
		puts("\r\nProximity sensor initialization error.");

		while (true) {
			/* Error occurred, loop forever */
		}
	}

#if (USE_PRINTF == true)
	uint32_t id;      /* Device ID */
	uint8_t version;  /* Device version */

	sensor_device_id(&prox_dev, &id, &version);
	printf("\r\nProximity sensor: %s    ID = 0x%02x ver. 0x%02x\r\n",
			prox_dev.drv->caps.name, (unsigned)id,
			(unsigned)version);
#endif

	/* Set sample rate */
	sensor_set_sample_rate(&prox_dev, PROX_SAMPLE_RATE);

	/* Select all proximity sensor channels */
	sensor_set_channel(&prox_dev, SENSOR_CHANNEL_ALL);
	
#if (SET_PROX_THRESHOLD == true)
	/* Manually  set proximity threshold values for each channel */
	/*  Otherwise, sensor will use values previously stored in nvram. */
	sensor_set_threshold(&prox_dev, SENSOR_THRESHOLD_NEAR_PROXIMITY,
			PROX_THRESHOLD);
#endif

#if (SET_PROX_CURRENT == true)
	/* Manually set LED current value for each channel */
	/*  Otherwise, sensor will use default values */
	sensor_set_current(&prox_dev, PROX_CURRENT_mA);
#endif

	/* Set up close proximity event to wakeup system */
	sensor_add_event(&prox_dev, SENSOR_EVENT_NEAR_PROXIMITY,
			prox_event_handler, 0, false);

	while (true) {
		/* Enable proximity event */
		sensor_enable_event(&prox_dev, SENSOR_EVENT_NEAR_PROXIMITY);

		/* Delay before putting device to sleep */
		delay_ms(10);

		/* Put device in low power sleep mode; wait for an interrupt to
		 * wake. */
		LED_Off(UP_LED);
		LED_Off(DOWN_LED);
		LED_Off(LEFT_LED);
		LED_Off(RIGHT_LED);

		/* Enter specified sleep mode */
		sleepmgr_enter_sleep();

		/* Only do sensor processing if proximity event woke device up */
		if (prox_event_occurred) {
			prox_event_occurred = false;

			/* Disable new proximity events during gesture sampling */
			sensor_disable_event(&prox_dev,
					SENSOR_EVENT_NEAR_PROXIMITY);

			/* Get starting value saved by event handler routine */
			start_channels = test_channels(&prox_data);
			end_channels = start_channels;

			/* Loop until no longer detecting proximity */
			do {
				/* Get new readings from sensor */
				sensor_get_proximity(&prox_dev, &prox_data);

				current_channels = test_channels(&prox_data);

				/* Update end value if proximity is still
				 * detected */
				if (current_channels != CHAN_NONE) {
					end_channels = current_channels;
				}
			} while (current_channels != CHAN_NONE);

			/* Get direction from lookup table based on start/end
			 * channel sets */
			direction = dir_tbl [start_channels] [end_channels];

#if USE_PRINTF
			/* Display direction */
			printf("Start: %s  End: %s  Direction: %s \r\n",
					channel_labels[start_channels],
					channel_labels[end_channels],
					direction_labels[direction]);
#endif

			/* Use LEDs to display direction */
			switch (direction) {
			case UP:
				LED_On(UP_LED);
				break;

			case DOWN:
				LED_On(DOWN_LED);
				break;

			case LEFT:
				LED_On(LEFT_LED);
				break;

			case RIGHT:
				LED_On(RIGHT_LED);
				break;

			default: 
				/* Unknown - blink all LEDs to indicate */
				for (i = 0; i < (ERR_BLINK_COUNT * 2); i++) {
					LED_Toggle(UP_LED);
					LED_Toggle(DOWN_LED);
					LED_Toggle(LEFT_LED);
					LED_Toggle(RIGHT_LED);

					delay_ms(50);
				}
				break;
			}
		}
		
		delay_ms(500);
	}
	
	return 0;
}
示例#4
0
/** \brief Inertial sensor demo application entry
 *
 * After initializing the Xplained platform and sensor boards, this application
 * attaches descriptors to the accelerometer, gyroscope, and compass devices on
 * an Xplained inertial sensor board.  The sensor data, which is formatted and
 * printed via printf() after being read, can be viewed with a serial terminal
 * application on a machine attached to the USB interface on the Xplained
 * board.
 */
int main(void)
{
	sensor_t light_dev;  /* Light sensor device descriptor */
	sensor_t prox_dev;   /* Proximity sensor device descriptor */

	/* Initialize the board (Xplained UC3 or XMEGA & Xplained Sensor boards)
	 * I/O pin mappings and any other configurable resources selected in
	 * the build configuration.
	 */
	sensor_platform_init();

	/* Attach descriptors to the defined sensor devices. */
	sensor_attach(&light_dev, SENSOR_TYPE_LIGHT, 0, 0);
	sensor_attach(&prox_dev, SENSOR_TYPE_PROXIMITY, 0, 0);

	if (light_dev.err || prox_dev.err) {
		puts("\rSensor initialization error.");

		while (true) {
			/* Error occurred, loop forever */
		}
	}

	/* Set sample rates for light and proximity sensors */
	if (sensor_set_sample_rate(&light_dev, LIGHT_SAMPLE_RATE) != true) {
		printf("Error setting light sensor sample rate.\r\n");
	}

	if (sensor_set_sample_rate(&prox_dev, PROX_SAMPLE_RATE) != true) {
		printf("Error setting proximity sensor sample rate.\r\n");
	}

	/* Select all proximity sensor channels */
	sensor_set_channel(&prox_dev, SENSOR_CHANNEL_ALL);

#if (SET_PROX_THRESHOLD == true)
	/* Manually  set proximity threshold values for each channel */
	/* Otherwise, sensor will use values previously stored in nvram. */
	sensor_set_threshold(&prox_dev, SENSOR_THRESHOLD_NEAR_PROXIMITY,
			PROX_THRESHOLD);
#endif

#if (SET_PROX_CURRENT == true)
	/* Manually set LED current value for each channel */
	/* Otherwise, sensor will use default values. */
	sensor_set_current(&prox_dev, PROX_CURRENT_mA);
#endif

	/* Initialize sensor data descriptors for scaled vs. raw data. */
	static sensor_data_t light_data = {.scaled = SCALED_DATA};
	static sensor_data_t prox_data  = {.scaled = false};

	/* Wait for user to push button before continuing */
	LED_Off(ALL_LEDS);

	while (!SWITCH_PRESSED) {
		/* Just blink LED until button is pushed */
		LED_Toggle(PROMPT_LED);

		delay_ms(50);
	}

	LED_Off(PROMPT_LED);

	while (SWITCH_PRESSED) {
		/* wait until button is released */
	}

	/* Enable output streams for Atmel Data Visualizer (ADV) */
	visual_stream_init();

	while (true) {
		LED_Toggle(PROMPT_LED);

		/* Read sensor values */
		prox_data.scaled = false;
		sensor_get_light(&light_dev, &light_data);

		adv_data_send_1(LIGHT_STREAM_NUM, light_data.timestamp,
				light_data.light.value);

		delay_ms(15);
		sensor_get_proximity(&prox_dev, &prox_data);

		adv_data_send_3(PROX_STREAM_NUM, light_data.timestamp,
				prox_data.proximity.value[0],
				prox_data.proximity.value[1],
				prox_data.proximity.value[2]);

		delay_ms(15);
		prox_data.scaled = true;
		sensor_get_proximity(&prox_dev, &prox_data);

		adv_data_send_3(PROX_THRESHOLD_STREAM_NUM, light_data.timestamp,
				prox_data.proximity.value[0],
				prox_data.proximity.value[1],
				prox_data.proximity.value[2]);
	}

	return 0;
}
示例#5
0
文件: main.c 项目: InSoonPark/asf
/** \brief Inertial sensor demo application entry
 *
 * After initializing the Xplained platform and sensor boards, this application
 * attaches descriptors to the ambient light and proximity sensor devices on
 * an Xplained inertial sensor board.  The sensors are configured to wake up
 * the processor if given threshold values are surpassed.
 */
int main(void)
{
#if (USE_PRINTF == true)
	uint32_t id;      /* Device ID */
	uint8_t version;  /* Device version */
#endif

	/* Initialize the board (Xplained UC3 or XMEGA & Xplained Sensor boards)
	 * I/O pin mappings and any other configurable resources selected in
	 * the build configuration.
	 */
	sensor_platform_init();

	LED_On(ACTIVITY_LED);

#if (USE_PRINTF == true)
	printf("\r\n");
#endif

	/* Initialize the MCU sleep manager API and specify a sleep mode. */
	sleepmgr_init();
	sleepmgr_lock_mode(SLEEP_MODE);

#if (LIGHT_WAKE == true)
	/* Attach light sensor */
	sensor_attach(&light_dev, SENSOR_TYPE_LIGHT, 0, 0);

	if (light_dev.err) {
		puts("\r\nLight sensor initialization error.");

		while (true) {
			/* Error occurred, loop forever */
		}
	}

#  if (USE_PRINTF == true)
	sensor_device_id(&light_dev, &id, &version);
	printf("Light sensor: %s    ID = 0x%02x ver. 0x%02x\r\n",
			light_dev.drv->caps.name, (unsigned)id,
			(unsigned)version);
#  endif

	sensor_set_sample_rate(&light_dev, LIGHT_SAMPLE_RATE);

	sensor_set_threshold(&light_dev, SENSOR_THRESHOLD_HIGH_LIGHT,
			LIGHT_THRESH);

	/* Enable high light level event for wakeup */
	sensor_add_event(&light_dev, SENSOR_EVENT_HIGH_LIGHT,
			light_event, 0, true);
#endif

#if (PROX_WAKE == true)
	/* Attach proximity sensor */
	sensor_attach(&prox_dev, SENSOR_TYPE_PROXIMITY, 0, 0);

	if (prox_dev.err) {
		puts("\r\nProximity sensor initialization error.");

		while (true) {
			/* Error occurred, loop forever */
		}
	}

#  if (USE_PRINTF == true)
	sensor_device_id(&prox_dev, &id, &version);
	printf("Proximity sensor: %s    ID = 0x%02x ver. 0x%02x\r\n",
			prox_dev.drv->caps.name, (unsigned)id,
			(unsigned)version);
#  endif

	sensor_set_sample_rate(&prox_dev, PROX_SAMPLE_RATE);

	/* Select all proximity sensor channels */
	sensor_set_channel(&prox_dev, 0);

#  if (SET_PROX_THRESHOLD == true)
	/* Manually set proximity threshold values for each channel */
	/* Otherwise, sensor will use values previously stored in nvram. */
	sensor_set_threshold(&prox_dev, SENSOR_THRESHOLD_NEAR_PROXIMITY,
			PROX_THRESHOLD);
#  endif

#  if (SET_PROX_CURRENT == true)
	/* Manually set LED current value for each channel */
	/* Otherwise, sensor will use default values. */
	sensor_set_current(&prox_dev, PROX_CURRENT_mA);
#  endif

	/* Enable near proximity event for wakeup */
	sensor_add_event(&prox_dev, SENSOR_EVENT_NEAR_PROXIMITY,
			prox_event, 0, true);
#endif

	while (true) {
		LED_Off(ACTIVITY_LED);

		/* Put device in low power sleep mode; wait for an interrupt to
		 * wake. */
		sleepmgr_enter_sleep();

		/* Device has woken up */
		LED_On(ACTIVITY_LED);

#if (USE_PRINTF == true)
#  if (LIGHT_WAKE == true)
		if (light_event_occurred) {
			light_event_occurred = false;
			
			printf("light level = %5d\r\n",
					(int16_t)light_data.light.value);
		}
#  endif

#  if (PROX_WAKE == true)
		if (prox_event_occurred) {
			prox_event_occurred = false;

			printf("proximity: source channel=%d  time=%010ld  ",
					prox_channel, prox_data.timestamp);

			if (SCALED_DATA) {
				printf("Chan1:%s Chan2:%s Chan3:%s\r\n",
						prox_labels[prox_data.proximity.value[0]],
						prox_labels[prox_data.proximity.value[1]],
						prox_labels[prox_data.proximity.value[2]]);
			} else {
				printf("Chan1:%4d Chan2:%4d Chan3:%4d\r\n",
						(int16_t)prox_data.proximity.value[0],
						(int16_t)prox_data.proximity.value[1],
						(int16_t)prox_data.proximity.value[2]);
			}
		}
#  endif
#endif

		delay_ms(500);
	}

	return 0;
}
示例#6
0
/**
 * \brief Example application entry routine
 */
int main(void)
{
	/* The sensor_platform_init() function will initialize the system
	 * clock and sensor bus support in addition to configuring the
	 * XMEGA-A3BU and Sensor Xplained boards.
	 *
	 * Use gfx_mono_init() to initialize the monochrome graphical system
	 * API then write a splash screen after enabling the LCD display
	 * backlight and setting the contrast.
	 *
	 * The MCU is going to be put in a sleep mode, so initialize the
	 * sleep manager API with a call to the sleepmgr_init() routine.
	 */
	sensor_platform_init();
	gfx_mono_init();
	sleepmgr_init();

	gpio_set_pin_high(NHD_C12832A1Z_BACKLIGHT);
	st7565r_set_contrast(ST7565R_DISPLAY_CONTRAST_MIN);

	/* Attach an accelerometer on a Sensors Xplained board. */
	sensor_t accelerometer;
	sensor_attach(&accelerometer, SENSOR_TYPE_ACCELEROMETER, 0, 0);

	/* Enable the accelerometer low-g (free fall) event. */
	sensor_enable_event(&accelerometer, SENSOR_EVENT_LOW_G);

	/* Set the free fall threshold (low-g event), bandwidth and range. */
	sensor_set_threshold(&accelerometer, SENSOR_THRESHOLD_LOW_G,
			LOW_G_THRESHOLD);
	sensor_set_bandwidth(&accelerometer, BANDWIDTH);
	sensor_set_range(&accelerometer, RANGE);

	while (true) {
		/* Put the accelerometer into a low-power mode (if available). */
		sensor_set_state(&accelerometer, SENSOR_STATE_LOW_POWER);

		LED_Off(ACCEL_LED);

		clear_screen();

		/* Display the "armed" message and put the MCU in sleep mode. */
		gfx_mono_draw_string("ATMEL Drop Demo\r\nXMEGA Powered Down\r\n"
				"g Sensor Armed", 1, 5, &sysfont);

		sleepmgr_lock_mode(SLEEP_MODE);
		sleepmgr_enter_sleep();

		/* The following runs after the MCU has been woken by an
		 * external low-g interrupt from the accelerometer.
		 *
		 * Turn on the red LED while falling and put the accelerometer
		 * into a high-power mode (if available) to sample date points.
		 */
		LED_On(ACCEL_LED);

		sensor_set_state(&accelerometer, SENSOR_STATE_HIGHEST_POWER);

		static scalar_t acceleration_waveform[DATA_SAMPLE_COUNT];
		scalar_t acceleration_max = 0;

		for (int data_count = 0; data_count < DATA_SAMPLE_COUNT;
				++data_count) {
			acceleration_waveform[data_count] = 0;

			for (int i = 0; i < SAMPLE_AVG_COUNT; ++i) {
				/* Calculate the gravity vector magnitude. */
				vector3_t gvec;
				sensor_get_vector(&accelerometer, &gvec);

				scalar_t const acceleration_magnitude
					= vector3_magnitude(&gvec);

				/* Store the maximum g magnitude for this
				 * sub-group. */
				if (acceleration_magnitude >
						acceleration_waveform[data_count]) {
					acceleration_waveform[data_count]
						= acceleration_magnitude;
				}

				/* Store the maximum g magnitude for the whole
				 * data set. */
				if (acceleration_magnitude > acceleration_max) {
					acceleration_max = acceleration_magnitude;
				}
			}
		}

		clear_screen();

		/* Turn the max acceleration into a string and convert to g. */
		static char max_g_string[20];

		if (acceleration_max > LOW_G_SATURATION) {
			sprintf(max_g_string, "g Sensor Saturated");
		} else {
			sprintf(max_g_string, "Peak = %02.2f g",
					acceleration_max / 1000);
		}

		/* Print the max g on the monochrome display. */
		gfx_mono_draw_string("Drop Detected", 1, 5, &sysfont);
		gfx_mono_draw_string(max_g_string, 1, 13, &sysfont);
		gfx_mono_draw_string("Press SW1 for chart", 1, 21, &sysfont);

		do {
			LED_Toggle(ACCEL_LED);
			delay_ms(100);
		} while (!switch_pressed(SW1));

		/* Plot the collected data points to create the waveform chart. */
		clear_screen();
		screen_border();

		for (int data_count = 0; data_count < DATA_SAMPLE_COUNT; ++data_count) {
			gfx_mono_draw_filled_circle(data_count,
					32 -
					(acceleration_waveform[data_count] / 500), 1,
					GFX_PIXEL_SET, GFX_WHOLE);
		}

		do {
			LED_Toggle(PROMPT_LED);
			delay_ms(100);
		} while (!switch_pressed(SW1));

		LED_Off(PROMPT_LED);
	}
}