示例#1
0
文件: main.c 项目: alvarop/cwRoute
int main( int argc, char *argv[] )
{   
  uint8_t serial_buffer[BUFFER_SIZE]; 
  uint8_t packet_buffer[BUFFER_SIZE];
  uint8_t final_buffer[BUFFER_SIZE];  
  //uint8_t adc_sample_buffer[ADC_MAX_SAMPLES];    
  uint16_t buffer_offset = 0;
  uint8_t new_packet = 0;
 
  uint16_t bytes_read = 0;  
  
  // Handle interrupt events to make sure files are closed before exiting
  (void) signal( SIGINT, sigint_handler );

  tx_power = dbm_to_watt(1l);
  target_rssi = dbm_to_watt(-60l);

  // Make sure input is correct
  if( argc < 2 )
  {
    printf("Usage: %s port baudrate\n", argv[0]);
    return 0;
  }  
  
  printf("Power control test\r\n");
  
  // Convert string serial number to integer
  serial_port_number = atoi( argv[1] );
  
 
  // Use RS232 library to open serial port  
  if ( OpenComport( serial_port_number, atoi(argv[2]) ) )
  {
    
    printf("Error opening serial port.\n");
    return 1;
  }
    
  // Flush the port
  while( PollComport( serial_port_number, serial_buffer, BUFFER_SIZE ) );
  
  memset( serial_buffer, 0x00, sizeof(serial_buffer) );
  
  
   
  // Run forever
  for(;;)
  {  
    // Read a buffer full of data (if available)
    bytes_read = PollComport( serial_port_number, serial_buffer, BUFFER_SIZE );
    if( bytes_read > 0 )
    {

      if( bytes_read >= BUFFER_SIZE )
      {
        printf("Uh oh!\n");
      }
      else
      {
        
        memcpy( packet_buffer + buffer_offset, serial_buffer, bytes_read );                        
       
        if ( packet_in_buffer( packet_buffer ) )
        {          
                             
          buffer_offset = 0;
          
          new_packet = 1;
          bytes_read = find_and_escape_packet( packet_buffer, final_buffer );          
          
        } 
        else
        {   
          
          buffer_offset += bytes_read;
          
          if( buffer_offset > BUFFER_SIZE )
          {
            printf("damn...\n");
            memset( packet_buffer, 0x00, sizeof(packet_buffer) );
            memset( serial_buffer, 0x00, sizeof(serial_buffer) );
            buffer_offset = 0;
          }
        }
        
        if( new_packet == 1 )
        {
          
          process_packet( final_buffer );
          
          new_packet = 0;
          memset( packet_buffer, 0x00, sizeof(packet_buffer) );
        }      

      }
    }
    memset( serial_buffer, 0x00, sizeof(serial_buffer) );
    
    // Don't take up all the processor time    
    usleep(20000);
    if( 0 == send_message-- )
    {
      SendByte( serial_port_number, next_power ); // Send initial packet
      send_message = 1;
      
      if(next_power == 0xff)
      {
        printf("*");
      }
      // If no message is received before the next round, use full power
      next_power = 0xff;
    }
  }  

  return 0;
}
示例#2
0
// --- функция отправки файла --------------------------------------------------
bool MainWindow::SendFile(QString FileName)
{
    // отправка маркера начала передачи
    CHAR C_Write = S_MARK;
    DWORD write_counter;
    WriteFile(workPort, &C_Write, 1, &write_counter, NULL);
    C_Write = NAME_MARK;
    WriteFile(workPort, &C_Write, 1, &write_counter, NULL);

    //передача имени файла
    QFileInfo FInfo(FileName);
    QString FName = FInfo.fileName();
    ui->progressBar->setMaximum(FInfo.size());
    int progrProgress = 0;
    logstr = tr("] <font color=blue>отправка файла</font> <b>") + FName + tr("</b>");
    string2log(logstr);
    logstr = tr("] передача имени файла...");
    string2log(logstr);
    byte A;
    short errors = 0;
    CHAR C_Read;
    for(int i = 0; i < FName.size(); i++)
    {
        do {
            C_Read = NO_CHAR;
            A = FName[i].toAscii();
            SendByte(A, workPort);
            ReadFile(workPort, &C_Read, 1, &write_counter, NULL);
            if(C_Read == NO_CHAR) errors++; else errors = 0;
            if(errors == MAX_ERRORS)
            {
                logstr = tr("] <font color=red>слишком много ошибок</font>");
                string2log(logstr);
                return false;
            }
            if(C_Read == B_MARK)
            {
                logstr = tr("] <font color=red>прервано отправителем</font>");
                string2log(logstr);
                C_Write = B_MARK;
                WriteFile(workPort, &C_Write, 1, &write_counter, NULL);
                return false;
            }
           } while(C_Read != A_MARK);
    }
    logstr = tr("] имя файла передано");
    string2log(logstr);
    logstr = tr("] передача самого файла...");
    string2log(logstr);


    // передача файла
    C_Write = DATA_MARK;
    WriteFile(workPort, &C_Write, 1, &write_counter, NULL);
    QFile FileToSend(FileName);
    if (FileToSend.open(QIODevice::ReadOnly))
    {
        char A;
        short errors = 0;
        for(int i=0; i<(FileToSend.size()); i++)
        {
            do {
                C_Read = NO_CHAR;
                QByteArray AByte = "";
                AByte = FileToSend.read(1);
                A = AByte[0];
                SendByte(A, workPort);
                ReadFile(workPort, &C_Read, 1, &write_counter, NULL);
                if(C_Read == NO_CHAR) errors++; else errors = 0;
                if(errors == MAX_ERRORS)
                {
                    logstr = tr("] <font color=red>слишком много ошибок при передаче</font>");
                    string2log(logstr);
                    FileToSend.close();
                    return false;
                }
                if(C_Read == B_MARK)
                {
                    logstr = tr("] <font color=red>передача прервана отправителем</font>");
                    string2log(logstr);
                    C_Write = B_MARK;
                    WriteFile(workPort, &C_Write, 1, &write_counter, NULL);
                    FileToSend.close();
                    return false;
                }
               } while(C_Read != A_MARK);
               progrProgress++;
               ui->progressBar->setValue(progrProgress);
        }
        FileToSend.close();
    }
    C_Write = S_MARK;
    WriteFile(workPort, &C_Write, 1, &write_counter, NULL);
    logstr = tr("] <font color=green>файл передан</font>");
    string2log(logstr);
    return true;
}
示例#3
0
void GrabAndSendCameraData(CvCapture* aCamHandle, int i2c_handle, int skippedFrame, int delayPixelSending, unsigned int idPayloadNum, GPS_DATA *last_data, unsigned char rf_buffer_len) {
    unsigned char frameBuff[645*200], buff_gps_data[40];
    unsigned int i, idPixel;

    //capture camera, skip n frame
    IplImage *img = 0;
    uint8_t cntSkipFrame = 0;
    while (cntSkipFrame < skippedFrame) {
        //grab frame
        img = cvQueryFrame(aCamHandle);
        if (img) cntSkipFrame++;
    }

    //get picture and resize it
    //cvSaveImage("/dev/shm/capture.jpg", img, 0);

    //create image to store
    IplImage *dest = cvCreateImage(cvSize(200, 200), img->depth, img->nChannels);

    //resize it
    cvResize(img, dest, CV_INTER_LANCZOS4);

    //save the resized image
    //~ cvSaveImage("resized.jpg", dest, 0);

    //view pixel info 
    int hcnt, wcnt;

    //method 1:
    //print header paket gambar
    snprintf((char*) frameBuff, 10, "\r%.3d\xff\r", idPayloadNum);
    SendBuf(COM_PORT, frameBuff, 7);
    usleep(RF_DELAY_LESS_PACKET_US);
    
    //print pixel
    idPixel = 0;
    for (hcnt = 0; hcnt < dest->height; hcnt++) { //loop height
        unsigned char* row = &CV_IMAGE_ELEM(dest, unsigned char, hcnt, 0); //row scanline

        //print header frame
        //~ uchar dataTX[4] = {0xff}; //header data
        //~ dataTX[1] = ((hcnt + 1) / 100) + 0x30; //counter height
        //~ dataTX[2] = (((hcnt + 1) % 100) / 10) + 0x30;
        //~ dataTX[3] = ((hcnt + 1) % 10) + 0x30;        
        
        frameBuff[idPixel++] = 0xff;
        frameBuff[idPixel++] = ((hcnt + 1) / 100) + 0x30; //counter height
        frameBuff[idPixel++] = (((hcnt + 1) % 100) / 10) + 0x30;
        frameBuff[idPixel++] = ((hcnt + 1) % 10) + 0x30;

#if VERBOSE==1
        printf("Processing frame #%d\r\n", hcnt + 1);
#endif        

        //send header
        //~ SendBuf(COM_PORT, dataTX, 4);
        //~ usleep(RF_DELAY_LESS_PACKET_US);

        //loop per width
        for (wcnt = 0; wcnt < dest->width * dest->nChannels; wcnt += dest->nChannels) {
			// opencv rgb data sequence = BGR
            //            row[x] = {R,G,B};
			//~ frameBuff[wcnt + 4] = (row[wcnt + 2] == 0xff) ? 0xfe : row[wcnt + 2];
            //~ frameBuff[wcnt + 1 + 4] = (row[wcnt + 1] == 0xff) ? 0xfe : row[wcnt + 1];
            //~ frameBuff[wcnt + 2 + 4] = (row[wcnt + 0] == 0xff) ? 0xfe : row[wcnt + 0];
            frameBuff[idPixel++] = (row[wcnt + 2] == 0xff) ? 0xfe : row[wcnt + 2];
            frameBuff[idPixel++] = (row[wcnt + 1] == 0xff) ? 0xfe : row[wcnt + 1];
            frameBuff[idPixel++] = (row[wcnt + 0] == 0xff) ? 0xfe : row[wcnt + 0];
			
            //~ SendByte(COM_PORT, (row[wcnt + 2] == 0xff) ? 0xfe : row[wcnt + 2]);
            //usleep(5);
            //~ SendByte(COM_PORT, (row[wcnt + 1] == 0xff) ? 0xfe : row[wcnt + 1]);
            //usleep(5);
            //~ SendByte(COM_PORT, (row[wcnt + 0] == 0xff) ? 0xfe : row[wcnt + 0]);
            //usleep(5);
            
            //delay for buffer radio
            //~ if(wcnt%32==0)
				//~ usleep(delayPixelSending);
        }

        //send frame package
        //SendBuf(COM_PORT, frameBuff, 600);

        //delay for transceiver
        //usleep(delayPixelSending);
        
        //get gps data
		//~ GetAndFormatGPSData(i2c_handle, buff_gps_data, last_data);
		GetAndFormatGPSData(i2c_handle, &frameBuff[idPixel], last_data);
	
		//send the gps data
		//~ SendBuf(COM_PORT, buff_gps_data, 18); 
		//~ usleep(2000);
		//~ SendBuf(COM_PORT, &buff_gps_data[18], 19); 
		//~ usleep(RF_DELAY_US);
		
		//delay buffer radio
		//~ usleep(delayPixelSending+2000);
		
		//tail
		//~ snprintf(buff_gps_data, 5, " INA");
		idPixel += 37;
		snprintf(&frameBuff[idPixel], 6, " %s", "GPS");
		idPixel += 4;
		
		//send the data
		//~ SendBuf(COM_PORT, buff_gps_data, 4); 
		
		//~ for(i=0;i<672;i+=32)
		//~ {
			//~ SendBuf(COM_PORT, &frameBuff[i], 32); 
			//~ usleep(RF_DELAY_HALF_DUPLEX_US);
		//~ }
		
		//~ for(i=0;i<672;i++)
		//~ {
			//~ SendByte(COM_PORT, frameBuff[i]); 
			//~ if(i%32==0)
				//~ usleep(RF_DELAY_HALF_DUPLEX_US);
		//~ }
		//~ usleep(50000);
		
		//~ printf("F#%.3d = %.3d\r\n", hcnt, idPixel);
		
		//~ if(hcnt==0) break;
    }
    
    //save to file
    //~ FILE *fp;
	//~ fp=fopen("raw_cam.log", "wb+");
	//~ fwrite(
		//~ frameBuff, 
		//~ sizeof(frameBuff[0]), 
		//~ /* sizeof(frameBuff)/sizeof(frameBuff[0]) */
		//~ idPixel, 
		//~ fp);
	//~ fclose(fp);
    
    //send all data
    printf("Going to send %ld byte with delay %d us\r\n", idPixel, delayPixelSending);  

	//trw433
	#ifdef RADIO_TYPE_TRW433
		for(i=0;i<(idPixel);i++)
		{
			SendByte(COM_PORT, frameBuff[i]); 
			if(i%(rf_buffer_len-1)==0)
				//~ usleep(RF_DELAY_HALF_DUPLEX_US);
				usleep(delayPixelSending);
		}
		
		usleep(RF_DELAY_LESS_PACKET_US);
	#endif
	
	//hm trp
	#ifdef RADIO_TYPE_HMTRP
		for(i=0;i<(idPixel);i++)
		{
			SendByte(COM_PORT, frameBuff[i]); 
			if(i%(32-1)==0)
				//~ usleep(RF_DELAY_HALF_DUPLEX_US);
				usleep(delayPixelSending);
		}
		
		usleep(RF_DELAY_LESS_PACKET_US);
	#endif
}
示例#4
0
VOID
FloppyBootSetup(
    VOID
    )

