Published February 27, 2019 © MIT

Hiker Companion

Hold the the Hiker's Companion phone extension in your hand while hiking, and leave your expensive and delicate phone in your knapsack.

AdvancedFull instructions provided2 days569

Things used in this project

Hardware components

NXP Rapid IoT Prototyping Kit

Software apps and online services

NXP Rapid IOT Studio

Story

People in the American north-west love being outdoors

Mount Rainier from Sun Top; Forest Service road 7315

Modern phones are a great way to track where you are: the GPS and maps work even when you don't have cell service, and many have built-in compasses and altimeters.

But you have to be careful! I've broken two different phones when I've been out; one I dropped and the other got squished. Luckily I had a spare, but most people only have one phone.

The IOT Hiker's companion is the solution. It's cheap, lightweight, and durable, and presents information that you need for your hike. Information includes

Compass bearing
Dead reckoning "direction back home" calculated by integrating the compass bearing over time. This is useful as a back-up for GPS!
Altitude based on barometric pressure
Automatic fall detection

The pitch from the Rapid IOT studio is that anyone can simply wire together their sensors and computations and present the results to the IOT device user. Given the pain that many users feel when they have to deal with complex APIs to manage Bluetooth LE connections, with the services, characteristics and data values, and the generally poor documentation of them, this is a laudable goal.

In practice, this studio application, although quite polished, felt clumsy instead of empowering.

The Rapid IOT kit includes an embedded magnetometer. Magnetometers in general have several uses: you can detect the presence of a magnet, for example, by adding up the absolute value of the X, Y and Z magnetic flux. When the values go above a preset limit, you know a magnet is nearby. Many laptop computers use magnets to tell if the keyboard is closed or open; by checking the polarity of the X, Y, and Z flux values, you can even tell if the keyboard is in front of or behind the laptop screen. This is used with the "convertible" type laptops; when the keyboard is in front of the screen, the laptop can be shut down, and when the keyboard is behind the screen, the laptop is probably being used as a tablet and all keyboard presses should be ignored,

Some magnetometers will automatically calculate a compassheading. A compass heading tells the user in what direction compared to magnetic north they are facing. It's important to note that the magnetic north is not "true" north; the Earth's magnetic field is mostly aligned with the true north and south poles, but it's far from perfect. Not only that, but the declination is constantly moving; maps of the magnetic declination are updated about every five years to account for shifts in the magnetic field.

Map of the earth's magnetic declination, 2015

In addition, magnetometers have to deal with magnetic deviation. Deviation is the local changes to the magnetic field. When I was testing the Rapid IOT magnetometer, for example, I discovered that the short USB cable from my laptop to the dev kit meant that the magnetometer was always close to my laptop! North, as it turns out, was always "towards the screen"!

To convert the magnetometer's X, Y, and Z flux values, an IOT developer has two choices. The easiest choice is to use a magnetometer that provides a compass heading as one of the outputs. The Rapid IOT dev kit, alas, doesn't use one of those. Instead, the compass heading must be calculated from the X and Y values.

The conversion from the raw X and Y magnetometer values to a compass heading is conceptually simple. You first have to normalize both the X and Y values. Once normalized the values will be centered at 0 so that the value as you swing the compass all the way around will first be above zero, then zero, then less than zero, and then back to zero. The most-positive value must be very close to the most negative value. The normalized X and Y values will also have the same range. It doesn't mater what the range is so long at they are the same. Once you have the normalized values, you just have to take the arc-tangent of the X and Y values to get an angle in radians.

One of the drawback of the Rapid IOT Studio is that the available libraries aren't really documented. I even had to guess at the actual underlying language which luckily I recognized as "C". There was an atan2 function available.

As a mathematical aside: most trigonometry libraries includes both the forward functions sin, cos, and tan and the inverse functions asin, cos, and atan. The atan function in turn usually comes in two variants: the superior atan2 function which takes an y and x value and returns any angle, and an inferior version that takes a y/x value and which is subject to problems like "what if x is zero and you divide by zero" and "how can you tell the difference between x and y both being positive, and both being negative? Thanks to the remarkable electric library at the bitsaavers.org site, I could even look up the history of the ATAN2 function.

Actually applying this to the Rapid IOT device, however, was problematical, once because of the clumsiness of the Rapid IOT studio, and once in practice, the compass had to be held very level to get useful readings.

The problem with the RApid IOT studio had to do with global variables and their lack in the studio. Here's a diagram of part of my project:

The Hiker Compass, showing the presence and use of global variables

There are two sets of two global variables in this code; there is a min and max value in each of the MagCenterX and MagCenterY functions. To create these essential global variables, I created two functions; each function then contains a two staticfloat values; the function return the average of the two values.

Here's the code for the MagCenerX function:

ATMO_Status_t MagCenterX_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {   static float minValue = 99999.0;   static float maxValue = -99999.0;   if (in != 0)   {       float value;       ATMO_GetFloat (in, &value);       if (value < minValue) minValue = value;       if (value > maxValue) maxValue = value;       if (value == 99999.0)        {           minValue = 99999.0;           maxValue = -99999.0;       }   }   if (out != 0)   {       float av = (minValue + maxValue) / 2.0;       ATMO_CreateValueFloat (out, av);   }	return ATMO_Status_Success;}

