Exemplo n.º 1
0
void ArrowLineComp::Write (ostream& out) {
    LineComp::Write(out);
    ArrowLine* arrow = GetArrowLine();
    
    out << arrow->Head() << " " << arrow->Tail() << " ";
    out << arrow->ArrowScale() << " ";

    WritePattern(arrow->GetPattern(), out);
}
Exemplo n.º 2
0
Arquivo: line.cpp Projeto: PNCG/neuron
void MultiLineComp::Write (ostream& out) {
    VerticesComp::Write(out);
    SF_MultiLine* ml = GetMultiLine();
    const Coord* x, *y;
    int count = ml->GetOriginal(x, y);

    WriteVertices(x, y, count, out);

    WriteBgFilled(ml->BgFilled(), out);
    WriteColor(ml->GetFgColor(), out);
    WriteColor(ml->GetBgColor(), out);
    WriteBrush(ml->GetBrush(), out);
    WritePattern(ml->GetPattern(), out);
    WriteTransformer(ml->GetTransformer(), out);
}
Exemplo n.º 3
0
Arquivo: rect.cpp Projeto: PNCG/neuron
void RectComp::Write (ostream& out) {
    GraphicComp::Write(out);
    SF_Rect* rect = GetRect();
    Coord x0, y0, x1, y1;

    rect->GetOriginal(x0, y0, x1, y1);
    out << x0 << " " << y0 << " " << x1 << " " << y1 << " ";

    WriteBgFilled(rect->BgFilled(), out);
    WriteColor(rect->GetFgColor(), out);
    WriteColor(rect->GetBgColor(), out);
    WriteBrush(rect->GetBrush(), out);
    WritePattern(rect->GetPattern(), out);
    WriteTransformer(rect->GetTransformer(), out);
}
Exemplo n.º 4
0
void SplineComp::Write (ostream& out) {
    VerticesComp::Write(out);
    SFH_OpenBSpline* spline = GetSpline();
    const Coord* x, *y;
    int count = spline->GetOriginal(x, y);

    WriteVertices(x, y, count, out);

    WriteBgFilled(spline->BgFilled(), out);
    WriteColor(spline->GetFgColor(), out);
    WriteColor(spline->GetBgColor(), out);
    WriteBrush(spline->GetBrush(), out);
    WritePattern(spline->GetPattern(), out);
    WriteTransformer(spline->GetTransformer(), out);
}
Exemplo n.º 5
0
void EllipseComp::Write (ostream& out) {
    GraphicComp::Write(out);
    SF_Ellipse* ellipse = GetEllipse();
    Coord x0, y0;
    int r1, r2;

    ellipse->GetOriginal(x0, y0, r1, r2);
    out << x0 << " " << y0 << " " << r1 << " " << r2 << " ";

    WriteBgFilled(ellipse->BgFilled(), out);
    WriteColor(ellipse->GetFgColor(), out);
    WriteColor(ellipse->GetBgColor(), out);
    WriteBrush(ellipse->GetBrush(), out);
    WritePattern(ellipse->GetPattern(), out);
    WriteTransformer(ellipse->GetTransformer(), out);
}
Exemplo n.º 6
0
unsigned int PreloaderCmd::CMD_BootAsFastboot(BOOT_ARG_S * pArg)
{
	unsigned int iRet = S_DONE;

	//Check parameters
	if(NULL == pArg)
	{
		printf( "Incorrect parameters!(NULL pointer)\n");
		return S_INVALID_ARGUMENTS;
	}

	//Set parameters and open/configure port
	SetParameters(pArg);
	if(0 != (iRet = SetPort(pArg)))
	{
		printf("Set port fail!\n");
		return iRet;
	}


	//printf("Start handshake with Preloader...\n");

	//Read pattern "READY"
	PATTERN_INFO_S stPattern;
	stPattern.m_uStatus = S_DONE;
	stPattern.m_uLen = strlen(kStrReady);
	strcpy(stPattern.m_szPattern, kStrReady);
	iRet = ReadPattern(&stPattern, 1);
	if(S_DONE == iRet)
	{
		//printf("PreloaderCmd::CMD_BootAsFastboot(): Receive READY succeed!\n");
	}
	else
	{
		printf( "Cannot receive pattern wanted!Ret(%u).\n", iRet);
		m_cPort.Close();
		return iRet;
	}


	//Write pattern "FASTBOOT" and its parameters
	PL_MODE_PARA_S tModePara;
	PARA_VALUE_S_V1 tValue;

	tValue.m_cKernelUSBType = (pArg->m_bIsCompositeDeviceEnable) ? (0) : (1);
	tValue.m_cKernelUSBNum= 0;
	tValue.dummy1= 0;
	tValue.dummy2= 0;

	memcpy(tModePara.m_aMode, kStrFBTReq, strlen(kStrFBTReq));    
	tModePara.m_uParaLen = sizeof(PARA_VALUE_S_V1);
	tModePara.m_uParaVer = 1;
	tModePara.m_nParaVal.m_tParaV1 = tValue;


	//iRet = WritePattern(kStrFBTReq, strlen(kStrFBTReq));
	iRet = WritePattern((char *)&tModePara, sizeof(PL_MODE_PARA_S));
	if(S_DONE == iRet)
	{
		//printf( "Send Request.\n");
	}
	else
	{
		printf("Send request fail. Ret(%u).\n", iRet);
		m_cPort.Close();
		return iRet;
	}

	//Read pattern "TOOBTSAF"
	PATTERN_INFO_S stFBTPattern[1];
	stFBTPattern[0].m_uStatus = S_DONE;
	stFBTPattern[0].m_uLen = strlen(kStrFBTSuccess);
	strcpy(stFBTPattern[0].m_szPattern, kStrFBTSuccess);

	//stFBTPattern[1].m_uStatus = S_PL_MODE_FORBIDDEN;
	//stFBTPattern[1].m_uLen = strlen(kStrFBTInvalid);
	//strcpy(stFBTPattern[1].m_szPattern, kStrFBTInvalid);
	iRet = ReadPattern(stFBTPattern, 1);
#if 0
	stPattern.m_uStatus = S_DONE;
	stPattern.m_uLen = strlen(kStrFBTSuccess);
	strcpy(stPattern.m_szPattern, kStrFBTSuccess);
	iRet = ReadPattern(&stPattern, 1);
#endif

	if(S_DONE == iRet)
	{
		//printf("Receive confirm succeed.\n");
	}   
	else if(S_PL_MODE_INVALID_ARGUMETS == iRet)
	{
		printf("FASTBOOT mode arguments is invalid!\n");
	}
	else
	{
		printf("Cannot receive pattern wanted!Err(%u).\n", iRet);
	}

	m_cPort.Close();
	return iRet;    
}
Exemplo n.º 7
0
/* *********************************************************************
 * NAME:             CollisionAvoidanceTask
 * CALLED BY:        Created by main() thread
 * DESCRIPTION:      Thread to Display movement of Car. This car speed
 *                   is controlled the measured distance.
 * INPUT PARAMETERS: TimeoutFlagLocal : used for ending this task
 * RETURN VALUES:    None
 ***********************************************************************/
