StatusType Serv_BarCode_Read_Camera(ac_uint32 nCurOperNo, ac_uint8 *pParam, ac_uint16 nSize)
{   
    Scanhead_CameraRun_t tRun_Info;
	
    if (nSize < 2)
    {
        TRACE_ERROR("BarCode_Read_Camera: Size is wrong!\n");
        return Status_Param_Error;
    }

    if ((pParam[0] < 0x31) || (pParam[0] > 0x33) || 
        ((pParam[1] != 1) && (pParam[1] != 2) && (pParam[1] != 4))) 
    {
        TRACE_ERROR("BarCode_Read_Camera: Param is wrong!\n");
        return Status_Barcode_Camera_ParamError;
    }
	
    //开启拍照补光灯
    HAL_GPIO_WritePin(CARMERA_LED_GPIOx, CARMERA_LED_Pin, CARMERA_LED_Enable_Level);
    memset(&tRun_Info, 0x0, sizeof(Scanhead_CameraRun_t));
    tRun_Info.ePixel = (Scanhead_Camera_Pixel_e)pParam[0];
    tRun_Info.ePackage_Size = (Scanhead_Camera_PackageSize_e)pParam[1];
    tRun_Info.CameraRun_CallBack = Camera_Read_Callback;
    CHECK_STATUS_RS(BLL_Scanhead_CameraRun(&tRun_Info));
    //TRACE_DEBUG("Camera Run!");
    return Status_Success;
}

StatusType BLL_Scanhead_CameraRun(Scanhead_CameraRun_t *ptRun_Info)
{
    TRACE_MARK(); 
    ac_int8 nTimes = 3;
    ac_uint8 nTx_Data[7];
    VERIFY_PARAM(IS_PARAM_NONULL(ptRun_Info));

    if (g_ptScanHead_Info->eCamera_State != CameraRun_Free)
    {
        TRACE_ERROR("Camera Is Not Free!\n");
        return Status_Barcode_Camera_Busy;
    }	

    if ((ptRun_Info->ePackage_Size !=  PackageSize_256)
       && (ptRun_Info->ePackage_Size !=  PackageSize_512)
       && (ptRun_Info->ePackage_Size !=  PackageSize_1024))
    {
        TRACE_ERROR("Camera Package Size Is Error!\n");
        return Status_Barcode_Camera_ParamError;
    }
	
    if ((ptRun_Info->ePixel != Pixel_160) && (ptRun_Info->ePixel != Pixel_320)
       && (ptRun_Info->ePixel != Pixel_640))
    {
        TRACE_ERROR("Camera Pixel Size Is Error!\n");
        return Status_Barcode_Camera_ParamError;
    }

    memset(nTx_Data, 0x0, 7);
    nTx_Data[0] = 0x55;
    nTx_Data[1] = 0x48;
    nTx_Data[2] = 0x00;
    nTx_Data[3] = ptRun_Info->ePixel;
    nTx_Data[4] = 0x00;
    nTx_Data[5] = ptRun_Info->ePackage_Size;
    nTx_Data[6] = 0x23;

    g_ptScanHead_Info->nCamera_PackSize = (ptRun_Info->ePackage_Size << 8) | 0x00;
    g_ptScanHead_Info->CameraRun_CallBack = ptRun_Info->CameraRun_CallBack;

    g_ptScanHead_Info->nRx_Size = 0;
    memset(g_ptScanHead_Info->pnRx_Buff, 0x0, RXBUFF_SIZE);

    //发送拍照指令   
    while(nTimes-- > 0)
    {
				
        if ((HAL_UART_Transmit(g_ptScanHead_Info->phUart, nTx_Data, 7, 0xFFFF)) == HAL_OK)
        {
            g_ptScanHead_Info->nCamera_Tick = xTaskGetTickCount();	
            g_ptScanHead_Info->eCamera_State = CameraRun_RecPicInfo;
            break;
        }
		
        vTaskDelay(2);	
    }
	
    if (nTimes <= 0)
    {
        TRACE_ERROR("Camera Run Send Failed!\n");
        return Status_Barcode_CameraTx_Fail;
    }

    return Status_Success;
}

