config.cpp

用于DSP下摄像机的图像抓取、图像处理和传输、以及与上位机TCP/IP通信的工程文件。基于Texas Instruments Code Composer Studio实现。

		Phocus1820_rs485_set_baudrate(*ps);		
		Phocus1820_write_rs485_info(m_nBaudRate);
	}
	return rc;	
}

int CConfigure::UpdateProgram(char* pData, int nLen)
{
	volatile int i = 0;
	
	m_stModeInfo.boot = 2;
	Phocus1820_write_mode_info(&m_stModeInfo);
	
	while(i < 500000)
	{
		i++;
	}
	
	Phocus1820_read_mode_info(&m_stModeInfo);
	if(m_stModeInfo.boot != 2)
	{		
		return ESTORAGE;
	}	
		
	
	IRQ_globalDisable();
	Phocus1820_flash_erase(0x90080000, 0x400000);
	
	i = 0;
	while(i < 500000)
	{
		i++;
	}

	if(Phocus1820_flash_write(0x90080000, (unsigned int)pData, nLen) == 0)
	{
		m_stModeInfo.boot = 1;
		Phocus1820_write_mode_info(&m_stModeInfo);	

		i = 0;
		while(i < 500000)
		{
			i++;
		}
	
		Phocus1820_read_mode_info(&m_stModeInfo);
		if(m_stModeInfo.boot == 1)
		{
			IRQ_globalEnable();		
			return ENO;
		}	
	}
	IRQ_globalEnable();
	return ESTORAGE;
	
}

void* CConfigure::GetEthInfo()
{
	return &m_stEthInfo;
}

void* CConfigure::GetModeInfo()
{
	return &m_stModeInfo;
}

void* CConfigure::GetVersionInfo()
{
	return m_strVersion;
}

void* CConfigure::GetSerialPortInfo()
{
	return &m_nBaudRate;
}

unsigned char CConfigure::CheckSum(unsigned char* pData, int nLen)
{
	unsigned short cksum = 0;
	while(nLen > 0)
	{
		cksum += *pData++;
		nLen --;
	}
	cksum = (cksum >> 8) + (cksum & 0xff);
	cksum += (cksum >> 8);
	return (unsigned char)(~cksum);
}

int CConfigure::GetImage(int nXStart, int nYStart, int nWidth, int nHeight)
{
	if(Phocus1820_sensor_open_capture_port(m_stImageInfo.nXStart, m_stImageInfo.nYStart, m_stImageInfo.nWidth, m_stImageInfo.nHeight) == 0)
		if(Phocus1820_sensor_wait_image(50000) == 0)
			if(Phocus1820_sensor_get_image(dataBuf + 0x10000) != 0)
			{
				return -1;
			}		
	
	return 0;	
}

//Set sensor parameters without reset capture channel
//void CConfigure::SetSensor(CAMERA_INFO* pCameraInfo)
//{	
//	if(pCameraInfo->nExpose != m_stCameraInfo.nExpose)
//		Phocus1820_sensor_set_shutter(pCameraInfo->nExpose);
//	memcpy(&m_stCameraInfo, pCameraInfo, sizeof(CAMERA_INFO));
//	
//	return;
//}

//task functions
extern "C" void TaskConfigure()
{
	MBX_MESSAGE msg;
	int rc = ENO;
	if(g_pConfigure != NULL)
	{	
		while(true)
		{		
			MBX_pend(hMbxCfg, &msg, SYS_FOREVER);	
			rc = g_pConfigure->DoConfig(msg.nCommand, msg.pData, msg.nDataLen);					
			msg.cSrc = TSK_CFG;
			msg.cDst = TSK_NETNORMAL;
			msg.nDataLen = 0;
			msg.nError = rc;
			msg.nCommandType = COMU_RESPONSE;
			MBX_post(hMbxSchedule, &msg, 0);	
		}
	}
}	

