void test_that_rxbytecounter_is_reset_when_last_byte_is_received(){
  receiveByte(3); // length = 3
  receiveByte(1);
  receiveByte(2);
  
  assertEquals(0, rxbytecounter, "RX byte counter not reset");
}

// Receive a packet, copying it into a memory buffer and returning the buffer
static uint8_t *receivePacket(int fd)
{
	uint8_t packet_header[5];
	uint8_t *packet_buffer;
	uint32_t length;
	uint32_t i;

	for (i = 0; i < 5; i++)
	{
		packet_header[i] = receiveByte(fd);
	}
	length = readU32LittleEndian(&(packet_header[1]));
	if (length > PACKET_LENGTH_LIMIT)
	{
		printf("Got absurdly large packet length of %d\n", length);
		printf("Exiting, since the packet is probably garbled\n");
		exit(1);
	}
	packet_buffer = malloc(length + 5);
	memcpy(packet_buffer, packet_header, 5);
	for (i = 0; i < length; i++)
	{
		packet_buffer[i + 5] = receiveByte(fd);
	}
	return packet_buffer;
}

uint8_t I2C::read(uint8_t address, uint8_t numberBytes, uint8_t *dataBuffer)
{
  bytesAvailable = 0;
  bufferIndex = 0;
  if(numberBytes == 0){numberBytes++;}
  nack = numberBytes - 1;
  returnStatus = 0;
  returnStatus = start();
  if(returnStatus){return(returnStatus);}
  returnStatus = sendAddress(SLA_R(address));
  if(returnStatus){return(returnStatus);}
  for(uint8_t i = 0; i < numberBytes; i++)
  {
    if( i == nack )
    {
      returnStatus = receiveByte(0);
      if(returnStatus != MR_DATA_NACK){return(returnStatus);}
    }
    else
    {
      returnStatus = receiveByte(1);
      if(returnStatus != MR_DATA_ACK){return(returnStatus);}
    }
    dataBuffer[i] = TWDR;
    bytesAvailable = i+1;
    totalBytes = i+1;
  }
  returnStatus = stop();
  return(returnStatus);
}

void test_that_command_is_not_called_when_not_all_bytes_are_ready(){
  receiveByte(3); // length = 3
  receiveByte(SPI_CMD_PT_TEST); // type that triggers test function on receive

  SPI_checkForReceivedData();

  assertEquals(0, lastPackage[0], "No command should have been treated");
}

void timerHandlerReadByte1(void *T)
{
	static volatile uint32_t stageOfReading = 0;
	static uint8_t whichByte = 0;
	static uint8_t whichDevice = 0;
	addressAndData *address = (addressAndData*)T;

	if(readingAllowed == TRUE)
	{
		if(0 == whichDevice) //accel
		{
			receiveByte(address->adr.addressDevice[0], (address->adr.subAddress[0] + whichByte), &(address->dane[whichByte]));
			whichByte++;

			if(whichByte == 6)
			{
				//readingAllowed = FALSE;

				whichDevice++;

				whichByte = 0;
				stageOfReading = 0;
			}
		}
		else if(1 == whichDevice) //gyro
		{
			receiveByte(address->adr.addressDevice[0], (address->adr.subAddress[1] + whichByte), &(address->dane[whichByte + 6]));
			whichByte++;

			if(whichByte == 6)
			{
				//readingAllowed = FALSE;

				whichDevice++;

				whichByte = 0;
				stageOfReading++;
			}
		}
		else if(2 == whichDevice)
		{
			receiveByte(address->adr.addressDevice[1], (address->adr.subAddress[2] + whichByte), &(address->dane[whichByte + 12]));
			whichByte++;

			if(whichByte == 6)
			{
				readingAllowed = FALSE;

				whichDevice = 0;

				whichByte = 0;
				stageOfReading++;
			}
		}

	}
}

