Exemple #1
0
void Download(char *commandline, blobStatus *status)
{
	u32 startAddress = 0;
	int bufLen;
	int *numRead = 0;

	if(MyStrNCmp(commandline, "kernel", 6) == 0) {
		/* download kernel */
		startAddress = KERNEL_RAM_BASE;
		bufLen = status->blockSize - KERNEL_BLOCK_OFFSET;
		numRead = &status->kernelSize;
		status->kernelType = fromDownload;
	} else if(MyStrNCmp(commandline, "ramdisk", 7) == 0) {
		/* download ramdisk */
		startAddress = RAMDISK_RAM_BASE;
		bufLen = status->blockSize - RAMDISK_BLOCK_OFFSET;
		numRead = &status->ramdiskSize;
		status->ramdiskType = fromDownload;
	} else {
		SerialOutputString("*** Don't know how to download \"");
		SerialOutputString(commandline);
		SerialOutputString("\"\r");
		return;
	}


	SerialOutputString("Switching to ");
	PrintSerialSpeed(status->downloadSpeed);
	SerialOutputString(" baud\r");

	SerialOutputString("You have 60 seconds to switch your terminal emulator to the same speed and\r");
	SerialOutputString("start downloading. After that " PACKAGE " will switch back to 9600 baud.\r");
	
	SerialInit(status->downloadSpeed);

	*numRead = UUDecode((char *)startAddress, bufLen);
	
	SerialOutputString("\r(Please switch your terminal emulator back to 9600 baud)\r");
	
	if(*numRead < 0) {
		/* something went wrong */
		SerialOutputString("*** Uudecode receive failed\r");
		
		/* reload the correct memory */
		Reload(commandline, status);

		SerialInit(baud9k6);
		return;
	}
	SerialOutputString("Received ");
	SerialOutputDec(*numRead);
	SerialOutputString(" (0x");
	SerialOutputHex(*numRead);
	SerialOutputString(") bytes.\r");


	SerialInit(baud9k6);
}
/**
 * Initializes the UARTS.
 * @return The return value of SerialInit().
 */