extern "C" void TaskGet()
{
	MBX_MESSAGE msg;
	int rc = ENO;
	if(g_pConfigure != NULL)
	{
		while(true)
		{	
			MBX_pend(hMbxGet, &msg, SYS_FOREVER);
			msg.nDataType = Phocus1820_sensor_get_format();
			rc = g_pConfigure->DoGet(msg.nCommand, &(msg.pData), &(msg.nDataLen));
			msg.cSrc = TSK_TST;
			msg.cDst = TSK_NETNORMAL;
			msg.nError = rc;
			msg.nCommandType = COMU_RESPONSE;
			MBX_post(hMbxSchedule, &msg, 0);
		}
	}
}

extern "C" unsigned short LinkCheckSum(unsigned short* pBuffer, int nLen)
{
	unsigned int cksum = 0;
	while(nLen > 1)
	{
		cksum += *pBuffer++;
		nLen -= sizeof(unsigned short);
	}
	if(nLen) 
		cksum += *(unsigned char*)pBuffer;
	cksum = (cksum >> 16) + (cksum & 0xffff);
	cksum += (cksum >>16);
	return (unsigned short)(~cksum);
}

/*static int AutoGainExposure(int nSensorDataType, IMAGE_INFO *pImageInfo)
{
	UAGE_COLOR_MODE emColorMode;
	static void (*fxnAutoGain)(UAGE_PARAM &, int, unsigned int &) = UAGE_AutoGain_Fast;
	static void (*fxnAutoExposure)(UAGE_PARAM &, int, unsigned int &) = UAGE_AutoExposure_Fast;
	static void (*fxnAutoExposureAndGain)(UAGE_PARAM &, int, unsigned int &, unsigned int &) = UAGE_AutoExposureAndGain_Fast;
	if(nSensorDataType == DATA_IMAGE)
	{
		emColorMode = UAGE_COLOR_MODE_BAYER_RGBG;
	}
	else if(nSensorDataType == DATA_YUV)
	{
		emColorMode = UAGE_COLOR_MODE_YUYV;
	}
	
	UAGE_GetMeanBrightness
	(
		(unsigned char *)cBuffer[0] + sizeof(IMAGE_INFO),
		pImageInfo->nWidth,
		pImageInfo->nHeight,
		emColorMode,
		g_nBrightness
	);

	//fxnAutoGain = UAGE_AutoGain_Fast;
	//fxnAutoExposure = UAGE_AutoExposure_Fast;
	//fxnAutoExposureAndGain = UAGE_AutoExposureAndGain_Fast;	

	#ifdef _DEBUG
	printf("曝光时间%d微秒，增益%d，图像平均亮度%d\n\n\n", g_nExposureValue, g_nGainValue, g_nBrightness);
	#endif
	
	if(g_nAgeMode & (AGE_AUTOGAIN | AGE_AUTOEXPOSURE) == (AGE_AUTOGAIN | AGE_AUTOEXPOSURE))
	{
		fxnAutoExposureAndGain(g_stAgeParam, g_nBrightness, g_nGainValue, g_nExposureValue);
		Phocus1820_sensor_set_shutter(g_nExposureValue);
		Phocus1820_sensor_set_afe_pga(g_nGainValue);
	}
	else if(g_nAgeMode & AGE_AUTOGAIN)
	{
		fxnAutoGain(g_stAgeParam, g_nBrightness, g_nGainValue);
		Phocus1820_sensor_set_afe_pga(g_nGainValue);		
	}
	else if(g_nAgeMode & AGE_AUTOEXPOSURE)
	{
		fxnAutoExposure(g_stAgeParam, g_nBrightness, g_nExposureValue);
		Phocus1820_sensor_set_shutter(g_nExposureValue);		
	}
	
	return ENO;	
}*/