Normally to make a global variable in a program, you just make it. In this system, you have to make a special function and access the variable only through the function. But you also can't just call the function; you have to create the special structures that hold values, and make sure to free them later. One of the results of the extra clumsiness is that I wrote the globals "cleverly" instead of in a straightforward manner. Instead of just having four variables (min and max for the X and Y values), I have two functions which track the min and max values and, when a special value is passed in, will reset the min and max values.

These magnetometer values are used in two ways. Firstly, the values are self-adjusting. The user will, when starting out, ask the compass to calibrate; subsequent compass values will automatically set the min and max values and return a normalized version of the passed-in amount.

The compass is used as part of a dead-reckoning type system to construct a crude "what direction is home" map. My first thought here was to simply average compass headings over time. If we have five compass headings from the user, and they are east, east, north, east, and east then we can assume that to get back to the start they need to travel mostly west with a little bit of south.

This doesn't actually work, of course, because a compass is discontinuous. IF we have four compass readings from a person, and north is "0", and our actual readings are three readings of north (0, 0, and 0) and then one readings that is just a hair west of north (359), we would average the values out to be east! That surely would be a mistake!

And we can't get around the problem by "smoothing out" the compass readings; people are fully able to turn very quickly, and we won't want to make an enormous number of compass readings.

Instead, I averaged the north/south values separately from the east/west values; the average of each of these separately will be the average direction travelled in.

Naturally the compass values should be averaged when the person is moving, not when they are still. Just because a person ate lunch while facing south doesn't mean that they travelled south!

However, there's one additional complication to using a magnetometer to estimate a position: the X and Y ranges actually depend on whether the compass is being held upright or not. My original estimate was this orientation sensitivity would be trivial; in reality, when the compass was held and anything but almost level I would see large shifts in the compass heading.

There was one additional and unfortunate problem with using the magnetometer as a compass. An ideal display would look like a compass heading; I made a simple mockup of my preferred display like this:

In this mock-up, the user would see a simple compass rose, the current heading, and a trace of their estimated position. In the mock-up, the user started at the diamond position, went in a rough three-quarter circle along a path and then went part of the back -- this is very similar to the trail in to the "Otter Falls" in Washington State. The out and back are not perfectly in sync because of the roughness of the estimated position.

This map, however, is not possible in the Rapid IOT system. The device has a very nice high-resolution screen that would be perfect for such a display. The IDE does not support any kind of graphical output. It's apparently possible, if one has access to undocumented capabilities, to make a map like this. Using undocumented features is rarely a good thing when making a product; you never know when an undocumented feature will be changed or removed.

Code

Hiiker's Companion

#include "callbacks.h"

//HEADER START

//HEADER END

void ATMO_Setup() {

}


ATMO_Status_t EmbeddedStaticTextDisplay_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t EmbeddedStaticTextDisplay_displayPage(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_DisplayPageByCoord(ATMO_PROPERTY(EmbeddedStaticTextDisplay, x), ATMO_PROPERTY(EmbeddedStaticTextDisplay, y), false);
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedStaticTextDisplay_topRightButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedStaticTextDisplay_bottomRightButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedStaticTextDisplay_topLeftButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedStaticTextDisplay_bottomLeftButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedStaticTextDisplay_onDisplayed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
    
}