/*++

Routine Description:

    This routine is invoked to initialize the floppy boot device before any
    other floppy operations are attempted.  This routine performs the following
    operations to initialize the device:

        o  Clear the reset and DMA gate flags in the DOR
        o  Reset the floppy by writing the s/w reset in the DSR
        o  Set the program data rate in the CCR
        o  Issue a sense interrupt command and read the four statuses back
        o  Issue a configure command
        o  Issue a specify command

Arguments:

    None.

Return Value:

    None.

--*/

{

    ULONG i,j;
    //
    // Begin by clearing the reset and DMA gate flags in the DOR.
    //

    WRITE_REGISTER_UCHAR(&FLOPPY_CONTROL->DigitalOutput, 0x0c);

    //
    // Reset the floppy controller by setting the s/w reset bit in the DSR.
    //

    WRITE_REGISTER_UCHAR(&FLOPPY_CONTROL->MsrDsr.DataRateSelect, 0x80);

    //
    // Set the data rate in the CCR.
    //

//    WRITE_REGISTER_UCHAR(&FLOPPY_CONTROL->DirCcr.ConfigurationControl, 0);

    if (FwWaitForDeviceInterrupt(1 << (FLOPPY_VECTOR - DEVICE_VECTORS - 1),
                                 FW_FLOPPY_TIMEOUT)) {
//        FwPrint("Floppy setup timeout\r\n");
        return;
    }


    //
    // Issue the sense interrupt command and read back the status and
    // relative cylinder number from the controller.  This is done for
    // each of the four possible devices.  Note that the output is always
    // ignored.
    //

    for (i = j = 0; i <= 3; i++) {
        SendByte(COMMND_SENSE_INTERRUPT);
        DebugByte[j++] = ReceiveByte();
        DebugByte[j++] = ReceiveByte();
    }

    //
    // Issue the configuration command.
    //

    SendByte( COMMND_CONFIGURE );  // command
    SendByte( 0x00 );           // required 0
    SendByte( 0x58 );           // implied seeks, disable polling & threshold = 8
    SendByte( 0x00 );           // precompensation track = 0

    //
    // Issue the specify command.
    //

    SendByte( COMMND_SPECIFY );    // command
    SendByte( 0xdf );           // step rate time=d, head unload=f
    SendByte( 0x03 );           // head load=1, DMA disabled

    return;
}
/* ============================================================================
// XCH: fVerifySecurity()
// This step is optional. Verifies that the security bits have been written correctly
============================================================================ */
signed char fVerifySecurity(void)
{
	/* unsigned char bBlockNumber = 0;//wly */

	bTargetAddress = 0x00;
#ifdef USE_TP
	SetTPHigh();    /* Only used of Test Points are enabled */
#endif
#ifdef USE_TP
	SetTPLow();    /* Only used of Test Points are enabled */
#endif

	SendVector(verify_security, num_bits_verify_security);
	fIsError = fDetectHiLoTransition();
	if (fIsError)
		return INIT_ERROR;

#ifdef USE_TP
	SetTPHigh();    /* Only used of Test Points are enabled */
#endif

#ifdef USE_TP
	SetTPLow();	/* Only used of Test Points are enabled */
#endif

	SendVector(wait_and_poll_end, num_bits_wait_and_poll_end);

	bTargetAddress = 0x00;
	bTargetDataPtr = 0x00;

	SendVector(tsync_enable, num_bits_tsync_enable);

	SendVector(read_write_setup, num_bits_read_write_setup);

	/* fReadWriteSetup(); */

	/* we do SECURITY_BYTES_PER_BANK * 2 because we bTargetAddress += 2 */
	while (bTargetAddress < (SECURITY_BYTES_PER_BANK * 2)) {
		/* Send Read Byte vector and then get a byte from Target */
		SendVector(read_byte_v, 4);
		/* Set the drive here because SendByte() does not */
		SetSDATAStrong();

		SendByte(bTargetAddress, 7);

		SetSDATAHiZ();     /* Set to HiZ so Target can drive SDATA */
		RunClock(2);       /* Run two SCLK cycles between writing and reading */
		bTargetDataIN = bReceiveByte();

		RunClock(1);
		SendVector(read_byte_v + 1, 1);     /* Send the ReadByte Vector End */

		/* Test the Byte that was read from the Target against the original
		// value (already in the 128-Byte array "abTargetDataOUT[]"). If it
		// matches, then bump the address & pointer,loop-back and continue.
		// If it does NOT match abort the loop and return and error.
		*/

		if (bTargetDataIN != abTargetDataOUT[bTargetDataPtr])
			return BLOCK_ERROR;

		/* Increment the address by two to accomodate 7-Bit addressing
		   (puts the 7-bit address into MSBit locations for "SendByte()").
		 */

		bTargetDataPtr++;
		bTargetAddress += 2;
	}

	SendVector(tsync_disable, num_bits_tsync_disable);

	return PASS;
}
示例#6
0
static BOOLEAN SendByteAck(TCHAR b)
{
   SendByte(b);
   return Ack();
} /* end SendByteAck() */
//============================================================================
int main(int argc, char* argv[])
  {
  printf("Ultra-simple CFA-632 / CFA-634 command-line communications example.\n");
  printf("Crystalfontz America, Inc. http://www.crystalfontz.com\n\n");
  printf("Usage:\n");
  printf("%s PORT BAUD\n",argv[0]);
  printf("PORT is something like \"/dev/ttyS0\" or \"/dev/usb/ttyUSB1\"\n");
  printf("BAUD is 1200, 2400, 4800, 9600 or 19200\n");
  printf("To clear the display, enter \"clear\" as an optional third parameter\n\n");
  

  //If only 0 or 1 parameter is entered, prompt for the missing parameter(s)
  if(argc < 3)
    {
      printf("\nMISSING A PARAMETER. Enter both PORT and BAUD.\n\n");
      return(0);
    }

  //Check for optional "clear" parameter and set flag if found
  int
    cleardisplay=0;
  if((argc > 3) && (!strcmp(argv[3],"clear"))) 
    cleardisplay=1;
 

  int
    baud;
  //default the baud to 19200
  if(!strcmp(argv[2],"1200"))
    baud=1200;
  else
    if(!strcmp(argv[2],"2400"))
      baud=2400;
    else
      if(!strcmp(argv[2],"4800"))
        baud=4800;
      else
        if(!strcmp(argv[2],"9600"))
          baud=9600;
        else
          baud=19200;

  if(Serial_Init(argv[1],baud))
    {
      printf("Could not open port \"%s\" at \"%d\" baud.\n",argv[1],baud);
      return(1);
    }
  else
    printf("\"%s\" opened at \"%d\" baud.\n\n",argv[1],baud);


  //We will try to be tricky, and send out data that will show up correctly
  //on both the 634 and 632.

  //First turn off "scroll" and "wrap"
  SendByte(20);
  SendByte(24);
 
  //Write out the bottom two lines
  //on the 634. The 632 will ignore
  //these lines.

  //Position to line 4, col 1
  SendByte(17);
  SendByte(0);
  SendByte(3);
  if(cleardisplay==1)
    {
                //12345678901234567890
      SendString("                    ");
    }
  else
    {
                //12345678901234567890
      SendString("This is Line 4 *****");
    }

  //Position to line 3, col 1
  SendByte(17);
  SendByte(0);
  SendByte(2);
  if(cleardisplay==1)
    {
                //12345678901234567890
      SendString("                    ");
    }
  else
    {
                //12345678901234567890
      SendString("This is Line 3 *****");
    }


  //Write out top two lines of the 
  //634 and both lines of the 632.

  //Position to line 2, col 1
  SendByte(17);
  SendByte(0);
  SendByte(1);
  if(cleardisplay==1)
    {
                //12345678901234567890
      SendString("                    ");
    }
  else
    {
                //12345678901234567890
      SendString("This is Line 2 *****");
    }

  //Position to line 1, col 1
  SendByte(17);
  SendByte(0);
  SendByte(0);
  if(cleardisplay==1)
    {
                //12345678901234567890
      SendString("                    ");
    }
  else
    {
                //12345678901234567890
      SendString("This is Line 1 *****");
    }

  
  if(cleardisplay==1) printf("Display Cleared.\n");
  printf("Done.\n\n");
  Uninit_Serial();
  return 0;
  }
