/*                                -----\ /-----
                       MCLR/VPP  <01>       <28>  RB7/PGD.......<DBGTX>
    <PRES>..............RA0/AN0  <02>       <27>  RB6/PGC.......<DBGRX>
    <BATT>..............RA1/AN1  <03>   P   <26>  RB5...........<PTT>
    <CHRG>..RA2/AN2/VREF-/CVREF  <04>   I   <25>  RB4...........<CW>
          ....... RA3/AN3/VREF+  <05>   C   <24>  RB3/PGM.......<>
     <ANE>......RA4/T0CKI/C1OUT  <06>       <23>  RB2...........<ANE_E>
          .....RA5/AN4/SS/C2OUT  <07>   1   <22>  RB1...........<LED>
                            VSS  <08>   6   <21>  RB0/INT.......<>
                      OSC1/CLKI  <09>   F   <20>  VDD
                      OSC2/CLKO  <10>   8   <19>  VSS
          ......RC0/T1OSO/T1CKI  <11>   7   <18>  RC7/RX/DT.....<>
          .......RC1/T1OSI/CCP2  <12>   6   <17>  RC6/TX/CK.....<>
          .............RC2/CCP1  <13>       <16>  RC5/SDO.......
     <SCL>..........RC3/SCK/SCL  <14>       <15>  RC4/SDI/SDA...<SDA>
                                  -------------                               */

#include <16F876A.h>
#device ADC=10       // 10 bits ADC resolution

#include <stdlib.h>

#FUSES NOWDT         // No Watch Dog Timer
#FUSES HS            // Crystal osc <= 4mhz
#FUSES PUT           // Power Up Timer
#FUSES NOPROTECT     // Code not protected from reading
#FUSES NODEBUG       // No Debug mode for ICD
#FUSES NOBROWNOUT    // No brownout reset
#FUSES NOLVP         // No low voltage prg, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD         // No EE protection
#FUSES WRT_50%       // Lower half of Program Memory is Write Protected

#define PIN_ANE_E       PIN_B2   // Anemometer enable (5V for open collector)
#define PIN_CW          PIN_B4   // CW Audio Outpu
#define PIN_PTT         PIN_B5   // Push-To-Talk for radiot
#define PIN_DBGRX       PIN_B6   // Serial RX
#define PIN_DBGTX       PIN_B7   // Serial TX
#define PIN_PRESS       PIN_A0   // Pressure Sensor Signal (1:1/1)
#define PIN_BATT        PIN_A1   // Battery Voltage Input (1:1/3)
#define PING_CHRG       PIN_A2   // Charge Current Sensor Signal (1:1/1)
#define PIN_ANE      PIN_A4   // Anemometer Signal (10 pulses per rev.)
#define PIN_SCL         PIN_C3   // I2C SCL for LM35
#define PIN_SDA         PIN_C4   // I2C SDA for LM35

#define CW_T   60                // CW "T" unit (ms)
#define CWID  {0xC0,0x70,0xF4,0x48,0xA0,0xD8,0x00,0xD0,0xB0,0xC0,0x00,0x58,0xD0,0xC0,0x60,0x58,0xA0,0xFF}
            //    E    D    4    Y    A    F         U    R    E         C    U    E    N    C    A
         
         /* CW TABLE
         A 1010 0000   0xA0   N 0110 0000   0x60   Z 0011 1000   0x38
         B 0111 1000   0x78   O 0001 0000   0x10   0 0000 0100   0x04
         C 0101 1000   0x58   P 1001 1000   0x98   1 1000 0100   0x84
         D 0111 0000   0x70   Q 0010 1000   0x28   2 1100 0100   0xC4
         E 1100 0000   0xC0   R 1011 0000   0xB0   3 1110 0100   0xE4
         F 1101 1000   0xD8   S 1111 0000   0xF0   4 1111 0100   0xF4
         G 0011 0000   0x30   T 0100 0000   0x40   5 1111 1100   0xFC
         H 1111 1000   0xF8   U 1101 0000   0xD0   6 0111 1100   0x7C
         I 1110 0000   0xE0   V 1110 1000   0xE8   7 0011 1100   0x3C
         J 1000 1000   0x88   W 1001 0000   0x90   8 0001 1100   0x1C
         K 0101 0000   0x50   X 0110 1000   0x68   9 0000 1100   0x0C
         L 1011 1000   0xB8   Y 0100 1000   0x48   */

int T0_OVERFLOW;
int T1_OVERFLOW;
int16 ADC_DATA;

char *MSG="EE.E,EEE,EEE,EE,EEEE";
//         VV.V,AAA,GGG,WW,PPPP

#use delay(clock=4000000)
#use rs232(baud=9600,parity=N,xmit=PIN_DBGTX,rcv=PIN_DBGRX,bits=8)

#use i2c(Master,Fast,sda=PIN_SDA,scl=PIN_SCL)

#int_timer0
timed_0_int(){
   T0_OVERFLOW=1;
}