int UARTInit(void){
    char* env_ptr;
    int uart_selection = 0;
    unsigned int uarts[1] = { PHYSICAL_UART0 };

    return SerialInit(uarts, 1);
}
Exemple #3
0
void main()
{
	uchar len,i;
	uchar xdata Tvalue[6],Hvalue[6];
	SerialInit();
	LCDInit();
	while(1)
	{ 
	    RH();
		SerialPutString(buff);
		sprintf(Tvalue,"%2.2f",temperature);
		sprintf(Hvalue,"%2.2f%%",humidity);
		LCDWriteCom(0x01);//ÇåÆÁ
		LCDWriteCom(0x80);
		len=strlen(info1);
		//дÊý¾Ýµ½LCD1602
		for(i=0;i<len;i++)
			LCDWriteData(info1[i]);
		len=strlen(Tvalue);
		for(i=0;i<len;i++)
			LCDWriteData(Tvalue[i]);
		LCDWriteData((uchar)223);
		LCDWriteData('C');
		LCDWriteCom(0x80+0x43);
		len=strlen(info2);
		for(i=0;i<len;i++)
			LCDWriteData(info2[i]);
		len=strlen(Hvalue);
		for(i=0;i<len;i++)
			LCDWriteData(Hvalue[i]);
	   //
	   Delay(10000);
	}

}
void SerialReInit(HANDLE * hCom, int PortNum, int BaudRate, int dataBit,
                  int parity, int cts, int rts, int dsr, int dtr)
{
    close(*hCom);
    *hCom =
        SerialInit(PortNum, BaudRate, dataBit, parity, cts, rts, dsr, dtr);
}
Exemple #5
0
int main(int argc, char **argv)
{
    int nRet = 0,i;
    char buf[SIZE];
	if(argc<2)perror("Null Commend");
    if( SerialInit() == -1 )
    {
        perror("SerialInit Error!\n");
        return -1;
    }
    bzero(buf, SIZE);
	
	for(i=0;i<strlen(argv[1]);i++)
	{
		buf[i]=argv[1][i];
	}
	buf[i++]='\r';
	buf[i++]='\n';
	buf[i++]=0;
	printf(buf);
	write(nFd,buf,i-1);
	bzero(buf, SIZE);
	nRet = read(nFd, buf, SIZE);
	if(0 < nRet)
	{
		buf[nRet] = 0;
		printf("Recv Data: %s\n", buf);
	}
	if(-1 == nRet)
	{
		perror("Read Data Error!\n");
	}
    close(nFd);
    return 0;
}
Exemple #6
0
void main()
{
 //delay(10000);
 SerialInit();  //串口初始化,用以向调试终端发送数据
 while(1)
 {
 SerialPutString("yahoo!!!"); //发送一个测试字符串
 }
/*
 MMC_Init(); //SD卡初始化
 delay(10000);
 MMC_get_volume_info();	  //获得SD卡相关信息,输出到终端
 FAT32_Init(&Init_Arg);	  //FAT32文件系统初始化,装入参数
 Printf("BPB_Sector_No"  ,Init_Arg.BPB_Sector_No);
 Printf("Total_Size"     ,Init_Arg.Total_Size   );
 Printf("FirstDirClust"  ,Init_Arg.FirstDirClust); 
 Printf("FirstDataSector",Init_Arg.FirstDataSector); 
 Printf("BytesPerSector" ,Init_Arg.BytesPerSector); 
 Printf("FATsectors"     ,Init_Arg.FATsectors); 
 Printf("SectorsPerClust",Init_Arg.SectorsPerClust);
 Printf("FirstFATSector" ,Init_Arg.FirstFATSector); 
 Printf("FirstDirSector" ,Init_Arg.FirstDirSector);   //以上几个语句用以输出参数值到终端
 Printf("FAT32_OpenFile" ,(FAT32_OpenFile("\\TEST.TXT"))->FileSize); //打开根目录下的TEST.TXT文件,并输出文件大小 
 FAT32_ReadFile(&FileInfo);  //读取文件数据,输出到终端
*/
// while(1);
}
//****************************************************************************
//
// This is the main loop that runs the application.
//
//****************************************************************************
int
main(void)
{
    //
    // Set the clocking to run from the PLL at 50MHz.
    //
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
                       SYSCTL_XTAL_16MHZ);

    //
    // Set the system tick to fire 100 times per second.
    //
    ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
    ROM_SysTickIntEnable();
    ROM_SysTickEnable();

    //
    // Pass the USB library our device information, initialize the USB
    // controller and connect the device to the bus.
    //
    g_psCompDevices[0].pvInstance =
        USBDHIDMouseCompositeInit(0, (tUSBDHIDMouseDevice *)&g_sMouseDevice);
    g_psCompDevices[1].pvInstance =
        USBDCDCCompositeInit(0, (tUSBDCDCDevice *)&g_sCDCDevice);

    //
    // Set the USB stack mode to Device mode with VBUS monitoring.
    //
    USBStackModeSet(0, USB_MODE_DEVICE, 0);

    //
    // Pass the device information to the USB library and place the device
    // on the bus.
    //
    USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_DATA_SIZE,
                      g_pucDescriptorData);

    //
    // Initialize the mouse and serial devices.
    //
    MouseInit();
    SerialInit();

    //
    // Drop into the main loop.
    //
    while(1)
    {
        //
        // Allow the main mouse routine to run.
        //
        MouseMain();

        //
        // Allow the main serial routine to run.
        //
        SerialMain();
    }
}
Exemple #8
0
void Serial_Begin(unsigned int baudrate)
{
  //init buffers and attach events
  SerialInit();
  
  //configure registers
  USART_Begin(baudrate);
}
Exemple #9
0
void Serial_BeginConfigured(unsigned int baudrate, uint8_t conf)
{
  //init buffers and attach events
  SerialInit();
  
  //configure registers
  USART_BeginConfigured(baudrate, conf);
}
Exemple #10
0
void main()
{
   union {
      unsigned int32 hours;
      unsigned int8 minutes;
      unsigned int8 seconds;} upTime;
   
   
   TICK_TYPE CurrentTick,PreviousUDPTick,PreviousSATick;
   resetStatus = (RCON & 0b00111111) | !(STKPTR & 0b11000000); // Get the Reset Status
   RCON = RCON | 0b00111111; //Reset RCON Reset flags... (Reset Register)
   STKPTR = STKPTR & 0b00111111; // Clear Stack Overflow/Underflow flags
   PortInit(); 
   OutputInit();  
   restart_wdt();
   romEZHRInit();    //set up default ezhr settings
   eeROMinit();      //set up default eprom settings
   IPAddressInit();  //set up MAC and default IP addresses
   delay_ms(500); 
   ADCInit();        //set up ADC ports
   iniADCParams();    
   SerialInit();     //set up serial ports
   TickInit();       //set up tick timer
   enable_interrupts(INT_RDA);
   enable_interrupts(GLOBAL);
   StackInit();   
   WritePHYReg(ERXFCON,EthernetRXfilterSetting); // Allow only uni & multi
   SetLEDConfig(E_LED_CONFIG);   // swap LED's 
   output_high(E_SW_PWR_DN);     // Power Ethernet Switch
   output_high(E_SW_RST);
   output_low(RS485_TXEN);
   output_high(RS485_RXDIS);
   output_high(RS232_F_OFF);
   output_high(RS232_F_ON);
   CurrentTick = PreviousUDPTick = get_ticks();
   UDPSampleRate = eeReadUDPRate() * TICKS_PER_MILLISECOND;
   portControlInit();
   while(TRUE)
   {
      CurrentTick = get_ticks();
      restart_wdt();
      StackTask();
      restart_wdt();
      MyTCPTask();//handles TCP connections
      restart_wdt();
      setIO();// checks voltage status and sets ports accordingly
//!      if(CurrentTick-PreviousUDPTick >= UDPSampleRate)
//!      {
//!         currentRoutine=UDPTASK;
//!         BOOL UDPDone = MyUDPTask();
//!         if(UDPDone) 
//!         {
//!            PreviousUDPTick=CurrentTick;
//!         }
//!      }
      StackApplications();
   }
}
Exemple #11
0
void OutboundThread(void)
{
  WINDOW *local ;
  
  /* INITIALIZATION: Paint the local window. Create a	*/
  /* mailbox object to receive keystroke codes from the	*/
  /* keyboard ISR. Initialize the keyboard hardware.	*/
  /* Point interrupt vector 33 at the keyboard ISR.	*/
  /* Unmask the IRQ line in the 8259 PIC.			*/
  
  local = WindowCreate("Local", 0, 10, 0, 79) ;
  KeyboardInit() ;
  /* SerialInit have a guard inside to prevent multiple initializations */
  SerialInit() ;
 
  for (;;)
  {
    BYTE8 err, scan_code ;
    char ascii ;
    
    /* Suspend this thread (let it "sleep") until a	*/
    /* keyboard interrupt posts something to our	*/
    /* mailbox.  But first position the cursor 	*/
    /* at the next character position as a prompt.	*/
    
    WindowSelect(local) ;
    scan_code = ((unsigned) OSQPend(kybd_queue, 0, &err)) & 0xFF ;
    if (scan_code & 0x80)
      continue ; /* Key up */
    
    /* The keyboard ISR just woke us up. scan_code	*/
    /* is the keystroke that occurred. First check	*/
    /* to see if it simply changes state, like caps	*/
    /* lock, shift, ctrl, or alt.  Then convert the	*/
    /* scancode to ascii using the current state.	*/
    
    if (SetsKybdState(scan_code))
      continue ;
    
    ascii = ScanCode2Ascii(scan_code) & 0xFF ;
    if (!isprint(ascii) && !iscntrl(ascii))
      continue ;

    /* Display the character in the local window.	*/
    
    WindowPutChar(local, ascii) ;
    
    SendPacket(1, &ascii, 1) ;
    if (ascii == '\r')
    {
      static char linefeed = '\n' ;
      WindowPutChar(local, linefeed) ;
      SendPacket(1, &linefeed, 1) ;
    }
  }
}
int main( void )
{
	SerialInit(MYUBRR);
	while(1)
	{
		_delay_ms(10000);
		SendString("LAB");
	}

	
}
Exemple #13
0
void ResetTerminal(void)
{
	int i;

	SerialInit(baud9k6);
	SerialOutputString("          c");
	for(i = 0; i < 100; i++)
		SerialOutputByte('\r');

	SerialOutputString("c");
}
Exemple #14
0
int main(void) {
	ClockInit();
	SerialInit();
	TimerInit();
  
  //ADMUX = POWER_IN;//A7 power
  DIDR0 |= _BV(0);//1
  ADCSRA = _BV(ADEN) | _BV(ADPS0) | _BV(ADPS1) | _BV(ADPS2);// | _BV(ADIE) | _BV(ADATE) _BV(ADSC) | 
  ADCSRB = _BV(ADLAR);
  
  
	loop();
}
Exemple #15
0
void MasterInitialize()//called on startup, will call the port setup etc. as well as find the appropriate setting for the pot
{
	cli();//disable interrupts
	
	ADCInit();
	
	PortInit();//these init values (clock and port) are taken directly from our old code
	
	ClockInit();
	
	SerialInit();
		
	sei();//enable interrupts
	
	return;
}
Exemple #16
0
void main()
{
    //uchar i;
    //EX1=1;
    //IT1=1;
    LCDInit();
    SerialInit();
    len=strlen(value);
    for(i=0; i<len; i++)
        LCDWriteData(value[i]);
    //sendsms();
    //DialVoiceCall();
    //
    while(1)
    {
        ConnectGPRS(0.3,0.4,0.8);
        //delay(3000);
        //LCDWriteCom(0x01);//清屏
        /*
        LCDWriteCom(0x80);
        if(pulse==1)
        {
        	TL0=0;
        	while(pulse);
        	TR0=1;
        	while(!pulse);
        	TR0=0;
        	count=TL0;
        	P1=count;
        	duration=(unsigned long)count;
        	lowpulseoccupancy = lowpulseoccupancy+duration;
        	ratio = lowpulseoccupancy/(sampletime_ms*10.0);  // Integer percentage 0=>100
            concentration = 1.1*pow(ratio,3)-3.8*pow(ratio,2)+520*ratio+0.62; // using spec sheet curve
            //Serial.print("yeelink:");
            //Serial.println(concentration);
            //ConnectGPRS(concentration,(float)DHT11.temperature,(float)DHT11.humidity);
        	memset(value,0x00,20);
        	sprintf(value,"%s%f","yeelink:",concentration);
        	len=strlen(value);
        	for(i=0;i<len;i++)
        		LCDWriteData(value[i]);
            lowpulseoccupancy = 0;
        //	delay(3000);
        }
        */
    }
}
int serial_init (void)
{	
    const char * serial_port = "/dev/ttyUSB0";
    out = (char *) malloc(sizeof(char)*8);
    SerialInit(serial_port, 9600, &serial_fd);
    fd = fdopen(serial_fd, "rw");

    if (serial_fd > 0)
    {
        pthread_mutex_t serial_mutex = PTHREAD_MUTEX_INITIALIZER;
        servo.xPos = MIN_X_PWM+(MAX_X_PWM-MIN_X_PWM)/2;
        servo.yPos = MIN_Y_PWM+(MAX_Y_PWM-MIN_Y_PWM)/2;
        sprintf(out, "#%04d%04d$", MIN_X_PWM+(MAX_X_PWM-MIN_X_PWM)/2, MIN_Y_PWM+(MAX_Y_PWM-MIN_Y_PWM)/2);
        write(serial_fd,out,10);
        tcflush(serial_fd, TCIFLUSH);
        return 0;
		
    } else {
        fprintf (stderr,"failed to open serial port!\n");
        return -1;
    }
} 
Exemple #18
0
void __cdecl ldr_logo()
{
    kboot_info *bi;
	unsigned char ch;
    UINT32 e;

    HeapInit();
	ConsoleInit();
    TxtSetFlags(BGCOLOR_BLACK|FGCOLOR_GREEN);
	TxtClearScreen();
    SerialInit(); 
	PicInit();
	DescriptorsInit();
    InterruptsInit();
    ExceptionsInit();
    DbgInit();
	_enable();
	IrqInit();
	TssInit();
	Vm86Init();
	TimerInit();
	KbdInit();
    //DbgStepEnable();
	StorageProbe();
    e = VolReadFile("A:\\OSLDR.EXE", (VPTR)0x300000);
    DbgPrintf("%s\n", DbgStatusStr(e));
	if(VideoInit())
	{
		DbgPrintf("\nError Initializing Video Subsystem");
	}
	while(1)
	{
		ch=KbdGetKey();
		_Putch(ch);
		if(ch==33) KbdCpuReset();
	}
    while(1);
}
/*****************************************************************************
* 
*  This is the main loop that runs the application.
* 
*****************************************************************************/
int main(void)
{
    tRectangle sRect;

    MMUConfigAndEnable();
    
	/* Enable USB module clock */
	
	USB0ModuleClkConfig();

	/* configures arm interrupt controller to generate raster interrupt  */
	
	USBInterruptEnable();

	/* LCD Back light setup */
	
	LCDBackLightEnable();

	/* UPD Pin setup */
	
	UPDNPinControl();

	/* Delay timer setup */
	
	DelayTimerSetup();

	/* Configures raster to display image  */
	
	SetUpLCD();		
	/* Configures raster to display image  and Copy palette info into buffer */	
	LCDInit();

	GrOffScreen24BPPInit(&g_s35_800x480x24Display, g_pucBuffer, LCD_WIDTH, LCD_HEIGHT);
	
	/* Initialize a drawing context. */
	GrContextInit(&g_sContext, &g_s35_800x480x24Display);

	/* enable End of frame interrupt */
	RasterEndOfFrameIntEnable(SOC_LCDC_0_REGS);

	/* enable raster */
	RasterEnable(SOC_LCDC_0_REGS);	
		
	/* Fill the top 24 rows of the screen with blue to create the banner. */

	sRect.sXMin = 0;
	sRect.sYMin = 0;
	sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;
	sRect.sYMax = (MAX_ROW_NUM - 1);
	GrContextForegroundSet(&g_sContext, ClrDarkBlue);
	GrRectFill(&g_sContext, &sRect);


	/* Put a white box around the banner. */
	GrContextForegroundSet(&g_sContext, ClrWhite);
	GrRectDraw(&g_sContext, &sRect);

	/* Put the application name in the middle of the banner. */
	GrContextFontSet(&g_sContext, &g_sFontCm20);
	GrStringDrawCentered(&g_sContext, "usb-dev-composite", -1,
						 GrContextDpyWidthGet(&g_sContext) / 2, 10, 0);

		
     /* Show the various static text elements on the color STN display. */
     
     GrContextFontSet(&g_sContext, TEXT_FONT);
 	 GrContextForegroundSet(&g_sContext, ClrViolet);
     GrStringDraw(&g_sContext, "CDC Serial 1 :-", -1, CDC1_STR_X_POSITION,
                   CDC1_STR_Y_POSITION, false);
     GrStringDraw(&g_sContext, "CDC Serial 2 :-", -1, CDC2_STR_X_POSITION,
                   CDC1_STR_Y_POSITION, false);
 	 GrContextForegroundSet(&g_sContext, ClrWhite);

 	 GrStringDraw(&g_sContext, "Tx bytes:", -1, CDC1_STR_X_POSITION,
 	              (CDC1_STR_Y_POSITION + CDC_STR_Y_DIFF), false);
     GrStringDraw(&g_sContext, "Tx buffer:", -1, CDC1_STR_X_POSITION,
                  (CDC1_STR_Y_POSITION + (CDC_STR_Y_DIFF * 2)), false);
     GrStringDraw(&g_sContext, "Rx bytes:", -1, CDC1_STR_X_POSITION, 
                  (CDC1_STR_Y_POSITION + (CDC_STR_Y_DIFF * 4)), false);
     GrStringDraw(&g_sContext, "Rx buffer:", -1, CDC1_STR_X_POSITION, 
                  (CDC1_STR_Y_POSITION + (CDC_STR_Y_DIFF * 5)), false);
     DrawBufferMeter(&g_sContext, CDC1_BUF_METER_X_POS, CDC1_BUF_METER_Y_POS);
     DrawBufferMeter(&g_sContext, CDC1_BUF_METER_X_POS,
                     (CDC1_BUF_METER_Y_POS + CDC_BUF_METER_Y_DIFF));

 	 GrStringDraw(&g_sContext, "Tx bytes:", -1, CDC2_STR_X_POSITION, 
 	              (CDC2_STR_Y_POSITION + CDC_STR_Y_DIFF), false);
     GrStringDraw(&g_sContext, "Tx buffer:", -1, CDC2_STR_X_POSITION,
                  (CDC2_STR_Y_POSITION + (CDC_STR_Y_DIFF * 2)), false);
     GrStringDraw(&g_sContext, "Rx bytes:", -1, CDC2_STR_X_POSITION, 
                  (CDC2_STR_Y_POSITION + (CDC_STR_Y_DIFF * 4)), false);
     GrStringDraw(&g_sContext, "Rx buffer:", -1, CDC2_STR_X_POSITION, 
                  (CDC2_STR_Y_POSITION + (CDC_STR_Y_DIFF * 5)), false);
     DrawBufferMeter(&g_sContext, CDC2_BUF_METER_X_POS, CDC2_BUF_METER_Y_POS);
     DrawBufferMeter(&g_sContext, CDC2_BUF_METER_X_POS, 
                     (CDC2_BUF_METER_Y_POS + CDC_BUF_METER_Y_DIFF));

     DisplayStatus(&g_sContext, " Waiting for host... ");

    /* Pass the USB library our device information, initialize the USB
       controller and connect the device to the bus.
    */ 

    g_psCompDevices[0].pvInstance =
        USBDCDCCompositeInit(0, (tUSBDCDCDevice *)&g_sCDCDevice1);
    g_psCompDevices[1].pvInstance =
        USBDCDCCompositeInit(0, (tUSBDCDCDevice *)&g_sCDCDevice2);        

    /*
      Pass the device information to the USB library and place the device
      on the bus.
    */
    USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_DATA_SIZE,
                      g_pucDescriptorData);

    
    /* Initialize the serial devices. */
    SerialInit();

    
    /* Drop into the main loop. */
    while(1)
    {
        
        /* Allow the main serial routine to run. */
        SerialMain();
    }
}
//****************************************************************************
//
// This is the main loop that runs the application.
//
//****************************************************************************
int
main(void)
{
    //
    // Set the clocking to run from the PLL at 50MHz.
    //
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
                       SYSCTL_XTAL_16MHZ);

    //
    // Set the system tick to fire 100 times per second.
    //
    ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
    ROM_SysTickIntEnable();
    ROM_SysTickEnable();


    //
     // Configure and enable uDMA
     //
     ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
     SysCtlDelay(10);
     ROM_uDMAControlBaseSet(&sDMAControlTable[0]);
     ROM_uDMAEnable();


     //
        // Initialize the idle timeout and reset all flags.
        //
        g_ulIdleTimeout = 0;
        g_ulFlags = 0;
        g_eMSCState = MSC_DEV_DISCONNECTED;

    //
    // Pass the USB library our device information, initialize the USB
    // controller and connect the device to the bus.
    //
    g_psCompDevices[0].pvInstance =
    		USBDMSCInit(0, (tUSBDMSCDevice *)&g_sMSCDevice);
    g_psCompDevices[1].pvInstance =
        USBDCDCCompositeInit(0, (tUSBDCDCDevice *)&g_sCDCDevice);

    //
    // Set the USB stack mode to Device mode with VBUS monitoring.
    //
    USBStackModeSet(0, USB_MODE_DEVICE, 0);

    //
    // Pass the device information to the USB library and place the device
    // on the bus.
    //
    USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_DATA_SIZE,
                      g_pucDescriptorData);



    SerialInit();


    disk_initialize(0);
    //
    // Drop into the main loop.
    //
    while(1)
    {
        //
        // Allow the main serial routine to run.
        //
        SerialMain();


        switch(g_eMSCState)
                {
                    case MSC_DEV_READ:
                    {
                        //
                        // Update the screen if necessary.
                        //
                        if(g_ulFlags & FLAG_UPDATE_STATUS)
                        {

                            g_ulFlags &= ~FLAG_UPDATE_STATUS;
                        }

                        //
                        // If there is no activity then return to the idle state.
                        //
                        if(g_ulIdleTimeout == 0)
                        {

                            g_eMSCState = MSC_DEV_IDLE;
                        }

                        break;
                    }
                    case MSC_DEV_WRITE:
                    {
                        //
                        // Update the screen if necessary.
                        //
                        if(g_ulFlags & FLAG_UPDATE_STATUS)
                        {

                            g_ulFlags &= ~FLAG_UPDATE_STATUS;
                        }

                        //
                        // If there is no activity then return to the idle state.
                        //
                        if(g_ulIdleTimeout == 0)
                        {

                            g_eMSCState = MSC_DEV_IDLE;
                        }
                        break;
                    }
                    case MSC_DEV_DISCONNECTED:
                    {
                        //
                        // Update the screen if necessary.
                        //
                        if(g_ulFlags & FLAG_UPDATE_STATUS)
                        {

                            g_ulFlags &= ~FLAG_UPDATE_STATUS;
                        }
                        break;
                    }
                    case MSC_DEV_IDLE:
                    {
                        break;
                    }
                    default:
                    {
                        break;
                    }
                }

    }
}
void initArduino()
{
    //armArduinoHandle = SerialInit(armArduinoPort, 9600, 8, 0, 0, 0, 0, 0);
    bagArduinoHandle = SerialInit(bagArduinoPort, 9600, 8, 0, 0, 0, 0, 0);
}
Exemple #22
0
int _tmain(int argc, _TCHAR* argv[])
{
	int
		hmin=175,
		hmax=185,
		smin=65,
		smax=108,
		vmin=136,
		vmax=253;

	cv::VideoCapture cap;

	DCB dcb;

	DWORD byteswritten;

	char a[]="abcdefg";

	HANDLE hPort;
	SerialInit(&hPort,&dcb);
	WriteFile(
		hPort,
		a,	
		sizeof(a),	
		&byteswritten,
		NULL);

	std::cout<<byteswritten;

	CloseHandle(hPort);
	exit(1);

	std::cout << "initial webcam...";
	cap.open(0);
	if(!cap.isOpened())
	{
		std::printf("err init webcam!");
		std::getchar();
		return 0;
	}
	std::cout << "OK\n";

	cv::namedWindow("Raw",cv::WINDOW_AUTOSIZE);
	cv::namedWindow("Histrogram",cv::WINDOW_AUTOSIZE);
	cv::namedWindow("Filtered",cv::WINDOW_AUTOSIZE);
	cv::namedWindow("Setting",cv::WINDOW_AUTOSIZE);
	cv::setMouseCallback("Raw",onMouse,0);
	cv::createTrackbar("Hmin","Setting",&hmin,255,0);
	cv::createTrackbar("Hmax","Setting",&hmax,255,0);
	cv::createTrackbar("Smin","Setting",&smin,255,0);
	cv::createTrackbar("Smax","Setting",&smax,255,0);
	cv::createTrackbar("Vmin","Setting",&vmin,255,0);
	cv::createTrackbar("Vmax","Setting",&vmax,255,0);

	int keycode=-1;
	while(keycode!=27)
	{
		cv::Mat frame,hsv,hist,histshow;
		cv::Mat hue,sat,val;
		histshow=cv::Mat::zeros(CAM_X,CAM_Y,CV_8UC3);
		hue=cv::Mat::zeros(CAM_X,CAM_Y,CV_8UC1);
		sat=cv::Mat::zeros(CAM_X,CAM_Y,CV_8UC1);
		val=cv::Mat::zeros(CAM_X,CAM_Y,CV_8UC1);
		cv::Mat threshold=cv::Mat::zeros(CAM_X,CAM_Y,CV_8UC1);

		double tt=(double)cv::getTickCount();

		cap >> frame;
		if(frame.empty())
		{
			std::cout<<"err!!!";
			cv::waitKey(0);
			break;
		}

		cv::cvtColor(frame,hsv,CV_BGR2HSV);

		//split channels
		cv::Mat out[]={hue,sat,val};
		int channelmapping[]={0,0,1,1,2,2};
		cv::mixChannels(&hsv,3,out,3,channelmapping,3);
		//end split channels

		/*
		frame.adjustROI(
			select_rect.y,
			select_rect.x+select_rect.height,
			select_rect.x,
			select_rect.x+select_rect.width);
		*/

		float histranges[] = {0,180};
		const float* phistranges = histranges;
		int ch[]={0};
		int histdim=64;
		cv::Mat mask;
		cv::Mat roi(hue,select_rect);
		cv::Mat maskroi(mask,select_rect);
		cv::calcHist(&roi,1,0,maskroi,hist,1,&histdim,&phistranges,true,false);

		//threshold
		cv::inRange(hue,hmin,hmax,hue);
		cv::inRange(sat,smin,smax,sat);
		cv::inRange(val,vmin,vmax,val);
		//end threshold

		//and
		cv::bitwise_and(hue,sat,threshold,hue);
		cv::bitwise_and(threshold,val,threshold,val);
		//end and

		//erode&dilate
		cv::erode(threshold,threshold,cv::getStructuringElement(cv::MORPH_RECT,cv::Size(3,3)),cv::Point(-1,-1),1,0);
		cv::dilate(threshold,threshold,cv::getStructuringElement(cv::MORPH_RECT,cv::Size(5,5)),cv::Point(-1,-1),10,0);
		//end erode&dilate

		//find corner
		std::vector<cv::Point2f> eig;
		cv::goodFeaturesToTrack(threshold,eig,50,0.01,10,cv::Mat(),3,false,0.04);
		cv::cornerSubPix(threshold,eig,cv::Size(10,10),cv::Size(-1,-1),cv::TermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,20,0.03));
		cv::Point obj_origin;
		cv::Point obj_corner;
		cv::Rect obj_rect;
		obj_origin.x=(int)eig[0].x;
		obj_origin.y=(int)eig[0].y;
		obj_corner.x=(int)eig[0].x;
		obj_corner.y=(int)eig[0].y;
		for(int i=0;i<(int)eig.size();i++)
		{
			obj_origin.x=MIN(obj_origin.x,(int)eig[i].x);
			obj_origin.y=MIN(obj_origin.y,(int)eig[i].y);
			obj_corner.x=MAX(obj_corner.x,(int)eig[i].x);
			obj_corner.y=MAX(obj_corner.y,(int)eig[i].y);

			cv::circle(frame,eig[i],1,cv::Scalar(255,0,0),1,8,0);
		}
		obj_rect.x=obj_origin.x;
		obj_rect.y=obj_origin.y;
		obj_rect.width=abs(obj_rect.x-obj_corner.x);
		obj_rect.height=abs(obj_rect.y-obj_corner.y);
		//end find corner


		cv::rectangle(frame,obj_rect,cv::Scalar(0,0,255),1,8,0);
		cv::rectangle(frame,select_rect,cv::Scalar(0,255,0),1,8,0);

		cv::imshow("Raw",frame);
		cv::imshow("Filtered",threshold);

		tt=(double)cv::getTickCount()-tt;
		tt=tt/cv::getTickFrequency()*1000;
		std::cout<< "t:" << tt << "ms\n";

		keycode=cv::waitKey(1);
	}

	std::cout << keycode;
	cv::destroyWindow("Raw");
	cv::destroyWindow("Histrogram");
	cv::destroyWindow("Filtered");
	cv::destroyWindow("Setting");

	cv::waitKey(0);
	return 0;
}
Exemple #23
0
/**
 * Constructs the AHRS class using serial communication and the default update rate,
 * and returning processed (rather than raw) data.
 *<p>
 * This constructor should be used if communicating via either
 * TTL UART or USB Serial interface.
 *<p>
 * @param serial_port_id SerialPort to use
 */