void* CollisionAvoidanceTask(void *TimeoutFlagLocal)
{
	int FdDisplay;
	unsigned char count = 0, LoopIndex,SlowdownFlag = 0,LocalLineNum = 0,ReadBuff;
	/* Pattern that defines the CAR structure */
	const unsigned char PatternESP[8][8] = {
     	{0x00, 0x7c, 0x44, 0x47, 0x41, 0x7f, 0x22, 0x00},
		{0x00, 0x3e, 0x22, 0xa3, 0xa0, 0xbf, 0x11, 0x00},
		{0x00, 0x1f, 0x11, 0xd1, 0x50, 0xdf, 0x88, 0x00},
		{0x00, 0x8f, 0x88, 0xe8, 0x28, 0xef, 0x44, 0x00},
		{0x00, 0xc7, 0x44, 0x74, 0x14, 0xf7, 0x22, 0x00},
		{0x00, 0xe3, 0x22, 0x3a, 0x0a, 0xfb, 0x11, 0x00},
		{0x00, 0xf1, 0x11, 0x1d, 0x05, 0xfd, 0x88, 0x00},
		{0x00, 0xf8, 0x88, 0x8e, 0x82, 0xfe, 0x44, 0x00}
	};
	/* Two speeds for the car */
	unsigned short DisplaySequenceRun[10][2]={
		{0,CAR_DEFAULT_SPEED},{1,CAR_DEFAULT_SPEED},{2,CAR_DEFAULT_SPEED},
		{3,CAR_DEFAULT_SPEED},{4,CAR_DEFAULT_SPEED},{5,CAR_DEFAULT_SPEED},
		{6,CAR_DEFAULT_SPEED},{7,CAR_DEFAULT_SPEED},{0,0},
		{0,0}
		};
	unsigned short DisplaySequenceSlow[10][2]={
		{0,CAR_SLOWDOW_SPEED},{1,CAR_SLOWDOW_SPEED},{2,CAR_SLOWDOW_SPEED},
		{3,CAR_SLOWDOW_SPEED},{4,CAR_SLOWDOW_SPEED},{5,CAR_SLOWDOW_SPEED},
		{6,CAR_SLOWDOW_SPEED},{7,CAR_SLOWDOW_SPEED},{0,0},
		{0,0}
		};

    FdDisplay = open("/dev/spi_led",O_RDWR);
	if (FdDisplay < 0)
	{
		printf("\n spi_led driver file open failed");
	}
	/* Check if the display is free to accept new pattern */
	do
    {
#ifdef DEBUG
		printf("Waiting for display to get free ");
#endif
	    usleep(1000);
	}while (0 > read(FdDisplay,&ReadBuff,1));
	
    /* write the car pattern */
	for (LoopIndex = 0; LoopIndex < 8; LoopIndex++)
	{
        WritePattern(LoopIndex,&(PatternESP[LoopIndex][0]),FdDisplay);
	}
	
    /* Keep sending the sequence untill the timeout */
	do
	{
	    /* poll if the display has become free to accept new sequnece */
		do
		{
#ifdef DEBUG
			printf("Waiting for display to get free ");
#endif
			usleep(1000);
		}while (0 > read(FdDisplay,&ReadBuff,1));
		/* Read the distance and decide whether the car needs to be slowed down */
		pthread_mutex_lock(&DistanceMutex);
		SlowdownFlag = (GlobalDistance < MINIMUM_DISTANCE_TO_STOP) ? (1) : (0);
		pthread_mutex_unlock(&DistanceMutex);
		/* Check whether car needs to be slowed down */
		if(1 == SlowdownFlag)
		{
			/* Car needs to be slowed down , hence send the slow movement sequence */
			write(FdDisplay,&DisplaySequenceSlow,sizeof(DisplaySequenceSlow));
		}
		else
		{
			/* No obstacle with in the scan area, hence send full run sequence */
			write(FdDisplay,&DisplaySequenceRun,sizeof(DisplaySequenceRun));
		}
	}while(0 == (*((unsigned char *)TimeoutFlagLocal)));

#ifdef DEBUG
	printf("\n Display programmed %i \n",Result);
#endif
    return NULL;
}
Exemplo n.º 8
0
/* *********************************************************************
 * NAME:             ESPDisplayTask
 * CALLED BY:        Created by main() thread
 * DESCRIPTION:      Thread to display moving alphabets "ESP"
 * INPUT PARAMETERS: TimeoutFlagLocal : Not used
 * RETURN VALUES:    None
 ***********************************************************************/
