예제 #1
0
uint8_t WaspGPRS::sendDataFTP(char* file, char* path, uint8_t id)
{
	char command[100];
	char aux='"';
	long previous=0;
	uint8_t answer=0;
	uint8_t end=0;
	uint32_t i,j=0;
			
	sprintf(command,"AT%s%c,,%c%c,%c%s%c,0%c%c", AT_FTP_SEND, id, aux, aux, aux, file, aux, '\r', '\n');
	printString(command,PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("CONNECT",20,0,0);
	if(answer!=1) return 0;
		
	serialFlush(PORT_USED);
		
	Utils.strExplode(path,'/');
	while( path[i]!='\0' )
	{
		if( path[i]== '/' ) j++;
		i++;
	}
	i=0;
	
	SD.ON();
	
	while( j>0 )
	{
		if(!SD.cd(Utils.arguments[i])){
			SD.OFF();
			return 0;
		}
		i++;
		j--;
	}
	i=0;
	j=0;
	while( !end )
	{
		printString(SD.cat(file,250*i,250),PORT_USED);
		while( SD.buffer[j]!='\0' ) j++;
		if( j<249 ) end=1;
		i++;
		j=0;
	}
	printString(GPRS_PATTERN,PORT_USED);
		
	SD.OFF();
	
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("OK",20,0,0);
	if(answer!=1) return 0;
	
	return 1;	
}
예제 #2
0
/* manageIncomingData() - manage incoming data from serial port, executing proper functions to store received data
 *
 * This function manages incoming data from serial port, executing proper functions to store received data
 *
 * Returns '1' on success and '0' if error
*/
uint8_t	WaspGPRS::manageIncomingGSMData()
{
	char byteIN[100];
	uint8_t a=0;
	long previous=0;
	uint8_t answer=0;
	
	while(a<100){
		byteIN[a]=0;
		a++;
	}
	a=0;
	
	serialFlush(PORT_USED);
	previous=millis();
	while(!serialAvailable(PORT_USED) && (millis()-previous)<20000);
	previous=millis();
	while( (millis()-previous) < 2000 )
	{
		while( serialAvailable(PORT_USED) && (millis()-previous) < 2000 )
		{
			byteIN[a]=serialRead(PORT_USED);
			a++;
		}
	}
	answer=parse_GSM(byteIN);
	switch( answer ){
		case	0:	readCall(byteIN);
				break;
		case	1:	readSMS(byteIN);
				break;
	}
	if(answer==2) return 0;
	return 1;
}
예제 #3
0
static void radioProcessInstance(radioInstance_t *r) {
    serialPort_t *s = r->serialPort;
    int8_t q;

    switch (r->radioType) {
    case RADIO_TYPE_SPEKTRUM11:
    case RADIO_TYPE_SPEKTRUM10:
    case RADIO_TYPE_DELTANG:
        while (serialAvailable(s))
            if (spektrumCharIn(r, serialRead(s))) {
                r->lastUpdate = timerMicros();
                radioReceptionQuality(r, 1);
            }
        break;

    case RADIO_TYPE_SBUS:
        while (serialAvailable(s))
            if ((q = futabaCharIn(r, serialRead(s)))) {
                r->lastUpdate = timerMicros();
                radioReceptionQuality(r, q);
            }
        break;

    case RADIO_TYPE_PPM:
        if (ppmDataAvailable(r))
            r->lastUpdate = timerMicros();
        break;

    case RADIO_TYPE_SUMD:
        while (serialAvailable(s))
            if ((q = grhottCharIn(r, serialRead(s)))) {
                r->lastUpdate = timerMicros();
                radioReceptionQuality(r, q);
            }
        break;

    case RADIO_TYPE_MLINK:
        while (serialAvailable(s))
        if ((q = mlinkrxCharIn(r, serialRead(s)))) {
            r->lastUpdate = timerMicros();
            radioReceptionQuality(r, q);
        }
        break;
    }

    // no radio signal?
    if (timerMicros() - r->lastUpdate > RADIO_UPDATE_TIMEOUT)
        radioReceptionQuality(r, -1);                       // minimum signal quality (0%) if no updates within timeout value
    else if (r->radioType == RADIO_TYPE_PPM)
        radioReceptionQuality(r, ppmGetSignalQuality(r));   // signal quality based on PPM status
}
예제 #4
0
int main()
{
	serialOpen("/dev/tty.usbserial-A4001o0F", 9600);
  serialWriteByte(0x31);
	//serialport_write("1");
	usleep(100 * 1000);
	printf("available: %d \n", serialAvailable());
	printf("read: %c \n", serialRead());
	printf("available: %d \n", serialAvailable());
	printf("read: %c \n", serialRead());
	printf("available: %d \n", serialAvailable());
	serialClose();
	return 0;
}
예제 #5
0
/* getCellInfo() - gets the information from the cell where the module is connected
 *
 * This function gets the information from the cell where the module is connected
 *
 * It stores in 'RSSI' and 'cellID' variables the information from the cell
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::getCellInfo()
{
	char command[30];
	uint8_t byteIN[200];
	long previous=millis();
	uint8_t counter=0;
	uint8_t a,b,c=0;
	
	serialFlush(PORT_USED);
	sprintf(command,"AT%s\r\n",AT_GPRS_CELLID);
	printString(command,PORT_USED);
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
	previous=millis();
	a=0;
	while( (millis()-previous) < 2000 )
	{
		while( serialAvailable(PORT_USED) && (millis()-previous) < 2000 && (a<200) )
		{
			byteIN[a]=serialRead(PORT_USED);
			a++;
		}
	}
	a=0;
	while( counter < 5 )
	{
		while( (byteIN[a]!=',') && (a<200) )
		{
			a++;
		}
		a++;
		counter++;
	}
	if(a>=200) return 0;
	counter=0;
	while( (byteIN[a]!=',') && (a<200) )
	{
		cellID[c]=byteIN[a];
		a++;
		c++;
	}
	a++;
	while( (byteIN[a]!=',') && (a<200) )
	{
		RSSI[b]=byteIN[a];
		delay(10);
		b++;
		a++;
	}
	return 1;
}
/*
 Function: Parses module answer trying to find specified MAC, stops inquiry when mac is found. if dewvice is found, saved on position 0
 Returns: Returs 1 if found. 0 if not found.
 Parameters: 
	inquiryTime: wait for module answer during this time.
	mac: mac of desired device.
 Values: 
*/
bool  WaspBT_Pro::waitScanDeviceAnswer(long inquiryTime, char* mac) 
{
	delay(100);
	char dummy[4];						
	bool found = false;
	char * block;
	block = (char*)calloc(BLOCK_SIZE+1,sizeof(char));

	Utils.setLED(LED1, LED_ON);  // Inquiry while led on
    	
	long previous=millis();
	while( (millis()-previous<inquiryTime) && (!found) ) 
	{
		// Looks for keyword and save device.		
		if (serialAvailable(1))	{
			dummy[0]=serialRead(1);
			delay(50);
			if (dummy[0]=='I'){
				dummy[1]=serialRead(1);	
				delay(50);
				if (dummy[1]=='A'){
					dummy[2]=serialRead(1);	
					if (dummy[2]=='L'){
						while(serialAvailable(1)<BLOCK_SIZE);
						for(uint8_t x=0;x<BLOCK_SIZE;x++) block[x]= serialRead(1);
						if (lookForAnswer(block,mac)>=1) {
							found=true;
							parseBlock(block);
							sendCommand("IC");
							numberOfDevices = 1;
							delay(200);
						}
					}
				}
			}
		}
	#ifdef DEBUG_MODE
	printBuffer();
	#endif	

	// Condition to avoid an overflow (DO NOT REMOVE)
    	if( millis()-previous < 0 ) previous=millis();
	}
	free(block);
	block=NULL;
    	Utils.setLED(LED1, LED_OFF);  // Inquiry while led on
 	return found;
}
예제 #7
0
//------------------------------------------------------------------------------
// An adaptation of the loop in main() in the original Babuino code.
// This is intended to be called from within the Arduino loop() function.
//------------------------------------------------------------------------------
void 
Babuino::loop()
{
	debounce();
	
	switch (_states.getMachineState())
		{
		case READY:
			if (serialAvailable() > 0)
			{
				_states.setMachineState(COMM);
			}
			else if (_states.getRunRequest() == RUNNING)
			{
				_states.setMachineState(RUN);
			}
			break;

		case COMM:
			doComm();
			_states.setMachineState(READY);
			break;

		case RUN:
			_regs.pc.set(_storage.getStartAddress());
			initStack(_stack);
			_states.setMachineState(RUN);
			code_exec();
			_motors.off();
			_states.setMachineState(READY);
			break;
		}
}
예제 #8
0
unsigned char stmWaitAck(serialStruct_t *s, int retries) {
	unsigned char c;
	unsigned int i;

	for (i = 0; i < retries; i++) {
		if (serialAvailable(s)) {
			c = serialRead(s);
			if (c == 0x79) {
//				putchar('+'); fflush(stdout);
				return 1;
			}
			if (c == 0x1f) {
				putchar('-'); fflush(stdout);
				return 0;
			}
			else {
				printf("?%x?", c); fflush(stdout);
				return 0;
			}
		}
		usleep(500);
	}

	return 0;
}
예제 #9
0
byte WaspGPRS::sendCommand(char* theText, char* endOfCommand, char* expectedAnswer, int MAX_TIMEOUT, int sendOnce) {
    int timeout = 0;

    for (int i = 0; i < 100; i++) received[i] = ' ';

    int length=sprintf(theCommand, "%s%s", theText,endOfCommand);
    

  // try sending the command
  // wait for serial response
    timeout = 0;
    serialFlush(PORT_USED);
    while(!serialAvailable(PORT_USED) && timeout < MAX_TIMEOUT) {
        if (!sendOnce || !timeout) {
            printString(theCommand,PORT_USED);
            USB.print('T');
        }
        delay(DELAY_ON_SEND);
        timeout++;
    };

    int answer= waitForData( expectedAnswer, MAX_TIMEOUT, timeout, 0);
    
    return answer;
}
예제 #10
0
/*
 * 
 * name: readBuffer
 * This function reads from UART rx buffer and stores the contents in _buffer
 * attribute. _length indicates the number of valid bytes in _buffer
 * 
 * @param bool clearBuffer: indicates if the buffer has to be cleared before reading
 * 
 * @return 	number of bytes read 
 */
uint16_t  WaspUART::readBuffer(uint16_t requestBytes, bool clearBuffer)
{ 
	// index counter
	uint16_t i = 0;
	uint16_t nBytes = 0;
	
	if( clearBuffer == true )
	{
		// clear _buffer
		memset( _buffer, 0x00, sizeof(_buffer) );
		_length = 0;
	}
	
	// get actual instant
	//unsigned long previous = millis();
        
	// check available data for 'timeout' milliseconds
	while( serialAvailable(_uart) )
	{
		if ( (i < (sizeof(_buffer)-1)) && (requestBytes>0) )
		{
			_buffer[i++] = serialRead(_uart);				
			_length++;
			nBytes++;
			requestBytes--;	
			latencyDelay();
		}
		else
		{
			break;
		}
	}
		
	return nBytes;
}
예제 #11
0
void loop() {
	int bytes = serialAvailable();

        while (bytes--) {
                char byte;
                int val;

                byte = serialRead();
                val = byte;
		switch(byte) {
			case '0' ... '9':
				val = val - '0';        // convert from character to number
				val = val * (180/9);    // convert from number to degrees
				pulseWidth[servoIdx] = (val * 9) + minPulse;  // convert angle to microseconds
				Serial.print(">>> Moving servo #");
				Serial.print(servoIdx);
				Serial.print(" to ");
				Serial.print(pulseWidth[servoIdx], DEC);
				Serial.println("");
				break;
			default:
				Serial.println("Unknown Command");
				break;
		}
	}

	/* Now we do the servo jazz */
	servo_loop();
}
예제 #12
0
/* uploadFile() - uploads a file to a FTP server
 *
 * This function uploads a file to a FTP server
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::downloadFile(char* file, char* path, char* user, char* passw, char* ftp_server, uint8_t ftp_port)
{
	char command[70];
	long previous=0;
	uint8_t answer=0;
	char aux='"';
	uint16_t index=0;
	uint16_t i=0;
	uint8_t end=0;
	char* aux2;
	uint8_t j=0;
	uint8_t id=0;
	
	if(!setFlowControl()) return 0;
			
	if(!configureGPRS()) return 0;
		
	// Connect to FTP Server
	sprintf(command,"AT%s,%c%s%c,%c%s%c,%c%s%c,%u,1%c%c",AT_FTP_PARAM,aux,ftp_server,aux,aux,user,aux,aux,passw,aux,ftp_port,'\r','\n');
	printString(command,PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("+KFTPCFG: ",20,0,0);
	if(answer!=1) return 0;
		
	id=serialRead(PORT_USED);
	
	if( !readDataFTP(file, path, id) ) return 0;
	
	return 1;
}
예제 #13
0
uint8_t serialReadUntil(byte* buf, uint8_t maxlen, byte terminator)
{
    uint8_t i;
    for(i=0;i<_buffer_length;i++)
    {
        if((_buffer[i] == terminator) || i == (maxlen-1))
        {
            memcpy(buf,_buffer,i+1);
            shift(i+1);
            return i+1;
        }
    }
/*
    while(serialLast() != terminator)
        ;
    //в идеале так, но приходится делать как ниже..
 */
    while(1)
    {
        if(serialLast() == terminator)
            break;
        _delay_ms(1); //какойто глюк с gcc, надо вызывать задержку, иначе гуано
    }
    uint8_t length = serialAvailable();
    if(length > maxlen)
        length = maxlen;
    memcpy(buf,_buffer,length);
    shift(length);
    return length;
}
예제 #14
0
// Test purposes only
void WaspBT_Pro::printBuffer2(){
	int flag;
	flag= serialAvailable(1);
	//USB.println(flag);
	if (flag>900)	USB.println("_-*OVERFLOW in summary*-_");
	
}
예제 #15
0
uint8_t SerialProtocol::send()
{
    if (!serialAvailable())
    {
        // There is no place to send the data
        return ProtocolState::NO_SERIAL;
    }

    uint8_t checksum = payloadSize;

    // Write the header
    sendData(HEADER);
    sendData(payloadSize);

    // Write the payload
    for (int i = 0; i < payloadSize; i++)
    {
        checksum ^= *(payload + i);
        sendData(*(payload + i));
    }

    // Complete with the checksum
    sendData(checksum);

    return ProtocolState::SUCCESS;
}
예제 #16
0
/* sendData(data,socket) - sends 'data' to the specified 'socket'
 *
 * This function sends 'data' to the specified 'socket'
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * It gets from 'socket_ID' the TCP session ID assigned to the last call of creating a socket
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::sendData(const char* data, uint8_t* socket)
{
	char command[30];
	uint8_t answer=0;
	long previous=0;
	uint8_t byteIN=0;
	uint8_t counter=0;
        uint8_t i=0;

	
	while(data[counter]!='\0') counter++;
	counter+=2;
        while(socket[i]!='\r') i++;
        counter+=i-1;
	serialFlush(PORT_USED);
        switch(i)
        {
            case 1: sprintf(command,"%s%c,%u%c%c",AT_GPRS_TCP_SND,socket[0],counter,'\r','\n');
                    break;
            case 2: sprintf(command,"%s%c%c,%u%c%c",AT_GPRS_TCP_SND,socket[0],socket[1],counter,'\r','\n');
                    break;
	    case 3: sprintf(command,"%s%c%c%c,%u%c%c",AT_GPRS_TCP_SND,socket[0],socket[1],socket[2],counter,'\r','\n');
                    break;
        }
       	printString(command,PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
	delay(10);
	answer=waitForData("CONNECT",20,0,0);
	if(answer!=1) return 0;
	answer=0;
	counter=0;
	while( (counter<3) && (answer!=1) )
	{
		serialFlush(PORT_USED);
		delay(20);
		writeData(data);
		previous=millis();
		while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
		delay(10);
		answer=waitForData("OK",20,0,0);
		counter++;
	}
	if(answer!=1) return 0;
	return 1;
}
예제 #17
0
/////////////////////////////
//
//	runBitlash
//
//	This is the main entry point where the main loop gives Bitlash cycles
//	Call this frequently from loop()
//
void runBitlash(void) {

	// Pipe the serial input into the command handler
	if (serialAvailable()) doCharacter(serialRead());

	// Background macro handler: feed it one call each time through
	runBackgroundTasks();
}
예제 #18
0
/* sendMail() - sends an email
 *
 * This function sends an email
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::sendMail(char* from, char* to, char* subject, char* body, char* user, char* passw, char* smtp_server, uint16_t port)
{
	uint8_t counter=0;
	char command[30];
	long previous=0;
	uint8_t answer=0;
	
	if(!setFlowControl()) return 0;
		
	if(!configureGPRS()) return 0;
		
	if(!setEmailParams(smtp_server, port, from)) return 0;
		
	if(!setEmailPwd(user, passw)) return 0;
		
	if(!setEmailDestination(to)) return 0;
		
	if(!setEmailSubject(subject)) return 0;
		
	while( body[counter]!='\0' ) counter++;
	counter+=2;
	
	serialFlush(PORT_USED);
	sprintf(command,"AT%s1,%u%c%c",AT_SMTP_SEND,counter,'\r','\n');
	printString(command,PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("CONNECT",20,0,0);
	if(answer!=1) return 0;
	
	printString(body,PORT_USED);
	printByte('\r',PORT_USED);
	printByte('\n',PORT_USED);
	
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("OK",20,0,0);
	if(answer!=1) return 0;
	
	
	return 1;

}
예제 #19
0
/*
 Function: Reads and stores module answer.
 Returns: 
 Parameters: 
 Values: 
*/
void WaspBT_Pro::readCommandAnswer() {
	for (i = 0; i < RX_BUFFER; i++) commandAnswer[i] = ' ';	// Clears variable	
	i=0;
	while(serialAvailable(1)) {		
		commandAnswer[i]=serialRead(1);
		i++;
		delay(10);	
	}
}
예제 #20
0
uint8_t serialWaitUntil(byte terminator)
{
    while(1)
    {
        if(serialLast() == terminator)
            return serialAvailable();
        _delay_ms(1); //какойто глюк с gcc, надо вызывать задержку, иначе гуано
    }
    return 0;
}
예제 #21
0
/* getIMSI() - gets the IMSI from the SIM card
 *
 * This function gets the IMSI from the SIM card. It stores the IMSI into 'IMSI' variable.
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::getIMSI()
{
	char command[15];
	uint8_t byteIN[20];
	long previous=millis();
	uint8_t a,b=0;
	
	serialFlush(PORT_USED);
	sprintf(command,"%s\r\n",AT_GPRS_IMSI);
	printString(command,PORT_USED);
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
	previous=millis();
	a=0;
	while( (millis()-previous) < 2000 )
	{
		while( serialAvailable(PORT_USED) && (millis()-previous) < 2000 && (a<20) )
		{
			byteIN[a]=serialRead(PORT_USED);
			a++;
		}
	}
	a=0;

		while( (byteIN[a]!='\r') && (byteIN[a]!='\n') && (a<20) )
		{
			a++;
		}
		if(a>=20) return 0;
		a++;

	if(a>=20) return 0;

	b=0;
	while( (byteIN[a]!='\r') && (a<20) )
	{
		IMSI[b]=byteIN[a];
		a++;
		b++;
	}
	IMSI[b]='\0';
	if(b<=10) return 0;
	return 1;
}
예제 #22
0
/*
 * available() - checks if there is available data waiting to be read
 *  
 */