ATMO_Status_t EmbeddedStaticTextDisplay_setText(ATMO_Value_t *in, ATMO_Value_t *out) {

    ATMO_Value_t strVal;
    ATMO_InitValue(&strVal);
    ATMO_CreateValueConverted(&strVal, ATMO_DATATYPE_STRING, in);
    ATMO_UI_STATICTEXT_SetText(ATMO_VARIABLE(EmbeddedStaticTextDisplay,pageHandle), strVal.data);
    ATMO_FreeValue(&strVal);
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedStaticTextDisplay_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

    ATMO_UI_PAGE_Config_t config;
	config.hidden = ATMO_PROPERTY(EmbeddedStaticTextDisplay, pageHidden);
	config.textColor = ATMO_PROPERTY(EmbeddedStaticTextDisplay, textColor);
	config.activeButtons = ATMO_UI_Page_GetButtonMask(ATMO_PROPERTY(EmbeddedStaticTextDisplay, topRightButtonEnabled),
		ATMO_PROPERTY(EmbeddedStaticTextDisplay,bottomRightButtonEnabled), ATMO_PROPERTY(EmbeddedStaticTextDisplay, topLeftButtonEnabled), ATMO_PROPERTY(EmbeddedStaticTextDisplay, bottomLeftButtonEnabled));
    config.x = ATMO_PROPERTY(EmbeddedStaticTextDisplay, x);
	config.y = ATMO_PROPERTY(EmbeddedStaticTextDisplay, y);
	strncpy(config.topLeftButtonLabel, ATMO_PROPERTY(EmbeddedStaticTextDisplay, topLeftButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.topRightButtonLabel, ATMO_PROPERTY(EmbeddedStaticTextDisplay, topRightButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.bottomLeftButtonLabel, ATMO_PROPERTY(EmbeddedStaticTextDisplay, bottomLeftButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.bottomRightButtonLabel, ATMO_PROPERTY(EmbeddedStaticTextDisplay, bottomRightButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
    config.spanX = ATMO_PROPERTY(EmbeddedStaticTextDisplay, spanX);
	config.spanY = ATMO_PROPERTY(EmbeddedStaticTextDisplay, spanY);
    config.title = ATMO_PROPERTY(EmbeddedStaticTextDisplay, pageTitle);
    config.titleHidden = ATMO_PROPERTY(EmbeddedStaticTextDisplay, titleHidden);
	ATMO_UI_STATICTEXT_Init(&config);
	ATMO_VARIABLE(EmbeddedStaticTextDisplay, pageHandle) = config.templateInstance;
    ATMO_UI_STATICTEXT_SetText(config.templateInstance, ATMO_PROPERTY(EmbeddedStaticTextDisplay, text));
	ATMO_UI_STATICTEXT_SetTextSize(config.templateInstance, ATMO_PROPERTY(EmbeddedStaticTextDisplay, fontSize));
	ATMO_UI_STATICTEXT_SetAlignment(config.templateInstance, ATMO_PROPERTY(EmbeddedStaticTextDisplay, horizontalAlignment));
	ATMO_UI_STATICTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(EmbeddedStaticTextDisplay,pageHandle), 1, ATMO_ABILITY(EmbeddedStaticTextDisplay, topRightButtonPressed));
	ATMO_UI_STATICTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(EmbeddedStaticTextDisplay,pageHandle), 2, ATMO_ABILITY(EmbeddedStaticTextDisplay, bottomRightButtonPressed));
	ATMO_UI_STATICTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(EmbeddedStaticTextDisplay,pageHandle), 3, ATMO_ABILITY(EmbeddedStaticTextDisplay, topLeftButtonPressed));
    ATMO_UI_STATICTEXT_RegisterButtonAbilityHandle(ATMO_VARIABLE(EmbeddedStaticTextDisplay,pageHandle), 4, ATMO_ABILITY(EmbeddedStaticTextDisplay, bottomLeftButtonPressed));
    
	if(!config.hidden)
	{
		ATMO_UI_STATICTEXT_RegisterOnDisplayedAbilityHandle(ATMO_VARIABLE(EmbeddedStaticTextDisplay,pageHandle), ATMO_ABILITY(EmbeddedStaticTextDisplay, onDisplayed));
	}
    return ATMO_Status_Success;
    
}


ATMO_Status_t EmbeddedPageController_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t EmbeddedPageController_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_PAGE_CONTROLLER_Config_t config;
	config.enableUpDownNavLabels = ATMO_PROPERTY(EmbeddedPageController, upDownNavigationLabelsEnabled);
	config.enableLeftRightNavLabels = ATMO_PROPERTY(EmbeddedPageController, leftRightNavigationLabelsEnabled);
	ATMO_UI_Page_SetConfiguration(&config);
    return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedPageController_displayRootPage(ATMO_Value_t *in, ATMO_Value_t *out) {

	
	ATMO_UI_Page_DisplayRootPage();
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedPageController_navigateUp(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_ProcessNavButton(ATMO_UI_PAGE_NAV_UP);
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedPageController_navigateDown(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_ProcessNavButton(ATMO_UI_PAGE_NAV_DOWN);
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedPageController_navigateLeft(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_ProcessNavButton(ATMO_UI_PAGE_NAV_LEFT);
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedPageController_navigateRight(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_ProcessNavButton(ATMO_UI_PAGE_NAV_RIGHT);
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedPageController_processTopRightButton(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_ProcessUserButton(1);
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedPageController_processBottomRightButton(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_ProcessUserButton(2);
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedPageController_processTopLeftButton(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_ProcessUserButton(3);
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedPageController_processBottomLeftButton(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_ProcessUserButton(4);
	return ATMO_Status_Success;
	
}


ATMO_Status_t Interval_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t Interval_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_INTERVAL_Handle_t intervalHandle;
    ATMO_INTERVAL_AddAbilityInterval(
		ATMO_PROPERTY(Interval, instance), 
		ATMO_ABILITY(Interval, interval), 
		ATMO_PROPERTY(Interval, time), 
		&intervalHandle
	);
	
	return ATMO_Status_Success;
	
}


ATMO_Status_t Interval_interval(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t SX9500Touch_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t SX9500Touch_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_SX9500_Config_t config;
	config.address = ATMO_PROPERTY(SX9500Touch, i2cAddress);
	config.i2cDriverInstance = ATMO_PROPERTY(SX9500Touch, i2cInstance);
	config.gpioDriverInstance = ATMO_PROPERTY(SX9500Touch, gpioInstance);
	config.interruptEnabled = ATMO_PROPERTY(SX9500Touch, interruptEnabled);
	config.interruptPin = ATMO_PROPERTY(SX9500Touch, interruptGpio);
	ATMO_SX9500_Init(&config);
	ATMO_SX9500_RegisterTouchedAbilityHandle(SX9500_Touched_Up, ATMO_ABILITY(SX9500Touch, pressUp));
	ATMO_SX9500_RegisterTouchedAbilityHandle(SX9500_Touched_Down, ATMO_ABILITY(SX9500Touch, pressDown));
	ATMO_SX9500_RegisterTouchedAbilityHandle(SX9500_Touched_Left, ATMO_ABILITY(SX9500Touch, pressLeft));
	ATMO_SX9500_RegisterTouchedAbilityHandle(SX9500_Touched_Right, ATMO_ABILITY(SX9500Touch, pressRight));
	return ATMO_Status_Success;
}


ATMO_Status_t SX9500Touch_getTouchData(ATMO_Value_t *in, ATMO_Value_t *out) {
	return;
}


ATMO_Status_t SX9500Touch_pressUp(ATMO_Value_t *in, ATMO_Value_t *out) {
SX9500_TouchState_t touchState;
ATMO_GetBinary(in, &touchState, sizeof(touchState));
ATMO_CreateValueBinary(out, &touchState, sizeof(touchState));
return ATMO_Status_Success;
}


ATMO_Status_t SX9500Touch_pressDown(ATMO_Value_t *in, ATMO_Value_t *out) {
SX9500_TouchState_t touchState;
ATMO_GetBinary(in, &touchState, sizeof(touchState));
ATMO_CreateValueBinary(out, &touchState, sizeof(touchState));
return ATMO_Status_Success;
}


ATMO_Status_t SX9500Touch_pressLeft(ATMO_Value_t *in, ATMO_Value_t *out) {
SX9500_TouchState_t touchState;
ATMO_GetBinary(in, &touchState, sizeof(touchState));
ATMO_CreateValueBinary(out, &touchState, sizeof(touchState));
return ATMO_Status_Success;
}


ATMO_Status_t SX9500Touch_pressRight(ATMO_Value_t *in, ATMO_Value_t *out) {
SX9500_TouchState_t touchState;
ATMO_GetBinary(in, &touchState, sizeof(touchState));
ATMO_CreateValueBinary(out, &touchState, sizeof(touchState));
return ATMO_Status_Success;
}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_setup(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_FXOS8700_Config_t config;
	config.address = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, i2cAddress);
	config.i2cDriverInstance = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, i2cInstance);
	config.gpioDriverInstance = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, gpioInstance);
	config.int1En = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, interrupt1Enabled);
    config.int2En = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, interrupt2Enabled);
    config.int1Pin = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, interrupt1Gpio);
    config.int2Pin = ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, interrupt2Gpio);

    switch(ATMO_PROPERTY(FXOS8700AccelerometerMagnetometer, motionDetectType))
    {
        case FXOS8700_NoDetect:
        {
            config.freefallEnabled = false;
            config.motionEnabled = false;
            config.tapDetectionEnabled = false;
            break;
        }
        case FXOS8700_FreefallDetect:
        {
            config.freefallEnabled = true;
            config.motionEnabled = false;
            config.tapDetectionEnabled = false;
            break;
        }
        case FXOS8700_MotionDetect:
        {
            config.freefallEnabled = false;
            config.motionEnabled = true;
            config.tapDetectionEnabled = false;
            break;
        }
        case FXOS8700_TapDetect:
        {
            config.freefallEnabled = false;
            config.motionEnabled = false;
            config.tapDetectionEnabled = true;
            break; 
        }
        default:
        {
            config.freefallEnabled = false;
            config.motionEnabled = false;  
            config.tapDetectionEnabled = false;
            break;
        }
    }

    ATMO_FXOS8700_SetMotionDetectedAbilityHandle(ATMO_ABILITY(FXOS8700AccelerometerMagnetometer, detectMotion));
    ATMO_FXOS8700_SetFreefallDetectedAbilityHandle(ATMO_ABILITY(FXOS8700AccelerometerMagnetometer, detectFreefall));
    ATMO_FXOS8700_SetTapDetectedAbilityHandle(ATMO_ABILITY(FXOS8700AccelerometerMagnetometer, detectTap));
	ATMO_FXOS8700_Init(&config);

    return ATMO_Status_Success;
	
}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_setEnabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_FXOS8700_SetEnabled(true);
return ATMO_Status_Success;
}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_setDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
ATMO_FXOS8700_SetEnabled(false);
return ATMO_Status_Success;
}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_setEnabledDisabled(ATMO_Value_t *in, ATMO_Value_t *out) {
bool enabled = false;
ATMO_GetBool(in, &enabled);
ATMO_FXOS8700_SetEnabled(enabled);
return ATMO_Status_Success;
}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_getAccelData(ATMO_Value_t *in, ATMO_Value_t *out) {
    ATMO_3dFloatVector_t data;

    if( ATMO_FXOS8700_GetAccelData(&data) != ATMO_FXOS8700_Status_Success )
    {
        ATMO_CreateValueVoid(out);
        return ATMO_Status_Fail;
    }

    ATMO_CreateValue3dVectorFloat(out, &data);

    return ATMO_Status_Success;
}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_getAccelX(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_3dFloatVector_t data;

	if(ATMO_FXOS8700_GetAccelData(&data) != ATMO_FXOS8700_Status_Success)
	{
		ATMO_CreateValueVoid(out);
		return ATMO_Status_Fail;
	}

	ATMO_CreateValueFloat(out, data.x);
	return ATMO_Status_Success;

}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_getAccelY(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_3dFloatVector_t data;

	if(ATMO_FXOS8700_GetAccelData(&data) != ATMO_FXOS8700_Status_Success)
	{
		ATMO_CreateValueVoid(out);
		return ATMO_Status_Fail;
	}

	ATMO_CreateValueFloat(out, data.y);
	return ATMO_Status_Success;

}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_getAccelZ(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_3dFloatVector_t data;

	if(ATMO_FXOS8700_GetAccelData(&data) != ATMO_FXOS8700_Status_Success)
	{
		ATMO_CreateValueVoid(out);
		return ATMO_Status_Fail;
	}

	ATMO_CreateValueFloat(out, data.z);
	return ATMO_Status_Success;

}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_getMagData(ATMO_Value_t *in, ATMO_Value_t *out) {
    ATMO_3dFloatVector_t data;

    if( ATMO_FXOS8700_GetMagData(&data) != ATMO_FXOS8700_Status_Success )
    {
        ATMO_CreateValueVoid(out);
        return ATMO_Status_Fail;
    }

    ATMO_CreateValue3dVectorFloat(out, &data);

    return ATMO_Status_Success;
}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_getMagX(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_3dFloatVector_t data;

	if(ATMO_FXOS8700_GetMagData(&data) != ATMO_FXOS8700_Status_Success)
	{
		ATMO_CreateValueVoid(out);
		return ATMO_Status_Fail;
	}

	ATMO_CreateValueFloat(out, data.x);
	return ATMO_Status_Success;

}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_getMagY(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_3dFloatVector_t data;

	if(ATMO_FXOS8700_GetMagData(&data) != ATMO_FXOS8700_Status_Success)
	{
		ATMO_CreateValueVoid(out);
		return ATMO_Status_Fail;
	}

	ATMO_CreateValueFloat(out, data.y);
	return ATMO_Status_Success;

}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_getMagZ(ATMO_Value_t *in, ATMO_Value_t *out) {
	ATMO_3dFloatVector_t data;

	if(ATMO_FXOS8700_GetMagData(&data) != ATMO_FXOS8700_Status_Success)
	{
		ATMO_CreateValueVoid(out);
		return ATMO_Status_Fail;
	}

	ATMO_CreateValueFloat(out, data.z);
	return ATMO_Status_Success;

}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_detectTap(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;

}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_detectMotion(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;

}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_detectFreefall(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;

}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_enableFreefallDetection(ATMO_Value_t *in, ATMO_Value_t *out) {
if(ATMO_FXOS8700_EnableFreefallDetection() == ATMO_FXOS8700_Status_Success)
{
    return ATMO_Status_Success;
}

return ATMO_Status_Fail;
}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_enableMotionDetection(ATMO_Value_t *in, ATMO_Value_t *out) {
if(ATMO_FXOS8700_EnableMotionDetection() == ATMO_FXOS8700_Status_Success)
{
    return ATMO_Status_Success;
}

return ATMO_Status_Fail;
}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_enableTapDetection(ATMO_Value_t *in, ATMO_Value_t *out) {
if(ATMO_FXOS8700_EnableTapDetection() == ATMO_FXOS8700_Status_Success)
{
    return ATMO_Status_Success;
}

return ATMO_Status_Fail;
}


