parse_msg(msg,len ,IParameterHandler::TYPE_U16);
               }
               break;
+            case 'L':
+              {
+                  parse_msg(msg,len ,IParameterHandler::TYPE_U32);
+              }
+              break;
             case 'F':
               {
                   parse_msg(msg,len ,IParameterHandler::TYPE_FLOAT);
     } 
 }
 
-#define OUTPUT_BUFFER_SIZE 16 
+#define OUTPUT_BUFFER_SIZE 32
 void 
 CommunicationHandler::parse_msg(const Uint8_t *_msg,const Uint8_t len,IParameterHandler::eParameterType _eType)
 {
-    uint16_t nv  = 0;
-    uint16_t val = 0;
+    uint32_t nv  = 0;
+    uint32_t val = 0;
     uint8_t  pos = 0;
 
     parse_num(_msg+1,len -1,nv);
             m_Params->readValue(nv,fval);
             //dtostre(fval,(char *)l_OutBuffer,4,0);
             dtostrf(fval,8,4,(char *)l_OutBuffer);
-        } else
+        } else if (_eType == IParameterHandler::TYPE_U32)
+        {
+            m_Params->readValue(nv,val);
+            ltoa(val,(char *)l_OutBuffer,10);
+        }else
         {
             m_Params->readValue(nv,val);
             itoa(val,(char *)l_OutBuffer,10);
 }
 
 void 
-CommunicationHandler::parse_num(const Uint8_t *_msg,const Uint8_t len,Uint16_t &_out)
+CommunicationHandler::parse_num(const Uint8_t *_msg,const Uint8_t len,Uint32_t &_out)
 {
     Uint8_t chr = 0x00;
     Uint8_t pchr = 0x00;
 
     private:
         void parse_msg(const Uint8_t *_msg,const Uint8_t len,IParameterHandler::eParameterType _eT);
         ///
-        void parse_num(const Uint8_t *_msg,const Uint8_t len,  Uint16_t &_out);
+        void parse_num(const Uint8_t *_msg,const Uint8_t len,  Uint32_t &_out);
     private:
         IProtocolLayer2   *m_L2;
         IParameterHandler *m_Params;
 
 
     for (Uint8_t i = 0 ; (i < *uidLength) || (i < 7) ; i++)
     {
-       uid[i] = m_PacketBuffer[6 + i];
+       uid[i]   = m_PacketBuffer[6 + i];
+       m_UID[i] = m_PacketBuffer[6 + i];
     }
     return 1;
 }
 
     , PID_FirmwareVersion    =  9 /* Cycle Per rotation used in closed loop  */
     , PID_BadgePresent       = 10 /* Set PID constant factor   */
     , PID_BadgeCount         = 11 /* Set PID integral factor   */
-    , PID_Kd         = 12 /* Set PID derivation factor */
-    , PID_MAConsPwm  = 13 /* Pwm modulation instruction, Applied in open loop, ignore in closed loop */
-    , PID_MAConsRpm  = 14 /* Rpm instruction used as reference in closed loop */
+    , PID_BadgeLength        = 12 /* Badge ID length             */
+    , PID_BadgeLow           = 13 /* Write 4 bytes low badge ID  */
+    , PID_BadgeHigh          = 14 /* When 7 bytes Length add the 3 high bytes here */
     , PID_LowLevelError1  = 15 /* Low Level Error1  up to 32 errors */
     , PID_LowLevelError2  = 16 /* Low Level Error2  up to 32 errors */
     , PID_MAX        = 17
 
         virtual void readValue(const uint8_t paramID,uint16_t &_val);
         ///
         virtual void writeValue(const uint8_t paramID,const uint16_t _val);
-        
-       ///
+        ///
+        virtual void readValue(const uint8_t paramID,uint32_t &_val) {};
+        ///
+        virtual void writeValue(const uint8_t paramID,const uint32_t _val) {};
+        ///
         virtual void readValue(const uint8_t paramID,Float32_t &_val) ;
         ///
         virtual void writeValue(const uint8_t paramID,const Float32_t _val) ;
 
         enum eParameterType {
               TYPE_U8    = 0
             , TYPE_U16   = 1
-            , TYPE_FLOAT = 2
+            , TYPE_U32   = 2
+            , TYPE_FLOAT = 3
         };
     public:
         IParameterHandler() {};
         ///
         virtual void writeValue(const uint8_t paramID,const uint16_t _val) = 0;
         ///
+        virtual void readValue(const uint8_t paramID,uint32_t &_val) = 0;
+        ///
+        virtual void writeValue(const uint8_t paramID,const uint32_t _val) = 0;
+        ///
         virtual void readValue(const uint8_t paramID,Float32_t &_val) = 0;
         ///
         virtual void writeValue(const uint8_t paramID,const Float32_t _val) = 0;
 
     } 
 }
 