uint8_t WaspUSB::available()
{
	beginSerial(USB_RATE, _uart);

	// configure multiplexor to USB port
	digitalWrite(MUX_PW,HIGH);
	digitalWrite(MUX_USB_XBEE,LOW);
	
	return serialAvailable( _uart);
}
예제 #23
0
파일: serial.c 프로젝트: ChrelleP/autoquad
void serialWatch(void) {
#ifdef SERIAL_UART1_PORT
    if (serialPort1 && serialAvailable(serialPort1))
	CoSetFlag(serialPort1->waitFlag);
#endif
#ifdef SERIAL_UART2_PORT
    if (serialPort2 && serialAvailable(serialPort2))
	CoSetFlag(serialPort2->waitFlag);
#endif
#ifdef SERIAL_UART3_PORT
    if (serialPort3 && serialAvailable(serialPort3))
	CoSetFlag(serialPort3->waitFlag);
#endif
#ifdef SERIAL_UART4_PORT
    if (serialPort4 && serialAvailable(serialPort4))
	CoSetFlag(serialPort4->waitFlag);
#endif
#ifdef SERIAL_UART5_PORT
    if (serialPort5 && serialAvailable(serialPort5))
	CoSetFlag(serialPort5->waitFlag);
#endif
#ifdef SERIAL_UART6_PORT
    if (serialPort6 && serialAvailable(serialPort6))
	CoSetFlag(serialPort6->waitFlag);
#endif
}
예제 #24
0
void initlbuf(void) {
	lbufptr = lbuf;

#if defined(SERIAL_OVERRIDE) && 0
	// don't do the prompt in serialIsOverridden mode
	if (serialIsOverridden()) return;
#endif

	prompt();
	
	// flush any pending serial input
	while (serialAvailable()) serialRead();
}
예제 #25
0
/* sendCommand(ATcommand, ATcommand_R) - sends any command to GPRS module
 *
 * This function sends any command to GPRS module
 *
 * It stores in 'answer_command' variable the answer returned by the GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::sendCommand(char* ATcommand)
{
	char command[30];
	uint8_t timeout=0;
	uint8_t i=0;
	
	answer_command[0]='\0';
	sprintf(command, "AT%s%c%c", ATcommand,'\r','\n');

	serialFlush(PORT_USED);
	USB.print('d');
	while(!serialAvailable(PORT_USED)) {
		printString(command,PORT_USED);
		delay(DELAY_ON_SEND);
		USB.print('e');
	}
	USB.print('a');
	while( timeout < 5 )
	{
		while(!serialAvailable(PORT_USED) && timeout < 5) {
			timeout++;
			delay(1000);
		}
		USB.print('b');
		while(serialAvailable(PORT_USED) && timeout < 5){
			answer_command[i] = serialRead(PORT_USED);
			delay(20);
			i++;
			timeout=0;
			if(i>=199) timeout=5;
		}
		USB.print('c');
	}
	answer_command[i]='\0';
	if( i<5 ) return 0;
	return 1;
}
예제 #26
0
byte serialRead(byte* buf, uint8_t n)
{
    uint8_t counter = 0;
    uint8_t flag = 0;
    while(counter < 250)
    {
        if(serialAvailable() >= n)
        {
            flag = 1;
            break;
        }
        counter++;
        _delay_ms(4);
    }
    if(!flag) return 0;

    memcpy(buf,_buffer,n);
    shift(n);
    return n;
}
void loop(){
  seq.rotation.update(getAnalogValue(SEQUENCER_ROTATE_CONTROL));
  seq.step.update(getAnalogValue(SEQUENCER_STEP_CONTROL));
  seq.fill.update(getAnalogValue(SEQUENCER_FILL_CONTROL));
  seq.update();

#ifdef SERIAL_DEBUG
  if(serialAvailable() > 0){
    serialRead();
    printString("a: [");
    seq.dump();
    printString("] ");
    seq.print();
    if(clockIsHigh())
      printString(" clock high");
    if(resetIsHigh())
      printString(" reset high");
    printNewline();
  }
#endif
}
예제 #28
0
파일: level2.c 프로젝트: Feechka/UOBP
//Read one byte from serial
unsigned char nextChar
 (unsigned char * byte
 ,GioEndpoint *gioEndpoint){
 unsigned char get = 1;
 #ifdef ARDUINO
 unsigned char timeoutCounter = 0;
 while(1){
  if(serialAvailable(gioEndpoint))break;
  if(timeoutCounter++>TIMEOUT_AFTER){
   get = 0;
   break;
  }
  delay(1);
 }
 #endif
 if(get){
  serialRead(byte,gioEndpoint);
  return get;
 }else{
  return 0;
 }
}
예제 #29
0
/*
 * 
 * name: latencyDelay
 * This function waits for specific time depending on the baudrate used.
 * 
 * Latency time for ensure there is no more data is calculated suposing the 
 * worst condition: 1start+8data+1parity+2stop = 12 bits per byte
 * 
 */