#int_timer1
timed_1_int(){
   T1_OVERFLOW=1;
}

void NewLine(){
   printf("\r\n");
}

char LONG_2_CHAR(int32 NUM, int POS){
  char STR[6];
  itoa(NUM,10,STR);
  if (POS<strlen(STR))
     return(STR[strlen(STR)-POS-1]);
  else
     return('0');
}

void CW_tone(T_Units){
   long Ticks;
   Ticks=65535-((T_Units * CW_T)/0.008);  //65535-(T_Units * CW_T)/T1_TICK
   setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
   enable_interrupts(INT_TIMER1); 
   enable_interrupts(GLOBAL);
   set_timer1(Ticks);
   T1_OVERFLOW=0;
   while(!T1_OVERFLOW){                   // Tone generation
      output_high(PIN_CW);
      delay_us(617);                      // 1/2 wave @800Hz = 0.625ms (8us compensation)
      output_low(PIN_CW);
      delay_us(617);
      };
   output_high(PIN_CW);               // Always leave CW line high
   delay_us(617);                      
   output_float(PIN_CW);
   disable_interrupts(INT_TIMER1); 
   disable_interrupts(GLOBAL);
   setup_timer_1(T1_DISABLED);   
   }

void CW_letter(byte Letter){

   /* The NCDXF/IARU International Beacon Network (John. Troster, W6ISQ)
   http://www.iaru.org/articles/9411049.pdf
      
   Algorith idea by Curtis K6KU and used in the CDXF/IARU International Beacon Network
      
   ...The keying is accomplished electrically with one section of a 7417 open-collector
   driver chip. The program for sending Morse code, written by Jack Curtis, K6KU, was
   carried   over from the original beacon. The messages to be sent by the beacon are 
   stored in the memory as a string of ASCII characters, rather than as a string of dots
   and dashes. To send a character, the character is looked up in a table that specifies
   the dot and dash representation of the character. As one might imagine, a 1 bit in the
   specification stands for a dot and a 0 bit stands for a dash; the tricky part is to 
   find some simple way to specify how many dots and dashes a particular character requires.
      
   The solution is useful for any program that sends Morse code. The unused bit positions
   are filled with a 1   followed by enough 0s to fill the byte: A is encoded as 1010000 for
   dot-dash; B is encoded as 01111000 for dash-dot-dot-dot; and so on. If you have written
   any bit-twiddling programs, you can probably imagine the algorithm for sending the
   character specified in such a way: If the high-order bit of the specification is a 1,
   send a dot, otherwise send a dash. Shift the specification left one bit position, throwing
   away the old high-order   bit and filling the low-order bit with a 0. If the specification
   is now 10000000, exit; otherwise, go back to send the next dot or dash... */

   int Symbol,T_Units;
   while(Letter!=0b10000000){
      Symbol=Letter&0b10000000;   // we only care about the first bit
      if (Symbol==0)
         T_Units=3;              // DAH: tone will last 3x T_units long
      else
         T_Units=1;              // DI: tone will last 1x T_units long
      CW_tone(T_Units);
      delay_ms(CW_T);            // delay after each symbol
      Letter=Letter<<1;
   };
   delay_ms(CW_T*2);             // delay after each letter
}

void CW_BEACON(){
   int Pointer;
   char const Message[]=CWID;
   for (Pointer=0;Message[Pointer]!=0xFF;Pointer++){
      if (Message[Pointer]==0x00)
         delay_ms(CW_T*3); // delay after each word
      else
         CW_letter(Message[Pointer]);
   };
}

int16 GET_ADC(int CHANNEL){

   int16 VALUE;
   
   setup_adc_ports(ALL_ANALOG);
   setup_adc(ADC_CLOCK_DIV_8);
   set_adc_channel(CHANNEL);
   delay_ms(100);   
   VALUE=read_adc();
   delay_ms(50);
   setup_adc(ADC_OFF);
   return(VALUE);

}

void GET_BATTERY(){

/* Batery voltage is divided to 1/3 before connecting to the ADC              */

   ADC_DATA=GET_ADC(1);                // Read Channel 1
   ADC_DATA=ADC_DATA*14.7;             // Voltage scalation with REF=5V to 3X
   
   MSG[0]=LONG_2_CHAR(ADC_DATA,4);
   MSG[1]=LONG_2_CHAR(ADC_DATA,3);
   MSG[3]=LONG_2_CHAR(ADC_DATA,2);

}

void GET_CHARGE(){  // Charge current

   ADC_DATA=GET_ADC(2);                // Read Channel 0
   ADC_DATA=ADC_DATA*14.53;            // Conversion to mA (calibrated to 615mA)
   
   if (ADC_DATA<1000){
      MSG[5]=LONG_2_CHAR(ADC_DATA,2);
      MSG[6]=LONG_2_CHAR(ADC_DATA,1);
      MSG[7]=LONG_2_CHAR(ADC_DATA,0);
   }
   else if (ADC_DATA<10000){
           MSG[5]=LONG_2_CHAR(ADC_DATA,3);
           MSG[6]='.';
           MSG[7]=LONG_2_CHAR(ADC_DATA,2);
        }
        else {
           MSG[5]='>';
           MSG[6]='1';
           MSG[7]='0';        
        }
}