示例#8
0
文件: main.c 项目: DerGenaue/usbprog
void sendprgstr(char *s)
{
  char c;
  while ((c = PRG_RDB(s++)))
    SendByte(c);
}
void CheckBusy( void )
{
     do   SendByte(0xfc);      //11111,RW(1),RS(0),0
     while(0x80&ReceiveByte());      //BF(.7)=1 Busy
}
示例#10
0
void BioloidBus::SendCheckSum()
{
    SendByte( ~m_checksum );

    WriteBuffer();
}
示例#11
0
void cprintf(const char *text)  /* sends a string to serial port */
{
  while(*text != 0)   SendByte( *(text++));
}
示例#12
0
NS_IMETHODIMP
FCGXStream::NextRequest(PRInt32 *_retval)
{
    //TODO : return a different error code indicating protocol error
    char error[256];

    if (!RecvNextBlock(PR_FALSE)) {
        g_recv.LogProtocolError(mRecvBuf + mRecvOut, mRecvIn - mRecvOut);
        return NS_ERROR_ABORT;
    }

    if (mRecvCurBlockType != bt_BeginRequest) {
        LogFatal("Expected BeginRequest not received.");
        g_recv.LogProtocolError(mRecvBuf + mRecvOut, mRecvIn - mRecvOut);
        CloseConnection(true);
        return NS_ERROR_ABORT;
    }

    // Verify protocol version.
    PRUint16 version = RecvUint16();
    *_retval = RecvByte();
    PRBool bCanHandleRequest = (*_retval == RT_Handler || *_retval == RT_Filter);
    PRBool bCanHandleProtocol = (version == JAXER_PROTOCOL_VERSION || version == 3);
    if (!bCanHandleProtocol)
    {
        sprintf(error, 
            "Connector protocol version (%d) does not match jaxer's (%d).  You need to update the web connector or Jaxer.",
            version, JAXER_PROTOCOL_VERSION);
        LogFatal(error);
    }
    if (!bCanHandleRequest)
    {
        sprintf(error, 
            "Jaxer does not understand the request type (%d).  You need to update the web connector or Jaxer.",
            *_retval);
        LogFatal(error);
    }

    mPostDataAfterEndRequest = PR_FALSE;

    /*
     * Send back a msg indicating whether we are ok to handle the request
     */
    SendBlockType(bt_BeginRequest);
    //SendUint16(JAXER_PROTOCOL_VERSION); // protocol version
    SendUint16(bCanHandleProtocol? version : JAXER_PROTOCOL_VERSION); // protocol version
    SendByte((bCanHandleRequest && bCanHandleProtocol) ? 1 : 0); //whether we can handle the protocol
    if (!bCanHandleRequest || !bCanHandleProtocol)
    {
        //optionally, we can provide error code (INT32, A short text msg)
        if (!bCanHandleProtocol)
        {
            SendUint16(bre_ProtocolVersionMustBeTheSame);
        }else
        {
            SendUint16(bre_CannotHandleRequestType);
        }
        SendUint16(strlen(error));
        SendBytes(error, strlen(error));
    }

    nsresult rc = Flush(!bCanHandleRequest || !bCanHandleProtocol);
    if ( rc != NS_OK) 
        return rc;

    return (mFD != INVALID_SOCKET && (bCanHandleRequest && bCanHandleProtocol))? NS_OK : NS_ERROR_ABORT;
}
/* ----------------CapTouchActiveMode----------------------------------------------
 * Determine immediate gesture based on current & previous wheel position
 *
 *
 *
 *
 *
 *
 *
 * -------------------------------------------------------------------------------*/
