/[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 82 by hedin, Wed Nov 28 17:00:45 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
9    
10    #define LCD_LENGTH 16
11    #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, global_Pot_Lo;
20    unsigned char global_LCD_Buffer[LCD_ROWS][LCD_LENGTH];
21    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            global_recieve_done = 0;
55            
56            global_serial_byte_counter=0;
57            global_serial_recieve_buffer[0] = 0;
58            
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
67            ADCS0 = 0;
68            ADCS1 = 0;
69            ADCS2 = 0;
70    
71            //Select AN0/RA0 for AD source
72                    // In this (000) setup, it's only RA0/AN0 that does ad convertion.
73            CHS0=0;
74            CHS1=0;
75            CHS2=0;
76            
77            //Only AN0 is selected for AD and with Vdd/Vss as limits
78            PCFG0=0;
79            PCFG1=1;
80            PCFG2=1;
81            PCFG3=1;
82            
83            //Result is right justified
84            ADFM=1;
85            
86            //Fire up for A/D converter module
87            ADON=1;
88    }
89    
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 22  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;          TRISA0  = 1;    // analog input
131          TRISB1  = 1;          TRISA1  = 0;    // Output
132            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)
 // Finds out what interrupt have been trigged, and starts the respective function.  
160  {  {
161          if(RCIF == 1)          // Finds out what interrupt have been trigged, and starts the respective function.
162            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)
233    {
234            lcd_clear();
235            lcd_goto(0x00);
236            
237            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                    eeprom_write(i+4, cell_nr[i] );
279            }
280    }
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                    cell_nr[i] = eeprom_read(i+4);
294            }
295            
296            cell_nr[i] = 0; //zero terminated!
297    }      
298    
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          rs232_init();  ////////////////////
366    // Running Init's //
367    
368            // Running init for various components.
369          pic18_io_init();          pic18_io_init();
370            rs232_init();
371            ad_init();
372            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            reset_recieve_buffer();
383    
384            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_??
409                    if(GODONE==0)
410                    {
411                            global_Pot_Hi = ADRESH;
412                            global_Pot_Lo = ADRESL;
413                            convertTemp();
414                            //update_lcd();
415                            GODONE = 1;
416                    }
417            // Handels the recieve sms'es.
418                    on_recieve();
419            }
420  }  }
Legend:
Removed from v.82  
changed lines
  Added in v.155
  ViewVC Help
Powered by ViewVC 1.1.20