void GET_PRESSURE(){

/* From the output vs pressure table that EA4BCR provided, I calculated the
   DAC vs PRESSURE trend line parameters to be mBAR = 0.9531DAC + 119.91      */
   
   ADC_DATA=GET_ADC(0);                // Read Channel 0
   //ADC_DATA=ADC_DATA*0.95+222;         // Curve and sea level compensation
   ADC_DATA=ADC_DATA+182;
   
   msg[16]=LONG_2_CHAR(ADC_DATA,3);
   msg[17]=LONG_2_CHAR(ADC_DATA,2);
   msg[18]=LONG_2_CHAR(ADC_DATA,1);
   msg[19]=LONG_2_CHAR(ADC_DATA,0);
}

void GET_WIND(){

/* The anemometer outputs 10 pulses per m/s, from 2 to 30m/s, which makes it
   very easy to read the wind speed. We use a 8-bit counter in the pic to read
   the number of pulses during a gate time of 800ms, with the prescaler set
   to 1. This setting covers the wind speed up to 32m/s, more than what the
   anemometer is specified for. An overflow timer indicates error condition.  */
   
   int Counts;
   
   output_high(PIN_ANE_E);
   delay_ms(250);
   
   setup_timer_0(RTCC_EXT_L_TO_H|RTCC_DIV_1);   // Timer0 setup & int. enable
   enable_interrupts(INT_TIMER0); 
   enable_interrupts(GLOBAL);
   set_timer0(0);
   T0_OVERFLOW=0;

   delay_ms(800);                            // Gate & reading
   Counts=get_timer0()/8;                    // Actual m/s calculation   

   disable_interrupts(INT_TIMER0);           // Timer1 int. disable
   disable_interrupts(GLOBAL);
   output_low(PIN_ANE_E);

   if (!T0_OVERFLOW){
      MSG[13]=LONG_2_CHAR(Counts,1);
      MSG[14]=LONG_2_CHAR(Counts,0);
   }

}

void GET_TEMPERATURE(){

/* Temperature is read from an LM75 with SDA and SCL connected to RC4 and RC3 */

   int dataL;
   signed int dataH;
   
   output_high(PIN_SCL );    // i2c Bus Iddle
   output_high(PIN_SDA );

   // LM75 Start
   i2c_start();
   i2c_write(0b10010000);  // LM75 at address 00 and WRITE
   i2c_write(0b00000001);  // POINTER BYTE to CONFIGURATION REGISTER
   i2c_write(0b00000000);  // Config BYTE (LSB=0: operating)
   i2c_stop();
   delay_ms(100);

   // LM75 Read
   i2c_start();
   i2c_write(0b10010000);
   i2c_write(0b00000000);  // POINTER BYTE to TEMPERATURE REGISTER
   
   i2c_start();
   i2c_write(0b10010001);  // LM75 at address 00 and READ
   dataH = i2c_read();     // with ACK
   dataL = i2c_read();    // with NOACK 
   i2c_stop(); 
   delay_ms(50);
   
   // LM75 Shutdown
   i2c_start();
   i2c_write(0b10010000);  // LM75 at address 00 and WRITE
   i2c_write(0b00000001);  // POINTER BYTE to CONFIGURATION REGISTER
   i2c_write(0b00000001);  // Config BYTE (LSB=1: shutdown)
   i2c_stop();
   
   if (dataH<0){
      MSG[9]='-';
      dataH=-dataH;
   }
   else
      MSG[9]='+';
   MSG[10]=LONG_2_CHAR(dataH,1);
   MSG[11]=LONG_2_CHAR(dataH,0);
  
}

void TELEMETRY_PACKET(){
   //
   printf(MSG);
   putc(0x0A);
   //NewLine();
}

void PAUSE_10()
{
   int Second,Minute;
   
   for (Minute=0;Minute<10;Minute++)
      for (Second=0;Second<60;Second++)
         delay_ms(1000);
}            

void main()
{

   char c;

   // Wizard Generated Code
   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_OFF);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   
   // Inital settings
   output_float(PIN_CW);
   output_low(PIN_PTT);
   output_low(PIN_ANE_E);
   delay_ms(1000);
  
   // Measurements not related to TX current
   GET_TEMPERATURE();
   GET_PRESSURE();
   GET_WIND();      
   
   // TX cycle
   output_high(PIN_PTT);
   delay_ms(250);
   //CW_BEACON();
   GET_CHARGE();
   GET_BATTERY();
   TELEMETRY_PACKET();
   delay_ms(1000);
   output_low(PIN_PTT);
   
   delay_ms(1000);
   PAUSE_10();
   reset_cpu();
   
}