//--------------------------------------------------------------
// HIGH LEVEL MESSAGE FUNCTIONS
//--------------------------------------------------------------
// This function will receive a full request message from a
// RasPi and return proper confirmation bytes
int * receiveMessage(void){
    // Hold inital byte received
    uint8_t i=0;
    uint8_t j=0;
    uint8_t n=0;

    // Array to hold received data
    static int msgArray[10];
    int dataByteIn[2];

    // Receive initial byte
    for(j=0; j<2; j++){
        dataByteIn[j] = receiveByte();
    }

    // If message is not properly terminated write error code
        // to entire array and call commError()
    if(dataByteIn[1] != END_MSG){
        for (i=0; i<4; i++){
            msgArray[i] = UART_COMM_ERROR;
        }
        commError();
    }

    // RasPi normal request message to AVR
    else if (dataByteIn[0] == RASPI_REQ_AVR){
        // Transmit AVR ready to receive message
        transmitReady();
        
        // Loop through until EOM reached and store in array
        do{
            msgArray[n] = receiveByte();
            n++;
        }while(msgArray[n-1] != END_MSG);
        transmitConfirm();
    }

    // RasPi initialize request to AVR
    else if(dataByteIn[0] == RASPI_INIT_TO_AVR){
	    // Transmit AVR initialized ready byte
        transmitInitialize();

        // Write initialized byte to array
        for(i=0; i<4; i++){
            msgArray[i] = AVR_INIT_TO_RASPI;
        }
    }

    // Improper initial communication byte, call commError()
    else{
        commError();
    }

    return msgArray;
}

void test_that_package_is_received_by_spi(){
  receiveByte(3); // length = 3
  receiveByte(SPI_CMD_PT_TEST); // type that triggers test function on receive
  receiveByte(2);
  
  SPI_checkForReceivedData();
  
  assertEquals(3, lastPackage[0], "Incorrect package value 0");
  assertEquals(SPI_CMD_PT_TEST, lastPackage[1], "Incorrect package value 0");
  assertEquals(2, lastPackage[2], "Incorrect package value 0");
}

void test_that_only_first_command_is_treated_if_second_is_incomplete(){
  receiveByte(3); // length = 3
  receiveByte(SPI_CMD_PT_TEST); // type that triggers test function on receive
  receiveByte(4);

  receiveByte(4); // length = 3
  receiveByte(SPI_CMD_PT_TEST); // type that triggers test function on receive

  SPI_checkForReceivedData();

  assertEquals(3, lastPackage[0], "Wrong last command");
}

// This function will transmit a full message to RasPi
uint8_t transmitMessage(volatile int sendData[4]){
    // Initialize loop counter
    uint8_t i;
    uint8_t badSendFlag = 0;

    // Clear global interrupt to stop receive interrupt
    cli();

    // Send AVR request RasPi byte
    transmitRequest();

    // Wait for response from RasPi
    // **** This has possibility of hanging program -- needs improvement!
    if (receiveByte() == RASPI_READY){
        // Remove EOM from buffer
        receiveByte();

        // Loop to send all of data array
        for(i=0; i<4; i++){
            transmitByte(sendData[i]);
        }

        // Transmit end of message byte
        transmitByte(END_MSG);

        // Check for good confirm byte
        if (receiveByte() == RASPI_REC_MSG_CONFIRM){
            // Remove EOM from buffer
            receiveByte();
        }
        else{
            // Set bad send flag
            badSendFlag = 2;
        }
    }

    // If improper response is received, call commError()
    else{
        // Set bad send flag
            badSendFlag = 1;
    }

    // If badSendFlag is set - call commError()
    if(badSendFlag != 0){
        commError();
    }

    // reenable global interrupts
    sei();

    // Return value of badSendFlag
    return badSendFlag;
}

int main(void)
{
	DDRD = (1<<1);		// habilita output no pino PD1 (TXD)
	DDRB = (1<<PB0);	// LED na porta PB0
	DDRB = (1<<PB5);	// habilita LED usado no bootloader 
						// (para piscar em status)
	
	char serialCharacter;
	
	LED_DDR=0xff;
	
	initUSART();
	PORTB |= (1<<PB0);
	PORTB &= ~(1<<PB5);
	printString("Ola Mundo\r\n");
	
	
    while(1)
    {
		serialCharacter = receiveByte();
		PORTB ^= _BV(PB0);
		transmitByte(serialCharacter);
		
		//LED_PORT=serialCharacter;
		PORTB ^= _BV(PB5);
		
	}
	
	return(0);
}