void Camera_Read_Callback(Scanhead_CameraRun_CallBack_t tCameraInfo, StatusType eCmdState)
{
    //ac_uint16  i= 0;
    ac_uint8 *pnParam = NULL;
    ac_uint16 nPicSize = tCameraInfo.nPicture_Size & 0xFFFF;
    ac_uint16 nOperId = 0;	

    if ((tCameraInfo.eState == CameraRun_Error) || (tCameraInfo.eState == CameraRun_TimeOut))
    {        
        //关闭拍照补光灯
        HAL_GPIO_WritePin(CARMERA_LED_GPIOx, CARMERA_LED_Pin, CARMERA_LED_Disabled_Level);
		
        if (g_ptOper_Adress != NULL)
        {
            g_ptOper_Adress->Head.nCmdState = eCmdState;
            APP_Dm_SetOperState(g_ptOper_Adress, OPER_STATE_FAILURE);
            g_ptOper_Adress = NULL;	
        }
		
        TRACE_ERROR("Camera Read Failed !");
        return ;
	}

    pnParam = (ac_uint8 *)pvPortMalloc(tCameraInfo.nPackage_Size + 8);
    
    if (pnParam == NULL)
    {      
        //关闭拍照补光灯
        HAL_GPIO_WritePin(CARMERA_LED_GPIOx, CARMERA_LED_Pin, CARMERA_LED_Disabled_Level);
		
        if (g_ptOper_Adress != NULL)
        {
            g_ptOper_Adress->Head.nCmdState = Status_Malloc_Error;
            APP_Dm_SetOperState(g_ptOper_Adress, OPER_STATE_FAILURE);
            g_ptOper_Adress = NULL;	
        }
		
        TRACE_ERROR("pData Malloc fail !\n");
        return;
    }

    //TRACE_DEBUG("Num: %d, Size: %d, picSize: %d", tCameraInfo.nPackage_Num, tCameraInfo.nPackage_Size, nPicSize);

    if (tCameraInfo.nPackage_Num == 1)
    { 
        nOperId = 0x0606; 
        memcpy(pnParam, &g_ptOper_Adress->Head.nCurOperNo, 4);
        memcpy(&pnParam[4], &nPicSize, 2);
        pnParam[6] = tCameraInfo.nPackage_Count;
        APP_Dm_OperImportByNoId(g_ptOper_Adress->Head.nCurOperNo, nOperId, pnParam, 7);

        nOperId = 0x0607; 
        memset(pnParam, 0x0, tCameraInfo.nPackage_Size + 8);
        memcpy(pnParam, &g_ptOper_Adress->Head.nCurOperNo, 4);
        pnParam[4] = tCameraInfo.nPackage_Num;
        pnParam[5] = (ac_uint8)tCameraInfo.eState;
        memcpy(&pnParam[6], &tCameraInfo.nPackage_Size, 2);   
        memcpy(&pnParam[8], tCameraInfo.pCur_RxBuf, tCameraInfo.nPackage_Size);
        APP_Dm_OperImportByNoId(g_ptOper_Adress->Head.nCurOperNo, nOperId, pnParam, tCameraInfo.nPackage_Size + 8);

        vPortFree(pnParam);
        pnParam = NULL;
    }
    else
    {
        nOperId = 0x0607; 
        memset(pnParam, 0x0, tCameraInfo.nPackage_Size + 8);
        memcpy(pnParam, &g_ptOper_Adress->Head.nCurOperNo, 4);
        pnParam[4] = tCameraInfo.nPackage_Num;
        pnParam[5] = (ac_uint8)tCameraInfo.eState;
        memcpy(&pnParam[6], &tCameraInfo.nPackage_Size, 2);   
        memcpy(&pnParam[8], tCameraInfo.pCur_RxBuf, tCameraInfo.nPackage_Size);
        APP_Dm_OperImportByNoId(g_ptOper_Adress->Head.nCurOperNo, nOperId, pnParam, tCameraInfo.nPackage_Size + 8);
		
        vPortFree(pnParam);
        pnParam = NULL;
    }

    if (tCameraInfo.eState == CameraRun_Finish)
    {   
        //关闭拍照补光灯
        HAL_GPIO_WritePin(CARMERA_LED_GPIOx, CARMERA_LED_Pin, CARMERA_LED_Disabled_Level);
		
        if (g_ptOper_Adress != NULL)
        {
            g_ptOper_Adress->Head.nCmdState = Status_Success;
            APP_Dm_SetOperState(g_ptOper_Adress, OPER_STATE_FINISH);
            g_ptOper_Adress = NULL;	
        }

        //TRACE_DEBUG("Camera Read: Success!");
    }
   
}