static int PostProcess(int nSensorDataType, int nOutputDataType, IMAGE_INFO *pImageInfo, char **ppOutputBuffer, int *pLen)
{
//	AutoGainExposure();

	if(nSensorDataType == DATA_IMAGE)
	{	
		switch(nOutputDataType)
		{
			//输出图像为RAW格式
			case DATA_IMAGE:
			{
				*ppOutputBuffer = cBuffer[0];
				*pLen = pImageInfo->nWidth * pImageInfo->nHeight;
				break;
			}
			//输出图像为YUV格式
			case DATA_YUV:
			{
				*ppOutputBuffer = cBuffer[0];
				Phocus1820_format_bayer2yuyv(cBuffer[0] + sizeof(IMAGE_INFO), cBuffer[1] + sizeof(IMAGE_INFO), pImageInfo->nWidth, pImageInfo->nHeight);								
				Phocus1820_format_yyuv2yyyyuvuv(cBuffer[1] + sizeof(IMAGE_INFO), cBuffer[0] + sizeof(IMAGE_INFO), pImageInfo->nWidth, pImageInfo->nHeight);
				*pLen = pImageInfo->nWidth * pImageInfo->nHeight * 2;
				break;
			}
			//输出图像为JPEG格式
			case DATA_JPEG:
			{
				*ppOutputBuffer = cBuffer[1];
				Phocus1820_format_bayer2yuyv(cBuffer[0] + sizeof(IMAGE_INFO), cBuffer[1] + sizeof(IMAGE_INFO), pImageInfo->nWidth, pImageInfo->nHeight);								
				JPEG_control(pImageInfo->nWidth, pImageInfo->nHeight, g_nJpegQuality);
				JPEG_enc(cBuffer[1] + sizeof(IMAGE_INFO), cBuffer[0], pLen);
				if(nSoft_Rs)
				{
					memcpy((char*)cBuffer[1] + sizeof(IMAGE_INFO) + *pLen, rs_send.pData, rs_send.nDataLen);					
                    *pLen += rs_send.nDataLen; 
				}
				break;
			}
			default:
			{
				*pLen = 0;
				return EINVPARAM;
			}
		}
	}
	//原始图像为YUV格式
	else if(nSensorDataType == DATA_YUV)
	{
		switch(nOutputDataType)
		{
			//输出图像为YUV格式
			case DATA_YUV:
			{
				*ppOutputBuffer = cBuffer[1];
				Phocus1820_format_yyuv2yyyyuvuv(cBuffer[0] + sizeof(IMAGE_INFO), cBuffer[1] + sizeof(IMAGE_INFO), pImageInfo->nWidth, pImageInfo->nHeight);				
				*pLen = pImageInfo->nWidth * pImageInfo->nHeight * 2;									
				break;
			}
			//输出图像为JPEG格式
			case DATA_JPEG:
			{
			
				JPEG_control(pImageInfo->nWidth, pImageInfo->nHeight, g_nJpegQuality);
				JPEG_enc(cBuffer[0] + sizeof(IMAGE_INFO), cBuffer[1], pLen);
				if(nSoft_Rs)
				{
					memcpy((char*)cBuffer[0] + sizeof(IMAGE_INFO) + *pLen, rs_send.pData, rs_send.nDataLen);
                    *pLen += rs_send.nDataLen; 
				}
				*ppOutputBuffer = cBuffer[0];								
				break;
			}
			default:
			{
				*pLen = 0;
				return EINVPARAM;
			}
		}							
	}
	else
	{
		*pLen = 0;
		return EINVPARAM;
	}
	
	pImageInfo->unExposureValue = g_nExposureValue;
	pImageInfo->unGainValue = g_nGainValue;
	pImageInfo->nAveragePixelValue = g_nBrightness;
	pImageInfo->nAgeMode = g_nAgeMode;
	
	return ENO;
}

