// TX (hello.radio.c)
// Fab Academy Final Project
// Mio Kato
// 13/5/29

/****************************************************************/

/****************************************************************/
/* define serial_port add by mio */
// fanction
#define input(directions,pin) (directions &= (~pin)) // set port direction for input
#define set(port,pin) (port |= pin) // set port pin
#define clear(port,pin) (port &= (~pin)) // clear port pin
// serial
#define serial_port PORTD
#define serial_direction DDRD
#define serial_pins PINA
#define serial_rx (1 << PD0) // RXO

//#define DEBUG
/****************************************************************/
#include 
#include 
#include 
#include 
#include 

#define TRUE (0==0)
#define FALSE (0!=0)

typedef unsigned char		BOOL;			// 8-bit unsigned
typedef unsigned char		BYTE;			// 8-bit unsigned
typedef unsigned short int	WORD;			// 16-bit unsigned
typedef unsigned long		DWORD;			// 32-bit unsigned
typedef signed char         CHAR;			// 8-bit signed
typedef signed short int	SHORT;			// 16-bit signed
typedef signed long         LONG;			// 32-bit signed

typedef unsigned char		u08;			// 8-bit unsigned
typedef unsigned short int	u16;			// 16-bit unsigned
typedef unsigned long		u32;			// 32-bit unsigned
typedef signed char         s08;			// 8-bit signed
typedef signed short int	s16;			// 16-bit signed
typedef signed long         s32;			// 32-bit signed


/****************************************************************/
/* hal_spi.h */

#define DDR_SPI		DDRB
#define DD_SCK		RF_SCK
#define DD_MOSI		RF_MOSI
#define DD_MISO		RF_MISO

typedef enum {
  SPI_MSB_FIRST = 0, SPI_LSB_FIRST = 1
} SPI_data_order;

inline void SPI_Init (void);
inline unsigned char  SPI_Transfer_Byte (unsigned char d);

/****************************************************************/
/* hal_usart.h */

extern void USART_Init(void);
extern void USART_SetBaudRate(unsigned long baud);
extern void USART_Transmit(unsigned char data);
extern int  USART_Receive_Ready (void);
extern int  USART_Receive (unsigned char *data);

#define uartSendByte 	USART_Transmit
#define uartReceiveByte USART_Receive
#define uartInit	USART_Init
#define uartSetBaudRate USART_SetBaudRate

/****************************************************************/

#ifdef HELLO_RADIO_BREADBOARD
#include "hal_breadboard.h"
#endif
#ifdef HELL_O_RADIO_13
#include "hal_hell-o-radio-13.h"
#endif
#if defined(HELLO_RADIO_016) | defined(FABRADIO0_16)
#include "hal_hello_radio-016.h"
#endif

#define TXLED_ON	LED1_HI
#define TXLED_OFF	LED1_LO
#define RXLED_ON	LED0_HI
#define RXLED_OFF	LED0_LO

/****************************************************************/

//#define BAND_915
//#define BAND_868
#define BAND_434

#define XTAL_LD_CAP 0x0003		// crystal load 10pF

#define PAYLOAD_LEN 126		    	// maximum payload size
#define PACKET_LEN  PAYLOAD_LEN + 2	// maximum packet length with 2 byte CRC
#define PAYLOAD_MAX PACKET_LEN

#if 1
#if  defined(BAND_434)
#define FREQ_Band        0x0010		// 434MHz
#define _CFSREG           0xA640		// Center Frequency: 434MHz
#elif  defined(BAND_868)
#define FREQ_Band        0x0020		// 868MHz
#define _CFSREG           0xA640		// Center Frequency: 868MHz
#elif  defined(BAND_915)
#define FREQ_Band        0x0030	       	// 915MHz
#define _CFSREG           0xA7D0	       	// Center Frequency: 915.000MHz
#else
#error  "At least one frequency band must be defined"
#endif
#endif

#define _GENCREG                 (0x8000 | XTAL_LD_CAP |FREQ_Band)

#define AFCCREG                 0xC4F7
#define TXCREG                  0x9850	// deviation 90kHz, output power 7dBm-0dB
#define TXBREG                  0xB800
#define _RXCREG                  0x9481	// BW 200KHz, LNA gain 0dB, RSSI -97dBm
#define FIFORSTREG              0xCA81
#define _DRVSREG                 0xC623	// bit rate = 9579 / sec
#define PMCREG                  0x8201

/****************************************************************/

