attWriteReq_t req[10];
uint16_t offset = 0;
#define CMD_LENGTH 32
#define MAX_RETRY_COUNT 10
void Menu_doGattWriteCB(char *pData)
{
    bStatus_t status;  
    uint16_t connHandle;
    uint16_t cmd_length = 7;
    uint8_t largedownload = 0;
static uint8_t lCount =0;
uint8_t idx= 0;
    connHandle =  Connection_getConnhandle(0); // InstaxDataInUUID
 
   uint8_t charVals[8] = {0x41,0x62,0x00,0x08,0x00,0x02,0x00,0x52};
 //   uint8_t charVals[7] = { 0x41,0x62,0x00,0x07,0x00,0x00,0x55 };
  //  unsigned char charVals[8] = {0x41, 0x62, 0x0, 0x8, 0x0, 0x1, 0x2, 0x51};
//    uint8_t charVals[8] ={ 0x41,0x62,0x00,0x08,0x00,0x01,0x01 ,0x52 };
   // uint16_t mtu = MAX_PDU_SIZE -4;
    uint16_t mtu = 200;
     AddDebuggingflowState(199);
   if (pData)
   {
       cmd_length = *(uint16_t*)(pData+RX_LENGTH_OFFSET);              
   }
   else cmd_length = sizeof(charVals);
 
  AddDebuggingflowState(200);
  // cmd_length = sizeof(charVals);
 
   AddDebuggingflowState(201);
   if (cmd_length < mtu)                        
   {      
   
    req[idx].handle = attDataInHandle;
    req[idx].pValue = GATT_bm_alloc(connHandle, ATT_WRITE_REQ, cmd_length, NULL);
    req[idx].len =  cmd_length;
AddDebuggingflowState(202);
     if (pData)
     memcpy(req[idx].pValue , pData+RX_LENGTH_OFFSET+RX_LENGTH_SIZE , cmd_length);
    else memcpy(req[idx].pValue , charVals , cmd_length);
 //    memcpy(req[idx].pValue , charVals , cmd_length);
    if (pData[8] == 0x01 && pData[9] == 0x03) //connect interval
    {
        uint8_t* pInterval  =  ((uint8_t*) &pData[10]);
        pInterval[1] = 48;
        pInterval[3] = 48;
        gapUpdateLinkParamReq_t pParamUpdateReq ;    
       // pParamUpdateReq.connectionHandle = Connection_getConnhandle(0);
        pParamUpdateReq.intervalMin = (pInterval[0]<<8)+pInterval[1];
        pParamUpdateReq.intervalMax = (pInterval[2]<<8)+pInterval[3];
        pParamUpdateReq.connLatency = (pInterval[4]<<8)+pInterval[5];    
        pParamUpdateReq.connTimeout = (pInterval[6]<<8)+pInterval[7];      
    }
AddDebuggingflowState(203);
    req[idx].sig = 0;
    req[idx].cmd = TRUE;
   // charVal = charVals[index];
   // req.pValue[0] = charVals[0];
 
//  ClockP_usleep(8 * 1000); //debug
  AddDebuggingflowState(204);
    uint8_t retry = 0;
    while (retry < MAX_RETRY_COUNT)
    {    
        ClockP_usleep(2 * 1000);    
        status = GATT_WriteNoRsp(connHandle, &req[idx]);
    // status = GATT_WriteCharValue(connHandle, &req, BLEAppUtil_getSelfEntity());
 
        if ( status != SUCCESS )
        {  
             ClockP_usleep(10 * 1000);            
            GATT_bm_free((gattMsg_t *)&req[idx], ATT_WRITE_REQ);
            AddDebuggingflowState(207);
            AddDebuggingflowState((uint8_t)status);
            retry++;
            if (retry == MAX_RETRY_COUNT)
             retry++;
        }
        else
        {
            AddDebuggingflowState(208);
            retry = MAX_RETRY_COUNT;
#ifdef BLE_CENTRAL_CMD_TIMEOUT
            // benablecentraltimer = true;
            // xTimerReset(centraltimerhandle, 0);
            // xTimerStart(centraltimerhandle , 0);
#endif  
        }
   
    }
    }
    else
    {
        uint16_t chunk = mtu;
       // uint16_t offset = 0;    
        uint16_t length;
     //   uint8_t tmp = 50;
        uint8_t retry = 0;
        offset = 0;    
        idx =0;
       
        lCount++;
   
        AddDebuggingflowState(198);
        ClockP_usleep(3 * 1000); //1 ms
        length = chunk;
        offset = 0;
        //debug backup
        memcpy( DebugFFCmdBackup , pData+RX_LENGTH_OFFSET+RX_LENGTH_SIZE , 12);
        while ( offset < cmd_length )
        {
            req[idx].sig = 0;
            req[idx].cmd = TRUE;
            req[idx].handle = attDataInHandle;
            length = chunk;
            if (cmd_length-offset < chunk)
              length = cmd_length-offset;
            req[idx].len = length;
           
      //    
           // req.pValue = &data[offset];
            req[idx].pValue = GATT_bm_alloc(connHandle, ATT_WRITE_REQ, length , NULL);
            if (req[idx].pValue)
            {
                memcpy(req[idx].pValue , pData+RX_LENGTH_OFFSET+RX_LENGTH_SIZE+offset , length);
            }
            else //no hci buffer
            {
                     AddDebuggingflowState(204);  
                ClockP_usleep(4 * 1000); //1 ms
                if (retry++ < 10)
                {
                    continue;
                }
                else
                break;
            }
             
            //req.pValue = pData+RX_LENGTH_OFFSET+RX_LENGTH_SIZE+offset;
            if (retry == 0)
             ClockP_usleep(9 * 1000); //1 ms
            status = GATT_WriteNoRsp(connHandle, &req[idx]);
             
            if ( status != SUCCESS )
            {
                if (retry++ < 10)
                {
                  ClockP_usleep(4 * 1000); //1 ms
                  AddDebuggingflowState(201);  
                  AddDebuggingflowState(status);  
                  GATT_bm_free((gattMsg_t *)&req[idx], ATT_WRITE_REQ);
                 continue;                              
                }
                GATT_bm_free((gattMsg_t *)&req[idx], ATT_WRITE_REQ);
                AddDebuggingflowState(200);              
            }
            else {
          //   AddDebuggingflowState(tmp++);
             retry = 0;
            }  
            offset += length;
            idx++;
        }
        AddDebuggingflowState(205);  
    }
       
}