Easyelectronics.ru

/*
* Tester.c
*
* Created: 02.10.2019 6:07:12
* Author : Михаил
*/



#define F_CPU 8000000UL
#define SCL_CLOCK 100000L
#define time 100L

#define BAUDRATE 9600


#include <avr/io.h>
#include <compat/twi.h>
#include <util/delay.h>

//Protutypes of TWI functions
void TWI_init ();
char TWI_start (unsigned char address);
void TWI_start_wait (unsigned char address);
char TWI_rep_start (unsigned char address);
void TWI_stop ();
char TWI_write (unsigned char data);
char TWI_readACK ();
char TWI_readNAK ();

//Prototypes of USART function
void USART_init(uint8_t speed);
void USART_transmit(char data);

//Prototupe of LCD functions
void LCD_send_command (uint8_t data);
void LCD_send_data (uint8_t data);
void LCD_init ();


int main(void){

   TWI_init();
   LCD_init();
   LCD_send_data('H');
   LCD_send_data('e');
   LCD_send_data('l');
   LCD_send_data('l');
   LCD_send_data('o');
   LCD_send_data(' ');
   LCD_send_data('W');
   LCD_send_data('O');
   LCD_send_data('R');
   LCD_send_data('L');
   LCD_send_data('D');
   TWI_stop();

      
   DDRD = 0xFF;
   PORTD = (1 << PIND7);
   
   USART_init(0);
   
   while (1){
      USART_transmit('1');
      _delay_ms(1000);
   }
}


// TWI_atmega8
void TWI_init(){
   TWSR = 0x00;
   TWBR = ((F_CPU / SCL_CLOCK) - 16) / 2;
}

char TWI_start (unsigned char address){
   uint8_t twst;
   
   TWCR |= (1 << TWINT) | (1 << TWSTA) | (1 << TWEN);
   while (!(TWCR & (1 << TWINT)));
   
   twst = (TW_STATUS & 0xF8);
   if ((twst != TW_START) && (twst != TW_REP_START))
   return 1;

   TWDR = address;
   TWCR |= (1 << TWINT) | (1 << TWEN);
   while (!(TWCR & (1 << TWINT)));
   
   twst = (TW_STATUS & 0xF8);
   if ((twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK))
   return 1;
   return 0;
}

void TWI_start_wait(unsigned char address){
   uint8_t   twst;
   while (1){
      // send START condition
      TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
      // wait until transmission completed
      while(!(TWCR & (1<<TWINT)));
      // check value of TWI Status Register. Mask prescaler bits.
      twst = TW_STATUS & 0xF8;
      if ( (twst != TW_START) && (twst != TW_REP_START)) continue;
      // send device address
      TWDR = address;
      TWCR = (1<<TWINT) | (1<<TWEN);
      // wail until transmission completed
      while(!(TWCR & (1<<TWINT)));
      // check value of TWI Status Register. Mask prescaler bits.
      twst = TW_STATUS & 0xF8;
      if ((twst == TW_MT_SLA_NACK )||(twst ==TW_MR_DATA_NACK)){
         // device busy, send stop condition to terminate write operation
         TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
         // wait until stop condition is executed and bus released
         while(TWCR & (1<<TWSTO));
         continue;
      }
      //if( twst != TW_MT_SLA_ACK) return 1;
      break;
   }
}

char TWI_rep_start(unsigned char address){
   return TWI_start(address);
}

char TWI_write (unsigned char data){
   uint8_t twst;
   TWDR = data;
   TWCR |= (1 << TWINT) | (1 << TWEN);
   while (!(TWCR & (1 << TWINT)));
   
   twst = TW_STATUS & 0xF8;
   if (twst != TW_MT_DATA_ACK)
   return 1;
   return 0;
}

void TWI_stop (){
   TWCR |= (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
   while (TWCR & (1 << TWSTO));
}


char TWI_readACK(){
   TWCR |= (1 << TWINT) | (1 << TWEN) | (1 << TWEA);
   while (!(TWCR & (1 << TWINT)));
   return TWDR;
}

char TWI_readNAK(){
   TWCR |= (1 << TWINT) | (1 << TWEN);
   while (!(TWCR & (1 << TWINT)));
   return TWDR;
}

//LCD functions!
void LCD_send_command(uint8_t data){
   uint8_t firstNibble = 0x00;
   uint8_t secondNibble = 0x00;
   
   firstNibble = (data & 0xF0);
   secondNibble = ((data & 0x0F) << 4);
   
   
   TWI_write((0x08 |firstNibble)); // Set up first nibble.
   _delay_us(time);
   TWI_write((0x0C | firstNibble)); // pin EN set up to high level
   _delay_us(time);
   TWI_write((0x08 | firstNibble)); // pin En set up to low level
   TWI_write((0x08 |secondNibble)); // set up second nibble
   _delay_us(time);
   TWI_write((0x0C | secondNibble)); // pin En set up to high level
   _delay_us(time);
   TWI_write((0x08 | secondNibble)); // pin en set up to lov level
   _delay_us(time);
}

void LCD_send_data(uint8_t data){
   uint8_t firstNibble = 0x00;
   uint8_t secondNibble = 0x00;
   
   firstNibble = (data & 0xF0);
   secondNibble = ((data & 0x0F) << 4);

   
   TWI_write((0x09 |firstNibble)); // Set up first nibble.
   _delay_us(time);
   TWI_write((0x0D | firstNibble)); // pin EN set up to high level
   _delay_us(time);
   TWI_write((0x09 | firstNibble)); // pin En set up to low level
   TWI_write((0x09 |secondNibble)); // set up second nibble
   _delay_us(time);
   TWI_write((0x0D | secondNibble)); // pin En set up to high level
   _delay_us(time);
   TWI_write((0x09 | secondNibble)); // pin en set up to lov level
   _delay_us(time);
   

}

void LCD_init(){
   TWI_start(0x4E);
   TWI_write(0x00);
   _delay_ms(1000);
   
   TWI_write(0x20);
   _delay_us(100);
   TWI_write(0x24);
   _delay_us(100);
   TWI_write(0x20);
   _delay_ms(5);
   LCD_send_command(0x28);
   LCD_send_command(0x08);
   LCD_send_command(0x01);
   _delay_us(100);
   LCD_send_command(0x06);
   LCD_send_command(0x0C);
   _delay_ms(10);
}

//USART
void USART_init(uint8_t speed){
   UBRRL = (F_CPU/BAUDRATE/16-1); // Вычисляем скорость обмена данными
   UBRRH = (F_CPU/BAUDRATE/16-1) >> 8;
   
   UCSRB |= (1 << RXCIE)| // Разрешаем прерывание по завершению приема данных
   (1 << RXEN)|(1 << TXEN); // Включаем приемник и передатчик
   
   UCSRC |= (1 << URSEL)| // Для доступа к регистру UCSRC выставляем бит URSEL
   (1 << UCSZ1)|(1 << UCSZ0);
   
}

void USART_transmit(char data){
   while(!( UCSRA & (1 << UDRE)));
   UDR = data;
}