예제 #1
1
int main ()
{
  int fd;
  unsigned char data=3;


  if ((fd = serialOpen ("/dev/ttyAMA0", 9600))<0)
  {
	fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno));
	return 1;
  }


  printf ("\nRaspberry Pi UART Test \n");
  
  while(1)
  {

	  serialPutchar(fd,data);
//	  printf ("\nPC > RPi = %c", (char)data);
  
//	  serialPutchar(fd, data);
//	  serialPuts(fd, "\n");
	  fflush(stdout);
  }
  

  return 0 ;
}
예제 #2
0
void get_size()
{

  serialPutchar(fd,0x56);
  serialPutchar(fd,0x00);
  serialPutchar(fd,0x34);
  serialPutchar(fd,0x01);
  serialPutchar(fd,0x00);
}
예제 #3
0
static int myAnalogRead (struct wiringPiNodeStruct *node, int pin)
{
  int vHi, vLo ;

  serialPutchar (node->fd, 'a') ;
  serialPutchar (node->fd, pin - node->pinBase) ;
  vHi = serialGetchar (node->fd) ;
  vLo = serialGetchar (node->fd) ;

  return (vHi << 8) | vLo ;
}
예제 #4
0
static void myPinMode (struct wiringPiNodeStruct *node, int pin, int mode)
{
  /**/ if (mode == OUTPUT)
    serialPutchar (node->fd, 'o') ;       // Input
  else if (mode == PWM_OUTPUT)
    serialPutchar (node->fd, 'p') ;       // PWM
  else
    serialPutchar (node->fd, 'i') ;       // Default to input

  serialPutchar (node->fd, pin - node->pinBase) ;
}
예제 #5
0
파일: lcd.c 프로젝트: 0xfebytes/PandoBox
void loadCustomChar(int fd, uint8_t location, uint8_t img[8]){
	int i;
	cmd(fd, CUSTOMCHAR);
	
	// address of customchar (1-8)
	serialPutchar(fd, location);
	
	// load 8 bytes top to bottom
	for (i = 0; i < 8; i++){
		serialPutchar(fd, img[i]);
	}
}
예제 #6
0
파일: serialTest.c 프로젝트: ZH8000/zh800
int main ()
{
  int fd ;
  int count ;
  unsigned int nextTime ;

  if ((fd = serialOpen ("/dev/ttyAMA0", 9600)) < 0)
  {
    fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;
    return 1 ;
  }

  if (wiringPiSetup () == -1)
  {
    fprintf (stdout, "Unable to start wiringPi: %s\n", strerror (errno)) ;
    return 1 ;
  }
      char s1[41] ={ 0xdd, 0xdd, 0xdd, 0xdd, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
                     0x72, 0x68, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
                     0x01, 0x72, 0x68, 0xff, 0xff, 0xff, 0x01, 0x01, 0x01, 0x01,
                     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xee, 0xee, 0xee, 0xee,
                     '\0'};
      char s2[41] ={ 0xdd, 0xdd, 0xdd, 0xdd, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
                     0x02, 0x02, 0x72, 0x68, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
                     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
                     0x02, 0x02, 0x02, 0x72, 0x68, 0x02, 0xee, 0xee, 0xee, 0xee,
                     '\0'};
      

  nextTime = millis () + 3000 ;

  int flag = 0;
  while(1)
  {
    
    if (millis () > nextTime)
    {
      char a = 0x72;
      char b = 0x68;
      nextTime += 3000 ;
      //serialPuts (fd, s1);
      serialPutchar (fd, a);
      serialPutchar (fd, b);
      s1[10] = s1[10] + 1;
      s1[22] = s1[22] + 1;
    }

    //fflush (stdout) ;
  }

  return 0 ;
}
예제 #7
0
void SerialComm::SendData() {
//	unsigned char dataOut[100];
	unsigned char CRC = 0;
//	printf("%d\n", sizeof(sMapOut));
//	memset(&VariablesOut, 0, sizeof(sVarsOut));

//	bufferOut.data.s16[5] = 0;
//	bufferOut.data.s16[6] = 4;
////	printf("%d", dataOut[5]);
//	bufferOut.data.s16[25] = 100;
	printf("%s\n", __FUNCTION__);
	unsigned char u8Retry=0;
//	do {
	serialPutchar(fd, 's');
	CRC = 's';
//	sMapOut *map = &VariablesOut.Names;
//	map->DelayBlower = 45;
//	map->SaunaDelayLight = 99;
//	map->Digital[0] = (1<<0);
//	map->O_Blower = 1;
	for (int i=0; i<90; i++)
	{
		CRC = VariablesOut.Buffer.u8[i]^CRC;
//		printf("%X %x", CRC, VariablesOut.Buffer.u8[i]);
		serialPutchar(fd, VariablesOut.Buffer.u8[i]);
//		printf("%d:%d ", i ,VariablesOut.Buffer.u8[i]);
	}
	printf("\nCRC:%X\n", CRC);
	serialPutchar(fd, CRC);
	for (int i=0; i<3; i++)
	{
//		printf("%d:%d ", i, VariablesOut.Names.Digital[i]);
	}
	for (int i=0; i<42; i++)
	{
//		printf("%d:%d ", i, VariablesOut.Names.Analog[i]);
	}
	for (int i=0; i<3; i++)
	{
		VariablesIn.Names.Digital[i] = VariablesOut.Names.Digital[i];
	}
	for (int i=0; i<42; i++)
	{
		VariablesIn.Names.Analog[i] = VariablesOut.Names.Analog[i];
	}
//	printf("\n");
//	serialPrintf(fd)
	delay(200);
//	u8Retry++;
//	} while ((u8Retry < 3)&&(false == ReadRAW()));
}
예제 #8
0
void change_size()
{
  serialPutchar(fd,0x56);
  serialPutchar(fd,0x00);
  serialPutchar(fd,0x31);
  serialPutchar(fd,0x05);
  serialPutchar(fd,0x04);
  serialPutchar(fd,0x01);
  serialPutchar(fd,0x00);
  serialPutchar(fd,0x19);
  serialPutchar(fd,0x00);
}
예제 #9
0
파일: opt2s.cpp 프로젝트: bhuneshwar21/AUV
void sendchar(char varchar)
{
   int val=varchar;
   fflush(stdout);
   serialPutchar(fd,varchar);
   //printf("send number is: %d\n",val);
}
예제 #10
0
int main ()
{
	int fd,i=0;
	fd= serialOpen("/dev/ttyAMA0",115200);
	if(fd < 0)  { printf("Opening serial failed.\n"); return 0; }

	while(i<10)
	{
		delay(500);
		serialPutchar(fd,i);
		i++;

		//printf("serialDataAvail: %d\n", serialDataAvail(fd));

		if(serialDataAvail(fd) >= 1)
		{
       			printf ("->%d\n", serialGetchar(fd));
       			fflush (stdout);
		}
	}

	printf("Serial port closing.\n");
	serialClose(fd);
	return 0;
}
예제 #11
0
파일: lcdprint.c 프로젝트: zorglub42/tools
int main(int argc, char *argv[]){
        if (argc < 3 ){
                printf("Usage:\nlcdprint line col [text]\n");
                return 1;
        }else{
                int col=atoi(argv[2]);
                if (col<0 || col> 15){
                        printf("col must be between 0 and 15\n");
                        return 2;
                }
                int line=atoi(argv[1]);
                if (line<0 || line> 1){
                        printf("col must be between 0 and 1\n");
                        return 3;
                }
                lcd=serialOpen(SERIAL, BAUD_RATE);
                setLCDCursor(line*16+col);
				if (argc>3){
					int i;
					for (i=3;i<argc;i++){
							serialPuts(lcd, argv[i]);
							if (i<argc-1){
									serialPuts(lcd, " ");
							}
					}
				}else{
					char c;
					while ((c=getchar()) !=255){
						serialPutchar(lcd, c); 
					}
				}
                serialClose(lcd);
                return 0;
        }
}
int main ()
{
    printf("Program started.\n");

    int ser_handle; // the serial connection (file descriptor)

    if ((ser_handle = serialOpen("/dev/ttyAMA0", BAUD_RATE)) < 0)
    {
        fprintf(stderr, "Unable to open serial device: %s\n", strerror(errno));
        return 1 ;
    }
    else
        printf("Serial open\n");

    int counter = 0;

    int avail_bytes;
    for(;;) {
        if(avail_bytes = serialDataAvail(ser_handle))
        {
            serialPutchar(ser_handle,serialGetchar(ser_handle));
            counter = counter + 1;
            if(counter%100 == 0) {
                printf("Byte %i has been passed on\n", counter);
            }
        }
    }
}
예제 #13
0
void Serial::PutChar(unsigned char c){
	if(Open()){
//	std::cout << "Wrote character: " << c << std::endl;
	serialPutchar(this->fd, c);
//	Close();
	}
}
예제 #14
0
void transmit(void)
{
	// Pong every 3 seconds
	if (millis() - time >= 3000) {
		serialPuts(fd0, "Pong!\n");
		serialPuts(fd1, "Pong1!\n");
		serialPuts(fd2, "Pong2!\n");
		// you can also write data from 0-255
		// 65 is in ASCII 'A'
		serialPutchar(fd0, 65);
		serialPutchar(fd1, 65);
		serialPutchar(fd2, 65);
		time = millis();
	}

}
예제 #15
0
void cleanup(void){
  serialPrintf(fd, "%cSDMP", 13);
  for(i = 0; i < 25; i++){
    serialPutchar(fd,0);
  }
  fclose(fp);
  serialClose(fd);
}
예제 #16
0
파일: lcd.c 프로젝트: 0xfebytes/PandoBox
void changeBaud(int fd, uint32_t rate){
	int i = 0;
	while (rate != bauds[i]){
		i++;
	}
	cmd(fd, BAUD);
	serialPutchar(fd, i);
}
예제 #17
0
파일: rs485.cpp 프로젝트: alown/fireworks2
void RS485::puts(char *data, int len)
{
  digitalWrite(DIRPIN, DIR_WRITE);
  usleep(5000);
  for(int i=0; i<len; i++)
    serialPutchar(dev, data[i]);
  usleep(5000);
  digitalWrite(DIRPIN, DIR_READ);
}
예제 #18
0
int main (void)
{
int handle = serialOpen ("/dev/ttyAMA0", 19200); //115200) ;
serialParity(handle,1);
  while(1) {
    serialPutchar(handle,0b10100000);
	usleep (800);
  }

  return 0 ;
}
예제 #19
0
int start_capturing()
{
  serialPutchar(fd,0x56);
  serialPutchar(fd,0x00);
  serialPutchar(fd,0x36);
  serialPutchar(fd,0x01);
  serialPutchar(fd,0x00);

	int i = 0;
	char temp[5];
	char return_val[] = {0x76,0x0,0x36,0x0,0x0};
	while(i<5)
	{
	  temp[i] = serialGetchar(fd);
	  if(temp[i] != return_val[i])
	    return -1;
		i++;
	}
	return 1;
}
예제 #20
0
int drcSetup (const int pinBase, const int numPins, const char *device)
{
  int fd ;
  int ok, tries ;
  time_t then ;
  struct wiringPiNodeStruct *node ;

  if ((fd = serialOpen (device, 115200)) < 0)
    return wiringPiFailure (WPI_ALMOST, "Unable to open DRC device (%s): %s", device, strerror (errno)) ;

  delay (10) ;	// May need longer if it's an Uno that reboots on the open...

// Flush any pending input

  while (serialDataAvail (fd))
    (void)serialGetchar (fd) ;

  ok = FALSE ;
  for (tries = 1 ; tries < 5 ; ++tries)
  {
    serialPutchar (fd, '@') ;
    then = time (NULL) + 2 ;
    while (time (NULL) < then)
      if (serialDataAvail (fd))
      {
        if (serialGetchar (fd) == '@')
        {
          ok = TRUE ;
          break ;
        }
      }
    if (ok)
      break ;
  }

  if (!ok)
  {
    serialClose (fd) ;
    return wiringPiFailure (WPI_FATAL, "Unable to communidate with DRC device") ;
  }

  node = wiringPiNewNode (pinBase, numPins) ;

  node->fd              = fd ;
  node->pinMode         = myPinMode ;
  node->pullUpDnControl = myPullUpDnControl ;
  node->analogRead      = myAnalogRead ;
  node->digitalRead     = myDigitalRead ;
  node->digitalWrite    = myDigitalWrite ;
  node->pwmWrite        = myPwmWrite ;

  return 0 ;
}
예제 #21
0
int serial_writebyte(int serial_id, uint8_t byte)
{
	struct serial_bus *sb = serial_buses[serial_id];
	if(!sb)
		return -1;
	if(sb->fd < 0)
	{
		sb->fd = serialOpen(sb->bus, sb->speed);
	}
	serialPutchar (sb->fd, byte) ;
	return 0;
}
예제 #22
0
파일: ser.c 프로젝트: DexterInd/ArduBerry
int main(void)
{
	int handle = serialOpen ("/dev/ttyAMA0", 9600);	//Open the Serial port
	serialFlush(handle);	//Clear the stream of old data packets
	while(1)
	{	
		serialPutchar (handle, 's');		//Send 's' to the Arduberry
		char inp=serialGetchar(handle);		//Receive the characters from the Arduberry
		printf("%c",inp);
	}
	return 0;
}
예제 #23
0
파일: wpi.c 프로젝트: alepharchives/wpi
static ERL_NIF_TERM
serial_put_char_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    int handle, character;
    if (!enif_get_int(env, argv[0], &handle) ||
        !enif_get_int(env, argv[1], &character))
    {
        return enif_make_badarg(env);
    }
    serialPutchar(handle, (uint8_t)character);
    return atom_ok;
}
예제 #24
0
void WpiEngine::serialWrite()
{
    static unsigned int lastTime  = millis();
    unsigned int thisTime = millis();
    if ( thisTime - lastTime > 60e3 )
    {
        lastTime = thisTime;
        time_t timer = time(NULL);
        unsigned short  thetime         = round( difftime(timer, mktime(&time2016)) * 1000 ) ;

        avgHumidity     = Humidity      / (double) nHumidity;
        avgTemperature  = Temperature   / (double) nTemperature;
        avgPressure     = Pressure      / (double) nPressure;
        avgWind         = Wind          / (double) nWind;

        unsigned short  humidity        = round( avgHumidity * 100 );
        short           temperature     = round( avgTemperature * 100 ) ;
        unsigned short  pressure        = round( avgPressure ) ;
        unsigned short  wind            = round( avgWind * 100 ) ;
        char            winddir         = 0;

        char message[34];
        sprintf(message, "AT+DTX=22,");
        sprintf(message+10, "%04X%04X%04X%04X%04X%02X", thetime, humidity, temperature, pressure, wind, winddir);
        message[32] = '\r';
        message[33] = '\n';

        for (int i=0; i<34; i++)
            serialPutchar (fd, message[i]);

        printf("Sent to serial: %s\n", message);

        windoo_humidity     = avgHumidity;
        windoo_temperature  = avgTemperature;
        windoo_pressure     = avgPressure;
        windoo_wind         = avgWind;
        location_heading    = winddir;

        post();

        Temperature = Wind = Pressure = Humidity = 0;
        nTemperature = nWind = nPressure = nHumidity = 0;
    }

    /*if (serialDataAvail (fd))
    {
      printf (" --> ");
      printf ("%c", serialGetchar (fd));
      while (serialDataAvail (fd)) printf ("%c", serialGetchar (fd)) ;
      printf ("\n");
    }*/
}
예제 #25
0
int send_usart(uint16_t len,uint8_t *data) //id,state1,state2,state3 1=开,0=关,2=保持
{
  uint8_t i=0;
  if(len>100)
  	{
  		printf("send usart failed! len>100");
  		return 1;
  	}
   
  for(i=0;i<len;i++)
    serialPutchar(usart_fd,data[i]);
    return 0;
}
예제 #26
0
int8_t CProtocol::sendAddress(uint8_t address, uint32_t data){
	// Only write if there is a Stream/filedescriptor to write to
#ifdef RaspberryPi
	if(mSerial<0) return-1;
#else //Arduino
	if (mSerial==NULL) return-1;
#endif

	// block buffer for sending
	uint8_t b[6];

	// b[5] has the ‘address’ byte
	b[5] = 0x80 | ((address-1) & 0x3F);

	// fill in the rest of the data, b[0]-b[4] is going to have data
	// in MSB order, e.g. b[4] will have the lowest 7 bits, b[3] the next
	// lowest, etc...
	b[4] = data & 0x7F;

	uint8_t blocks=2;

	// only loop/shift if there's data to put out
	while(data>0x7F) {
		data >>= 7;
		b[6-(++blocks)] = data & 0x7F;
	}

	// if we can fit our highest bits in the first block, add them here
	if((blocks==6) || b[6-blocks] < 8) {
		// add to existing data
	}
	// if not just initialize the next byte
	else b[6-(++blocks)] =  0;

	// add in the block count to lead
	b[6-blocks] |=  0xC0 | (blocks<<3);

	// now write out the data - the blocks array in reverse, which will
	// get your data written out in LSB order
#ifdef RaspberryPi
	for(int i=0;i<blocks;i++){
		serialPutchar (mSerial, b[6-blocks+i]);
	}
#else //Arduino
	// we need to write the buffer as array to work for the Wire library
	mSerial->write(&b[6-blocks],blocks);
#endif

	// return the number of blocks written to the Serial
	return blocks;
}
예제 #27
0
//initialize the GPIO and UART pins for the Raspberry Pi 2
int initGPIO_Uart(void) {

	//manually configure the GPIO pins for inputs or outputs using terminal commands
	//terminal commands: https://projects.drogon.net/raspberry-pi/wiringpi/the-gpio-utility/
	system("gpio mode 0 out"); //set GPIO pin 1 to output (breakBeamLEDOutput pin 17) indicates puck is held by robot
	system("gpio mode 1 out"); //set GPIO pin 1 to output (shootpin pin 18)
	system("gpio mode 3 out"); //set GPIO pin 3 to output (controllerConnectedLEDOutput pin 22)
	system("gpio mode 4 out"); //set GPIO pin 4 to output //GPIO pin 23 output controls the solenoid discrete output
	
	system("gpio mode 2 in"); //set GPIO pin 2 to input //GPIO pin 27 input from break beam (garage-door-like sensor)
	system("gpio mode 5 in"); //set GPIO pin 5 to input //GPIO pin 24 input from break beam (garage-door-like sensor)


	//Initialize the Wiring Pi Libary
	pinMode(breakBeamInput, INPUT);
	pullUpDnControl(breakBeamInput, PUD_UP); // Enable pull-down resistor on button
	pinMode(shutdownPiSwitchInput, INPUT);
	pullUpDnControl(shutdownPiSwitchInput, PUD_DOWN); // Enable pull-down resistor on button
	
	pinMode(breakBeamLEDOutput, OUTPUT);
	pinMode(shootPinOutput, OUTPUT);
	pinMode(controllerConnectedLEDOutput, OUTPUT);
	pinMode(enableAndGateOutput, OUTPUT);


	//initialize the UART @ 19200 BAUD
	if ((UART_ID = serialOpen(UART_TXD0, 19200)) < 0) {
		fprintf(stderr, "Unable to open serial device: %s\n", strerror(errno));
		return 0;
	}

	//Initialize WiringPi -- using Broadcom processor pin numbers
	wiringPiSetupGpio();

	digitalWrite(enableAndGateOutput, HIGH); //enable the AND GATE and allow the UART and breakBeam outputs to turn on

	usleep(2000000); //wait 2 seconds (in microseconds) to act as a power up delay for the Sabertooth Motor Controller
	serialPutchar(UART_ID, 0xAA); //Send the autobauding character to Sabertooth first to stop motors from twitching!
	usleep(100000); //wait 100ms (in microseconds) before commanding motors


	if (wiringPiSetup() == -1) {
		fprintf(stdout, "Unable to start wiringPi: %s\n", strerror(errno));
		return 0;
	}

	printf("Initialized GPIO and UART!\r\n");
	//if return(0), something did not get initialized correctly
}
예제 #28
0
void command_ctl(const char cmd[]) {
	if(strcmp(cmd, "rd!") == 0) {
		// read
		serialPutchar(fd, 114);
		serialPutchar(fd, 100);
		serialPutchar(fd, 33);
	} else if(strcmp(cmd, "vo!") == 0) {
		// ventil open
		serialPutchar(fd, 118);
		serialPutchar(fd, 111);
		serialPutchar(fd, 33);
	} else if(strcmp(cmd, "vo!") == 0) {
		// ventil close
		serialPutchar(fd, 118);
		serialPutchar(fd, 99);
		serialPutchar(fd, 33);
	} else {
		printf("wrong command\n");
	}
}
예제 #29
0
int serial_writebytes(int serial_id, uint8_t *bytes, uint8_t length)
{
	struct serial_bus *sb = serial_buses[serial_id];
	int i;
	if(!sb)
		return -1;
	if(sb->fd < 0)
	{
		sb->fd = serialOpen(sb->bus, sb->speed);
	}
	for (i=0; i<length; i++)
	{
		serialPutchar (sb->fd, bytes[i]);
	}
	return 0;
}
예제 #30
0
파일: lcd.c 프로젝트: 0xfebytes/PandoBox
void setCursor(int fd, uint8_t y, uint8_t x){
	uint8_t pos;
	// line one starts at 0x00 line two at 0x40
	if (y == 1)
		pos = 0x00 + x;
	else if (y == 2)
		pos = 0x40 + x;
	else if (y == 3)
		pos = 0x14 + x;
	else if (y == 4)
		pos = 0x54 + x;
	else
		pos = 0x00 + x;
		
	cmd(fd, POSITION);
	serialPutchar(fd, pos);
}