AHRS::AHRS(SerialPort::Port serial_port_id) {
    SerialInit(serial_port_id, SerialDataType::kProcessedData, NAVX_DEFAULT_UPDATE_RATE_HZ);
}
Exemple #24
0
    /**
     * Constructs the AHRS class using serial communication, overriding the
     * default update rate with a custom rate which may be from 4 to 60,
     * representing the number of updates per second sent by the sensor.
     *<p>
     * This constructor should be used if communicating via either
     * TTL UART or USB Serial interface.
     *<p>
     * Note that the serial interfaces can communicate either
     * processed data, or raw data, but not both simultaneously.
     * If simultaneous processed and raw data are needed, use
     * one of the register-based interfaces (SPI or I2C).
     *<p>
     * Note that increasing the update rate may increase the
     * CPU utilization.
     *<p>
     * @param serial_port_id SerialPort to use
     * @param data_type either kProcessedData or kRawData
     * @param update_rate_hz Custom Update Rate (Hz)
     */
AHRS::AHRS(SerialPort::Port serial_port_id, AHRS::SerialDataType data_type, uint8_t update_rate_hz) {
    SerialInit(serial_port_id, data_type, update_rate_hz);
}
void initRoboteq()
{
    roboteqHandle = SerialInit(roboteqPort, 115200, 8, 0, 0, 0, 0, 0);
    SerialPuts(roboteqHandle, "!G 1 0000\r!G 2 0000\r");
}
Exemple #26
0
int main(void) {
	ClockInit();
	SerialInit();
	TimerInit();
	loop();
}
int main ( void )
{
    int8_t status;
	sei();



	SerialInit(MYUBRR);
	InitWatch();
    /**
     * Reuse part of the idle thread's stack for the stack required
     * during this startup function.
     */
    SP = (int)&idle_thread_stack[(IDLE_STACK_SIZE_BYTES/2) - 1];

    /**
     * Note: to protect OS structures and data during initialisation,
     * interrupts must remain disabled until the first thread
     * has been restored. They are reenabled at the very end of
     * the first thread restore, at which point it is safe for a
     * reschedule to take place.
     */

    /**
     * Initialise the OS before creating our threads.
     *
     * Note that we cannot enable stack-checking on the idle thread on
     * this platform because we are already using part of the idle
     * thread's stack now as our startup stack. Prefilling for stack
     * checking would overwrite our current stack.
     *
     * If you are not reusing the idle thread's stack during startup then
     * you are free to enable stack-checking here.
     */
    status = atomOSInit(&idle_thread_stack[0], IDLE_STACK_SIZE_BYTES, FALSE);
    if (status == ATOM_OK)
    {

        /* Enable the system tick timer */
        avrInitSystemTickTimer();

        /* Create the main thread */
        status = atomThreadCreate(&main_tcb,
                     MAIN_THREAD_PRIO, main_thread_func, 0,
                     &main_thread_stack[0],
                     MAIN_STACK_SIZE_BYTES,
                     FALSE);
        if (status == ATOM_OK)
        {
            /**
             * Application threads successfully created. It is
             * now possible to start the OS. Execution will not return
             * from atomOSStart(), which will restore the context of
             * our application thread and start executing it.
             *
             * Note that interrupts are still disabled at this point.
             * They will be enabled as we restore and execute our first
             * thread in archFirstThreadRestore().
             */
            atomOSStart();

        }
    }
    while (1)
	{
		atomTimerDelay (2 * SYSTEM_TICKS_PER_SEC); // wait 2 sec

	}
    /* There was an error starting the OS if we reach here */
    return (0);
}
Exemple #28
0
/**
 * Constructs the AHRS class using serial communication and the default update rate,
 * and returning processed (rather than raw) data.
 *<p>
 * This constructor should be used if communicating via either
 * TTL UART or USB Serial interface.
 *<p>
 * @param serial_port_id SerialPort to use
 */