// transmit and receive packet buffers
//volatile BOOL       	hasPacket = FALSE;
//volatile BYTE       	RxPacket[PACKET_LEN];
//volatile BYTE       	RxPacketLen;
#if 0
BYTE 	       	TxPacket[PACKET_LEN] = {
  0xAA, 0xAA,
  0x55, 0x55,
  0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
  0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
  0x55, 0x55,
  0xAA, 0xAA
};
#endif

/****************************************************************/
/* app_sniffer.h */

#define NUM_RX_BUFS       4

BYTE FreqBand;
BYTE DataRate;
BYTE Deviation;
BYTE Channel;

WORD GENCREG = _GENCREG;
WORD DRVSREG = _DRVSREG;
WORD RXCREG  = _RXCREG;
WORD CFSREG  = _CFSREG;

/****************************************************************/

/****************************************************************/
/* hal_usart.c */

void USART_Init(void)
{
  /* Enable receiver and transmitter */
  UCSR0B = (1<>8);
  UBRR0L = (unsigned char)ubrr;
}

void USART_Transmit(unsigned char data)
{
  /* Wait for empty transmit buffer */
  while ( !( UCSR0A & (1<> i)) != 0) {
      RF_MOSI_HI ();
    } else {
      RF_MOSI_LO ();
    }
    data = (data << 1) | (RF_MISO_IN() ? 1 : 0);
#ifdef USE_HARDWARE_SPI
    RF_SCKm_ZZ();
#endif
    RF_SCK_HI ();
    RF_SCK_LO ();
  }
  RF_MOSI_LO ();
  return data;
#endif
}

