OpenShoe

Open­Shoe is an open source embed­ded foot-mounted iner­tial nav­i­ga­tion sys­tem (INS) imple­men­ta­tion, includ­ing both hard­ware and soft­ware designs. The mod­ule tracks the motion of the foot over the step by means of iner­tial nav­i­ga­tion. The steps can then be summed up to get a rel­a­tive posi­tion of a pedes­trian, as illus­trated above.

The embed­ded imple­men­ta­tion and the step-wise iner­tial nav­i­ga­tion mod­u­lar­izes the foot-mounted INS tech­nol­ogy which facil­i­tates the inte­gra­tion in real­time pedes­trian posi­tion­ing sys­tems, and make it fea­si­ble to equip a larger num­ber of users with foot-mounted INS mod­ules for field per­for­mance tests and coop­er­a­tive local­iza­tion stud­ies. The mod­ules are wire­less and can pro­vide the track­ing infor­ma­tion to, for exam­ple, a smart-phone. Mod­ules can be used on both feet for improved performance.

Gen­eral fea­tures of the implementation:

1. Embed­ded ZUPT-aided INS
2. Open source
3. Wire­less
4. Dead reck­on­ing updates*

Hard­ware features:**

1. Four Invensense MPU9150 IMUs
2. Atmel AVR32UC3C microcontroller
3. Blue­tooth and USB interfaces
4. Approx. 1.5[h] bat­tery time
5. Size 23.2x31x13.5[mm]

Soft­ware features:

1. Embed­ded soft­ware writ­ten in C
2. Gen­eral pro­cess­ing and com­mu­ni­ca­tion framework
3. Algo­rithm implementations
4. Repro­gram­ma­ble via USB
5. Appears as a vir­tual com-port

For a more detailed pre­sen­ta­tion of the imple­men­ta­tion, see the paper Foot-mounted iner­tial nav­i­ga­tion made easy (opens in a new tab). The cur­rent mod­ule is the sec­ond gen­er­a­tion of mod­ules. Descrip­tion of the pre­vi­ous gen­er­a­tion can be found in the paper Foot-mounted INS for Every­body — An Open-Source Embed­ded Imple­men­ta­tion.

We hope that you find the imple­men­ta­tion inter­est­ing and use­ful. If you have any ques­tions, com­ments, sug­ges­tions, or inquiries, please con­tact us at openshoe@ee.kth.se.

Best regards
/The Open­Shoe team

* For sys­tem inte­gra­tion, the sta­tis­tics of the posi­tion and head­ing is nec­es­sary. This is achieved by pro­vid­ing dead reck­on­ing updates (dis­place­ment and head­ing changes over indi­vid­ual steps) which can be used to repro­duce the sta­tis­tics. This way, most of the pro­cess­ing can be hid­den from the user while still pro­vid­ing suf­fi­cient infor­ma­tion for fusion with other infor­ma­tion sources.

** Addi­tional hard­ware fea­tures such as a FLASH mem­ory and a pres­sure sen­sor are avail­able. How­ever, no soft­ware sup­port for these com­po­nents is yet available.

Finally a video of some of our ongo­ing research …

Over the last years we have spent a sig­nif­i­cant research effort on analy­sis of the multiple-IMU (MIMU) sys­tems and plat­forms we have built. Recently we have had result of two major efforts published:

I. Skog, J.-O. Nils­son, P. Hän­del, A. Neho­rai, “Iner­tial Sen­sor Arrays, Max­i­mum Like­li­hood, and Cramér–Rao Bound”, IEEE Trans­ac­tions on Sig­nal Pro­cess­ing, vol. 64, no. 16, pp. 4218 — 4227, 2016.

The arti­cle con­tains the first esti­ma­tion the­o­ret­i­cal for­mu­la­tion and analy­sis of MIMU sys­tems. The for­mu­la­tion makes it pos­si­ble to analys fun­da­men­tal prop­er­ties of such sys­tems and to derive effi­cient esti­ma­tors. In the article,we:

