Msg const *MainState_idle(MainState *me, Msg *msg) { switch (msg->evt) { case ENTRY_EVT: OscLog(INFO, "Enter idle mode.\n"); #ifndef HAS_CPLD /* Set onboard LED green */ OscGpioSetTestLed( TRUE); OscGpioSetTestLedColor(FALSE, TRUE); /* R, G*/ #endif /* !HAS_CPLD */ return 0; case FRAMESEQ_EVT: /* Sleep here for a short while in order not to violate the vertical * blank time of the camera sensor when triggering a new image * right after receiving the old one. This can be removed if some * heavy calculations are done here. */ usleep(1000); return 0; case FRAMEPAR_EVT: return 0; case CMD_GO_IDLE_EVT: data.comm.enReqState = REQ_STATE_ACK_PENDING; return 0; case CMD_GO_ACQ_EVT: if(data.enTriggerMode == TRIG_MODE_INTERNAL) { STATE_TRAN(me, &me->internal); } else if(data.enTriggerMode == TRIG_MODE_EXTERNAL) { STATE_TRAN(me, &me->external); } else { OscLog(ERROR, "%d: Invalid trigger mode configured (%d)!\n", __func__, data.enTriggerMode); data.comm.enReqState = REQ_STATE_NACK_PENDING; return 0; } data.comm.enReqState = REQ_STATE_ACK_PENDING; return 0; case CMD_USE_INTERN_TRIGGER_EVT: /* Switch state to internal capturing mode. */ data.enTriggerMode = TRIG_MODE_INTERNAL; data.comm.enReqState = REQ_STATE_ACK_PENDING; return 0; case CMD_USE_EXTERN_TRIGGER_EVT: /* Switch state to external capturing mode. */ data.enTriggerMode = TRIG_MODE_EXTERNAL; data.comm.enReqState = REQ_STATE_ACK_PENDING; return 0; } return msg; }
Msg const *MainState_CaptureColor(MainState *me, Msg *msg) { struct APPLICATION_STATE *pState; bool bCaptureColor; switch (msg->evt) { case ENTRY_EVT: data.ipc.state.enAppMode = APP_CAPTURE_COLOR; data.pCurRawImg = data.u8FrameBuffers[0]; return 0; case FRAMESEQ_EVT: /* Sleep here for a short while in order not to violate the vertical * blank time of the camera sensor when triggering a new image * right after receiving the old one. This can be removed if some * heavy calculations are done here. */ usleep(1000); return 0; case FRAMEPAR_EVT: /* Process the image. */ ProcessFrame(data.pCurRawImg); /* Timestamp the capture of the image. */ data.ipc.state.imageTimeStamp = OscSupCycGet(); data.ipc.state.bNewImageReady = TRUE; return 0; case IPC_GET_APP_STATE_EVT: /* Fill in the response and schedule an acknowledge for the request. */ pState = (struct APPLICATION_STATE*)data.ipc.req.pAddr; memcpy(pState, &data.ipc.state, sizeof(struct APPLICATION_STATE)); data.ipc.enReqState = REQ_STATE_ACK_PENDING; return 0; case IPC_GET_COLOR_IMG_EVT: /* Write out the image to the address space of the CGI. */ memcpy(data.ipc.req.pAddr, data.u8ResultImage, sizeof(data.u8ResultImage)); data.ipc.state.bNewImageReady = FALSE; /* Mark the request as executed, so it will be acknowledged later. */ data.ipc.enReqState = REQ_STATE_ACK_PENDING; return 0; case IPC_SET_CAPTURE_MODE_EVT: /* Read the option from the address space of the CGI. */ bCaptureColor = *((bool*)data.ipc.req.pAddr); if (bCaptureColor == FALSE) { /* Need to capture raw images from now on, this is done in the captureRaw state. */ STATE_TRAN(me, &me->captureRaw); } data.ipc.enReqState = REQ_STATE_ACK_PENDING; return 0; } return msg; }
Msg const *MainState_top(MainState *me, Msg *msg) { struct APPLICATION_STATE *pState; switch (msg->evt) { case START_EVT: /* initialize the whole stuff - is this the right place ? */ STATE_START(me, &me->showgray); data.ipc.state.enAppMode = APP_CAPTURE_ON; data.pCurRawImg = data.u8FrameBuffers[0]; data.nExposureTimeChanged = true; data.ipc.state.nExposureTime = 25; data.ipc.state.nStepCounter = 0; data.ipc.state.nThreshold = 30; return 0; case IPC_GET_APP_STATE_EVT: /* Fill in the response and schedule an acknowledge for the request. */ pState = (struct APPLICATION_STATE*)data.ipc.req.pAddr; memcpy(pState, &data.ipc.state, sizeof(struct APPLICATION_STATE)); data.ipc.enReqState = REQ_STATE_ACK_PENDING; return 0; case FRAMESEQ_EVT: /* Timestamp the capture of the image. */ data.ipc.state.imageTimeStamp = OscSupCycGet(); data.ipc.state.bNewImageReady = TRUE; /* Sleep here for a short while in order not to violate the vertical * blank time of the camera sensor when triggering a new image * right after receiving the old one. This can be removed if some * heavy calculations are done here. */ usleep(4000); return 0; case FRAMEPAR_EVT: { /* we have a new image increase counter: here and only here! */ data.ipc.state.nStepCounter++; /* debayer the image first -> to half size*/ OscVisDebayerGreyscaleHalfSize( data.pCurRawImg, OSC_CAM_MAX_IMAGE_WIDTH, OSC_CAM_MAX_IMAGE_HEIGHT, ROW_BGBG, data.u8TempImage[GRAYSCALE]); /* Process the image. */ /* the parameter is not really required */ ProcessFrame(data.u8TempImage[GRAYSCALE]); return 0; } case IPC_SET_IMAGE_TYPE_EVT: { if(data.ipc.state.nImageType == GRAYSCALE) { STATE_TRAN(me, &me->showgray); } else if(data.ipc.state.nImageType == THRESHOLD) { STATE_TRAN(me, &me->showthresh); } else if(data.ipc.state.nImageType == EROSION) { STATE_TRAN(me, &me->showerosion); } else if(data.ipc.state.nImageType == DILATION) { STATE_TRAN(me, &me->showdilation); } else if(data.ipc.state.nImageType == LABELIMG) { STATE_TRAN(me, &me->showlabel); } else { data.ipc.enReqState = REQ_STATE_NACK_PENDING; } data.ipc.enReqState = REQ_STATE_ACK_PENDING; return 0; } case IPC_GET_NEW_IMG_EVT: /* If the IPC event is not handled in the actual substate, a negative acknowledge is returned by default. */ data.ipc.enReqState = REQ_STATE_NACK_PENDING; return 0; } return msg; }
Msg const *MainState_capture(MainState *me, Msg *msg) { OSC_ERR err; uint8 *pDummyImg = NULL; uint32 imgSize; switch (msg->evt) { case ENTRY_EVT: OscLog(INFO, "Enter generic capture mode.\n"); #ifndef HAS_CPLD /* Set onboard LED red */ OscGpioSetTestLed( TRUE); OscGpioSetTestLedColor(TRUE, FALSE); /* R, G*/ #endif /* !HAS_CPLD */ OscLog(INFO, "Setup capture\n"); err = OscCamSetupCapture( OSC_CAM_MULTI_BUFFER); if (err != SUCCESS) { OscLog(ERROR, "%s: Unable to setup initial capture (%d)!\n", __func__, err); } return 0; case FRAMESEQ_EVT: /* Fill out the feed header. */ data.comm.feedHdr.seqNr++; /* We need the uptime in milliseconds. */ data.comm.feedHdr.timeStamp = (uint32)(OscSupCycToMilliSecs(OscSupCycGet64())); data.comm.feedHdr.imgWidth = OSC_CAM_MAX_IMAGE_WIDTH; data.comm.feedHdr.imgHeight = OSC_CAM_MAX_IMAGE_HEIGHT; #ifdef TARGET_TYPE_LEANXCAM data.comm.feedHdr.pixFmt = V4L2_PIX_FMT_GREY; imgSize = data.comm.feedHdr.imgWidth * data.comm.feedHdr.imgHeight * 1; #endif /* TARGET_TYPE_LEANXCAM */ #ifdef TARGET_TYPE_INDXCAM data.comm.feedHdr.pixFmt = V4L2_PIX_FMT_SBGGR8; imgSize = data.comm.feedHdr.imgWidth * data.comm.feedHdr.imgHeight * 1; #endif /* TARGET_TYPE_INDXCAM */ /* Send the image to the host. */ Comm_SendImage(&data.comm, data.pCurRawImg, imgSize, &data.comm.feedHdr); return 0; case FRAMEPAR_EVT: return 0; case CMD_GO_IDLE_EVT: /* Read picture until no more capture is active.Always use self-trigg*/ err = SUCCESS; while(err != -ENO_CAPTURE_STARTED) { SelfTrigger(); err = OscCamReadPicture(OSC_CAM_MULTI_BUFFER, &pDummyImg, 0, CAMERA_TIMEOUT); OscLog(DEBUG, "%s: Removed picture from queue! (%d)\n", __func__, err); } STATE_TRAN(me, &me->idle); data.comm.enReqState = REQ_STATE_ACK_PENDING; return 0; case CMD_GO_ACQ_EVT: data.comm.enReqState = REQ_STATE_ACK_PENDING; return 0; case CMD_USE_INTERN_TRIGGER_EVT: case CMD_USE_EXTERN_TRIGGER_EVT: /* Not supported in acquisition mode. */ data.comm.enReqState = REQ_STATE_NACK_PENDING; return 0; case EXIT_EVT: /* Read picture until no more capture is active. Always use self-trigg*/ err = SUCCESS; while(err != -ENO_CAPTURE_STARTED) { SelfTrigger(); err = OscCamReadPicture(OSC_CAM_MULTI_BUFFER, &pDummyImg, 0, CAMERA_TIMEOUT); OscLog(DEBUG, "%s: Removed picture from queue! (%d)\n", __func__, err); } return 0; } return msg; }
Msg const *MainState_top(MainState *me, Msg *msg) { struct APPLICATION_STATE *pState; switch (msg->evt) { case START_EVT: /* initialize the whole stuff - is this the right place ? */ STATE_START(me, &me->showGray); data.ipc.state.enAppMode = APP_CAPTURE_ON; data.pCurRawImg = data.u8FrameBuffers[0]; data.nExposureTimeChanged = true; data.nResetProcessing = false; data.AddBufSize = 0; data.ipc.state.nExposureTime = 25; data.ipc.state.nStepCounter = 0; data.ipc.state.nThreshold = 0; return 0; case IPC_GET_APP_STATE_EVT: /* Fill in the response and schedule an acknowledge for the request. */ pState = (struct APPLICATION_STATE*)data.ipc.req.pAddr; memcpy(pState, &data.ipc.state, sizeof(struct APPLICATION_STATE)); data.ipc.enReqState = REQ_STATE_ACK_PENDING; return 0; case FRAMESEQ_EVT: /* Timestamp the capture of the image. */ data.ipc.state.imageTimeStamp = OscSupCycGet(); data.ipc.state.bNewImageReady = TRUE; /* Sleep here for a short while in order not to violate the vertical * blank time of the camera sensor when triggering a new image * right after receiving the old one. This can be removed if some * heavy calculations are done here. */ //usleep(4000); return 0; case FRAMEPAR_EVT: { /* we have a new image increase counter: here and only here! */ data.ipc.state.nStepCounter++; /* debayer the image first -> to half size*/ #if NUM_COLORS == 1 OscVisDebayerGreyscaleHalfSize(data.pCurRawImg, OSC_CAM_MAX_IMAGE_WIDTH, OSC_CAM_MAX_IMAGE_HEIGHT, ROW_YUYV, data.u8TempImage[SENSORIMG]); #else memcpy(data.u8TempImage[SENSORIMG], data.pCurRawImg, NUM_COLORS*OSC_CAM_MAX_IMAGE_HEIGHT*OSC_CAM_MAX_IMAGE_WIDTH); #endif /* Process the image. */ //set data buffer to zero before each step data.AddBufSize = 0; ProcessFrame(); return 0; } case IPC_SET_IMAGE_TYPE_EVT: { if(data.ipc.state.nImageType == SENSORIMG) { STATE_TRAN(me, &me->showGray); } else if(data.ipc.state.nImageType == THRESHOLD) { STATE_TRAN(me, &me->showThreshold); } else if(data.ipc.state.nImageType == BACKGROUND) { STATE_TRAN(me, &me->showBackground); } else { data.ipc.enReqState = REQ_STATE_NACK_PENDING; } data.ipc.enReqState = REQ_STATE_ACK_PENDING; return 0; } case IPC_GET_NEW_IMG_EVT: /* If the IPC event is not handled in the actual substate, a negative acknowledge is returned by default. */ data.ipc.enReqState = REQ_STATE_NACK_PENDING; return 0; } return msg; }