inline unsigned char SPI_Transfer_Word (unsigned short w)
{
  unsigned short v;

#ifdef USE_HARDWARE_SPI
  SPDR = w >> 8;			  /* start transfer of high byte to SPI */
  while(!(SPSR & (1<> 8) >> 8;
  v |= SPI_Transfer_Byte (w & 255) & 255;
#endif

  return v;				  /* return stored word */
}

/****************************************************************/

void RF_Interface_Init(void)
{
  // set I/O ports
  RF_nCS_HI ();
  RF_MOSI_HI ();
  RF_MISO_ZZ ();
#ifdef RF_SCKm_ZZ
  RF_SCKm_ZZ ();
#endif
  RF_SCK_HI ();

#ifdef RF_FINT_ZZ
  RF_FINT_ZZ ();
#endif
  RF_nFSEL_ZZ ();
#ifdef RF_INT_ZZ
  RF_INT_ZZ ();
#endif
  RF_nIRQ_ZZ ();

  RF_nRST_LO();
  _delay_us(500);
  RF_nRST_HI ();
  _delay_us(500);
  RF_nRST_PU();

  BUT0_PU();

  LED0_HI ();
  _delay_ms (100);
  LED0_LO ();
  LED1_HI ();
  _delay_ms (100);
  LED1_LO ();

  // XXX - TODO: enable RF interrupts
}


void RF_Set_Register(WORD setting)
{
  RF_nCS_LO();				/* select MRF49XA SPI */
  SPI_Transfer_Word (setting);
  RF_nCS_HI();				/* deselect MRF49XA SPI */
}

void RF_Int_Disable (void)
{
  // XXX
}

void RF_Int_Enable (void)
{
  // XXX
}

//#define DEBUG
void MRF49XA_Init (void)
{
#ifdef DEBUG
  printf ("entering MRF49XA_Init ()\n");
#endif

  // configuring the MRF49XA radio
  RF_Int_Disable ();

  RF_Set_Register(FIFORSTREG);
#ifdef DEBUG
  printf ("FIFORSTREG\n");
#endif

  RF_Set_Register(FIFORSTREG | 0x0002);       // enable synchron latch
#ifdef DEBUG
  printf ("FIFORSTREG | 0x0002\n");
#endif

  RF_Set_Register(GENCREG);
#ifdef DEBUG
  printf ("GENCREG\n");
#endif

  RF_Set_Register(AFCCREG);
#ifdef DEBUG
  printf ("AFCCREG\n");
#endif

  RF_Set_Register(CFSREG);
#ifdef DEBUG
  printf ("CFSREG\n");
#endif

  RF_Set_Register(DRVSREG);
#ifdef DEBUG
  printf ("DRVSREG\n");
#endif

  RF_Set_Register(PMCREG);
#ifdef DEBUG
  printf ("PMCREG\n");
#endif

  RF_Set_Register(RXCREG);
#ifdef DEBUG
  printf ("RXCREG\n");
#endif

  RF_Set_Register(TXCREG);
#ifdef DEBUG
  printf ("TXCREG\n");
#endif

  // antenna tuning on startup
#ifdef DEBUG
  printf ("turning on transmitter ()\n");
#endif
  RF_Set_Register(PMCREG | 0x0020);	    // turn on the transmitter
  _delay_ms(5);			    // wait for oscillator to stablize
  // end of antenna tuning
  RF_Set_Register(PMCREG | 0x0080); 	    // turn off transmitter, turn on receiver
#ifdef DEBUG
  printf ("turned off transmitter, turned on receiver\n");
#endif

  RF_Set_Register(GENCREG | 0x0040);	// enable the FIFO
  RF_Set_Register(FIFORSTREG);
  RF_Set_Register(FIFORSTREG | 0x0002); 	// enable synchron latch
  RF_Set_Register(0x0000);		// read status byte (read ITs)

  RF_Int_Enable ();
}
#undef DEBUG

void Cmd_RF_buzz (void)
{
  int i;

  RF_Set_Register(FIFORSTREG);
  RF_Set_Register(FIFORSTREG | 0x0002);       // enable synchron latch
  RF_Set_Register(GENCREG);
  RF_Set_Register(AFCCREG);
  RF_Set_Register(CFSREG);
  RF_Set_Register(DRVSREG);
  RF_Set_Register(PMCREG);
  RF_Set_Register(RXCREG);
  RF_Set_Register(TXCREG);
  for (i = 0; i < 20; i++) {
    RF_Set_Register(PMCREG | 0x0020);	    // turn on the transmitter
    _delay_ms(1);
    RF_Set_Register(PMCREG | 0x0080); 	    // turn off transmitter
    _delay_ms(1);
  }
}


/****************************************************************/
/* RF_packet.c */

#include 

WORD CRC16(BYTE *ptr, BYTE count)
{
  WORD crc;

  crc = 0;

  while(count-- > 0 ) {
    crc = _crc_xmodem_update (crc, *ptr++);
  }

  return crc;
}

void MRF_Send_Packet(BYTE *packet, BYTE len)
{
    BYTE ptr; // send data packet?
    BYTE synCount;
    WORD crc = 0;

#define SPI_Transfer_Byte_CRC(b) {	\
      BYTE d=(b);			\
      crc =_crc_xmodem_update (crc, d);	\
      SPI_Transfer_Byte(d);		\
}

    TXLED_ON();

    if (len > PACKET_LEN) {
        len = PACKET_LEN;
    }

    //Start_Transmitting:
    RF_Int_Disable ();

    // Turn off receiver, enable the TX register
    RF_Set_Register(PMCREG);
    RF_Set_Register(GENCREG | 0x0080);

    // enable transmitter
    RF_Set_Register(PMCREG | 0x0020);


    RF_nCS_LO ();			// select MRF49XA SPI */

    SPI_Transfer_Byte(0xB8);                 // FIFO write
    SPI_Transfer_Byte(0xAA);                 // 3rd preamble

    for (ptr = 0, synCount = 0; ptr < len+2; ) {    // 2 CRC bytes follow packet
      if( RF_MISO_IN() ) {
          if( ptr == 0 && synCount < 3 ) {
              switch(synCount) {
                  case 0:
                      SPI_Transfer_Byte(0x2D);
                      break;
                  case 1:
                      SPI_Transfer_Byte(0xD4);
                      break;
                  case 2:
                      crc = 0;
                      SPI_Transfer_Byte_CRC(len+2);
                      break;
                  default:
                      break;
              }
              synCount++;
          } else {
              if (ptr < len) {
                  SPI_Transfer_Byte_CRC(packet[ptr]);
              } else if (ptr == len) {
                  SPI_Transfer_Byte(crc >> 8);
              } else if (ptr == len+1) {
                  SPI_Transfer_Byte(crc &  0xff);
              }
              ptr++;
          }
        }
        }

    RF_nCS_HI ();

    // Turn off the transmitter, disable the Tx register
    RF_Set_Register(PMCREG | 0x0080);
    RF_Set_Register(GENCREG | 0x0040 );
    RF_Set_Register(FIFORSTREG | 0x0002);
    RF_Int_Enable ();

    TXLED_OFF ();
}

/****************************************************************/
/* RF_interrupts.c */

BOOL RF_Int_Enabled (void)
{
  return TRUE;
}


BOOL RF_Int_Flag (void)
{
  return TRUE;
}

void RF_Int_Clear (void)
{
}

#if 0
volatile BOOL RxPacketValid[NUM_RX_BUFS];
BYTE RxPacket[NUM_RX_BUFS][PACKET_LEN];
volatile BYTE RxPacketLen[NUM_RX_BUFS];
WORD totalReceived = 0;

int ISR(INT0_vect)
{
  if (RF_Int_Enabled() && RF_Int_Flag()) {
    RF_nCS_LO ();
    if (RF_MISO_IN ()) {
      BYTE RxPacketPtr;
      BYTE tmpPacketLen;
      WORD counter;

      // There is data in RX FIFO
      RF_nCS_HI ();
      RF_nFSEL_LO ();                   // FIFO selected

      tmpPacketLen = SPI_Transfer_Byte(0);

      if (tmpPacketLen >= PAYLOAD_LEN || tmpPacketLen == 0 || hasPacket) {
      IGNORE_HERE:
	RF_nFSEL_HI();                          // bad packet len received
	RF_Set_Register(PMCREG);                // turn off the transmitter and receiver
	RF_Set_Register(FIFORSTREG);            // reset FIFO
	RF_Set_Register(GENCREG);               // disable FIFO, TX_latch
	RF_Set_Register(GENCREG | 0x0040);      // enable FIFO
	RF_Set_Register(PMCREG | 0x0080);       // turn on receiver
	RF_Set_Register(FIFORSTREG | 0x0002);   // FIFO synchron latch re-enabled
	goto RETURN_HERE;
      }

      RxPacketLen = tmpPacketLen;
      RXLED_ON();
      RF_nFSEL_HI();

      RxPacketPtr = 0;
      counter = 0;

      while(1) {
	  if (counter++ == 0xFFFF) {
	      goto IGNORE_HERE;
	  } else if (RF_FINT_IN()) {
	      RF_nFSEL_LO ();
	      counter = 0;
	      RxPacket[RxPacketPtr++] = SPI_Transfer_Byte(0);

	      if (RxPacketPtr >= RxPacketLen) {
		  WORD received_crc;
		  WORD calculated_crc;
		  BYTE i;

		  RF_nFSEL_HI();
		  RF_Set_Register(FIFORSTREG);
		  RXLED_OFF();

		  RxPacketLen -= 2;       // do not count CRC
		  received_crc = ((WORD)RxPacket[RxPacketLen+1])
		    + (((WORD)RxPacket[RxPacketLen]) << 8);
		  calculated_crc = CRC16((BYTE *)RxPacket, RxPacketLen);

		  if (received_crc != calculated_crc) {
		      RxPacketPtr = 0;
		      RxPacketLen = 0;
		      // FIFO synchron latch re-enable
		      RF_Set_Register(FIFORSTREG | 0x0002);
		      goto IGNORE_HERE;
		  }

		  RF_Set_Register(FIFORSTREG | 0x0002);
		  hasPacket = TRUE;

		  goto RETURN_HERE;
	      }
	      RF_nFSEL_HI();
	  }
      }
    } else {            // read the rest of the interrupts
	SPI_Transfer_Byte(0);
  	RF_nCS_HI ();
    }

  RETURN_HERE:
    RF_Int_Clear ();
  }
}
#endif

/****************************************************************/

#define NODATA		0
#define DATA_RECEIVED	-1
#define PACKET_RECEIVED 1

int MRF_Receive_Packet (BYTE *data, BYTE *length)
{
  static unsigned char len = 0;
  static unsigned char nrbytes = 0;
  unsigned char bl;

  RF_nCS_LO();		// chip select low

  if (RF_MISO_IN()) {		// in case of FINT then read out
    RF_nCS_HI();
    RF_nFSEL_LO();
    if(len) {	       // is this the first byte? go on if not
      // number of bytes in payload is the first byte
      data[(nrbytes++)] = SPI_Transfer_Byte(0);

      if (nrbytes >= len) {    // end of packet
	RF_Set_Register(FIFORSTREG); // reset FIFO
	RF_nFSEL_HI();		     // whole packet received
	*length = nrbytes;
	nrbytes=0;
	len =0;
	return PACKET_RECEIVED;
      }
    } else {			// the first byte received
      bl=SPI_Transfer_Byte(0);
      // check if correct number of bytes in payload
      if((bl>0) && (bl>4)]);
  putchar (hex[0xf & (b)   ]);
}

#define BUTTON0_PRESSED() (!BUT0_IN())

//#define DEBUG

void Cmd_TXRX_button_loop (void)
{
  BYTE c;
  BYTE rx_len, tx_len = 0, i;
  BOOL receiving = FALSE;
  BOOL building_packet = FALSE;
  BYTE button_down = 10;
  WORD crc = 0, pcrc;

  while (1) {
    if (!receiving) {
      if (BUTTON0_PRESSED()) {
          button_down = 10;

          input(serial_direction, serial_rx); // DDRD set input
          set(serial_port, serial_rx); // PORTD set pull up

          char x[1];
          x[0] = 0b00001000;

          MRF_Send_Packet ((BYTE *)x, 3);

      } else if (button_down > 0) {
          button_down--;
          MRF_Send_Packet ((BYTE *)"radio", 5);
      }
    }

    switch (MRF_Receive_Packet (rx_packet, &rx_len)) {
    case NODATA:
      break;

    case DATA_RECEIVED:
      RXLED_ON();
      receiving = TRUE;
      break;

    case PACKET_RECEIVED:
      RXLED_OFF();
      receiving = FALSE;

      for (i = 0; i < rx_len - 2; i++) {
	crc =0;
	crc = _crc_xmodem_update (crc, rx_packet[i]);
      }

      pcrc = rx_packet[rx_len]<<8 | rx_packet[rx_len+1];

      if (TRUE || crc == pcrc) {
#ifdef DEBUG
	printf ("[%02x]", rx_len);
#endif
	putchar ('{');
#ifdef DEBUG
	for (i = 0; i < rx_len; i++) {
	  puthex (rx_packet[i]);
	}
#else
	for (i = 0; i < rx_len - 2; i++) {
	  putchar (rx_packet[i]);
	}
#endif
	putchar ('}');
      }
      RF_Set_Register(FIFORSTREG | 0x0002); // FIFO sync latch re-enable
#ifdef DEBUG
      printf ("<%04x,%04x>", pcrc, crc);
#endif
      putchar ('\n');
      break;

    default:
      break;
    }

    if (USART_Receive_Ready()) {
      USART_Receive (&c);
      switch (c) {
      case '{':
	tx_len = 0;
	building_packet = TRUE;
	break;

      case '}':
	MRF_Send_Packet (tx_packet, tx_len);
	break;

      case '\033':
      case 'x':
      case 'q':
	if (!building_packet)
	  return;
      default:
	if (tx_len < PACKET_LEN) {
	  tx_packet[tx_len++] = c;
	}
	break;
      }
    }
  }
}

void Cmd_TX_loop (void)
{
  BYTE dummy;

  while (!USART_Receive_Ready()) {
    MRF_Send_Packet ((BYTE *)"Hello, radio!", 13);
    _delay_ms (100);
  }
  USART_Receive (&dummy);
  return;
}

BOOL running = TRUE;
void Cmd_Interpreter (void)
{
  BYTE c;

  while (running) {
    printf ("> ");
    while (!USART_Receive_Ready());
    if (USART_Receive (&c)) {
      printf ("%c\n", c);
      switch (c) {
      case '?':
	printf ("?\tprint this help message\n");
	printf ("b\tbuzz on RF (500 Hz OOK for 20 cycles\n");
	printf ("r\treceive and print packets until keypress\n");
	printf ("t\ttransmit packets until keypress\n");
	printf ("k\tremote keyfob demo loop until keypress\n");
	break;
      case 't':
	Cmd_TX_loop ();
	break;
      case 'r':
	Cmd_RX_loop ();
	break;
      case 'b':
	Cmd_RF_buzz ();
	break;
      case 'k':
	Cmd_TXRX_button_loop ();
	break;
      default:
	printf ("unknown command\n");
	break;
      }
    }
  }
}

/****************************************************************/

char version[] = "hello_radio.c - Hello Radio v0.2 " __DATE__ " " __TIME__;

int main(void)
{
    BYTE c;

    cli();

    BUT0_PU ();
    LED1_HI ();
    //  while (BUT0_IN());
    LED1_LO ();

    USART_Init ();
    USART_SetBaudRate (9600L);
    stdout = stdout_usart;
    //printf ("\n*** %s ***\n", version); // Not show, because I only communicate one microcomtroller.

    // printf ("initializing SPI...");
    SPI_Init ();
    // printf ("\n");

    // printf ("initializing RF interface...");
    RF_Interface_Init ();
    // printf ("\n");

    // printf ("MRF49XA_init()...");
    MRF49XA_Init ();
    printf ("\n");

    unsigned char chr[1];
      while(1){
        while (!USART_Receive_Ready());
        USART_Receive (&chr);
        MRF_Send_Packet (chr, 1);
      }
    // printf ("\n");
    Cmd_TXRX_button_loop ();

    printf ("*** entering command interpreter; type '?' for help\n");
    Cmd_Interpreter ();

    return 0;
}