Then the controller is called at regular intervals (seconds) by the “Application level” layer, triggered at regular intervals (seconds) to compute the Membership functions, the Fuzzy Rules and derive a decision (defuzzification).<\/p>\n
![\"\"](\"http:\/\/www.em-company.fr\/blog\/wp-content\/uploads\/owd.jpg\")
<\/p>\n
Data Structures<\/h6>\n
To convey information from the Interrupt level to the Framework level, the following paradigm has been chosen<\/p>\n
- \n
- ISR (Interrupt service routine) sends a 2 bytes data structure, whose mapping is specific to the Originating sensor<\/li>\n
- ISR calls a Framework interrupt callback\u00a0<\/em>by supplying the following information: Originator and Specific Bit-mapped value<\/li>\n<\/ul>\n
\/\/ Originator of the OWD info\r\ntypedef enum { FROM_BMI_NO_MO, FROM_BMI_ANY_MO, FROM_OHRM, FROM_LS, MAX_OWD_CONTRIBUTORS } fwk_owd_from_t; \r\n\r\n\/\/ decision type\r\ntypedef enum { ON_ARM_STATE, OFF_ARM_STATE, OWD_UNDEFINED_STATE } OWD_Decision_t;<\/pre>\nShared data structures are defined to hold information from the Sensor detection.<\/p>\n
\/\/ Shared Data structures\r\n\/\/\r\n\r\n\/\/ Case of BMI160 accelerometer<\/strong>\r\ntypedef struct fwd_owd_bmi {\r\n union {\r\n uint16_t val8;\r\n struct {\r\n uint8_t bmi_anymo_event : 1; \/\/ Any-motion\r\n uint8_t bmi_nomo_event : 1; \/\/ no motion\r\n uint8_t bmi_signimo_event : 1; \/\/ significant movement\r\n uint8_t bmi_orient_fup : 1; \/\/ Orientation facing up\r\n uint8_t bmi_orient_fdown : 1; \/\/ Orientation facing down\r\n uint8_t bmi_orient_portrait_top : 1; \/\/ Orientation portait top\r\n uint8_t bmi_orient_portrait_down : 1; \/\/ Orientation portait down\r\n uint8_t bmi_orient_land_left : 1; \/\/ Orientation landscape left\r\n uint8_t bmi_orient_lan_right : 1; \/\/ Orientation landscape right\r\n uint8_t padding : 7;\r\n } bits;\r\n };\r\n} fwk_bmi_events_t;\r\n\r\n\/\/ Case of OHRM detector<\/strong>\r\ntypedef struct fwd_owd_ohrm {\r\n union {\r\n uint16_t val16;\r\n struct {\r\n uint8_t ohrm_conf_level : 8; \/\/ confidence level in %\r\n uint8_t ohrm_locked : 1;\r\n uint8_t padding : 7;\r\n } bits;\r\n };\r\n} fwk_owd_ohrm_events_t;\r\n\r\n\/\/ Case of ambient light sensing<\/strong>\r\ntypedef struct fwd_owd_light {\r\n union {\r\n uint16_t val16; \/\/ light sensor adc value (12 bits)\r\n struct {\r\n uint16_t val : 16;\r\n } bits;\r\n };\r\n} fwk_owd_light_events_t;<\/pre>\nInterfaces to the OWD Framework<\/h6>\n
As an example, the BMI NoMotion ISR would call the framework callback<\/p>\n
void bmi160_isr_int2_handler(void)\r\n{\r\n \r\n\/\/ anymotion was detected\r\nif ( .... )\r\n {\r\n fwk_bmi_events_t event = { 0 };\r\n event.bits.bmi_anymo_event = 1;\r\n \r\nfwk_owd_common_int_cb(FROM_BMI_ANY_MO, &event);<\/strong>\r\n }\r\n\/\/ nomotion was detected \r\nif ( .... )\r\n {\r\n fwk_bmi_events_t event = { 0 };\r\n event.bits.bmi_nomo_event = 1;\r\n\r\nfwk_owd_common_int_cb(FROM_BMI_NO_MO, &event);<\/strong>\r\n }\r\n}<\/pre>\nSimilarly the light sensor reading callback would call the framework as follows<\/p>\n
void fwk_owd_al_adc_cb(void)\r\n{\r\n uint16_t LsValue;\r\n\r\n ......\r\n ......\r\n fwk_owd_add_info(FROM_LS, (void*)&LsValue);<\/strong> \/\/ LsValue holds the reading\r\n .......\r\n .......\r\n}<\/pre>\nWithin the callback, the passed data is used to call the Controller appropriately. Depending on the sensor, this can be pure value translation, but some processing can also be done. An interesting case is the AnyMotion\/NoMotion events<\/p>\n
if (ActiveNoMotionStatus)\r\n {\r\n fwk_owd_add_event(FROM_BMI_NO_MO, true);<\/strong>\r\n fwk_owd_add_event(FROM_BMI_ANY_MO, false<\/strong>);\r\n }\r\n else\r\n {\r\n fwk_owd_add_event(FROM_BMI_NO_MO, false);\r\n fwk_owd_add_event(FROM_BMI_ANY_MO, true);\r\n }<\/pre>\nNotice that we had to duplicate the calls to signal both NO_MOTION and ANY_MOTION at each time. The reason lies deep into the BMI specifications and operations. Basically, if we detect “ANY_MOTION” that also means that “NO_MOTION” was NOT detected\u00a0 :). This sounds redundant but really isn’t to our purpose.<\/p>\n
Fuzzy Logic Controller (Sensor Fusion Controller)<\/h6>\n
The Fuzzy logic based\u00a0 controller does three main things<\/p>\n
- \n
- It aggregates the sensors provided data into proper structures<\/li>\n
- Maintain running averages on those data<\/li>\n
- Upon being called (fwk_compute_owd_decision)<\/em>\n
- \n
- For each sensor computes the membership values (on the averaged values)<\/li>\n
- computes the Inference rules<\/li>\n
- Performs the defuzzification and derives the decision<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
As seen earlier, the controller has two main entry points, for sensors carrying analog information and sensors carrying digital information. Although this could have been done with a generic method, I preferred this approach for code clarity<\/p>\n
void fwk_owd_add_info(fwk_owd_from_t orig, void *data); \r\nvoid fwk_owd_add_event(fwk_owd_from_t orig, bool found);<\/pre>\n
The\u00a0fwk_add_event<\/em> will basically fall down to the normal case after a simplistic transformation of boolean values into numerical values, as follows<\/p>\n
#define EVENT_FOUND_NUMERICAL (100)\r\n#define EVENT_NOTFOUND_NUMERICAL (0)\r\n\r\nvoid fwk_owd_add_event(fwk_owd_from_t orig, bool found)\r\n{\r\n uint16_t value;\r\n\r\n\/\/ arbitrarily normalise to 0-100 range\r\n if (found)\r\n {\r\n value = EVENT_FOUND_NUMERICAL;\r\n }\r\n else\r\n {\r\n value = EVENT_NOTFOUND_NUMERICAL;\r\n }\r\n fwk_owd_add_info(orig, (void *)&value);<\/strong>\r\n}<\/pre>\nHere I defined a compound data structure to hold all the data received, but also the averaged values and pointers to static methods like averaging function, membership functions. It is definitely not required to do so, it is purely a matter of personal habit.<\/p>\n
static const owd_contrib_t owdContribTable[MAX_OWD_CONTRIBUTORS] = { \/* avg pAvgFunc pMFunc*\/\r\n { &owd_data.bmiNoMo, stdAvgFunc, bmiNoMoMfArray}, \/* BMI_NOMO*\/\r\n { &owd_data.bmiAnyMo, stdAvgFunc, bmiAnyMoMfArray }, \/* BMI_ANYMO*\/\r\n { &owd_data.hrLockVal, stdAvgFunc, hrLockMfArray }, \/* OHRM*\/\r\n { &owd_data.lsValue , stdAvgFunc, lsValueMfArray } \/* LS*\/\r\n };<\/pre>\nLet us now review the main entry point\u00a0\u00a0fwk_add_info.<\/em><\/p>\n
#define STD_RUNNING_AVG_DEPTH (3) \/* This means 2**3 = 8 *\/\r\n#define VL_RUNNING_AVG_DEPTH (8) \/* HR Conf level (256 seconds) *\/\r\n\r\nvoid fwk_owd_add_info(fwk_owd_from_t orig, void *data)\r\n{\r\n uint16_t val;\r\n\r\n\/\/ Accept auto-generated 0 values, to help decreasing the avg,\r\n \/\/ as well as real non-zero values for actual sensor values\r\n val = *(uint16_t*)data;\r\n \/\/ average each value (running avg)\r\n if (orig == FROM_OHRM)\r\n {\r\n val = val > OHRM_CFLVL_THR ? 1 : 0;\r\n owdContribTable[orig].avgFunc(owdContribTable[orig].avg, VL_RUNNING_AVG_DEPTH<\/strong>, val);\r\n }\r\n else\r\n owdContribTable[orig].avgFunc(owdContribTable[orig].avg, STD_RUNNING_AVG_DEPTH<\/strong>, val);\r\n\r\n\/\/ update the noMotion status\r\n if ((orig == FROM_BMI_NO_MO) && (val == EVENT_FOUND_NUMERICAL))\r\n ActiveNoMotionStatus = true;\r\n else if ((orig == FROM_BMI_ANY_MO) && (val == EVENT_FOUND_NUMERICAL))\r\n ActiveNoMotionStatus = false;\r\n}<\/pre>\nSo for each value, we call the averaging function with different depth, depending on the sensor nature. The averaging function can be easily changed, by changing the table pointers. I opted for a standard running average<\/p>\n
\/********************************************************************\r\n* \\brief generic averaging function whatever the data. We therefore assume a\r\n* reference to the avg os passed as parameter (as the func is generic ..)\r\n*\r\n* \\param[in] reference to the avg\r\n* \\param[in] depth of the estimator (2**depth)\r\n* \\param[in] new value to add to the avg\r\n* \\return 0 None\r\n*\r\n* @remarks we use a running average .... this could be change to something else\r\n* if needed\r\n********************************************************************\/\r\nstatic void stdAvgFunc(uint16_t * const avg, int depth, uint16_t newval)\r\n{\r\n uint32_t temp = ((uint32_t)(*avg)) << 16; \/\/ upconvert to high precision\r\n temp -= (temp >> depth);\r\n temp += ((((uint32_t)newval) << 16) >> depth);\r\n\r\n*avg = ((temp >> 16) & 0x0000FFFF); \/\/ downconvert and writeback result\r\n}<\/pre>\nso, as a result, we maintain proper sensor values regularly updated and averaged. Now the interesting part, the Fuzzy Rules computation<\/p>\n
Fuzzy Operators \/ Fuzzy Rules<\/h6>\n
Let’s recall that we have to compute fuzzy rules which look like this<\/p>\n
if motion low and hr not locked and ambient light high<\/p><\/blockquote>\n
For doing this, we need to first define the Operators (Fuzzy operators). There are 2 main approaches, one based on MIN and MAX operators (recommended by Pr. Zadeh), the other\u00a0 based on probabilistic operations. Let’s stick with the latter.<\/p>\n
#define f_one 1.0f\r\n#define f_zero 0.0f\r\n\r\n#define f_or(a,b) (((a)+(b))-((a)*(b))) \/\/ OR\r\n#define f_and(a,b) ((a)*(b)) \/\/ PROD\r\n#define f_not(a) (f_one - a)<\/pre>\n
So now, we can compute the Fuzzy Rules inferences. We compute the values for each of the propositions. For example, the “certainly off-arm” proposition was defined by 4 rules, so we infer the proposition value using RSS (Root of Sum of Squares). RSS was chosen after experimentation. One should refer to the various documents mentioned in the first article<\/a> of this serie. For this particular proposition, the inference is as follows:<\/p>\n
\/\/ Rules 1, 2, 3 , 3'==> certainly\r\n \/\/ Rule 1\r\n \/\/ 1. if motion low and hr not locked and ambient light high == > certainly off - arm\r\n temp = f_and(MotionMFunc_LOW(owd_data.bmiAnyMo), OhrmMFunc_CFL_OFF_ARM(owd_data.hrLockVal));\r\n temp = f_and(temp,LsMFunc_HIGH(owd_data.lsValue));\r\n certainly = pow_s (temp, 2);<\/strong>\r\n\r\n\/\/ Rule 2\r\n \/\/ 2. if motion high and hr not locked and ambient light high ==> certainly off-arm\r\n temp = f_and(MotionMFunc_HIGH(owd_data.bmiAnyMo), OhrmMFunc_CFL_OFF_ARM(owd_data.hrLockVal));\r\n temp = f_and(temp,LsMFunc_HIGH(owd_data.lsValue));\r\n certainly += pow_s(temp, 2);<\/strong>\r\n\r\n\/\/ Rule 3\r\n \/\/ 2. if motion low and hr not locked and (ambient light low or ambient light moderate)==> certainly off-arm\r\n temp = f_and(MotionMFunc_LOW(owd_data.bmiAnyMo), OhrmMFunc_CFL_OFF_ARM(owd_data.hrLockVal));\r\n temp = f_and(temp, f_or(LsMFunc_LOW(owd_data.lsValue), LsMFunc_MID(owd_data.lsValue)));\r\n certainly += pow_s(temp, 2);<\/strong>\r\n\r\n\/\/ Rule 3'\r\n \/\/ 2. if ambient light high ==> certainly off-arm\r\n temp = LsMFunc_HIGH(owd_data.lsValue);\r\n certainly += pow_s(temp, 2); certainly = root2_s(certainly);<\/strong>\r\n\r\n<\/pre>\n
One will notice the use of the operators previously defined and the various membership functions for each of the fuzzy variables subsets. Finally, we make use of optimised POW and ROOT functions, to minimize the runtime penalty (see my article <\/a>on these optimised functions).<\/p>\n
Similarly, the computation of all the other proposition values (probably, certainly not<\/em>)\u00a0 is done.<\/p>\n
Defuzzification<\/h6>\n
As an outcome, we have a numerical value for each proposition, which is stored in variables like\u00a0 “certainly” (see above figure), “CertainlyNot”, etc.<\/p>\n
The only small problem is that, statements like “Certainly”, “Probably” have to also be quantified so we can calculate a “crisp” decision value out of our rules. Let us define arbitrarily the output variable “off-arm plausibility” as follows<\/p>\n
![\"Fuzzy](\"http:\/\/www.em-company.fr\/blog\/wp-content\/uploads\/owd2-1-e1513346117524.jpg\")
That way we can compute the crisp decision (Defuzzification) via the COG method, which is commonly used. COG (Center Of Gravity) can be computed, in our case, with the very common formula<\/p>\n\/\/ Decision (using COG)\r\n temp = (((10.0f * certainlyNot) + (40.0f * unlikely) + (65.0f * probably) + (90.0f * certainly))\r\n \/ (certainlyNot + unlikely + probably + certainly));<\/pre>\n
It assumes that the COG for each of the subset is right at the middle.<\/p>\n
temp<\/em> variable then contains the degree of plausibility of the “off-arm” output variable. By using some carefully chosen decision threshold, one can derive a decision. For example<\/p>\n
\u00a0if (temp> DECISION_THR)\r\n *decision = OFF_ARM_STATE; \/\/ mean of maxima for certainly\r\n else\r\n *decision = OWD_UNDEFINED_STATE;<\/pre>\n
This is a simplistic example, but it answers to the design objectives set at the beginning, which was very conservative.<\/p>\n
Experimental results \/ improvements<\/h6>\n