void WaspUART::latencyDelay()
{
	// In the case there are not any bytes left in the incoming uart
	// wait for the time one byte needs for tranmission regarding the baudrate
	if (serialAvailable(_uart) == 0)
	{
		switch (_baudrate)
		{
			case 115200:	delayMicroseconds(105); 	break;
			case 57600:		delayMicroseconds(209); 	break;
			case 38400:		delayMicroseconds(313); 	break;
			case 19200:		delayMicroseconds(625); 	break;
			case 9600:		delay(1); 	break;
			case 4800:		delay(3); 	break;
			case 2400:		delay(5); 	break;
			case 1800:		delay(7); 	break;
			case 1200:		delay(10); 	break;
			case 600:		delay(20); 	break;
			case 300:		delay(40); 	break;
			default:					break;			
		}
	}
}
예제 #30
0
/*
 Function: Reads internal temperature sensor of bluetooth module.
 Returns: Temperature
 Parameters: 
 Values: 
*/
long WaspBT_Pro::getTemp(){
	long a;
	char dummy[3];
	char temperature[4];
	for (uint8_t i = 0; i < COMMAND_SIZE; i++) theCommand[i] = ' ';	// Clear variable
	for (uint8_t i = 0; i < 3; i++) temperature[i] = ' ';
	sendCommand("temp");
	delay(100);
	while(serialAvailable(1)){
		dummy[0]=serialRead(1);	
		if (dummy[0]=='M'){
			dummy[1]=serialRead(1);	
			if (dummy[1]=='P'){
				dummy[0]=serialRead(1);
				temperature[0]=serialRead(1);
				temperature[1]=serialRead(1);
				temperature[2]=serialRead(1);
				a = Utils.array2long(temperature);
				}
			}
	}
return a;
}