/[H9]/trunk/Embedded/main.c
ViewVC logotype

Diff of /trunk/Embedded/main.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 112 by hedin, Fri Nov 30 16:07:03 2007 UTC revision 155 by hedin, Wed Dec 5 09:53:16 2007 UTC
# Line 1  Line 1 
1  #include <pic18.h>  #include <pic18.h>
2  #include <stdio.h>  #include <stdio.h>
3    #include <htc.h>
4  #include <string.h>  #include <string.h>
5    
6  #include "lcd.h"  #include "lcd.h"
7    #include "Delay.h"
8  // Delay.h is included inside lcd.c  // Delay.h is included inside lcd.c
9    
10  #define LCD_LENGTH 16  #define LCD_LENGTH 16
11  #define LCD_ROWS 2  #define LCD_ROWS 2
12    #define BUFFER 128
13    #define PWRFAIL RB1
14    #define FIREDET RB2
15    #define FEEDING RB3
16    #define EMPTYTANK RB4
17    
18    
19  unsigned char global_Pot_Hi;  unsigned char global_Pot_Hi, global_Pot_Lo;
 unsigned char global_Pot_Lo;  
20  unsigned char global_LCD_Buffer[LCD_ROWS][LCD_LENGTH];  unsigned char global_LCD_Buffer[LCD_ROWS][LCD_LENGTH];
21  /*void AD_init(void)  unsigned char global_serial_send[BUFFER], global_serial_recieve_buffer[BUFFER];
22    bit global_recieve_done = 0, global_interval_changed = 0;
23    unsigned int global_serial_byte_counter = 0, global_sms_counter = 1, global_time_counter = 0;
24    unsigned int global_emergency_counter = 600, global_time_interval = 3600;
25    unsigned char global_temp = 0;
26    
27    unsigned char global_message_buffer[BUFFER];
28    unsigned char global_message_buffer_length;
29    
30    unsigned char global_lcd_buf[16];
31    
32    unsigned short global_imei_tversum;
33    
34    unsigned char cell_nr[15] = ""; // = "21681784";
35    bit global_modem_init = 0;
36    
37    unsigned char global_sms_recieve_number[3];
38    
39    __EEPROM_DATA( 60, 0, 1, 8, '2', '1', '6', '8');
40    __EEPROM_DATA( '1', '7', '8', '4',0,0,0,0);
41    
42    void serial_recieved(void);
43    void serial_send(void);
44    void update_lcd(void);
45    void convertTemp(void);
46    void timer1_interrupt(void);
47    void on_recieve(void);
48    void on_initial_recieve(void);
49    void sms_recieved(void);
50    
51    
52    void reset_recieve_buffer(void)
53  {  {
54          ADON    = 1;          global_recieve_done = 0;
55  }          
56  */          global_serial_byte_counter=0;
57  // Nicked from H7          global_serial_recieve_buffer[0] = 0;
58  void ad_init(void)          
59            global_message_buffer_length = 0;
60            global_message_buffer[0] = 0;  
61    }      
62    
63    
64    void ad_init(void) // Nicked from H7
65  {  {
66          // AD Conversion clock          // AD Conversion clock
67          ADCS0 = 0;          ADCS0 = 0;
# Line 36  void ad_init(void) Line 80  void ad_init(void)
80          PCFG2=1;          PCFG2=1;
81          PCFG3=1;          PCFG3=1;
82                    
83          //Result is left justified          //Result is right justified
84          ADFM=0;          ADFM=1;
85                    
86          //Fire up for A/D converter module          //Fire up for A/D converter module
87          ADON=1;          ADON=1;
# Line 46  void ad_init(void) Line 90  void ad_init(void)
90  void rs232_init(void)  void rs232_init(void)
91  {  {
92          SPEN    = 0;    // Serial Port Enable Bit... 0 = disabled          SPEN    = 0;    // Serial Port Enable Bit... 0 = disabled
93          TRISC6  = 0;          TRISC6  = 0;    
94          TRISC7  = 1;          TRISC7  = 1;
95          SYNC    = 0;    // SYNC switches between async(0) and sync(1) mode.  
96          SPBRG   = 25;          SPBRG   = 207;  // 1200 baud rate... 25 = 9600
97          TXSTA   = 0x24;                                          // x = (Fosc / (16*[baud rate]) )-1
98          RCSTA   = 0x90;          TXSTA   = 0x24; // Enables BRGH and TXEN inthe TXSTA register
99          SPEN    = 1;          RCSTA   = 0x90; // 0x90 enables SPEN and CREN in the RCSTA register
100  }  }
101    
102  void interrupt_init(void)  void interrupt_init(void)
# Line 60  void interrupt_init(void) Line 104  void interrupt_init(void)
104          // Assumes that all interrupts default is 0          // Assumes that all interrupts default is 0
105          PEIE    = 1;          PEIE    = 1;
106          GIE             = 1;          GIE             = 1;
107          RCIE    = 1;          RCIE    = 1;    // Recieve interrupt enable.
108            IPEN    = 0;    // Nfo interrupt priority
109            TXIE    = 0;    // Serial interrupt enabled
110            TMR1IE  = 1;    // Enables timer 1
111  }        }      
112    
113    void timer_init(void)
114    {
115            TMR1CS = 1; //use external clock
116            
117            T1CKPS1 = 1; //1:8 prescale
118            T1CKPS0 = 1;
119            
120            TMR1H = 0xEF;
121            TMR1L = 0xFF;
122    
123            T1OSCEN = 1; //enable oscillator circuit        
124            RD16 = 0; //normal 8 bit writes
125            TMR1ON = 1;
126    }
127    
128  void pic18_io_init(void)  void pic18_io_init(void)
129  {  {
130          TRISA0  = 1;    // analog input          TRISA0  = 1;    // analog input
131            TRISA1  = 0;    // Output
132          TRISB1  = 1;    // TRISB1-4 Digital input          TRISB1  = 1;    // TRISB1-4 Digital input
133          TRISB2  = 1;          TRISB2  = 1;
134          TRISB3  = 1;          TRISB3  = 1;
135          TRISB4  = 1;          TRISB4  = 1;
136  }        }      
137    
138  void interrupt_recieve_handler(void)  void sms_init(void)
139  {  {
140          // Handle recieve inputs...          int i;
141    
142            reset_recieve_buffer();
143            sprintf(global_serial_send,"at+cgsn\r");
144            serial_send();
145            DelaySek(1);
146            while(!global_recieve_done) ;
147    
148    
149            sprintf(global_serial_send,"%s", "at+cpin=8043\r");
150            serial_send();
151            
152            while(global_modem_init == 0)
153            {
154                    on_initial_recieve();
155            }
156  }  }
157    
158    
159  void interrupt interrupt_handler(void)  void interrupt interrupt_handler(void)
160  {  {
161          // Finds out what interrupt have been trigged, and starts the respective function.          // Finds out what interrupt have been trigged, and starts the respective function.
162          if(RCIF == 1)          if(RCIF == 1)                   // Serial recieve interrupt
163          {          {
164                  interrupt_recieve_handler();                  serial_recieved();
165                  RCIF = 0;                  RCIF = 0;
166          }          }
167            
168            if(TMR1IF == 1)                 // timer1 interrupt trigger.
169            {
170                    timer1_interrupt();
171                    TMR1IF = 0;
172            }
173  }                }              
174    
175    
176    void serial_send(void)
177    {
178            int i;
179            char data_byte;
180            for(i = 0; i < BUFFER; i++)
181            {
182                    data_byte = global_serial_send[i];
183                    if( data_byte == '\r')
184                            i = (BUFFER - 1);
185                    TXREG = data_byte;
186                    while(TRMT==0) ;
187                    DelayMs(10);
188            }
189            DelayMs(250);
190            DelayMs(250);
191    }      
192    
193    void serial_recieved(void)
194    {
195            char data_byte, saved_data[LCD_LENGTH];
196            
197            data_byte = RCREG;
198            
199            if (data_byte == '\n')
200                    return;
201                    
202            if (global_serial_byte_counter == 0 && data_byte == '\r')
203                    return;
204    
205            global_serial_recieve_buffer[global_serial_byte_counter] = data_byte;
206                    
207            if (data_byte == '\r')
208            {
209                    global_recieve_done = 1;
210                    //global_serial_byte_counter = 0;
211                    global_serial_recieve_buffer[global_serial_byte_counter] = 0; //zero terminate
212                    
213                    strcpy(global_message_buffer, global_serial_recieve_buffer);
214                    global_message_buffer_length = global_serial_byte_counter;
215            }      
216            else
217            {
218                    global_serial_byte_counter++;
219            }
220            
221    }
222    
223    void timer1_interrupt(void)
224    {
225            TMR1H = 0xEF;
226            TMR1L = 0xFF;
227            global_time_counter++;
228            global_emergency_counter++;
229            RA1 = !RA1;
230    }
231    
232  void update_lcd(void)  void update_lcd(void)
233  {        {
234          char toLCD0[LCD_LENGTH], toLCD1[LCD_LENGTH];          lcd_clear();
         char B1[LCD_LENGTH];  
         char sprintF[LCD_LENGTH];  
235          lcd_goto(0x00);          lcd_goto(0x00);
236          sprintf(toLCD0, "%s", "Ejdesgaard");          
237          if(RB1)          sprintf(global_lcd_buf, "%d", global_temp);
238            lcd_puts(global_lcd_buf);
239    
240    }
241            
242    void send_update(void)
243    {
244            sprintf(global_serial_send, "at+cmgs=\"%s\"\r", cell_nr);
245            serial_send();
246            sprintf(global_serial_send, "%d:%d:%d:%d:%d:%d%c", global_sms_counter, global_temp, FIREDET, EMPTYTANK, FEEDING, PWRFAIL, 0x1A);
247            lcd_goto(40);
248            lcd_puts(global_serial_send);
249            serial_send();
250            DelayMs(250);
251            global_sms_counter++;
252    }      
253    
254    void convertTemp()
255    {
256            short adVal;
257            adVal = (global_Pot_Hi << 8) | global_Pot_Lo;
258            if( adVal >=840 )
259                    global_temp = 100;
260            else
261                    global_temp = (adVal / 8.3886);
262    }
263    
264    
265    
266    void eeprom_writer(void)
267    {
268            char len,i;
269            
270            len = strlen(cell_nr);
271            eeprom_write(0, (global_time_interval/60));
272            eeprom_write(1, global_sms_counter>>8);
273            eeprom_write(2, global_sms_counter);
274            eeprom_write(3, len);
275            
276            for (i=0; i<len; ++i)
277          {          {
278                  sprintf(B1, "Pwr%s", "True");                  eeprom_write(i+4, cell_nr[i] );
279          }          }
280          else  }
281    
282    void eeprom_reader(void)
283    {
284            char len,i;
285            
286            global_time_interval = eeprom_read(0);
287            global_time_interval *= 60;
288            global_sms_counter = (eeprom_read(1)<<8) | eeprom_read(2);
289            len = eeprom_read(3);
290            
291            for (i=0; i<len; ++i)
292          {          {
293                  sprintf(B1, "%s", "False");                  cell_nr[i] = eeprom_read(i+4);
294          }          }
         lcd_puts(B1);  
295                    
296          lcd_goto(0x40);          cell_nr[i] = 0; //zero terminated!
297          sprintf(sprintF,"%08d%08d", global_Pot_Hi, global_Pot_Lo);  }      
298          lcd_puts(sprintF);  
299    void on_initial_recieve(void)
300    {
301            char imei[16];
302            char* ptr;
303            char i;
304                    
305            if (strstr(global_serial_recieve_buffer,"+WIND: 11") != 0)
306            {
307                    global_modem_init = 1;
308    
309                    ptr = strstr(global_serial_recieve_buffer,"cgsn");
310                    ptr +=4;
311                    strncpy(imei, ptr,15);
312                    imei[15] = 0;
313    
314                    global_imei_tversum = 0;
315                    for (i=0; i<15; ++i)
316                    {
317                            global_imei_tversum += (imei[i] - '0');
318                    }
319                    
320                    
321                    reset_recieve_buffer();
322            }
323    }
324    
325    
326    void on_recieve(void)
327    {
328            char tmp[17];
329            char* ptr;
330            tmp[0]=0;
331                    
332            if (global_recieve_done == 0 || global_message_buffer_length == 0)
333                    return;
334    
335            
336            if (strstr(global_serial_recieve_buffer,"CMTI") != 0)
337            {
338                    ptr = strstr(global_serial_recieve_buffer,",");
339                    strcat(tmp,ptr+1);
340                    sprintf(global_sms_recieve_number,"%s", tmp);
341                    lcd_clear();
342                    lcd_puts(global_sms_recieve_number);
343                    sms_recieved();
344            }
345            else if (strstr(global_message_buffer,"CMTI") != 0)
346            {
347                    ptr = strstr(global_message_buffer,",");
348                    strcat(tmp,ptr+1);
349                    lcd_clear();
350                    lcd_puts(tmp);
351            }
352            
353            
354            reset_recieve_buffer();
355    }
356    
357    void sms_recieved(void)
358    {
359            sprintf(global_serial_send, "AT+CMGR=%s\r", global_sms_recieve_number);
360            serial_send();
361  }  }
362    
363  void main()  void main()
364  {  {
365  /////////////////////////////////////////////  ////////////////////
366  // Running Init's  // Running Init's //
367    
368          // Running init for various components.          // Running init for various components.
         //AD_init();  
         ad_init();  
         rs232_init();  
369          pic18_io_init();          pic18_io_init();
370            rs232_init();
371            ad_init();
372          lcd_init(0);          lcd_init(0);
373            interrupt_init();
374            sms_init();
375            //eeprom_init();
376            timer_init();
377            eeprom_reader();
378    ///////////////
379    // Main loop //
380    
381  /////////////////////////////////////////////          DelayMs(50);
382  // Main loop          reset_recieve_buffer();
383    
384          while(1)          while(1)
385          {          {
386            // If there happends to be a critical state on the system, we send a sms.
387                    if( (global_temp >= 90 || PWRFAIL == 1 || FIREDET == 0 || FEEDING == 1 || EMPTYTANK == 1) && global_emergency_counter >= 600 )
388                    {
389                            send_update();
390                            global_emergency_counter = 0;
391                    }
392            // Every X sec. a status sms is send.
393                    if(global_time_counter >= 3600)
394                    {
395                            send_update();
396                            global_time_counter = 0;
397                    }
398            // To avoid buffer overrun.
399                    if( global_emergency_counter > 7200 )
400                            global_emergency_counter = 600;
401    
402            // Checks if there has been recieved a config sms.
403                    if(global_interval_changed )
404                    {
405                            eeprom_writer();
406                            global_interval_changed = 0;
407                    }
408          // Checking if A/D convertion is done, and save the data in global_Pot_??          // Checking if A/D convertion is done, and save the data in global_Pot_??
409                  if(GODONE==0)                  if(GODONE==0)
410                  {                  {
411                          global_Pot_Hi = ADRESH;                          global_Pot_Hi = ADRESH;
412                          global_Pot_Lo = ADRESL;                          global_Pot_Lo = ADRESL;
413                            convertTemp();
414                            //update_lcd();
415                          GODONE = 1;                          GODONE = 1;
416                  }                  }
417                            // Handels the recieve sms'es.
418          update_lcd();                  on_recieve();
419          }          }
420  }  }
Legend:
Removed from v.112  
changed lines
  Added in v.155
  ViewVC Help
Powered by ViewVC 1.1.20