int main(void)
{
  // Single character for serial TX/RX
  char a;

  // Enable output on all 8 bits in DDRB (but only PB0 and PB1 are used)
  DDRB = 0xff;

  // Enable pin change interrupt for the B pins, but only check PB0 and PB1.
  sei();
  PCICR |= (1 << PCIE0);
  PCMSK0 |= ((1 << PB0) | (1 << PB1));

  init_timer1();
  initUSART();

  pb[0] = PB0;
  pb[1] = PB1;
  while (1)
  {

    // for (uint8_t i=0; i<255; i++)
    //   cmd[i] = 0;

    // char cmd[255];
    // readString(cmd, 255);

    // if (strcmp(cmd, "V0_ON") == 0)
    // {
    //   printString("\r\nYou wrote: ");
    //   printString(cmd);
    //   printString("\r\n");
    //   PORTB |= (1 << PB0);
    // }

    // if (strcmp(cmd, "V1_ON"))
    //   PORTB |= (1 << PB1);
    // if (strcmp(cmd, "V0_OFF"))
    //   PORTB &= ~(1 << PB0);
    // if (strcmp(cmd, "V1_OFF"))
    //   PORTB &= ~(1 << PB1);

    // if (cmd == "V0_ON") set_bit(PORTB, PB0);
    // PORTB |= (1 << PB0);
    a = receiveByte();
    transmitByte(a);

    if (a == '0')
      PORTB &= ~(1 << PB0);
    if (a == '1')
      PORTB |= (1 << PB0);
    if (a == '2')
      PORTB &= ~(1 << PB1);
    if (a == '3')
      PORTB |= (1 << PB1);

    // PORTB = a;
  }
  return 0;
}

bool PBBP::receiveBytes(uint8_t *buf, uint8_t len) {
  while (len--) {
    if (!receiveByte(buf++))
      return false;
  }
  return true;
}

void readString( char myString[], uint8_t maxLength ) 
{
  	char response;
  	uint8_t i;
  	i = 0;
  	while ( i < ( maxLength - 1 ) ) 
  	{
  		/* prevent over-runs */
    	response = receiveByte();
    	/* echo */
    	transmitByte(response);
    	if ( response == '\r' ) 
		{
			/* enter marks the end */
      		break;
    	}
    	else
    	{
    		/* add in a letter */
      		myString[ i ] = response;
      		i++;
    	}
  	}
  	/* terminal NULL character */
  	myString[ i ] = 0;
}

int main(void) 
{
    //-----------INITS------------//

    DDRB |= 0x01;
    PORTB = 0x00;
    initUSART();

    PORTB = 0x01;
    _delay_ms(100);
    PORTB = 0x00;
    _delay_ms(100);
    PORTB = 0x01;
    _delay_ms(1000);
    PORTB = 0x00;

    //-------EVENT LOOP-----------//
    while(1) 
    {  
        
        char in = receiveByte();
        /*
        if (in == 'h')
            PORTB = 0x01;
        else if (in == 'l')
            PORTB = 0x00;
        */
        PORTB = 0x01;
        for (int i=0; i<in; i++)
            _delay_ms(1);
        PORTB = 0x00;
    }
    return(0);

}

int main(void)
{
	char serialCharacter;
	
	lcd_init(LCD_DISP_ON);
	lcd_gotoxy(2,0); lcd_puts("Serial");
	lcd_gotoxy(3,1); lcd_puts("LCD");
	
	DDRD |= (1<<PD1);	// habilita o pino PD1 como TXD (output)
	DDRB |= (1<<PB0);	// habilita o LED no pino PB0
	
	PORTB|=(1<<PB0);
	
	initUSART();
	printString("Serial ok:");
	
	PORTB&=~(1<<PB0);
	
    while(1)
    {	PORTB|=(1<<PB0);
        serialCharacter = receiveByte();
		PORTB&=~(1<<PB0);
		lcd_putc(serialCharacter);
    }
}

/* Reads a z85 encoded string from serial interface and decodes the string into byte array of size size */ 
uint8_t receive_and_decode_Z85(uint8_t *data, size_t size)
{
    //  Accepts only strings bounded to 5 bytes
    /* if (strlen (string) % 5) */
    /*     return NULL; */
    
    /* size_t decoded_size = strlen (string) * 4 / 5; */
    /* byte *decoded = malloc (decoded_size); */
    if (size % 4) // only multiples of 4 bytes are possible
        return 1;
    size_t size_encoded = size*5/4;
    
    size_t byte_nbr = 0;
    size_t char_nbr = 0;
    uint32_t value = 0;
    while (char_nbr < size_encoded) {
        //  Accumulate value in base 85
        /* value = value * 85 + decoder [(byte) string [char_nbr++] - 32]; */
        value = value * 85 + decoder [receiveByte() - 32];
        char_nbr++;
        if (char_nbr % 5 == 0) {
            //  Output value in base 256
            uint32_t divisor = 16777216; // = 256 * 256 * 256;
            while (divisor) {
                data [byte_nbr++] = value / divisor % 256;
                divisor /= 256;
            }
            value = 0;
        }
    }

    if (byte_nbr != size) return 1;

    return 0;
}