static void TcpSend(SERIALPARAM *pSerialParam, COMU_HEAD *pCh, char *pOutputBuffer, int nLen)
{
	SOCKET hSocket;
	struct sockaddr_in stPeerAddr;
	struct timeval timeout;
	int rc = -1;

	hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	bzero(&stPeerAddr, sizeof(struct sockaddr_in));
	stPeerAddr.sin_family = AF_INET;
	stPeerAddr.sin_len    = sizeof(stPeerAddr);
	stPeerAddr.sin_port = htons(pSerialParam->linkAddr.nLinkPortNum);
	stPeerAddr.sin_addr.s_addr = pSerialParam->linkAddr.nLinkIp;
	
	timeout.tv_sec = 3;
	timeout.tv_usec = 0;
	setsockopt(hSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof( timeout ) );
	setsockopt(hSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof( timeout ) );
		
	if(connect(hSocket, (struct sockaddr *)&stPeerAddr, sizeof(sockaddr_in)) != -1)
	{
		if(send(hSocket, (void *)"UNIC", strlen("UNIC"), 0) != -1)
		{		
			if(send(hSocket, pCh, sizeof(COMU_HEAD), 0) != -1)
			{		
				if(send(hSocket, pOutputBuffer, nLen, 0) != -1)
				{								
					#ifdef _DEBUG
					static int nTime0 = 0, nTime1 = 0;
					nTime0 = nTime1;
					nTime1 = PRD_getticks();					
					printf("发送图像成功，与上次发送间隔%d毫秒。\n", nTime1 - nTime0);
					#endif
					rc = 0;	
				}
			}
		}
	}
	
	fdClose(hSocket);
	
	if(rc)
	{
		TSK_sleep(1000);
	}
}