void* ESPDisplayTask(void *TimeoutFlagLocal)
{
	int FdDisplay;
	unsigned char count = 0, LoopIndex, ReadBuff;
	const unsigned char PatternESP[23][8] = {
		{0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
		{0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03},
		{0x07, 0x07, 0x06, 0x07, 0x07, 0x06, 0x07, 0x07},
		{0x0f, 0x0f, 0x0c, 0x0f, 0x0f, 0x0c, 0x0f, 0x0f},
		{0x1f, 0x1f, 0x18, 0x1f, 0x1f, 0x18, 0x1f, 0x1f},
		{0x3e, 0x3e, 0x30, 0x3e, 0x3e, 0x30, 0x3e, 0x3e},
		{0x7d, 0x7d, 0x61, 0x7d, 0x7d, 0x60, 0x7d, 0x7d},
		{0xfb, 0xfb, 0xc3, 0xfb, 0xfb, 0xc0, 0xfb, 0xfb},
		{0xf7, 0xf7, 0x86, 0xf7, 0xf7, 0x81, 0xf7, 0xf7},
		{0xef, 0xef, 0x0c, 0xef, 0xef, 0x03, 0xef, 0xef},
		{0xde, 0xde, 0x18, 0xde, 0xde, 0x06, 0xde, 0xde},
		{0xbd, 0xbd, 0x31, 0xbd, 0xbd, 0x0d, 0xbd, 0xbd},
		{0x7b, 0x7b, 0x63, 0x7b, 0x7b, 0x1b, 0x7b, 0x7b},
		{0xf7, 0xf7, 0xc6, 0xf6, 0xf7, 0x36, 0xf6, 0xf6},
		{0xef, 0xef, 0x8c, 0xec, 0xef, 0x2c, 0xec, 0xec},
		{0xdf, 0xdf, 0x19, 0xd9, 0xdf, 0xd8, 0xd8, 0xd8},
		{0xbe, 0xbe, 0x32, 0xb2, 0xbe, 0xb0, 0xb0, 0xb0},
		{0x7c, 0x7c, 0x64, 0x64, 0x7c, 0x60, 0x60, 0x60},
		{0xf8, 0xf8, 0xc8, 0xc8, 0xf8, 0xc0, 0xc0, 0xc0},
		{0xf0, 0xf0, 0x90, 0x90, 0xf0, 0x80, 0x80, 0x80},
		{0xe0, 0xe0, 0x20, 0x20, 0xe0, 0x00, 0x00, 0x00},
		{0xc0, 0xc0, 0x40, 0x40, 0xc0, 0x00, 0x00, 0x00},
		{0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00}
	};
	unsigned short DisplaySequence[10][2]={
		{0,500},{1,500},{2,500},
		{3,500},{4,500},{5,500},
		{6,500},{7,500},{8,500},
		{9,400}/*Last one will be followed by a pattern change, hence less time*/
		};
    FdDisplay = open("/dev/spi_led",O_RDWR);
	if (FdDisplay < 0)
	{
		printf("\n spi_led driver file open failed");
	}
	/* write first 10 pattern */
	for(LoopIndex = 0; LoopIndex < 10; LoopIndex++)
	{
    	WritePattern(LoopIndex,&(PatternESP[LoopIndex][0]),FdDisplay);
    }

	/* Write the display sequence */ 
	write(FdDisplay,&DisplaySequence,sizeof(DisplaySequence));
	
	/* poll if the display has become free to accept new pattern */
	do
	{
		usleep(10000);
	}while (0 > read(FdDisplay,&ReadBuff,1));
	/* By now it will be ready to accept new commands */
	/* write next 10 pattern */
	for(LoopIndex = 0; LoopIndex < 10; LoopIndex++)
	{
    	WritePattern(LoopIndex,&(PatternESP[LoopIndex + 10][0]),FdDisplay);
    }

	/* Write the display sequence */ 
	write(FdDisplay,&DisplaySequence,sizeof(DisplaySequence));
	
	/* poll if the display has become free to accept new pattern */
	do
	{
		usleep(10000);
	}while (0 > read(FdDisplay,&ReadBuff,1));
	/* By now it will be ready to accept new commands */
	

	/* write next 10 pattern */
	for(LoopIndex = 0; LoopIndex < 3; LoopIndex++)
	{
    	WritePattern(LoopIndex,&(PatternESP[LoopIndex + 20][0]),FdDisplay);
    }
    /* Display only last 3 patterns */
    DisplaySequence[3][0] = 0;
    DisplaySequence[3][1] = 0;
    
	/* Write the display sequence */ 
	write(FdDisplay,&DisplaySequence,sizeof(DisplaySequence));	
	
#ifdef DEBUG
	printf("\n Display programmed %i \n",Result);
#endif
    close(FdDisplay);
    return NULL;
}