+/// Handle UInt16_t
+void
+ParameterHandler::readValue(const uint8_t paramID,uint32_t &_val)
+{
+    if (paramID < PID_MAX)
+    {
+        _val = m_Values[paramID].u.m_U32;
+    } 
+}
+
+///
+void
+ParameterHandler::writeValue(const uint8_t paramID,const uint32_t _val)
+{
+    if (paramID < PID_MAX)
+    {
+        m_Values[paramID].u.m_U32 = _val;
+        if (m_Values[paramID].m_Listener != 0 )
+        {
+            m_Values[paramID].m_Listener->onWriteValue(paramID,m_Values[paramID].u.m_U8);
+        }
+    } 
+}
+
+
 /// Handle Float32_t
 void
 ParameterHandler::readValue(const uint8_t paramID,Float32_t &_val)
 
         virtual void readValue(const uint8_t paramID,uint16_t &_val);
         ///
         virtual void writeValue(const uint8_t paramID,const uint16_t _val);
-        
-       ///
+        ///
+        virtual void readValue(const uint8_t paramID,uint32_t &_val);
+        ///
+        virtual void writeValue(const uint8_t paramID,const uint32_t _val);
+        ///
         virtual void readValue(const uint8_t paramID,Float32_t &_val) ;
         ///
         virtual void writeValue(const uint8_t paramID,const Float32_t _val) ;
 
         virtual void readValue(const uint8_t paramID,uint16_t &_val);
         ///
         virtual void writeValue(const uint8_t paramID,const uint16_t _val);
-        
-       ///
+        ///
+        virtual void readValue(const uint8_t paramID,uint32_t &_val) {};
+        ///
+        virtual void writeValue(const uint8_t paramID,const uint32_t _val) {};
+        ///
         virtual void readValue(const uint8_t paramID,Float32_t &_val) ;
         ///
         virtual void writeValue(const uint8_t paramID,const Float32_t _val) ;
 
 
 
 RFIDReaderHandler::RFIDReaderHandler(PN532 *argNFC,IParameterHandler *argParam)
-  : m_NFC(argNFC), m_Param(argParam),m_State(ST_IDLE)
+  : m_NFC(argNFC), m_Param(argParam),m_State(ST_INIT)
+    , m_1Milli(10),m_CurrentRequest(ST_IDLE),m_Ticks(0)
 {
 }
 
 {
     switch (m_State)
     {
+       case ST_INIT:
+       {
+           m_State = ST_REQ_FIRMWAREVERSION;
+       }
+       break;
        case ST_IDLE:
        { // Check if 
            //m_State = ST_DISP_OFF;
        }
        break;
        case ST_REQ_FIRMWAREVERSION:
+       {
+           Uint32_t ver = m_NFC->getFirmwareVersion();
+           m_Param->writeValue(PID_RFFirmwareVersion,ver);
+       }
        break;
        case ST_REQ_BADGE_ID:
        doRequestBadgeID();
 
 void RFIDReaderHandler::doProcessBadgeID()
 {
-     Uint8_t Uid[9];
+     Uint8_t Uid[7]    = {0,0,0,0,0,0,0};
      Uint8_t UidLength = 0;
+     Uint8_t count     = 0;
      m_NFC->processPassiveTargetID(Uid,&UidLength);
-     m_Param->writeValue(PID_BadgePresent,UidLength);
-     Uint8_t disp = 0;
-     m_Param->writeValue(PID_Display,disp);
+     if (UidLength)
+     {
+         m_Param->writeValue(PID_BadgePresent,static_cast<Uint8_t>(1));
+         m_Param->writeValue(PID_BadgeLength,static_cast<Uint8_t>(UidLength));
+         
+         m_Param->readValue(PID_BadgeCount,count);
+         count++;
+         m_Param->writeValue(PID_BadgeCount,count);
+         Uint32_t low = static_cast<Uint32_t>(static_cast<Uint32_t>(Uid[3])
+                         | (static_cast<Uint32_t>(Uid[2])<<8) 
+                         | (static_cast<Uint32_t>(Uid[1]) <<16) 
+                         | (static_cast<Uint32_t>(Uid[0]) <<24));
+         m_Param->writeValue(PID_BadgeLow,low);
+         if (UidLength > 4)
+         {
+             Uint32_t high = static_cast<Uint32_t>(static_cast<Uint32_t>(Uid[6]) 
+                             | (static_cast<Uint32_t>(Uid[5])<<8) 
+                             | (static_cast<Uint32_t>(Uid[4]) <<16)) ;
+             m_Param->writeValue(PID_BadgeHigh,high);
+         }
+     } else 
+     {
+         m_Param->writeValue(PID_BadgePresent,static_cast<Uint8_t>(0));
+     }
 }
 
 void RFIDReaderHandler::doDisplay(Uint8_t _on)
 
 class RFIDReaderHandler : public ITask
 {
     enum eStates {
-      ST_IDLE
+      ST_INIT
+      ,ST_IDLE
       ,ST_REQ_FIRMWAREVERSION
       ,ST_REQ_BADGE_ID
       ,ST_PROCESS_BADGE_ID
 
         virtual void readValue(const uint8_t paramID,uint16_t &_val);
         ///
         virtual void writeValue(const uint8_t paramID,const uint16_t _val);
-        
-       ///
+        ///
+        virtual void readValue(const uint8_t paramID,uint32_t &_val) {};
+        ///
+        virtual void writeValue(const uint8_t paramID,const uint32_t _val) {};
+        ///
         virtual void readValue(const uint8_t paramID,Float32_t &_val) ;
         ///
         virtual void writeValue(const uint8_t paramID,const Float32_t _val) ;