ATMO_Status_t FXOS8700AccelerometerMagnetometer_disableDetection(ATMO_Value_t *in, ATMO_Value_t *out) {
if(ATMO_FXOS8700_DisableAllDetection() == ATMO_FXOS8700_Status_Success)
{
    return ATMO_Status_Success;
}

return ATMO_Status_Fail;
}


ATMO_Status_t CompassHeading_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
    	ATMO_3dFloatVector_t values;
ATMO_Get3dVectorFloat(in, &values);
//char testStr[64];
double x = values.x + 61.875;

double y = values.y + 89.75;
double z = values.z - 77;
double angle = atan2 (x, y) * 180.0 / 3.141592;
char direction[100];
if (angle > 168.75)       sprintf (direction, "N    ", angle);
else if (angle >  146.25) sprintf (direction, "NNW  ", angle);
else if (angle >  123.75) sprintf (direction, "NW   ", angle);
else if (angle >  101.25) sprintf (direction, "WNW  ", angle);
else if (angle >   78.75) sprintf (direction, "W    ", angle);
else if (angle >   56.25) sprintf (direction, "WSW  ", angle);
else if (angle >   33.75) sprintf (direction, "SW   ", angle);
else if (angle >   11.25) sprintf (direction, "SSW  ", angle);
else if (angle >  -11.25) sprintf (direction, "S    ", angle);
else if (angle >  -33.75) sprintf (direction, "SSE  ", angle);
else if (angle >  -56.25) sprintf (direction, "SE   ", angle);
else if (angle >  -78.75) sprintf (direction, "ESE  ", angle);
else if (angle > -101.25) sprintf (direction, "E    ", angle);
else if (angle > -123.75) sprintf (direction, "ENE  ", angle);
else if (angle > -146.25) sprintf (direction, "NE   ", angle);
else if (angle > -168.75) sprintf (direction, "NNE  ", angle);
else                      sprintf (direction, "N    ", angle);



