Rs485Dev.c

/*

 * Rs485Dev.c

 *

 * Created: 11.11.2016 06:22:25

 * Author: Admin

 */ 

#ifndef F_CPU

#define F_CPU 16000000UL

#endif

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

#include <stdio.h>

#include <stdbool.h>

#include <stdlib.h>

#include <string.h>

#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) \

( ( F_OSC ) / ( ( UART_BAUD_RATE ) * 8UL ) - 1 )

#define NOP asm volatile ("nop" ::)

#define NET_UCSRA             UCSR0A

#define NET_UCSRB             UCSR0B

#define NET_UCSRC             UCSR0C

#define NET_UDR               UDR0

#define CRC_BIT         0x10

#define INCLUDE_CRC(x)        (((x) & (CRC_BIT)) !=0) ? (2):(0)

#define MAX_DATA_LENGTH 10

#define CRC16_POLYNOM   0x1002

typedef struct {

  unsigned char RxAddress;

  unsigned char InfoByte;

  unsigned char TxAddress;

  unsigned char DataLength;

  unsigned char Data[MAX_DATA_LENGTH];

} st_protokoll_Data;

typedef void ( *fptrNetTask)(st_protokoll_Data*);

typedef struct{

  unsigned char MyAdr;

  bool MasterMode;

  unsigned int speed;

  fptrNetTask  fptrCallBackOnOk;

  }st_Dev_Config;

volatile bool DataOk;

/*     neu **********************/

bool LCD_Update;

unsigned char LCD_buf[20];

st_Dev_Config *Dev_Config;

st_protokoll_Data stRxData;

st_protokoll_Data stTxData;

unsigned char RxHeader;

unsigned char RxBody;

unsigned int RxCrc16;

unsigned int crc16;

unsigned char *NetTxPtr;

unsigned char NetTxCount;

unsigned char NetTxCount_temp;

void NetSetTxEnable(bool enable) {

  if (enable) {

    PORTB |= (1 << PINB2);

  }

  else {

    PORTB &= ~(1 << PINB2);

  }

}

void NetInit(st_Dev_Config *config) {

  char c;

  Dev_Config = config;

  UBRR0H = (unsigned char)(UART_BAUD_CALC(Dev_Config->speed, F_CPU) >> 8);

  UBRR0L = (unsigned char)UART_BAUD_CALC(Dev_Config->speed, F_CPU);

  NET_UCSRA = (1 << U2X0) | (1 << MPCM0);

  NET_UCSRB = (1 << UCSZ02) | (1 << RXCIE0) | (1 << RXEN0) | (1 << TXEN0) | (1 << TXCIE0); 

  NET_UCSRC = (1 << UCSZ01) | (1 << UCSZ00);

  NetSetTxEnable(false);

  c = NET_UDR; // Rx Buffer leeren und verwerfen

}

void InitCRC(void) {

  crc16 = 0xffff;

}

void CalcCRC(unsigned char data) {

  unsigned char bitCount;

  unsigned char PolynomFlag;

  for (bitCount = 0; bitCount < 8; bitCount++) {

    PolynomFlag = (crc16 & 0x8000) != 0;

    crc16 <<= 1;

    if (data & 0x80) {

      crc16 |= 1;

    }

    data <<= 1;

    if (PolynomFlag)

    crc16 ^= CRC16_POLYNOM;

  }

}

void Net_NewFrameStart(void) {

  RxHeader = 0x00;

  RxBody = 0x00;

  RxCrc16 = 0;

  InitCRC();

  stRxData.TxAddress = NULL;

}

void Net_SendFrame(void)