AHRS::AHRS(SerialPort::Port serial_port_id) {
	printf("AHRS Constructor!\n");
    SerialInit(serial_port_id, SerialDataType::kProcessedData, NAVX_DEFAULT_UPDATE_RATE_HZ);
}
Exemple #29
0
void c_main()
{
	int		i;
	bool	autoboot=true;
	char	cmd[128];
	long	timeout;
	int		argc=0;
	char	*argv[MAX_ARGS];
	CMD_TBL	*cptr;
	 
	// initiate status.
	status.terminalSpeed = SERIAL_SPEED;
	status.downloadSpeed = SERIAL_DOWNLOAD_SPEED;

	/* initiate serial and timer */
	// serial and timer init.
	SerialInit(status.terminalSpeed);
         printf("\n\nFFUART has been initiated");

	TimerInit();

	//// printf the required GPL string. //////////////////////////////////////
	printf("\n\n");
	//printf(" "PACKAGE "-" VERSION "\n Copyright 2005 Embedded Group at 211.1010@UESTC\n");
	//printf(" Support:211.1010@UESTC\n");
	printf("\n");

	//MemCpy((char *)KERNEL_DRAM_BASE, (char *)KERNEL_SRAM_BASE, KERNEL_MAX_SIZE);	// kernel image reload

	EthInit();
        //sendtest();

	///// wait 10 seconds before starting autoboot. ///////////////////////////
	printf("Autoboot in progress, press any key to stop ");

	for (i=0; i<3; i++){
		timeout = GetTime()+1;	// 1ÃÊ°£ Delay

		printf(".");
		while (GetTime()<timeout){
			if ((FFLSR & 0x00000001)){	// Serial
				FFRBR;
				autoboot = false;
				break;
			}
		}
		if (autoboot==false) break;
	}


	/* No key was pressed, so proceed booting the kernel. */
	if (autoboot)
	{
		printf("Autoboot started.\n");
		for (cptr=cmdTbl; cptr->cmd; cptr++){
			if (!StrCmp(cptr->cmd, "boot")) break;
		}
		DoBootKernel(cptr, 1, 0);
	}


	/* Key was pressed, so proceed command mode. */
	printf("\nAutoboot aborted\n");
	printf("Type \"help\" to get a list of commands\n");

	// the command loop. endless, of course.
	for(;;) {
		DisplayPrompt("bootloader>");

		// wait an hour to get a command.
		GetCommand(cmd, 128, 3600);
		if (!cmd || !cmd[0]) continue;
		
		argc = GetArgs(cmd, argv);
		for (cptr=cmdTbl; cptr->cmd; cptr++){
			if (!StrCmp(argv[0], cptr->cmd)){
				(cptr->run)(cptr, argc, argv);
				break;
			}
		}
		if (!StrCmp(argv[0], "help") || !StrCmp(argv[0], "?")){
			DoPrintfHelp(argc, argv);
		} else if (!(cptr->cmd)){
			printf("\tUnknown command : %s\n", argv[0]);
		}
	}
} // CMain.
Exemple #30
0
    /**
     * Constructs the AHRS class using serial communication, overriding the
     * default update rate with a custom rate which may be from 4 to 60,
     * representing the number of updates per second sent by the sensor.
     *<p>
     * This constructor should be used if communicating via either
     * TTL UART or USB Serial interface.
     *<p>
     * Note that the serial interfaces can communicate either
     * processed data, or raw data, but not both simultaneously.
     * If simultaneous processed and raw data are needed, use
     * one of the register-based interfaces (SPI or I2C).
     *<p>
     * Note that increasing the update rate may increase the
     * CPU utilization.
     *<p>
     * @param serial_port_id SerialPort to use
     * @param data_type either kProcessedData or kRawData
     * @param update_rate_hz Custom Update Rate (Hz)
     */
AHRS::AHRS(SerialPort::Port serial_port_id, AHRS::SerialDataType data_type, uint8_t update_rate_hz) {
	printf("AHRS Constructor!\n");
    SerialInit(serial_port_id, data_type, update_rate_hz);
}