extern "C" void TaskSendImage()
{
	char *pOutputBuffer;
	int nLen, rc, nSensorDataType = -1, nOutputDataType, nTrigerMode = 0, nCancelTriger;
	//static char rs_485;
//	int cnt = 0;
	COMU_HEAD ch;
	static MBX_MESSAGE msg1, msg2, rs_image;//, msg3;
	IMAGE_INFO stImageInfo;
	IMAGE_INFO *pImageInfo;
	SERIALPARAM stSerialParam;	
	SERIALPARAM *pSerialParam = &stSerialParam;;
					
	fdOpenSession(TaskSelf());
	
	pImageInfo = &stImageInfo;
	
	JPEG_init(FF_WIDTH, FF_HEIGHT, intHeap, extHeap, 100);
	
	while(true)
	{
		MBX_pend(hMbxStartSerial, &msg1, SYS_FOREVER);
		//关闭线程切换，保证数据完整性
		TSK_disable();
		memcpy(&stSerialParam, msg1.pData, sizeof(g_stSerialParam));
		memcpy(&stImageInfo, &(pSerialParam->image_info), sizeof(stImageInfo));
		nOutputDataType = pSerialParam->image_info.nImgType;
		TSK_enable();
		
		g_nStopSerialImage = 0;
		while(!g_nStopSerialImage)
		{
			//防止最后一帧图像处理时间过长，导致无法及时响应控制命令
			if(MBX_pend(hMbxStartSerial, &msg1, 0))
			{
				TSK_disable();
				memcpy(&stSerialParam, msg1.pData, sizeof(g_stSerialParam));
				memcpy(&stImageInfo, &(pSerialParam->image_info), sizeof(stImageInfo));
				nOutputDataType = pSerialParam->image_info.nImgType;
				TSK_enable();
				
				g_nStopSerialImage = 0;				
			}

			if(g_nSensorDataType != nSensorDataType)
			{
				Phocus1820_sensor_set_format(g_nSensorDataType);
			}
			
			if(g_nTrigerMode != nTrigerMode)
			{
				Phocus1820_sensor_set_mode(g_nTrigerMode);
			}
			
			if(g_nDouble && (nTrigerMode & SENSOR_CAP_SOFTTRIGGER))
			{
				while(MBX_pend(hMbxImageSerial, &rs_image, 500) == FALSE)
				{
					if(!g_nStopSerialImage)
					{
						continue;
					}
					else
					{				
						break;
					}
				}  
			}		
			if(Phocus1820_sensor_open_capture_port(pImageInfo->nXStart, pImageInfo->nYStart, pImageInfo->nWidth, pImageInfo->nHeight) == 0)
			{				
				nSensorDataType = Phocus1820_sensor_get_format();
				nTrigerMode = Phocus1820_sensor_get_mode();
				
				if(g_nDouble && (nTrigerMode & SENSOR_CAP_SOFTTRIGGER))
				{
					while(!g_nStopSerialImage)
					{					
						if(MBX_pend(hMbxSoftTriger, &msg2, 500) == true)
						{		
							nSoft_Rs = 1;
							rs_send.pData = msg2.pData;
							rs_send.nDataLen = msg2.nDataLen;	
							break;						
						}  
					}			     
				}
				else
				{				
					while((nTrigerMode & SENSOR_CAP_SOFTTRIGGER) && (!g_nStopSerialImage))
					{
						//收到触发信号，采集一张图像
						if(MBX_pend(hMbxSoftTriger, &msg2, 1000) == TRUE)
						{
							if(msg2.nCommand)
							{
								nSoft_Rs = 1;
								rs_send.pData = msg2.pData;
								rs_send.nDataLen = msg2.nDataLen;
							}
							else
							{
								nSoft_Rs = 0;
							}
							nCancelTriger = 0;
							break;
						}				
						else
						{
							nCancelTriger = 1;
						}
						
						nTrigerMode = Phocus1820_sensor_get_mode();
						if((nTrigerMode & SENSOR_CAP_SOFTTRIGGER) == 0)
						{
							nCancelTriger = 1;
						}	
					}
				}
				
				if(nCancelTriger)
				{
					nCancelTriger = 0;
					continue;	
				}
						
				if(Phocus1820_sensor_wait_image((int)SYS_FOREVER) == 0)
				{
					if(Phocus1820_sensor_get_image(cBuffer[0] + sizeof(IMAGE_INFO)) == 0)
					{
						rc = PostProcess(nSensorDataType, nOutputDataType, pImageInfo, &pOutputBuffer, &nLen);
					}
				}
				else
				{
					nLen = 0;
					rc = ECAPIMAGE;
				}
			}
			else
			{
				nLen = 0;
				rc = EINVPARAM;			
			}
					
			*(IMAGE_INFO *)pOutputBuffer = *pImageInfo;
			if(nOutputDataType == DATA_JPEG)
			{
				((IMAGE_INFO *)pOutputBuffer)->nHeight &= 0xFFFFFFF0;
			}
			
			nLen += sizeof(IMAGE_INFO);
			
			ch.nError = rc;
			ch.nDataLen = nLen;
			ch.nDataType = nOutputDataType;
			ch.nCommand = 0;
			ch.nCheckSum = 0;
			ch.nCommandType = COMU_RESPONSE;
			ch.nCheckSum = LinkCheckSum((unsigned short*)&ch, sizeof(ch));	

			#ifdef _DEBUG
			switch(ch.nDataType)
			{
				case DATA_IMAGE:
				{
					printf("图像格式为RAW，");
					break;
				}
				case DATA_YUV:
				{
					printf("图像格式为YUV，");
					break;
				}
				case DATA_JPEG:
				{
					printf("图像格式为JPEG，");
					break;
				}				
			}
			printf("图像数据长度为%d\n", ch.nDataLen);
			#endif
			
			if(!g_nStopSerialImage && rc == ENO)
			{
				TcpSend(pSerialParam, &ch, pOutputBuffer, nLen);
			}	
		}//while(!g_nStopSerialImage)				
	}//while(true)		
}

extern "C" void PrdFeedDog()
{
	if(g_nIsFeed)
		Phocus1820_dog_feed();
}