{

  int i, loop;

  i = 0;

  InitCRC();

  CalcCRC(stTxData.RxAddress);

  i++;

  CalcCRC(stTxData.InfoByte);

  i++;

  CalcCRC(stTxData.TxAddress);

  i++;

  CalcCRC((stTxData.DataLength += (INCLUDE_CRC(stTxData.InfoByte))));

  i++;

  for (loop = 0; loop < (stTxData.DataLength - (INCLUDE_CRC(stTxData.InfoByte))); loop++) // Framedaten

  {

    CalcCRC(stTxData.Data[loop]);

    i++;

  }

  CalcCRC(0);

  CalcCRC(0);

  stTxData.Data[loop++] = (crc16>>8)&0xff;

  stTxData.Data[loop] = (crc16)&0xff;

  NetTxCount = i+(INCLUDE_CRC(stTxData.InfoByte));

  NetTxCount_temp = NetTxCount;

  NetTxPtr = &stTxData.RxAddress;

  NetSetTxEnable(true);

  if(Dev_Config->MasterMode)NET_UCSRB |= (1<< TXB80); // nur beim Master

  NET_UCSRB |= (1<<UDRIE0); // Tx Empty einschalten

}

void Net_SendChar(unsigned char ptr_RXAddress,unsigned char *val,

unsigned int len)

{

  int loop;

  stTxData.RxAddress = ptr_RXAddress;

  stTxData.TxAddress = Dev_Config->MyAdr;

  stTxData.InfoByte = CRC_BIT;

  stTxData.DataLength = len;

  for(loop = 0; loop < len; loop++){

    stTxData.Data[loop] = *val++;

  }

  Net_SendFrame();

}

ISR(USART_UDRE_vect) // Tx Buffer ist leer und braucht nachschub

{

  if (NetTxCount)

  {

    if(NetTxCount != NetTxCount_temp)NET_UCSRB &= ~(1<< TXB80); 

    NET_UDR = *NetTxPtr;

    NetTxPtr++;

    NetTxCount--;

  }

  else

  NET_UCSRB &= ~(1<<UDRIE0); // Tx Empty abschalten

}

ISR(USART_TX_vect)  // Leztes Byte wurde gesendet

{

  NetSetTxEnable(false);

  NOP;

  NOP;

}

ISR(USART_RX_vect) {

    unsigned char ucRxByte;

  if (NET_UCSRA & ((1 << FE0) + (1 << DOR0))) // Fehler

  {

    ucRxByte = NET_UDR; // Rx Buffer leeren

    NET_UCSRA |= (1 << MPCM0); // MPCM Mode einschalten

    DataOk = false;

    return;

  }

  if ((NET_UCSRB & (1 << RXB80)) ) // OK mit 9. bit

  {

    ucRxByte = NET_UDR;

    if (ucRxByte == Dev_Config->MyAdr) {

      NET_UCSRA &= ~(1 << MPCM0); // MPCM Mode ausschalten

      stRxData.RxAddress = ucRxByte;

      Net_NewFrameStart();

      CalcCRC(ucRxByte);

      RxHeader++;

      return;

    }

    else // Packet ist nicht für mich gedacht.

    {

      NET_UCSRA |= (1 << MPCM0);

      return;

    }

  }

  // ab hier geht es weiter mit 8 bit

  ucRxByte = NET_UDR;

  if (RxHeader == 1) // Info BYTE

  {

    stRxData.InfoByte = ucRxByte;

    RxHeader++;

    CalcCRC(ucRxByte);

    return;

  }

  if (RxHeader == 2) // Sender ADR

  {

    stRxData.TxAddress = ucRxByte;

    RxHeader++;

    CalcCRC(ucRxByte);

    return;

  }

  if (RxHeader != 0xFF) // DATA Länge

  {

    RxHeader = 0xFF;

    stRxData.DataLength = ucRxByte;

    CalcCRC(ucRxByte);

    return;

  }

  if (RxBody < (stRxData.DataLength - (INCLUDE_CRC(stRxData.InfoByte)))) // DATA

  {

    stRxData.Data[RxBody] = ucRxByte;

    CalcCRC(ucRxByte);

    RxBody += 1;

    if (!INCLUDE_CRC(stRxData.InfoByte) &&

    (RxBody == stRxData.DataLength)) // Keine CRC nötig

    {

      NET_UCSRA |= (1 << MPCM0);

      Dev_Config->fptrCallBackOnOk(&stRxData);

    }

    return;

  }

  if (RxBody == (stRxData.DataLength - 2)) // CRC16 High

  {

    RxCrc16 = ucRxByte << 8;

    //stRxData.Data[RxBody] = ucRxByte;

    RxBody++;

    return;

  }

  if (RxBody == (stRxData.DataLength - 1)) // CRC16 Low

  {

    RxCrc16 |= ucRxByte;

    //stRxData.Data[RxBody] = ucRxByte;

    CalcCRC(0);

    CalcCRC(0);

    RxBody = RxHeader = 0;

    if (crc16 != RxCrc16) // fehler CRC

    {

      NET_UCSRA |= (1 << MPCM0);

      return;

    }

    else // alles OK

    {

      NET_UCSRA |= (1 << MPCM0);

      Dev_Config->fptrCallBackOnOk(&stRxData);

      return;

    }

  }

  if (RxBody==MAX_DATA_LENGTH)

  {

    NET_UCSRA |= (1 << MPCM0);

    return;

  }

}