bool PBBP::receiveAck() {
  bool first, second;
  if (!receiveBit(&first) || !receiveBit(&second))
    return false;

  // Acks are sent as 01, nacks as 10. Since the 0 is dominant during
  // a bus conflict, a receiveing of 00 means both an ack and a nack was
  // sent.
  if (!first && !second ) {
    this->last_error = ACK_AND_NACK;
    return false;
  } else if (!second ) {
    // Read error code from the slave
    if (receiveByte(&this->last_slave_error)) {
      this->last_error = NACK;
    } else {
      this->last_error = NACK_NO_SLAVE_CODE;
    }
    return false;
  } else if (first) {
    this->last_error = NO_ACK_OR_NACK;
    return false;
  } else {
    return true;
  }
}

void CDirectSerial::RXBufferEmpty () {
	ULONG dwRead;
	Bit8u chRead;
	USHORT errors = 0;
	ULONG ulParmLen = sizeof(errors);

	if (lastChance > 0) {
		receiveByte (ChanceChar);
		lastChance = 0;
	} else {
		// update RX
		if (DosRead (hCom, &chRead, 1, &dwRead) != NO_ERROR) {
			if (dwRead != 0) {
				//LOG_MSG("UART 0x%x: RX 0x%x", base,chRead);
				receiveByte (chRead);
			}
		}
	}
	// check for errors
	Bit8u errreg = 0;
	APIRET rc = DosDevIOCtl(hCom, IOCTL_ASYNC, ASYNC_GETCOMMERROR, 0, 0, 0, &errors, ulParmLen, &ulParmLen);
	if (rc != NO_ERROR && errors)
                                     {
		if (errors & 8) {
			LOG_MSG ("Serial port at 0x%x: line error: framing error.", base);
			errreg |= LSR_FRAMING_ERROR_MASK;
		}
		if (errors & 4) {
			LOG_MSG ("Serial port at 0x%x: line error: parity error.", base);
			errreg |= LSR_PARITY_ERROR_MASK;
		}
	}
	errors = 0;
	rc = DosDevIOCtl(hCom, IOCTL_ASYNC, ASYNC_GETCOMMEVENT, 0, 0, 0, &errors, ulParmLen, &ulParmLen);
	if (rc != NO_ERROR && errors)
	{
		if (errors & 6) {
			LOG_MSG ("Serial port at 0x%x: line error: break received.", base);
			errreg |= LSR_RX_BREAK_MASK;
		}
	}
	if (errreg != 0)
	{
		receiveError (errreg);
	}

}

// recv and decode byte
ERecvState CChannelHandler::recv(unsigned char *byte)
{
    static bool decryptNext;
    unsigned char rawByte;
    
    if(!decryptNext)
    {
        if(receiveByte(&rawByte))
        {
            if(rawByte == '}')
            {
                return eRecvEnd;
            }
            else if(rawByte == '{')
            {
                return eRecvBegin;
            }
            else if(rawByte == '|')
            {
                decryptNext = true;
            }
            else
            {
                *byte = rawByte;
                return eRecvData;
            }
        }
    }
    
    if(decryptNext)
    {
        if(receiveByte(&rawByte))
        {
            decryptNext = false;
            *byte = rawByte ^ 0x20;
            return eRecvData;
        }
    }
    
    return eRecvNothing;
}

uint16_t SHT1x::readCommand(uint8_t command) {
	reset();

	// Send command
	startCommand();
	bool ok = sendByte(command);
	if(!ok)
		console.print(Error, "Error writing byte to sensor !!!");

	// Wait for competition
	delayTimer.mDelay(320);

	// Receive result
	union {
		uint16_t value;
		uint8_t bytes[2];
	} result;
	result.bytes[1] = receiveByte();
	result.bytes[0] = receiveByte();
	receiveByte();

	return result.value;
}