add Blinker + polish

03-software/ch/kb28/blinkerProject/app/factory/factory.c

@@ -57,6 +57,14 @@ CLICK_HANDLER* ch3() {
     return &theFactory.ch3_;
 }
 
+BLINKER* blA() {
+    return &theFactory.blA_;
+}
+BLINKER* blB() {
+    return &theFactory.blB_;
+}
+
+
 
 LEDBlinker* lb() {
     return &theFactory.lb_;
@@ -75,15 +83,6 @@ void Factory_init() {
     LED_init(l9(), 9);
     LED_init(l10(), 10);
     
-    BUTTON_init(b1(), 1);
-    BUTTON_init(b2(), 2);
-    BUTTON_init(b3(), 3);
-    
-    CLICK_HANDLER_init(ch1(), b1());
-    CLICK_HANDLER_init(ch2(), b2());
-    CLICK_HANDLER_init(ch3(), b3());
-    
-    
     LED_initHW(l1());
     LED_initHW(l2());
     LED_initHW(l3());
@@ -95,25 +94,45 @@ void Factory_init() {
     LED_initHW(l9());
     LED_initHW(l10());
     
+    
+    BUTTON_init(b1(), 1);
+    BUTTON_init(b2(), 2);
+    BUTTON_init(b3(), 3);
+    
     BUTTON_initHW(b1());
     BUTTON_initHW(b2());
     BUTTON_initHW(b3());
+    
+    CLICK_HANDLER_init(ch1(), b1());
+    CLICK_HANDLER_init(ch2(), b2());
+    CLICK_HANDLER_init(ch3(), b3());
+    
+    BLINKER_init(blA());
+    BLINKER_init(blB());
+    
 }
 
 //connect objects if required
 void Factory_build() {
-    //BUTTON_setEventFunctions(b1(), BUTTON_defineCallBack(&LED_on, l1()), BUTTON_defineCallBack(NULL, NULL));
+    BLINKER_defineNblink(blA(), 3);
-    //BUTTON_setEventFunctions(b3(), BUTTON_defineCallBack(&LED_off, l1()), BUTTON_defineCallBack(NULL, NULL));
+    BLINKER_defineNblink(blB(), 5);
     
+    BLINKER_setTimeOn(blA(), 20);
+    BLINKER_setTimeOff(blA(), 480);
     
-    CLICK_HANDLER_setSingleClickCallback(ch1(), CLICK_HANDLER_defineCallBack(&LED_on, l1()));
+    BLINKER_setTurnOn(blA(), BLINKER_defineCallBack(&LED_on, l1()));
-    CLICK_HANDLER_setSingleClickCallback(ch3(), CLICK_HANDLER_defineCallBack(&LED_on, l3()));
+    BLINKER_setTurnOff(blA(), BLINKER_defineCallBack(&LED_off, l1()));
+    BLINKER_setTurnOn(blB(), BLINKER_defineCallBack(&LED_on, l10()));
+    BLINKER_setTurnOff(blB(), BLINKER_defineCallBack(&LED_off, l10()));
     
-    CLICK_HANDLER_setDoubleClickCallback(ch1(), CLICK_HANDLER_defineCallBack(&LED_off, l1()));
+    CLICK_HANDLER_setSingleClickCallback(ch1(), CLICK_HANDLER_defineCallBack(&BLINKER_blink, blA()));
-    CLICK_HANDLER_setDoubleClickCallback(ch3(), CLICK_HANDLER_defineCallBack(&LED_off, l3()));
+    CLICK_HANDLER_setDoubleClickCallback(ch1(), CLICK_HANDLER_defineCallBack(&BLINKER_endBlink, blA()));
+    CLICK_HANDLER_setLongClickCallback(ch1(), CLICK_HANDLER_defineCallBack(&BLINKER_blinkN, blA()));
+    
+    CLICK_HANDLER_setSingleClickCallback(ch3(), CLICK_HANDLER_defineCallBack(&BLINKER_blink, blB()));
+    CLICK_HANDLER_setDoubleClickCallback(ch3(), CLICK_HANDLER_defineCallBack(&BLINKER_endBlink, blB()));
+    CLICK_HANDLER_setLongClickCallback(ch3(), CLICK_HANDLER_defineCallBack(&BLINKER_blinkN, blB()));
     
-    CLICK_HANDLER_setLongClickCallback(ch1(), CLICK_HANDLER_defineCallBack(&LED_on, l2()));
-    CLICK_HANDLER_setLongClickCallback(ch3(), CLICK_HANDLER_defineCallBack(&LED_off, l2()));
 }
 
 //start all state machines
@@ -125,4 +144,6 @@ void Factory_start() {
     CLICK_HANDLER_startBehaviour(ch1());
     CLICK_HANDLER_startBehaviour(ch2());
     CLICK_HANDLER_startBehaviour(ch3());
+    BLINKER_starBehaviour(blA());
+    BLINKER_starBehaviour(blB());
 }

03-software/ch/kb28/blinkerProject/app/factory/factory.h

@@ -11,6 +11,7 @@
 #include "../../board/button/button.h"
 #include "../ledblinker.h"
 #include "../../middleware/clickHandler.h"
+#include "../../middleware/blinker.h"
 
 typedef struct {
     LED l1_;
@@ -29,6 +30,8 @@ typedef struct {
     CLICK_HANDLER ch1_;
     CLICK_HANDLER ch2_;
     CLICK_HANDLER ch3_;
+    BLINKER blA_;
+    BLINKER blB_;
     
     LEDBlinker lb_;
 } Factory;
@@ -58,6 +61,7 @@ CLICK_HANDLER* ch1();
 CLICK_HANDLER* ch2();
 CLICK_HANDLER* ch3();
 
-LEDBlinker* lb();
+BLINKER* blA();
+BLINKER* blB();
 
 #endif

03-software/ch/kb28/blinkerProject/app/lebblinker.c

@@ -1,57 +0,0 @@
-#include "ledblinker.h"
-#include "factory/factory.h"
-#include "../board/led/led.h"
-
-void LEDBlinker_init(LEDBlinker* me) {
-    me->state = ST_LBINIT;
-}
-
-void LEDBlinker_startBehaviour(LEDBlinker* me) {
-    POST(me, &LEDBlinker_processEvent, evLBInit,0,0);
-}
-
-bool LEDBlinker_processEvent(Event* ev) {
-    bool processed = false;
-    LEDBlinker* me = (LEDBlinker*)Event_getTarget(ev);
-    LBSTATES oldState = me->state;
-    evIDT evid = Event_getId(ev);
-    
-    switch (me->state) {
-        case ST_LBINIT:
-            if (evid == evLBInit) {
-                me->state = ST_LBOFF;
-            }
-            break;
-        case ST_LBOFF:
-            if (evid == evLBTMOn) {
-                me->state = ST_LBON;
-            }
-            break;
-        case ST_LBON:
-            if (evid == evLBTMOff) {
-                me->state = ST_LBOFF;
-            }
-            break;
-        default:
-            break;
-    }
-    
-    if (oldState != me->state) {
-        switch (me->state) {
-            case ST_LBINIT:
-                break;
-            case ST_LBOFF:
-                LED_off(l1());
-                POST(me, &LEDBlinker_processEvent, evLBTMOn,TMOFF,0);
-                break;
-            case ST_LBON:
-                LED_on(l1());
-                POST(me, &LEDBlinker_processEvent, evLBTMOff,TMON,0);
-                break;
-            default:
-                break;
-        }   
-        processed = true;
-    }
-    return processed;
-}

03-software/ch/kb28/blinkerProject/app/ledblinker.h

@@ -1,42 +0,0 @@
-/* 
- * File:   ledblinker.h
- * Author: rim
- *
- * Created on May 14, 2023, 9:58 AM
- */
-
-#ifndef LEDBLINKER_H
-#define	LEDBLINKER_H
-
-#ifdef	__cplusplus
-extern "C" {
-#endif
-    
-#include "../xf/xf.h"
-    
-    enum LBSTATES_ {ST_LBINIT, ST_LBOFF, ST_LBON};
-    enum LBEVENTS_  {evLBInit=200, evLBTMOff, evLBTMOn};
-    typedef enum LBSTATES_ LBSTATES;
-    typedef enum LBEVENTS_ LBEVENTS;
-    
-    struct LEDBlinker_ {
-        LBSTATES state;
-    };
-    
-    typedef struct LEDBlinker_ LEDBlinker;
- 
-#define TMON 500
-#define TMOFF 1000
-    
-    
-    void LEDBlinker_init(LEDBlinker* me);
-    
-    void LEDBlinker_startBehaviour(LEDBlinker* me);
-    bool LEDBlinker_processEvent(Event* ev);
-
-#ifdef	__cplusplus
-}
-#endif
-
-#endif	/* LEDBLINKER_H */
-

03-software/ch/kb28/blinkerProject/app/main.c

@@ -14,7 +14,7 @@ void main(void)
     INTERRUPT_GlobalInterruptEnable();
     //INTERRUPT_GlobalInterruptDisable();
     //INTERRUPT_PeripheralInterruptEnable();
-    //INTERRUPT_PeripheralInterruptDisable();
+    //INTERRUPT_PeripheralInterruptDisable();                
 
     XF_init();
 

03-software/ch/kb28/blinkerProject/board/button/button.c

@@ -1,9 +1,7 @@
 /**
- * @file button.c
  * @author Rémi Heredero (remi@heredero.ch)
- * @version 1
+ * @version. 1.0.0
- * @date 2023-06-13
+ * @date 2023-06-15
- * 
  */
 
 #include "button.h"

03-software/ch/kb28/blinkerProject/board/button/button.h

@@ -12,28 +12,37 @@
 #include <stdbool.h>
 #include "../../xf/xf.h"
 
-#define PB_POLL_TIME 20
+#define PB_POLL_TIME 20 // Poll time for BUTTON
 
-typedef enum {ST_PBINIT,  ST_PBRELEASED, ST_PBPRESSED} BUTTON_STATES;
+typedef enum {
-typedef enum {evPBInit=100, evPBPoll} BUTTON_EVENTS;
+    ST_PBINIT,
+    ST_PBRELEASED,
+    ST_PBPRESSED
+}  BUTTON_STATES;
 
-typedef void (*fButtonCallback)(void*);
+typedef enum {
+    evPBInit=50,
+    evPBPoll
+} BUTTON_EVENTS;
+
+// Calback function
+typedef void (*fButtonCallback)(void*); 
 typedef struct {
     fButtonCallback fCallBack;
     void* param;
 } buttonCallBack;
 
 typedef struct {
-    uint8_t id;
+    uint8_t id; // Id of the button
-    BUTTON_STATES state;
+    BUTTON_STATES state; // Actual state 
-    buttonCallBack press;
+    buttonCallBack press; // Callback for the rising edge of the button
-    buttonCallBack release;
+    buttonCallBack release;  // Callback for the falling edge of the button
 } BUTTON;
 
 /**
  * @brief Initialize the button
  * 
- * @param me The object to initialize
+ * @param me button itself
  * @param id The id of the button
  */
 void BUTTON_init(BUTTON* me, uint8_t id);
@@ -41,22 +50,50 @@ void BUTTON_init(BUTTON* me, uint8_t id);
 /**
  * @brief Initialize the hardware of the button
  * 
- * @param me The object to initialize
+ * @param me button itself
  */
 void BUTTON_initHW(BUTTON* me);
 
+/**
+ * @brief Set both callback event functions
+ * 
+ * @param me button itself
+ * @param fPress callback function when the button have a rising edge
+ * @param release callback function whent the  have a falling edge
+ */
+void BUTTON_setEventFunctions(BUTTON* me, buttonCallBack fPress, buttonCallBack release);
+
 /**
  * @brief Check if the button is pressed
  * The function returns true if the button is pressed, false otherwise
  * 
- * @param me The object to check
+ * @param me button itself
  * @return true if the button is pressed
  * @return false if the button is not pressed
  */
-void BUTTON_setEventFunctions(BUTTON* me, buttonCallBack fPress, buttonCallBack release);
 bool BUTTON_isPressed(BUTTON* me);
+
+/**
+ * @biref Start state machine of the BUTTON
+ * 
+ * @param me the button itself
+ */
 void BUTTON_startBehaviour(BUTTON* me);
+
+/**
+ * @brief State machine of the BUTTON
+ * 
+ * @param ev event to process on the state machine
+ */
 bool BUTTON_processEvent(Event* ev);
+
+/**
+ * @brief Define a callback for BUTTON
+ * 
+ * @param f callback function
+ * @param param callback parameter for the function
+ * @return the callback struct
+ */
 buttonCallBack BUTTON_defineCallBack(fButtonCallback f, void* param);
 
 #endif	/* BUTTON_H */

03-software/ch/kb28/blinkerProject/board/led/led.c

@@ -1,3 +1,9 @@
+/**
+ * @author Rémi Heredero (remi@heredero.ch)
+ * @version. 1.0.0
+ * @date 2023-06-15
+ */
+
 #include "led.h"
 #include "../../mcc_generated_files/pin_manager.h"
 

03-software/ch/kb28/blinkerProject/board/led/led.h

@@ -1,25 +1,42 @@
-/* 
+/**
- * File:   led.h
+ * @file led.h
- * Author: rim
+ * @author Rémi Heredero (remi@heredero.ch)
- *
+ * @version. 1.0.0
- * Created on May 15, 2023, 7:56 AM
+ * @date 2023-06-15
  */
-
 #ifndef LED_H
 #define LED_H
 
 #include <stdint.h>
 
-struct LED_
+// LED struct
-{
+typedef struct {
-    uint8_t id;
+    uint8_t id; // The id of the LED
-};
+}LED;
-
-typedef struct LED_ LED;
 
+/**
+ * Initialize the led
+ * @param me the led itself
+ * @param id the id of the led
+ */
 void LED_init(LED* me, uint8_t id);
+
+/**
+ * Initializing the led
+ * @param me the led itself
+ */
 void LED_initHW(LED* me);
+
+/**
+ * Turn On the led 
+ * @param me the led itself
+ */
 void LED_on(void* me);
+
+/**
+ * Turn Off the led 
+ * @param me the led itself
+ */
 void LED_off(void* me);
 
 #endif	/* LED_H */

03-software/ch/kb28/blinkerProject/middleware/blinker.c

@@ -0,0 +1,135 @@
+/**
+ * @file blinker.c
+ * @author Rémi Heredero (remi@heredero.ch)
+ * @version 0
+ * @date 2023-06-14
+ */
+
+#include "blinker.h"
+
+
+void BLINKER_init(BLINKER* me) {
+    me->state = STBL_INIT;
+    me->tON = 500;
+    me->tOFF = 500;
+    me->nBlink = 3;
+    me->nBlinkIsOn = false;
+    me->remainBlinks = 3;
+    me->turnOn.fCallBack = NULL;
+    me->turnOff.fCallBack = NULL;
+}
+
+blinkerCallBack BLINKER_defineCallBack(fBlinkerCallBack f, void* param) {
+    blinkerCallBack c;
+    c.fCallBack = f;
+    c.param = param;
+    return c;
+}
+
+void BLINKER_starBehaviour(BLINKER* me) {
+    POST(me, &BLINKER_processEvent, evBLinit, 0, 0);
+}
+
+void BLINKER_setTurnOn(BLINKER* me, blinkerCallBack callBack) {
+    me->turnOn = callBack;
+}
+
+void BLINKER_setTurnOff(BLINKER* me, blinkerCallBack callBack) {
+    me->turnOff = callBack;
+}
+
+void BLINKER_defineNblink(BLINKER* me, uint8_t n){
+    me->nBlink = n;
+}
+
+void BLINKER_setTimeOn(BLINKER*me, uint16_t t) {
+    me->tON = t;
+}
+
+void BLINKER_setTimeOff(BLINKER*me, uint16_t t) {
+    me->tOFF = t;
+}
+
+void BLINKER_blinkN(BLINKER* me){
+    POST(me, &BLINKER_processEvent, evBLblinkN, 0, 0);
+}
+
+void BLINKER_blink(BLINKER* me){
+    POST(me, &BLINKER_processEvent, evBLblink, 0, 0);
+}
+
+bool BLINKER_processEvent(Event* ev) {
+    bool processed = false;
+    BLINKER* me = (BLINKER*) Event_getTarget(ev);
+    BLINKER_STATES oldState = me->state;
+    evIDT evid = Event_getId(ev);
+    
+    switch(me->state) {
+        case STBL_INIT:
+            if(evid == evBLinit) {
+                me->state = STBL_WAIT; 
+            }
+            break;
+            
+        case STBL_WAIT:
+            me->remainBlinks = me->nBlink;
+            
+            if(evid == evBLblinkN) {
+                me->state = STBL_ON;
+                me->nBlinkIsOn = true;
+                POST(me, &BLINKER_processEvent, evBLtimer, me->tON, 0);
+            }
+            
+            if(evid==evBLblink) {
+                me->state = STBL_ON;
+                me->nBlinkIsOn = false;
+                POST(me, &BLINKER_processEvent, evBLtimer, me->tON, 0);
+            }
+            break;
+            
+        case STBL_ON:
+            if(me->nBlinkIsOn) me->remainBlinks--;
+            
+            if(evid == evBLtimer) {
+                me->state = STBL_OFF;
+                POST(me, &BLINKER_processEvent, evBLtimer, me->tOFF, 0);
+            }
+            
+            break;
+            
+        case STBL_OFF:
+            
+            if(evid == evBLtimer) {
+                if(me->remainBlinks == 0) {
+                    me->state = STBL_WAIT;
+                } else {
+                    me->state = STBL_ON;
+                    POST(me, &BLINKER_processEvent, evBLtimer, me->tON, 0);
+                }
+            }
+            
+            break;
+    }
+    
+    if(oldState != me->state) {
+        switch(me->state) {
+            case STBL_INIT:
+                break;
+
+            case STBL_WAIT:
+                break;
+
+            case STBL_ON:
+                if(me->turnOn.fCallBack != NULL) me->turnOn.fCallBack(me->turnOn.param);
+                break;
+
+            case STBL_OFF:
+                if(me->turnOff.fCallBack != NULL) me->turnOff.fCallBack(me->turnOff.param);
+                break;
+        }
+    }
+}
+
+void BLINKER_endBlink(BLINKER* me) {
+    me->remainBlinks = 0;
+}

03-software/ch/kb28/blinkerProject/middleware/blinker.h

@@ -0,0 +1,126 @@
+/**
+ * @file blinker.h
+ * @author Rémi Heredero (remi@heredero.ch)
+ * @version 0
+ * @date 2023-06-14
+ */
+
+#ifndef BLINKER_H
+#define	BLINKER_H
+
+#include "../xf/xf.h"
+
+typedef enum {
+    STBL_INIT,
+    STBL_WAIT,
+    STBL_ON,
+    STBL_OFF
+} BLINKER_STATES;
+
+typedef enum {
+    evBLinit = 200,
+    evBLblink,
+    evBLblinkN,
+    evBLtimer,
+    evEndBlink
+} BLINKER_EVENTS;
+
+typedef void (*fBlinkerCallBack)(void*);
+typedef struct {
+    fBlinkerCallBack fCallBack;
+    void* param;
+} blinkerCallBack;
+
+typedef struct {
+    BLINKER_STATES state;
+    uint16_t tON; // Time on
+    uint16_t tOFF; // Time off
+    uint8_t nBlink; // Number of blink for this blinker when start with blinkN
+    bool nBlinkIsOn; // If the nBlink way is enable
+    uint8_t remainBlinks; // Actual remain blink
+    blinkerCallBack turnOn; // Callback for turnOn
+    blinkerCallBack turnOff; // Calbback for turnOff
+}BLINKER;
+
+/**
+ * Initialize the blinker
+ * @param me blinker itself
+ */
+void BLINKER_init(BLINKER* me);
+
+/**
+ * Define a callback for BLINKER    
+ * @param f callback for BLINKER
+ * @param param callback paramater for ther function 
+ * @return the callback struct
+ */
+blinkerCallBack BLINKER_defineCallBack(fBlinkerCallBack f, void* param);
+
+/**
+ * Start state machine of the BLINKER
+ * @param me the blinker itself
+ */
+void BLINKER_starBehaviour(BLINKER* me);
+
+/**
+ * Set callback event functions for turn on
+ * @param me the blinker itself
+ * @param callBack function when the blinker is on
+ */
+void BLINKER_setTurnOn(BLINKER* me, blinkerCallBack callBack);
+
+/**
+ * Set callback event functions for turn off
+ * @param me the blinker itself
+ * @param callBack function when the blinker is off
+ */
+void BLINKER_setTurnOff(BLINKER* me, blinkerCallBack callBack);
+
+/**
+ * define number of time the Blinker have to blink
+ * @param me the blinker itself
+ * @param n number of blink
+ */
+void BLINKER_defineNblink(BLINKER* me, uint8_t n);
+
+/**
+ * define time to stay ON
+ * @param me the blinker itself
+ * @param t the time to stay ON
+ */
+void BLINKER_setTimeOn(BLINKER*me, uint16_t t);
+
+/**
+ * define time to stay OFF
+ * @param me the blinker itself
+ * @param t the time to stay OFF
+ */
+void BLINKER_setTimeOff(BLINKER*me, uint16_t t);
+
+/**
+ * Start to blink n time
+ * @param me the blinker itself
+ */
+void BLINKER_blinkN(BLINKER* me);
+
+/**
+ * Start to blink indefinitely
+ * @param me the blinker itself
+ */
+void BLINKER_blink(BLINKER* me);
+
+/**
+ * State machine of the BUTTON
+ * @param ev event to process on the state machine
+ */
+bool BLINKER_processEvent(Event* ev);
+
+/**
+ * Stop to blink if it was indefinitely blinking
+ * @param me the blinker itself
+ */
+void BLINKER_endBlink(BLINKER* me);
+
+
+#endif	/* BLINKER_H */
+

03-software/ch/kb28/blinkerProject/middleware/clickHandler.c

@@ -1,7 +1,7 @@
 /**
  * @file clickHandler.c
  * @author Rémi Heredero (remi@heredero.ch)
- * @version 0.1
+ * @version 0
  * @date 2023-06-13
  */
 

03-software/ch/kb28/blinkerProject/middleware/clickHandler.h

@@ -1,8 +1,8 @@
 /**
  * @file clickHandler.h
  * @author Rémi Heredero (remi@heredero.ch)
- * @version 0.1
+ * @version 1
- * @date 2023-06-13
+ * @date 2023-06-14
  */
 
 #ifndef CLICKHANDLER_H
@@ -22,7 +22,7 @@ typedef enum {
 } CLICK_HANDLER_STATES;
 
 typedef enum {
-    evCHinit = 150,
+    evCHinit = 100,
     evCHtimer,
     evCHpbPress,
     evCHpbRelease
@@ -35,19 +35,59 @@ typedef struct {
 } clickHandlerCallBack;
 
 typedef struct {
-    BUTTON* button;
+    BUTTON* button; // The button connected to the clickHandler
-    CLICK_HANDLER_STATES state;
+    CLICK_HANDLER_STATES state; // The actual state
-    clickHandlerCallBack longClick;
+    clickHandlerCallBack longClick; // Callback for longClick
-    clickHandlerCallBack singleClick;
+    clickHandlerCallBack singleClick; // Callback for singleClick
-    clickHandlerCallBack doubleClick;
+    clickHandlerCallBack doubleClick; // Callback for doubleClick
 }CLICK_HANDLER;
 
+/**
+ * Initialize the clickHandler
+ * @param me the clickHandler itself
+ * @param b the button to connect on the clickHandler
+ */
 void CLICK_HANDLER_init(CLICK_HANDLER* me, BUTTON* b);
+
+/**
+ * Define a callback for CLICKHANDLER
+ * @param f  callback function for CLICKHANDLER
+ * @param param callback parameter for the function
+ * @return the callback struct
+ */
 clickHandlerCallBack CLICK_HANDLER_defineCallBack(fClickHandlerCallBack f, void* param);
+
+/**
+ * Start state machine of the CLICKHANDLER
+ * @param me the clickHandler itself
+ */
 void CLICK_HANDLER_startBehaviour(CLICK_HANDLER* me);
+
+/**
+ * Set Callback eventfunction for long click
+ * @param me the clickHandler itself
+ * @param callBack callback function when the click handler have a long click
+ */
 void CLICK_HANDLER_setLongClickCallback(CLICK_HANDLER* me, clickHandlerCallBack callBack);
+
+/**
+ * Set Callback event function for single click
+ * @param me the clickHandler itself
+ * @param callBack callback function when the click handler have a single click
+ */
 void CLICK_HANDLER_setSingleClickCallback(CLICK_HANDLER* me, clickHandlerCallBack callBack);
+
+/**
+ * Set Callback evenet function for double click
+ * @param me the clickHandler itself
+ * @param callBack callback function when the click handler have a double click
+ */
 void CLICK_HANDLER_setDoubleClickCallback(CLICK_HANDLER* me, clickHandlerCallBack callBack);
+
+/**
+ * State machine of the CLICKHANDLER
+ * @param ev event to process on the state machine
+ */
 bool CLICK_HANDLER_processEvent(Event* ev);
 
 

03-software/nbproject/configurations.xml

@@ -8,7 +8,6 @@
         <logicalFolder name="factory" displayName="factory" projectFiles="true">
           <itemPath>ch/kb28/blinkerProject/app/factory/factory.h</itemPath>
         </logicalFolder>
-        <itemPath>ch/kb28/blinkerProject/app/ledblinker.h</itemPath>
       </logicalFolder>
       <logicalFolder name="board" displayName="board" projectFiles="true">
         <logicalFolder name="button" displayName="button" projectFiles="true">
@@ -29,6 +28,7 @@
       </logicalFolder>
       <logicalFolder name="middleware" displayName="middleware" projectFiles="true">
         <itemPath>ch/kb28/blinkerProject/middleware/clickHandler.h</itemPath>
+        <itemPath>ch/kb28/blinkerProject/middleware/blinker.c</itemPath>
       </logicalFolder>
       <logicalFolder name="xf" displayName="xf" projectFiles="true">
         <itemPath>ch/kb28/blinkerProject/xf/ireactive.h</itemPath>
@@ -47,7 +47,6 @@
         <logicalFolder name="factory" displayName="factory" projectFiles="true">
           <itemPath>ch/kb28/blinkerProject/app/factory/factory.c</itemPath>
         </logicalFolder>
-        <itemPath>ch/kb28/blinkerProject/app/lebblinker.c</itemPath>
         <itemPath>ch/kb28/blinkerProject/app/main.c</itemPath>
       </logicalFolder>
       <logicalFolder name="board" displayName="board" projectFiles="true">
@@ -69,6 +68,7 @@
       </logicalFolder>
       <logicalFolder name="middleware" displayName="middleware" projectFiles="true">
         <itemPath>ch/kb28/blinkerProject/middleware/clickHandler.c</itemPath>
+        <itemPath>ch/kb28/blinkerProject/middleware/blinker.h</itemPath>
       </logicalFolder>
       <logicalFolder name="xf" displayName="xf" projectFiles="true">
         <itemPath>ch/kb28/blinkerProject/xf/xf.c</itemPath>
@@ -262,6 +262,7 @@
         <property key="debugoptions.debug-startup" value="Use system settings"/>
         <property key="debugoptions.reset-behaviour" value="Use system settings"/>
         <property key="debugoptions.useswbreakpoints" value="false"/>
+        <property key="firmware.download.all" value="false"/>
         <property key="hwtoolclock.frcindebug" value="false"/>
         <property key="memories.aux" value="false"/>
         <property key="memories.bootflash" value="true"/>