StatusType BLL_Scanhead_Camera_Monitor(ac_void)
{
    
    ac_uint8 nTx_Data[6], nTimes = 3;
    ac_uint16 i = 0, nCheckSum = 0, nSize = 0;
    ac_uint32 nTick = xTaskGetTickCount();
    Scanhead_CameraRun_CallBack_t tCallBack;
    static ac_int8 nCheck_Times = 3;
	
    memset(&tCallBack, 0x0, sizeof(Scanhead_CameraRun_CallBack_t));

 
    if (((nTick - g_ptScanHead_Info->nCamera_Tick) > CAMERARUN_TIMEOUT)
        && (g_ptScanHead_Info->eCamera_State != CameraRun_Free))
    {
        TRACE_DEBUG("Camera Run Timeout!");
        g_ptScanHead_Info->eCamera_State = CameraRun_TimeOut;
        g_ptScanHead_Info->eCameraRun_CmdState = Status_Barcode_Camera_TimeOut;
    }

    switch(g_ptScanHead_Info->eCamera_State)
    {
        case CameraRun_Free:
        {
            //Undo
        }
        break;
        case CameraRun_RecPicInfo:
        {
            //判断图片信息是否正确
            if ((g_ptScanHead_Info->nRx_Size >= 14) && (g_ptScanHead_Info->pnRx_Buff[13] == CAMERA_END_NUM)
                && (memcmp(g_ptScanHead_Info->pnRx_Buff, g_nCamera_PicInfoCheck, CAMERA_PICINFO_CHECKSIZE) == 0))          
            {
                memcpy(&g_ptScanHead_Info->nCamera_PicSize, &g_ptScanHead_Info->pnRx_Buff[7], 4); 
                memcpy(&g_ptScanHead_Info->nCamera_PackCount, &g_ptScanHead_Info->pnRx_Buff[11], 2); 
                g_ptScanHead_Info->nCamera_PackNum = 1;
                g_ptScanHead_Info->eCamera_State = CameraRun_SendPackageNum;
            }

        }
        break;
        case CameraRun_SendPackageNum:
        {
            memset(nTx_Data, 0x0, 6);
            nTx_Data[0] =  0x55;
            nTx_Data[1] =  0x45;
            nTx_Data[2] =  0x00;
            nTx_Data[3] =  g_ptScanHead_Info->nCamera_PackNum & 0xFF;
            nTx_Data[4] =  g_ptScanHead_Info->nCamera_PackNum / 0xFF;
            nTx_Data[5] =  0x23;
            
            //清空接收缓冲区				
            g_ptScanHead_Info->nRx_Size = 0;
            memset(g_ptScanHead_Info->pnRx_Buff, 0x00, RXBUFF_SIZE);
			
            while(nTimes-- > 0)
            {		
            
                if ((HAL_UART_Transmit(g_ptScanHead_Info->phUart, nTx_Data,6, 0xFFFFFF)) == HAL_OK)
                {	
                    g_ptScanHead_Info->nCamera_Tick = nTick;
                    g_ptScanHead_Info->eCamera_State = CameraRun_DataCheck;
                    break;              
                }
				
            }

            if (nTimes <= 0)	
            {       
                TRACE_ERROR("Camera Run Send PackageNum Failed!");
                g_ptScanHead_Info->eCamera_State = CameraRun_Error;
                g_ptScanHead_Info->eCameraRun_CmdState = Status_Barcode_CameraTx_Fail;
            }	
			          
        }
        break;
        case CameraRun_DataCheck:
        {
            //前面几个包
            if (g_ptScanHead_Info->nCamera_PackNum < g_ptScanHead_Info->nCamera_PackCount)
            {
            
                if (g_ptScanHead_Info->nRx_Size >= g_ptScanHead_Info->nCamera_PackSize+13)
                    g_ptScanHead_Info->nCamera_Checksum = 0; 
                    memcpy(&nCheckSum, &g_ptScanHead_Info->pnRx_Buff[g_ptScanHead_Info->nCamera_PackSize+11], 2);
                    for(i = 4; i < g_ptScanHead_Info->nCamera_PackSize+11; i++)
                    {
                        g_ptScanHead_Info->nCamera_Checksum += g_ptScanHead_Info->pnRx_Buff[i];
                    }

                    //校验数据对比
                    if (g_ptScanHead_Info->nCamera_Checksum != nCheckSum)
                    {
                        if (nCheck_Times <= 0)
                        {
                            TRACE_ERROR("Camera Run Package Data Check Failed!");
                            nCheck_Times = 0; 
                            g_ptScanHead_Info->eCamera_State = CameraRun_Error;  
                            g_ptScanHead_Info->eCameraRun_CmdState = Status_Barcode_CameraRun_Error;                      
                            return Status_Failure;
                        }

                        nCheck_Times--;						
                        g_ptScanHead_Info->eCamera_State = CameraRun_SendPackageNum;  
                        break;
                    }

                    nCheck_Times = 3;
                    g_ptScanHead_Info->eCamera_State = CameraRun_DataCallBack;                                                                              					 
                }
				
            }
            else //最后一个包
            {
                nSize = g_ptScanHead_Info->nCamera_PicSize
                    - (g_ptScanHead_Info->nCamera_PackCount-1)*g_ptScanHead_Info->nCamera_PackSize + 13;
    
                if (g_ptScanHead_Info->nRx_Size >= nSize)
                {
                    g_ptScanHead_Info->nCamera_Checksum = 0; 
                    memcpy(&nCheckSum, &g_ptScanHead_Info->pnRx_Buff[nSize-2], 2);
                    for(i = 4; i < nSize-2; i++)
                    {
                        g_ptScanHead_Info->nCamera_Checksum += g_ptScanHead_Info->pnRx_Buff[i];
                    }

                    //校验数据对比
                    if (g_ptScanHead_Info->nCamera_Checksum != nCheckSum)
                    {

                        if (nCheck_Times <= 0)
                        {
                            TRACE_ERROR("Camera Run Package Data Check Failed!");
                            nCheck_Times = 0; 
                            g_ptScanHead_Info->eCamera_State = CameraRun_Error; 
                            g_ptScanHead_Info->eCameraRun_CmdState = Status_Barcode_CameraRun_Error;                       
                            return Status_Failure;
                        }

                        nCheck_Times--;						
                        g_ptScanHead_Info->eCamera_State = CameraRun_SendPackageNum;  
                        break;
                    }

                    nCheck_Times = 3;
                    g_ptScanHead_Info->nCamera_PackSize = nSize - 13;
                    //TRACE_DEBUG("nSize: %d", g_ptScanHead_Info->nCamera_PicSize);
                    g_ptScanHead_Info->eCamera_State = CameraRun_DataCallBack;                                                                              					 
                }
				
            }
			

        }
        break;
        case CameraRun_DataCallBack:
        {
            //TRACE_DEBUG("Data Callback!!");
            tCallBack.nPicture_Size = g_ptScanHead_Info->nCamera_PicSize;
            tCallBack.nPackage_Count = g_ptScanHead_Info->nCamera_PackCount;
            tCallBack.nPackage_Num = g_ptScanHead_Info->nCamera_PackNum;
            tCallBack.nPackage_Size = g_ptScanHead_Info->nCamera_PackSize;
            tCallBack.pCur_RxBuf = &g_ptScanHead_Info->pnRx_Buff[11];

            //不是最后一个包
            if (g_ptScanHead_Info->nCamera_PackNum < g_ptScanHead_Info->nCamera_PackCount)
            {
                //TRACE_DEBUG("Data Callback! Num: %d", g_ptScanHead_Info->nCamera_PackNum);
                tCallBack.eState = CameraRun_DataCallBack;	
				
                if (g_ptScanHead_Info->CameraRun_CallBack != NULL)
                {
                    g_ptScanHead_Info->CameraRun_CallBack(tCallBack, g_ptScanHead_Info->eCameraRun_CmdState);
                }
				
                g_ptScanHead_Info->nCamera_PackNum++;
                g_ptScanHead_Info->eCamera_State = CameraRun_SendPackageNum;			
            }
            else
            {
                tCallBack.eState = CameraRun_Finish; 
				
                if (g_ptScanHead_Info->CameraRun_CallBack != NULL)
                {
                    g_ptScanHead_Info->CameraRun_CallBack(tCallBack, g_ptScanHead_Info->eCameraRun_CmdState);
                    g_ptScanHead_Info->CameraRun_CallBack = NULL;
                }
				  
                g_ptScanHead_Info->eCamera_State = CameraRun_Finish;                             
            }
              
        }
        break;
        case CameraRun_Finish:
        {
            //TRACE_DEBUG("Camera Run Finish!");
            g_ptScanHead_Info->eCamera_State = CameraRun_Free; 
            
        }
        break;
        case CameraRun_Error:
        {
				
            if (g_ptScanHead_Info->CameraRun_CallBack != NULL)
            {
                tCallBack.eState = CameraRun_Error; 
                g_ptScanHead_Info->CameraRun_CallBack(tCallBack, g_ptScanHead_Info->eCameraRun_CmdState);
                g_ptScanHead_Info->CameraRun_CallBack = NULL;
            }
			
            TRACE_ERROR("Camera Run Failure!");
            g_ptScanHead_Info->eCamera_State = CameraRun_Free; 
        }
        break;
        case CameraRun_TimeOut:
        {
			
            if (g_ptScanHead_Info->CameraRun_CallBack != NULL)
            {
                tCallBack.eState = CameraRun_TimeOut;
                g_ptScanHead_Info->CameraRun_CallBack(tCallBack, g_ptScanHead_Info->eCameraRun_CmdState);
                g_ptScanHead_Info->CameraRun_CallBack = NULL;
            }
            
            TRACE_ERROR("Camera Run Timeout!");
            g_ptScanHead_Info->eCamera_State = CameraRun_Free;
        }
        break;        	
        default:
        { 
			
        }
        break;

    }

    return Status_Success;
}

#endif