//sprintf(testStr, "X: %.2f\r\nY:%.2f\nZ:%.2f\nang:%.2f", x, y, z, angle);
ATMO_CreateValueString(out, direction);
    	return ATMO_Status_Success;
}


ATMO_Status_t StatusDisplay_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t StatusDisplay_displayPage(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_DisplayPageByCoord(ATMO_PROPERTY(StatusDisplay, x), ATMO_PROPERTY(StatusDisplay, y), false);
	return ATMO_Status_Success;
	
}


ATMO_Status_t StatusDisplay_onDisplayed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t StatusDisplay_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

    ATMO_UI_PAGE_Config_t config;
    config.hidden = ATMO_PROPERTY(StatusDisplay, pageHidden);
    config.activeButtons = ATMO_UI_Page_GetButtonMask(ATMO_PROPERTY(StatusDisplay, topRightButtonEnabled),
    ATMO_PROPERTY(StatusDisplay,bottomRightButtonEnabled), ATMO_PROPERTY(StatusDisplay, topLeftButtonEnabled), ATMO_PROPERTY(StatusDisplay, bottomLeftButtonEnabled));
    config.x = ATMO_PROPERTY(StatusDisplay, x);
    config.y = ATMO_PROPERTY(StatusDisplay, y);
	strncpy(config.topLeftButtonLabel, ATMO_PROPERTY(StatusDisplay, topLeftButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.topRightButtonLabel, ATMO_PROPERTY(StatusDisplay, topRightButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.bottomLeftButtonLabel, ATMO_PROPERTY(StatusDisplay, bottomLeftButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.bottomRightButtonLabel, ATMO_PROPERTY(StatusDisplay, bottomRightButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
    config.spanX = ATMO_PROPERTY(StatusDisplay, spanX);
	config.spanY = ATMO_PROPERTY(StatusDisplay, spanY);
    config.title = ATMO_PROPERTY(StatusDisplay, pageTitle);
    config.titleHidden = ATMO_PROPERTY(StatusDisplay, titleHidden);
    ATMO_UI_SYSTEMSTATUS_Init(&config);
    
}


ATMO_Status_t CompasDisplay_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t CompasDisplay_displayPage(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_DisplayPageByCoord(ATMO_PROPERTY(CompasDisplay, x), ATMO_PROPERTY(CompasDisplay, y), false);
	return ATMO_Status_Success;
	
}


ATMO_Status_t CompasDisplay_onDisplayed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
    
}


ATMO_Status_t CompasDisplay_onLeave(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t CompasDisplay_setIconLabelAndColor(ATMO_Value_t *in, ATMO_Value_t *out) {

    struct {
        char str[32];
        GUI_COLOR color;
    } icon_data;
 
    ATMO_GetBinary(in, &icon_data, sizeof(icon_data));
    ATMO_UI_ICONLINES_SetIconLabelColor(ATMO_VARIABLE(CompasDisplay, pageHandle), icon_data.str, icon_data.color);
    return ATMO_Status_Success;
    
}


ATMO_Status_t CompasDisplay_setIconLabel(ATMO_Value_t *in, ATMO_Value_t *out) {

    char str[32];
    ATMO_GetString(in, str, 32);
    ATMO_UI_ICONLINES_SetIconLabel(ATMO_VARIABLE(CompasDisplay, pageHandle), str);
    return ATMO_Status_Success;
    
}


ATMO_Status_t CompasDisplay_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

    ATMO_UI_PAGE_Config_t config;
    config.hidden = ATMO_PROPERTY(CompasDisplay, pageHidden);
    config.textColor = ATMO_PROPERTY(CompasDisplay, textColor);
    config.activeButtons = ATMO_UI_Page_GetButtonMask(ATMO_PROPERTY(CompasDisplay, topRightButtonEnabled),
    ATMO_PROPERTY(CompasDisplay,bottomRightButtonEnabled), ATMO_PROPERTY(CompasDisplay, topLeftButtonEnabled), ATMO_PROPERTY(CompasDisplay, bottomLeftButtonEnabled));
	config.x = ATMO_PROPERTY(CompasDisplay, x);
    config.y = ATMO_PROPERTY(CompasDisplay, y);
	strncpy(config.topLeftButtonLabel, ATMO_PROPERTY(CompasDisplay, topLeftButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.topRightButtonLabel, ATMO_PROPERTY(CompasDisplay, topRightButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.bottomLeftButtonLabel, ATMO_PROPERTY(CompasDisplay, bottomLeftButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
	strncpy(config.bottomRightButtonLabel, ATMO_PROPERTY(CompasDisplay, bottomRightButtonLabel), ATMO_BUTTON_LABEL_MAXLEN);
    config.spanX = ATMO_PROPERTY(CompasDisplay, spanX);
	config.spanY = ATMO_PROPERTY(CompasDisplay, spanY);
    config.title = ATMO_PROPERTY(CompasDisplay, pageTitle);
    config.titleHidden = ATMO_PROPERTY(CompasDisplay, titleHidden);
	ATMO_UI_ICONLINES_Init(&config, ATMO_PROPERTY(CompasDisplay, numLines), false);
	ATMO_VARIABLE(CompasDisplay, pageHandle) = config.templateInstance;
    ATMO_UI_ICONLINES_SetMainText(config.templateInstance, 0, ATMO_PROPERTY(CompasDisplay, line1Text));
    ATMO_UI_ICONLINES_SetMainText(config.templateInstance, 1, ATMO_PROPERTY(CompasDisplay, line2Text));
    ATMO_UI_ICONLINES_SetMainText(config.templateInstance, 2, ATMO_PROPERTY(CompasDisplay, line3Text));
    ATMO_UI_ICONLINES_SetMainText(config.templateInstance, 3, ATMO_PROPERTY(CompasDisplay, line4Text));
    ATMO_UI_ICONLINES_SetIconLabel(config.templateInstance, ATMO_PROPERTY(CompasDisplay, iconLabel));
    ATMO_UI_ICONLINES_RegisterButtonAbilityHandle(ATMO_VARIABLE(CompasDisplay,pageHandle), 1, ATMO_ABILITY(CompasDisplay, topRightButtonPressed));
	ATMO_UI_ICONLINES_RegisterButtonAbilityHandle(ATMO_VARIABLE(CompasDisplay,pageHandle), 2, ATMO_ABILITY(CompasDisplay, bottomRightButtonPressed));
	ATMO_UI_ICONLINES_RegisterButtonAbilityHandle(ATMO_VARIABLE(CompasDisplay,pageHandle), 3, ATMO_ABILITY(CompasDisplay, topLeftButtonPressed));
    ATMO_UI_ICONLINES_RegisterButtonAbilityHandle(ATMO_VARIABLE(CompasDisplay,pageHandle), 4, ATMO_ABILITY(CompasDisplay, bottomLeftButtonPressed));
    ATMO_UI_ICONLINES_SetIcon(config.templateInstance, ATMO_PROPERTY(CompasDisplay, icon));
    ATMO_UI_ICONLINES_RegisterOnDisplayedAbilityHandle(ATMO_VARIABLE(CompasDisplay,pageHandle), ATMO_ABILITY(CompasDisplay, onDisplayed));
    ATMO_UI_ICONLINES_RegisterOnLeaveAbilityHandle(config.templateInstance, ATMO_ABILITY(CompasDisplay, onLeave));
    return ATMO_Status_Success;
    
}


ATMO_Status_t CompasDisplay_setLine1Text(ATMO_Value_t *in, ATMO_Value_t *out) {

    char label[32];
    if(ATMO_GetString(in, label, 32) == ATMO_Status_Success)
    {
        ATMO_UI_ICONLINES_SetMainText(ATMO_VARIABLE(CompasDisplay,pageHandle), 0, label);
    }
    else
    {
        return ATMO_Status_Fail;
    }

    return ATMO_Status_Success;
    
}


ATMO_Status_t CompasDisplay_setLine2Text(ATMO_Value_t *in, ATMO_Value_t *out) {

    char label[32];
    if(ATMO_GetString(in, label, 32) == ATMO_Status_Success)
    {
        ATMO_UI_ICONLINES_SetMainText(ATMO_VARIABLE(CompasDisplay,pageHandle), 1, label);
    }
    else
    {
        return ATMO_Status_Fail;
    }

    return ATMO_Status_Success;
    
}


ATMO_Status_t CompasDisplay_setLine3Text(ATMO_Value_t *in, ATMO_Value_t *out) {

    char label[32];
    if(ATMO_GetString(in, label, 32) == ATMO_Status_Success)
    {
        ATMO_UI_ICONLINES_SetMainText(ATMO_VARIABLE(CompasDisplay,pageHandle), 2, label);
    }
    else
    {
        return ATMO_Status_Fail;
    }

    return ATMO_Status_Success;
    
}


ATMO_Status_t CompasDisplay_setLine4Text(ATMO_Value_t *in, ATMO_Value_t *out) {

    char label[32];
    if(ATMO_GetString(in, label, 32) == ATMO_Status_Success)
    {
        ATMO_UI_ICONLINES_SetMainText(ATMO_VARIABLE(CompasDisplay,pageHandle), 3, label);
    }
    else
    {
        return ATMO_Status_Fail;
    }

    return ATMO_Status_Success;
    
}


ATMO_Status_t CompasDisplay_topRightButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t CompasDisplay_bottomRightButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t CompasDisplay_topLeftButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t CompasDisplay_bottomLeftButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t CompassAngle_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
// Get the vector of values.
ATMO_3dFloatVector_t values; ATMO_Get3dVectorFloat(in, &values);

// Update the x and y centers
ATMO_Value_t atmox, atmoy;
ATMO_CreateValueFloat (&atmox, values.x); MagCenterX_trigger (&atmox, 0);
ATMO_CreateValueFloat (&atmoy, values.y); MagCenterY_trigger (&atmoy, 0);

// Get the MagCenterX and MagCenterY
MagCenterX_trigger (0, &atmox); float xcenter; ATMO_GetFloat (&atmox, &xcenter);
MagCenterY_trigger (0, &atmoy); float ycenter; ATMO_GetFloat (&atmoy, &ycenter);



//char testStr[64];
double x = values.x - xcenter; // 61.875;
double y = values.y - ycenter; // + 89.75;
double z = values.z - 77;
double angle = atan2 (x, y) * 180.0 / 3.141592;
char direction[32];
sprintf (direction, "   %.0f", angle);


//sprintf(testStr, "X: %.2f\r\nY:%.2f\nZ:%.2f\nang:%.2f", x, y, z, angle);
ATMO_CreateValueString(out, direction);
    	return ATMO_Status_Success;
	return ATMO_Status_Success;
}


ATMO_Status_t EmbeddedNxpRpkBacklight_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t EmbeddedNxpRpkBacklight_setup(ATMO_Value_t *in, ATMO_Value_t *out) {

    Backlight_SetLevel(ATMO_PROPERTY(EmbeddedNxpRpkBacklight, initialSetting));
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedNxpRpkBacklight_setBacklightOff(ATMO_Value_t *in, ATMO_Value_t *out) {

    Backlight_SetLevel(BLIGHT_LEVEL_OFF);
	return ATMO_Status_Success;
    
}


ATMO_Status_t EmbeddedNxpRpkBacklight_setBacklightLow(ATMO_Value_t *in, ATMO_Value_t *out) {

    Backlight_SetLevel(BLIGHT_LEVEL_LOW);
	return ATMO_Status_Success;
	
}


ATMO_Status_t EmbeddedNxpRpkBacklight_setBacklightMedium(ATMO_Value_t *in, ATMO_Value_t *out) {

    Backlight_SetLevel(BLIGHT_LEVEL_MEDIUM);
	return ATMO_Status_Success;
    
}


ATMO_Status_t EmbeddedNxpRpkBacklight_setBacklightHigh(ATMO_Value_t *in, ATMO_Value_t *out) {

    Backlight_SetLevel(BLIGHT_LEVEL_HIGH);
	return ATMO_Status_Success;
	
}


ATMO_Status_t ReturnCourse_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
static double xtotal = 0.0;
static double ytotal = 0.0;
static double count = 0.0;

    	ATMO_3dFloatVector_t values;
ATMO_Get3dVectorFloat(in, &values);
//char testStr[64];
double x = values.x + 61.875;
double y = values.y + 89.75;
double z = values.z - 77;
double angle = atan2 (x, y);

double xcurrent = sin (angle);
double ycurrent = cos (angle);

//Exponentially Weighted Moving Average
// Will be converted to straight average.
count += 1;
//xtotal = xtotal * 0.9 + xcurrent * 0.1;
//ytotal = ytotal * 0.9 + ycurrent * 0.1;

// Real totals
xtotal = xtotal + xcurrent;
ytotal = ytotal + ycurrent;

double returnangle = atan2 (xtotal, ytotal) * 180 / 3.14159265359;
//returnangle = returnangle + 180.0;
//if (returnangle > 180) returnangle -= 360.0;
char direction[32];
sprintf (direction, "%.2f", returnangle);


//sprintf(testStr, "X: %.2f\r\nY:%.2f\nZ:%.2f\nang:%.2f", x, y, z, angle);
ATMO_CreateValueString(out, direction);
    	return ATMO_Status_Success;
}


ATMO_Status_t MagCenterX_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
    static float minValue = 99999.0;
    static float maxValue = -99999.0;
    if (in != 0)
    {
        float value;
        ATMO_GetFloat (in, &value);
        if (value < minValue) minValue = value;
        if (value > maxValue) maxValue = value;
        if (value == 99999.0) 
        {
            minValue = 99999.0;
            maxValue = -99999.0;
        }
    }
    if (out != 0)
    {
        float av = (minValue + maxValue) / 2.0;
        ATMO_CreateValueFloat (out, av);
    }
	return ATMO_Status_Success;
}


ATMO_Status_t MagCenterY_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
    static float minValue = 99999.0;
    static float maxValue = -99999.0;
    if (in != 0)
    {
        float value;
        ATMO_GetFloat (in, &value);
        if (value < minValue) minValue = value;
        if (value > maxValue) maxValue = value;
        if (value == 99999.0) 
        {
            minValue = 99999.0;
            maxValue = -99999.0;
        }
    }
    if (out != 0)
    {
        float av = (minValue + maxValue) / 2.0;
        ATMO_CreateValueFloat (out, av);
    }
	return ATMO_Status_Success;
}


ATMO_Status_t SetupMenu_trigger(ATMO_Value_t *in, ATMO_Value_t *out) {
	return ATMO_Status_Success;
}


ATMO_Status_t SetupMenu_displayPage(ATMO_Value_t *in, ATMO_Value_t *out) {

	ATMO_UI_Page_DisplayPageByCoord(ATMO_PROPERTY(SetupMenu, x), ATMO_PROPERTY(SetupMenu, y), false);
	return ATMO_Status_Success;
	
}


ATMO_Status_t SetupMenu_topRightButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t SetupMenu_bottomRightButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t SetupMenu_topLeftButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

	return ATMO_Status_Success;
	
}


ATMO_Status_t SetupMenu_bottomLeftButtonPressed(ATMO_Value_t *in, ATMO_Value_t *out) {

...

This file has been truncated, please download it to see its full contents.

Credits

Peter Smith

2 projects • 3 followers

C# Programmer for many years, and a lover of all things IOT and Bluetooth.

Hiker Companion

Things used in this project

Hardware components

Software apps and online services

Story

Schematics

Code Flow

Code

Hiiker's Companion

Credits

Peter Smith

Comments

Embed the widget on your own site

Hiker Companion

Hiker Companion

Things used in this project

Hardware components

Software apps and online services

Story

Schematics

Code Flow

Code

Hiiker's Companion

Credits

Peter Smith

Comments

Related channels and tags