• Derive bound on the achiev­able per­for­mance of MIMU-systems
• Sug­gest an effi­cient (achiev­ing the bounds) maximum-likelihood esti­ma­tors for such systems
• Ana­lyze the prop­er­ties and per­for­mance of MIMU-systems by sim­u­la­tions an exper­i­men­tal data

J.-O. Nils­son and I. Skog, “Iner­tial sen­sor arrays — a lit­er­a­ture sur­vey”, Proc. of 2016 Euro­pean Nav­i­ga­tion Con­fer­ence (ENC), 30 May — 2 June, Helsinki, Fin­land, 2016.

Work­ing with MIMU sys­tems, we have come to real­ize that the related results are very much spread out and poorly cross­cited. There­fore, we com­piled a lit­er­a­ture sur­vey con­sist­ing of some +300 pub­li­ca­tions, cat­e­go­rized accord­ing to array setup, study area and appli­ca­tion. The sur­vey also con­tains a descrip­tion of fun­da­men­tal sys­tem prop­er­ties of iner­tial arrays. Our hope is that the sur­vey will pro­vide the inter­ested reader with an overview of the topic and inspire fur­ther research in an area where the rapid devel­op­ment of sen­sor and com­pu­ta­tional tech­nolo­gies pro­vides many new opportunities.

I see there has been almost a year since last update. In other words, time for some updates! I will start with some mod­ules soft­ware updates. I’ve recently pushed some soft­ware updates for the embed­ded code. The main updates are:

• Sup­port for read­ing out mag­ne­tome­ter data from the IMUs
• Bug­fix for the loss­less com­mu­ni­ca­tion mode. A bug pre­vented pack­ages from being resent.

In addi­tion, numer­ous small improve­ment and mod­i­fi­ca­tions have been made.

The embed­ded soft­ware can be found at:

https://sourceforge.net/p/openshoe/_list/git

Recently there has been a num­ber of soft­ware updates on source forge:

1. The com­mu­ni­ca­tion logic has now been iso­lated from the hard­ware depen­den­cies and the UART (Blue­tooth) and the USB is now han­dled by the same rou­tines. Pre­vi­ously the com­mu­ni­ca­tion logic code was dupli­cated to han­dle the two interfaces.

2. The project files have now been upgraded from Atmel Stu­dio 6.5 to Atmel Stu­dio 7.

3. The Atmel Soft­ware Frame­work (ASF) has been updated from ver­sion 2.7 to ver­sion 3.18. Fur­ther, all ASF/platform depen­den­cies have been removed from the algo­rithms so there is no ASF stuff longer in the algo­rithm project.

Over the last weeks I’ve updated the low-level com­mu­ni­ca­tion rou­tines in the embed­ded code. This should be the end of the clean-up and update of the com­mu­ni­ca­tion inter­faces over the last two month. Now the USB and the Blue­tooth inter­faces should behave iden­ti­cal, apart from the lower band­width of the Blue­tooth inter­face. Fur­ther, both inter­faces are now dou­ble buffered giv­ing a slightly bet­ter per­for­mance. Over­all these changes should not affect high level usage of the mod­ules. What remains to be done is to actu­ally merge the com­mu­ni­ca­tion log­ics of the two dif­fer­ent inter­faces. Now there is a lot of code dupli­ca­tion, not more than before but just much more obvi­ous. How­ever, for now I’m con­tent with the state of the code and I don’t think I will do this in the near future.

Some­what adjusted control-scripts and cal­i­bra­tion scripts:

OpenShoe_Matlab_scripts

Cal­i­bra­tion

Espe­cially, in the cal­i­bra­tion script I’ve added a pac­ing beep for plac­ing the cal­i­bra­tion body on the dif­fer­ent sides for roughly the same time.

Edit:  I’ve not updated the com­mu­ni­ca­tion pro­to­col doc­u­men­ta­tion jet. I hope to do that before I for­get about it. How­ever, the changes are very small, essen­tially that the USB inter­face sup­ports loss­less com­mu­ni­ca­tion just like the Blue­tooth interface.