void CapTouchActiveMode()
{
  unsigned char idleCounter, activeCounter;
  unsigned char gesture, gestureDetected;
  unsigned char centerButtonTouched = 0;
  unsigned int wheelTouchCounter = WHEEL_TOUCH_DELAY - 1;


  gesture = INVALID_GESTURE;            // Wipes out gesture history

  /* Send status via UART: 'wake up' = [0xBE, 0xEF] */
  SendByte(WAKE_UP_UART_CODE);
  SendByte(WAKE_UP_UART_CODE2);

  idleCounter = 0;
  activeCounter = 0;
  gestureDetected = 0;

  while (idleCounter++ < MAX_IDLE_TIME)
  {
	/* Set DCO to 8MHz */
	/* SMCLK = 8MHz/8 = 1MHz */
//	BCSCTL1 = CALBC1_8MHZ;
//	DCOCTL = CALDCO_8MHZ;
//	BCSCTL2 |= DIVS_3;

	/* SMCLK = 1MHz/4 = 250kHz */
	BCSCTL1 = CALBC1_1MHZ;
	DCOCTL = CALDCO_1MHZ;
	BCSCTL2 |= DIVS_2;
    TACCTL0 &= ~CCIE;

    wheel_position = ILLEGAL_SLIDER_WHEEL_POSITION;
    wheel_position = TI_CAPT_Wheel(&wheel);

    /* Process wheel touch/position/gesture  if a wheel touch is registered*/
    /* Wheel processing has higher priority than center button*/

    if(wheel_position != ILLEGAL_SLIDER_WHEEL_POSITION)
    {
      centerButtonTouched = 0;

      /* Adjust wheel position based: rotate CCW by 2 positions */
      if (wheel_position < 0x08)
      {
         wheel_position += 0x40 - 0x08;
      }
      else
      {
         wheel_position -= 0x08;
            /* Adjust wheel position based: rotate CCW by 2 positions */
      }

      wheel_position = wheel_position >>2;  // divide by four

      gesture = GetGesture(wheel_position);

      /* Add hysteresis to reduce toggling between wheel positions if no gesture
       * has been TRULY detected. */

      if ( (gestureDetected==0) && ((gesture<=1) || (gesture==0x11) || (gesture==0x10)))
      {
        if (last_wheel_position != ILLEGAL_SLIDER_WHEEL_POSITION)
            wheel_position = last_wheel_position;
        gesture = 0;
      }

      /* Turn on corresponding LED(s) */
      P1OUT = (P1OUT & BIT0) | LedWheelPosition[wheel_position];


      if ((gesture != 0) && (gesture != 16) && (gesture != INVALID_GESTURE))
      { /* A gesture has been detected */

        if (gestureDetected ==0)
        { /* Starting of a new gesture sequence */
          gestureDetected = 1;

          /* Transmit gesture start status update & position via UART to PC */
          SendByte(GESTURE_START);
          SendByte(last_wheel_position + GESTURE_POSITION_OFFSET);
        }

        /* Transmit gesture & position via UART to PC */
        SendByte(gesture);
        SendByte(wheel_position + GESTURE_POSITION_OFFSET);
      }
      else
        if (gestureDetected==0)
        { /* If no gesture was detected, this is constituted as a touch/tap */
          if (++wheelTouchCounter >= WHEEL_TOUCH_DELAY)
          {
          	/* Transmit wheel position [twice] via UART to PC */
          	wheelTouchCounter = 0;
          	SendByte(wheel_position + WHEEL_POSITION_OFFSET );
          	SendByte(wheel_position + WHEEL_POSITION_OFFSET );
          }
        }
       	else
          wheelTouchCounter = WHEEL_TOUCH_DELAY - 1;

      idleCounter = 0;                      // Reset idle counter
      activeCounter++;
      last_wheel_position = wheel_position;
    }
    else
    { /* no wheel position was detected */

      if(TI_CAPT_Button(&middle_button))
示例#14
0
static int
writeByteToSerial(unsigned int byt) {
  return SendByte(SERIAL_PORT, byt);
}
示例#15
0
static int BlockReceive( byte *err, trap_elen max_len, byte *p )
{
    byte            buffer[8];     /* storing bytes other than actual data from blocks */
    trap_elen       i;             /* loop index */
    trap_elen       len;
    word            crc_val;
    unsigned        blkno;
    int             c;
    int             wait;

    ZeroWaitCount();
    BytesReceived = 0;
    wait = (MaxBaud == MIN_BAUD) ? SEC(1)/2 : SEC(1)/4;
    /* Receiving bytes before actual data (up to err byte) */
    for( i = 1; i <= 7; ++i ) {
        c = WaitByte( wait );
        if( c == SDATA_NO_DATA ) {    /* time-out error */
            LastResponse = SDATA_NAK;
            SendByte( SDATA_NAK );  /* send NAK to request resending of block */
            return( FAIL );
        }
        buffer[i] = c;
    }

    len = (buffer[MLEN+1] << 8) | buffer[MLEN];   /* number of data bytes */
    if( len > max_len ) {        /* not enough buffer space to store data */
        ClearCom();
        return( FAIL );
    }

    /* Receiving actual data bytes */
    for( i = 0; i < len; ++i ) {
        c = WaitByte( wait );
        if( c == SDATA_NO_DATA ) {    /* time-out error */
            LastResponse = SDATA_NAK;
            SendByte( SDATA_NAK );  /* send NAK to request resending of block */
            return( FAIL );
        }
        p[i] = c;
    }

    /* Receiving the last byte: ETX */
    buffer[0] = WaitByte( wait );
    if( buffer[0] != SDATA_ETX ) {    /* time-out error */
        LastResponse = SDATA_NAK;
        SendByte( SDATA_NAK );  /* send NAK to request resending of block */
        return( FAIL );
    }

    *err = buffer[MERR];            /* storing command byte */
    blkno = (buffer[MBLKNO+1] << 8) | buffer[MBLKNO];  /* blk# received */
    crc_val = (buffer[MCRC+1] << 8) | buffer[MCRC];  /* crc received */

    if( CRC( &buffer[MBLKNO], len, p ) != crc_val ) {   /* CRC error */
        LastResponse = SDATA_NAK;
        SendByte( SDATA_NAK );  /* send NAK to request resending of block */
        return( FAIL );
    }

    if( ReceiveBlkNo != blkno ) {      /* incorrect block */
        ClearCom();
        LastResponse = SDATA_ACK;
        SendByte( SDATA_ACK );
        return( FAIL );
    }

    /* Block received successfully */
    LastResponse = SDATA_ACK;
    SendByte( SDATA_ACK );
    ++ReceiveBlkNo;
    BytesReceived = len;
    return( SUCCESS );
}
unsigned char ReadData( void )
{
     CheckBusy();
     SendByte(0xfe);            //11111,RW(1),RS(1),0
     return ReceiveByte();
}
示例#17
0
static char *SetupModem( char *parm )
{
    char        *start;
    unsigned    wait;
    unsigned    ch;
    int         data;

    Baud( MaxBaud );
    wait = SEC(3);
    while( *parm == ' ' && *parm == '\t' ) ++parm;
    if( *parm == '\0' ) return( NULL );
    for( ;; ) {
        if( *parm == '(' ) {
            start = ++parm;
            for( ;; ) {
                ch = *parm;
                if( ch == '\0' ) goto done;
                ++parm;
                if( ch == ')' ) break;
                if( ch == '\\' ) {
                    ch = *parm++;
                    switch( ch ) {
                    case '\0':
                        return( TRP_ERR_invalid_modem_string );
                    case 'r':
                        ch = '\r';
                        break;
                    case 'n':
                        ch = '\n';
                        break;
                    }
                }
                data = WaitByte( wait );
                if( data == SDATA_NO_DATA ) {
                    if( wait != SEC(60) ) {
                        wait = SEC(60);
                    } else {
                        return( TRP_ERR_timeout_on_modem_string );
                    }
                    --parm;
                } else {
                    wait = SEC(3);
                    if( data != ch ) parm = start;
                }
            }
        } else {
            Wait( SEC(1)/5 );
            for( ;; ) {
                ch = *parm;
                if( ch == '\0' ) goto done;
                if( ch == '(' ) break;
                ++parm;
                if( ch == '\\' ) {
                    ch = *parm++;
                    switch( ch ) {
                    case '\0':
                        return( TRP_ERR_invalid_modem_string );
                    case '`':
                        Wait( 1 );
                        break;
                    case '~':
                        Wait( SEC(1) );
                        break;
                    case 'r':
                        SlowSend( '\r' );
                        Wait( SEC(1)/2 );
                        break;
                    case 'n':
                        SlowSend( '\n' );
                        break;
                    default:
                        SlowSend( ch );
                        break;
                    }
                } else {
                    SlowSend( ch );
                }
            }
        }
    }
done:
#ifdef SERVER
  #define SEND_CHAR     '='
  #define EXPECT_CHAR   '-'
#else
  #define SEND_CHAR     '-'
  #define EXPECT_CHAR   '='
#endif
    wait = 1;
    for( ;; ) {
        data = WaitByte( wait );
        if( data == EXPECT_CHAR ) break;
        if( data == SDATA_NO_DATA ) {
            if( wait != SEC(10) ) {
                wait = SEC(10);
                SendByte( SEND_CHAR );
            } else {
                return( TRP_ERR_modem_failed_connection );
            }
        }
    }
    if( wait != SEC(10) )
        SendByte( SEND_CHAR );
    return( NULL );
}
示例#18
0
static void SendIndex( unsigned short Index)
{
    SendStartByte( 0, 0);
    SendByte( (Index>>8));
    SendByte( (Index&0xFF));
}
示例#19
0
文件: Lcd.c 项目: mingv150/Project
/****************************************************************************
Function: Name
Description:查询LCD是否处于忙状态
Input:
Output:
Notes:
*****************************************************************************/
static void Lcd_CheckBusy(void)
{
     do   SendByte(0xfc);         
     while(0x80&ReceiveByte());       //BF(.7)=1 Busy
}
示例#20
0
static void SendData( unsigned short Data)
{
    SendStartByte( 0, 1);
    SendByte( (Data>>8));
    SendByte( (Data&0xFF));
}
 /******************坐标系***************/
void SpaceCreate(float A[3][3])
{
	int idata i,a,b,c,ap,bp,cp;
	VECTOR idata test[3];
	float idata temp;
	GetAll(&ap,&bp,&cp);
	for(i=0;i<3;i++)
	{
		GetAll(&a,&b,&c);
		delay(70);
		if( abs(ap-a)<10 && abs(bp-b)<10 && abs(cp-c)<10 )
		{
			 test[i].a=a;
			 test[i].b=b;
			 test[i].c=c;
		}
		else
			i--;
		ap=a;
		bp=b;
		cp=c;
	}
	//x暂时借作为临时变量,算标准化过的z
	A[0][0]=-(test[0].a+test[1].a+test[2].a)/3;
	A[0][1]=-(test[0].b+test[1].b+test[2].b)/3;
	A[0][2]=-(test[0].c+test[1].c+test[2].c)/3;
	temp=sqrt(A[0][0]*A[0][0]+A[0][1]*A[0][1]+A[0][2]*A[0][2]);
	A[2][0]=A[0][0]/temp;
	A[2][1]=A[0][1]/temp;
	A[2][2]=A[0][2]/temp;

	GetAll(&a,&b,&c);
	i=0;
	test[0].a=0;
	test[0].b=0;
	test[0].c=0;
	while( 1 )
	{
		if( i<10
			&& abs(a-ap)<20 && abs(b-bp)<20 && abs(c-cp)<20 
			&& (abs(a+A[0][0])>130 || abs(b+A[0][1])>130 || abs(c+A[0][2])>130)
			)
		{
			test[0].a+=a;
			test[0].b+=b;
			test[0].c+=c;
			i++;
		}
		if(i==10)
			break;	
		ap=a;	bp=b;	cp=c;
		GetAll(&a,&b,&c);
		delay(50);
	}

	//第一下变化方向
	A[1][0]=test[0].a/10+A[0][0];
	A[1][1]=test[0].b/10+A[0][1];
	A[1][2]=test[0].c/10+A[0][2];
	//X轴正向
	A[0][0]=A[1][1]*A[2][2]-A[2][1]*A[1][2];
	A[0][1]=A[1][2]*A[2][0]-A[2][2]*A[1][0];
	A[0][2]=A[1][0]*A[2][1]-A[2][0]*A[1][1];
	//X轴标准化
	temp=sqrt(A[0][0]*A[0][0]+A[0][1]*A[0][1]+A[0][2]*A[0][2]);
	A[0][0]=A[0][0]/temp;
	A[0][1]=A[0][1]/temp;
	A[0][2]=A[0][2]/temp;
	//Y轴标准化
	A[1][0]=A[2][1]*A[0][2]-A[0][1]*A[2][2];
	A[1][1]=A[0][2]*A[2][2]-A[2][0]*A[0][2];
	A[1][2]=A[2][0]*A[0][1]-A[0][0]*A[2][1];
	SendByte('K');
}
示例#22
0
void NcrComPort::ClearText()
{
	SendByte(0x1B);
	SendByte(0x02);
}
/* ============================================================================
// fEraseBlock()
// Perform a block erase of the target device.
// Returns:
//     0 if successful
//     ERASE_ERROR if timed out on handshake to the device.
============================================================================*/
signed char fEraseBlock(unsigned char bBlockNumber)
{
	unsigned char bTargetDataPtr = 0;
	SendVector(tsync_enable, num_bits_tsync_enable);

	SendVector(read_write_setup, num_bits_read_write_setup);

	/* Set SDATA to Strong Drive here because SendByte() does not */
	SetSDATAStrong();

	/* Transfer the temporary RAM array into the target.
	// In this section, a 128-Byte array was specified by #define, so the entire
	// 128-Bytes are written in this loop.
	*/
	bTargetAddress = 0x00;

	while (bTargetDataPtr < TARGET_DATABUFF_LEN) {
		SendByte(write_byte_start, 4);	/* we need to be able to write 128 bytes from address 0x80 to 0xFF*/
		SendByte(bTargetAddress, 7);	 /* we need to be able to write 128 bytes from address 0x80 to 0xFF*/
		SendByte(0, 8);			 /* load 0x00 */
		SendByte(write_byte_end, 3);

		/* !!!NOTE:
		// SendByte() uses MSbits, so inc by '2' to put the 0..128 address into
		// the seven MSBit locations.
		//
		// This can be confusing, but check the logic:
		//   The address is only 7-Bits long. The SendByte() subroutine will
		// send however-many bits, BUT...always reads them bits from left-to-
		// right. So in order to pass a value of 0..128 as the address using
		// SendByte(), we have to left justify the address by 1-Bit.
		//   This can be done easily by incrementing the address each time by
		// '2' rather than by '1'.
		*/

		bTargetAddress += 2;	/* inc by 2 in order to support a 128 byte address space */
		bTargetDataPtr++;
	}

	SendVector(set_block_num, num_bits_set_block_num);

	/* Set the drive here because SendByte() does not. */
	SetSDATAStrong();
	SendByte(bBlockNumber, 8);
	SendByte(set_block_num_end, 3);

	SendVector(tsync_disable, num_bits_tsync_disable);

	/* Send the program-and-verify vector. */
	SendVector(program_and_verify, num_bits_program_and_verify);
	/* wait for acknowledge from target. */
	fIsError = fDetectHiLoTransition();
	if (fIsError)
		return BLOCK_ERROR;

	/* Send the Wait-For-Poll-End vector */
	SendVector(wait_and_poll_end, num_bits_wait_and_poll_end);
	/*----------------------------------------------------------------
	// XCH: the lines below actually implement the erase SROM function
	// however, Product Engineering recommends using the WRITE SROM
	// function instead and write all '0' to the block.  The function
	// below is saved for possible future implementation
	 */

	/*    SendVector(tsync_enable, num_bits_tsync_enable);

	//    SendVector(set_block_num, num_bits_set_block_num);

	// Set the drive here because SendByte() does not.
	//    SetSDATAStrong();
	//    SendByte(bBlockNumber,8);
	//    SendByte(set_block_num_end, 3);

	//    SendVector(tsync_disable, num_bits_tsync_disable);

	// Send the erase-block vector.
	//    SendVector(erase_block, num_bits_erase_block);

	// wait for acknowledge from target.
	//    if (fIsError == fDetectHiLoTransition()) {
	//        return(BLOCK_ERROR);
	//    }

	// Send the Wait-For-Poll-End vector
	//    SendVector(wait_and_poll_end, num_bits_wait_and_poll_end);
	//-----------------------------------------------------------------
	 */
	return PASS;
}
示例#24
0
void NcrComPort::SendString(const char *str)
{
	while (*str) {
		SendByte(*str++);
	}
}
示例#25
0
void cprintf(int comport_number, const char *text)  /* sends a string to serial port */
{
  while(*text != 0)   SendByte(comport_number, *(text++));
}
int main()
{
	MYSQL* con ;
	MYSQL_RES * res ;
	MYSQL_ROW row ;

    con = mysql_init(NULL);
	
   char *server = "localhost";
   char *user = "******";
   char *password = "******"; /* set me first */

   char *database = "zandu";


	// initiate the com port 
  int i, n,cport_nr=16,/* /dev/ttyS0 (COM1 on windows) */  bdrate=9600;       /* 9600 baud */
  if(OpenComport(cport_nr, bdrate))
  {
    printf("Can not open comport\n");

    return(0);
  }

 // initiate the mysql connection
   if (!mysql_real_connect(con, server,user, password, database, 0, NULL, 0)) {
      fprintf(stderr, "%s\n", mysql_error(con));
      exit(1);
   }

    //start the main logic

	char query[100] ;
	char * storeTime  = (char *)malloc(100);
	char * timeFormat = (char *)malloc(100);
	timeFormat = "%Y-%m-%d %T";

	
	
	
	//sprintf(query,"select * from SendToBot order by timestampdiff(microsecond,time_stamp,current_timestamp) desc");
	sprintf(query,"select * from sendtobot");

	 /* send SQL query */
   if (mysql_query(con, query)) 
   {
      fprintf(stderr, "%s\n", mysql_error(con));
      exit(1);
   }
   i = 0 ;
   int j =  0;

	while(1)
    {
		res = mysql_use_result(con);
		while( (row = mysql_fetch_row(res) ) != NULL )
		{
			
			printf("%s\t %s\t %d \t %s\n",row[0],row[3],i,row[2]);

			int n , j ;
			
			int length = strlen(row[0]);
			
			for(j = 0 ; j < length  ; j ++)
			{
				n = SendByte(cport_nr,row[0][j]) ;
				
			}
			
			n = SendByte(cport_nr,':') ;	//To seperate ID from Command 
			
			length = strlen(row[3]);

			for(j = 0 ; j < length  ; j ++)
			{
				n = SendByte(cport_nr,row[3][j]) ;
				
			}
			
			//n = SendBuf(cport_nr,row[3],2) ;
            i ++ ;		
			strcpy(storeTime,row[2]) ;	
		}
		
		
		sprintf(query,"delete from sendtobot where time_stamp <= \"%s\"",storeTime);
		if (mysql_query(con,query)) 
		{
      		fprintf(stderr, "%s\n", mysql_error(con));
		    exit(1);
   		}
		
		mysql_free_result(res);
		
		sprintf(query,"select * from sendtobot order by timestampdiff(microsecond,time_stamp,str_to_date(\'%s\',\'%s\'))desc;",storeTime,timeFormat);
		//sprintf(query,"select * from sendtobot");
		if (mysql_query(con,query)) 
		{
      		fprintf(stderr, "%s\n", mysql_error(con));
		    exit(1);
   		}


   	}
  
}
// ============================================================================
// PTJ: fReadSecurity()
// This reads from SM0 with Read Supervisory SPC command.
// Need to have SPC Test Mode enabled before using these commands?
// Returns:
//     0 if successful
//     __________ if timed out on handshake to the device.
// ============================================================================
signed char fReadSecurity(void)
{
	SendVector(ReadSecuritySetup, num_bits_ReadSecuritySetup);
//      SendVector(SPCTestMode_enable, num_bits_SPCTestMode_enable);

	bTargetAddress = 0x00;
	while (bTargetAddress < (SECURITY_BYTES_PER_BANK * 2)) {	//PTJ: we do SECURITY_BYTES_PER_BANK * 2 because we bTargetAddress += 2

		//PTJ: TSYNC Enable
		SendVector(tsync_enable, num_bits_tsync_enable);

		SendVector(read_security_pt1, num_bits_read_security_pt1);	//PTJ:
		// Set the drive here because SendByte() does not.
		SetSDATAStrong();
		SendByte(bTargetAddress, 7);	//PTJ: hardcode MSb of address as 0 in bit stream
		SendVector(read_security_pt1_end,
			   num_bits_read_security_pt1_end);

		//PTJ: TSYNC Disable
		SendVector(tsync_disable, num_bits_tsync_disable);

		SendVector(read_security_pt2, num_bits_read_security_pt2);

		SendVector(wait_and_poll_end, num_bits_wait_and_poll_end);

		SendVector(read_security_pt3, num_bits_read_security_pt3);

		SetSDATAStrong();
		SendByte(bTargetAddress, 7);

		SendVector(read_security_pt3_end,
			   num_bits_read_security_pt3_end);

		SendVector(wait_and_poll_end, num_bits_wait_and_poll_end);

		bTargetAddress += 2;
	}

	bTargetAddress = 0x00;
	bTargetDataPtr = 0x00;

	SendVector(tsync_enable, num_bits_tsync_enable);	//PTJ: 307, added for tsync testing
	while (bTargetAddress < (SECURITY_BYTES_PER_BANK * 2)) {	//PTJ: we do SECURITY_BYTES_PER_BANK * 2 because we bTargetAddress += 2

		//Send Read Byte vector and then get a byte from Target
		SendVector(read_byte_v, 4);
		// Set the drive here because SendByte() does not
		SetSDATAStrong();
		SendByte(bTargetAddress, 7);

		RunClock(2);	// Run two SCLK cycles between writing and reading
		SetSDATAHiZ();	// Set to HiZ so Target can drive SDATA
		bTargetDataIN = bReceiveByte();

		RunClock(1);
		SendVector(read_byte_v + 1, 1);	// Send the ReadByte Vector End

		// Test the Byte that was read from the Target against the original
		// value (already in the 128-Byte array "abTargetDataOUT[]"). If it
		// matches, then bump the address & pointer,loop-back and continue.
		// If it does NOT match abort the loop and return and error.
		if (bTargetDataIN != abTargetDataOUT[bTargetDataPtr])
//            return(BLOCK_ERROR);

			// Increment the address by two to accomodate 7-Bit addressing
			// (puts the 7-bit address into MSBit locations for "SendByte()").
			bTargetDataPtr++;
		bTargetAddress += 2;
	}

	SendVector(tsync_disable, num_bits_tsync_disable);	//PTJ: 307, added for tsync testing
	return (PASS);
}
示例#28
0
static int BlockSend( trap_elen num, byte *p, unsigned timeout )
{
    word            crc_value;          /* crc value of block */
    unsigned        wait_time;          /* timer for testing time-out */
    trap_elen       i;                  /* loop index */
    int             reply;              /* reply message from other machine */
    unsigned char   crc_low, crc_hi;
    unsigned char   len_low, len_hi;
    byte            extra[3];           /* ..[0]=blkno_low, ..[1]=blkno_hi, ..[2]=err */
    unsigned        wait;

    ZeroWaitCount();
    extra[2] = PrevErrors = Errors;
    if( Errors > 255 ) {
        extra[2] = 255;       /* because it is a char, not an int */
    }
    Errors = 0;

    ClearCom();
    /* compose send buffer contents */
    len_low = num & 0xff;              /* low 8 bits of data block length */
    len_hi  = num >> 8;                /* high 8 bits of data block length */
    extra[0] = SendBlkNo & 0xff;      /* low 8 bits of send block no */
    extra[1] = SendBlkNo >> 8;        /* high 8 bits of send block no */
    crc_value = CRC( extra, num, p );  /* calculate crc for (blk#+err+data) */
    crc_low = crc_value & 0xff;        /* low 8 bits of crc_value */
    crc_hi  = crc_value >> 8;          /* high 8 bits of crc_value */

    wait = (MaxBaud == MIN_BAUD) ? SEC(2) : SEC(1);
    for( ;; ) {                 /* send block loop */
        /* send the block */
        StartBlockTrans();
        SendByte( SDATA_STX );
        SendByte( crc_low );
        SendByte( crc_hi );
        SendByte( len_low );
        SendByte( len_hi );
        SendByte( extra[0] );      /* blkno_low */
        SendByte( extra[1] );      /* blkno_hi */
        SendByte( extra[2] );      /* err */
        for( i = 0; i < num; ++i ) {
            SendByte( p[i] );
        }
        SendByte( SDATA_ETX );
        StopBlockTrans();

        wait_time = WaitCount() + timeout;
        for( ;; ) {                 /* wait proper acknowledgement loop */
            reply = WaitByte( wait );          /* receive reply */
            if( reply == SDATA_NO_DATA ) {
                if( (timeout != FOREVER) && (WaitCount() >= wait_time) ) {
                    return( FAIL );    /* time-out */
                } else {
                    SendByte( SDATA_RLR );     /* request last response */
                    ++Errors;            /* increment error counter */
                }
            } else {
                if( reply == SDATA_ACK ) {
                    ++SendBlkNo;
                    return( SUCCESS );    /* done, exit from BlockSend() */
                } else if( reply == SDATA_NAK ) {  /* unsuccessful, re-send block */
                    ++Errors;
                    break;     /* break out of acknowledgement loop;
                                  i.e. back to send block loop */
                } else if( reply == SDATA_RLR ) {  /* request last response */
                    SendByte( LastResponse );
                    break;     /* break out ackno loop; re-send block */
                } else {       /* things are totally messed up */
                    while( WaitByte( SEC(3)/4 ) != SDATA_NO_DATA )
                        ;             /* discard all characters sent */
                    SendByte( SDATA_RLR );     /* request last response */
                    ++Errors;
                }
            }
        }
    }
}
示例#29
0
void GetAndSendAccGyro(int i2c_handle, int i2c_acc_addr, int i2c_gyro_addr, unsigned int idPayloadNum, unsigned int delaySend, GPS_DATA *last_data, unsigned char rf_buffer_len )
{
	unsigned int gxvalue, gyvalue, gzvalue, gyrox, gyroy, gyroz;
	unsigned char buff_data[100], buff_gps_data[40];
	
	//tes clock length
	//clock_t c0,c1,c2;
	//double el1,el2;
	
	//c0 = clock();
	
	//set buff to all 0
	memset(buff_data,0,100);
	
	//get g data
	adxl345_get_gdata(i2c_handle, i2c_acc_addr, &gxvalue, &gyvalue, &gzvalue);
	
	//c1 = clock();
	
	//get gyro
	itg3200_get_gyro_data(i2c_handle, i2c_gyro_addr, &gyrox, &gyroy, &gyroz);
	
	//c2 = clock();
	
	//duration
	//el1 = ((double) c1-c0) / CLOCKS_PER_SEC;
	//el2 = ((double) c2-c1) / CLOCKS_PER_SEC;
	//printf("t1 = %f\t t2 = %f\n", el1, el2);
	
	//print g and gyro data
	//printf("\r%.3d %.3d %.3d %.3d %.3d %.3d %.3d %.3d",idPayloadNum, adxl345_normalize_gdata(adxl345_calc_gvalue(gxvalue), 0, 999) , adxl345_normalize_gdata(adxl345_calc_gvalue(gyvalue), 0, 999), adxl345_normalize_gdata(adxl345_calc_gvalue(gzvalue),0,999),itg3200_normalize_gyrodata(itg3200_calc_gyro_value(gyrox), 0, 999) , itg3200_normalize_gyrodata(itg3200_calc_gyro_value(gyroy), 0, 999), itg3200_normalize_gyrodata(itg3200_calc_gyro_value(gyroz),0,999), idPayloadNum);
	
	//c0 = clock();
	
	//format the data header+gyro acc
	snprintf(buff_data, 34, "%c%.3d %.3d %.3d %.3d %.3d %.3d %.3d ",
	13,
	idPayloadNum, 
	adxl345_normalize_gdata(adxl345_calc_gvalue(gxvalue), 0, 999) , 
	adxl345_normalize_gdata(adxl345_calc_gvalue(gyvalue), 0, 999), 
	adxl345_normalize_gdata(adxl345_calc_gvalue(gzvalue),0,999),
	itg3200_normalize_gyrodata(itg3200_calc_gyro_value(gyrox), 0, 999) , 
	itg3200_normalize_gyrodata(itg3200_calc_gyro_value(gyroy), 0, 999), 
	itg3200_normalize_gyrodata(itg3200_calc_gyro_value(gyroz),0,999)
	);
	
	//c1 = clock();
	
	//~ printf("%s", buff_data);
	
	//send the data
	//~ SendBuf(COM_PORT, buff_data, 29); 
	//~ cprintf(COM_PORT, buff_data);
	
	//~ usleep(delaySend);
	
	//get gps data
	//~ GetAndFormatGPSData(i2c_handle, buff_gps_data, last_data);
	GetAndFormatGPSData(i2c_handle, &buff_data[29], last_data);
	
	//send the gps data
	//~ SendBuf(COM_PORT, buff_gps_data, 37); 
	
	//~ usleep(RF_DELAY_US);
	
	//tail
	//~ snprintf(buff_data, 5, " %.3d",	idPayloadNum);
	//~ snprintf(&buff_data[64], 35, " %26.3s%4.3dX", ID_NAME, idPayloadNum);
	snprintf(&buff_data[66], 35, " %3.3s%4.3d", ID_NAME, idPayloadNum);
	
	//send the data
	//~ SendBuf(COM_PORT, buff_data, 4); 
	
	//c2 = clock();
	//el1 = ((double) c1-c0) / CLOCKS_PER_SEC;
	//el2 = ((double) c2-c1) / CLOCKS_PER_SEC;
	//printf("t1 = %f\t t2 = %f\n", el1, el2);
	
	//~ buff_data[0] = '\n';
	//~ printf("%s\n", buff_data);
	//~ buff_data[0] = '\r';
	
	unsigned int i;
	//~ for(i=0;i<96;i+=32)
	//~ {
		//~ SendBuf(COM_PORT, &buff_data[i], 32); 
		//~ usleep(delaySend);
	//~ }

	//for trw433
	#ifdef RADIO_TYPE_TRW433
		for(i=0;i<74;i++)
		{
			SendByte(COM_PORT,  buff_data[i]); 
			//~ if(i%(rf_buffer_len-1)==0)
			if(i%(16-1)==0)
				usleep(delaySend);
		}
	#endif
	
	//for hm-trp
	#ifdef RADIO_TYPE_HMTRP
		for(i=0;i<74;i++)
		{
			SendByte(COM_PORT,  buff_data[i]); 
			//~ if(i%(rf_buffer_len-1)==0)
			if(i%(32-1)==0)
				usleep(delaySend);
		}
	#endif
	
	//~ SendByte(COM_PORT,  13); 
	//~ SendByte(COM_PORT,  'A'); 
	
	usleep(delaySend);
}
示例#30
0
//Not in use for sending NMEA sentences through the serial port
void SerialPort::writeByte(unsigned char byte) {
    if(open) {
        SendByte(portNumber, byte);
    }

}