#define SET_LED 0x01

#define GET_INPUT 0x02

#define RESET 0x03

#define SET_PWM 0x04

#define GET_ADC 0x05

#define START_BOOTLOADER 0x06

#define WRITE_LCD_BUFFER 0x07

#define SET_NET_ADR      0x08

/*  usw    */

void NetAktion(st_protokoll_Data* RxFrame)

{

  NOP;

  switch(RxFrame->Data[0])

  {

    case SET_LED:

    PORTC |= (1 <<RxFrame->Data[1]);

    break;

    case WRITE_LCD_BUFFER:

    memcpy (LCD_buf,&RxFrame->Data[1],(RxFrame->DataLength - (INCLUDE_CRC(RxFrame->InfoByte))));

    LCD_buf[(RxFrame->DataLength - (INCLUDE_CRC(RxFrame->InfoByte)))+1] = 0x00;

    LCD_Update = true;

    break;

    default:

      // Info an Master NO SERVICE AVAILABLE

    break;

  }

}

// Slave Main

int main(void) {

  unsigned char buf[20];

  DDRB = (1 << PINB5) | (1 << PINB2); // set PINB0 and PINB2 as output

  DDRC =0xff;

  st_Dev_Config my_Dev_config;

  my_Dev_config.fptrCallBackOnOk = NetAktion;

  my_Dev_config.MasterMode = false;

  my_Dev_config.MyAdr = 0x44; // oder aus EEProm auslesen

  my_Dev_config.speed = 9600;

  NetInit(&my_Dev_config);

  _delay_ms(200);

  sei();

  while (1) {

    if(LCD_Update)

    {

    //lcd_string(&LCD_buf);   // da ich deine LCD Lib nicht habe ist das ausgeklammert.

    LCD_Update = false;  

    }

  } // while

} // main

// Master Main

/*

int main(void) {

  unsigned char buf[20];

  DDRB = (1 << PINB5) | (1 << PINB2); // set PINB0 and PINB2 as output

  DDRC =0xff;

  st_Dev_Config my_Dev_config;

  my_Dev_config.fptrCallBackOnOk = NetAktion;

  my_Dev_config.MasterMode = true;

  my_Dev_config.MyAdr = 0x01; // oder aus EEProm auslesen

  my_Dev_config.speed = 9600;

  NetInit(&my_Dev_config);

  _delay_ms(200);

  sei();

  while (1) {

    _delay_ms(1000);

    buf[0] = WRITE_LCD_BUFFER;

    sprintf(&buf[1],"LED");

    Net_SendChar( 0x44,&buf[0],4);

  } // while

} // main

*/