/[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 137 by hedin, Mon Dec 3 14:24:50 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"  #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, global_Pot_Lo;  unsigned char global_Pot_Hi, global_Pot_Lo;
20  unsigned char global_LCD_Buffer[LCD_ROWS][LCD_LENGTH];  unsigned char global_LCD_Buffer[LCD_ROWS][LCD_LENGTH];
21  unsigned char global_serial_data;  unsigned char global_serial_send[BUFFER], global_serial_recieve_buffer[BUFFER];
22  unsigned char global_serial_recieve_buffer[LCD_LENGTH];  bit global_recieve_done = 0, global_interval_changed = 0;
23  bit global_recieve_done = 0;  unsigned int global_serial_byte_counter = 0, global_sms_counter = 1, global_time_counter = 0;
24  int global_serial_byte_counter = 0;  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);  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  // Nicked from H7  void reset_recieve_buffer(void)
53  void ad_init(void)  {
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          // AD Conversion clock
67          ADCS0 = 0;          ADCS0 = 0;
# Line 38  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 65  void interrupt_init(void) Line 107  void interrupt_init(void)
107          RCIE    = 1;    // Recieve interrupt enable.          RCIE    = 1;    // Recieve interrupt enable.
108          IPEN    = 0;    // Nfo interrupt priority          IPEN    = 0;    // Nfo interrupt priority
109          TXIE    = 0;    // Serial interrupt enabled          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;
# Line 78  void pic18_io_init(void) Line 137  void pic18_io_init(void)
137    
138  void sms_init(void)  void sms_init(void)
139  {  {
140            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.
# Line 88  void interrupt interrupt_handler(void) Line 164  void interrupt interrupt_handler(void)
164                  serial_recieved();                  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)  void serial_send(void)
177  {  {
178          int i;          int i;
179          char tosend[3];          char data_byte;
180          char data;          for(i = 0; i < BUFFER; i++)
181          sprintf(tosend,"%s", "at\r");          {
182          for(i = 0; i < 3; i++)                  data_byte = global_serial_send[i];
183          {                  if( data_byte == '\r')
184                  data = tosend[i];                          i = (BUFFER - 1);
185                  TXREG = data;                  TXREG = data_byte;
186                  while(TRMT==0)                  while(TRMT==0) ;
187                  DelayMs(1000);                  DelayMs(10);
188          }          }
189            DelayMs(250);
190            DelayMs(250);
191  }        }      
192    
193  void serial_recieved(void)  void serial_recieved(void)
194  {  {
195          char data, saved_data[LCD_LENGTH];          char data_byte, saved_data[LCD_LENGTH];
196                    
197          data = RCREG;          data_byte = RCREG;
198                    
199          global_serial_recieve_buffer[global_serial_byte_counter] = data;          if (data_byte == '\n')
200          if(data == '\r')                  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;                  global_recieve_done = 1;
210                  global_serial_byte_counter = 0;                  //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          else
217          {          {
# Line 125  void serial_recieved(void) Line 219  void serial_recieved(void)
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  /////////////////////////////////////////////  ////////////////////
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();          interrupt_init();
374                    sms_init();
375  /////////////////////////////////////////////          //eeprom_init();
376  // Main loop          timer_init();
377            eeprom_reader();
378    ///////////////
379    // Main loop //
380    
381            DelayMs(50);
382            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                  if( global_recieve_done == 1 )                  on_recieve();
                 {  
                         lcd_clear();  
                         lcd_goto(0x00);  
                         lcd_puts(global_serial_recieve_buffer);  
                         global_recieve_done = 0;  
                 }  
419          }          }
420  }  }
Legend:
Removed from v.137  
changed lines
  Added in v.155
  ViewVC Help
Powered by ViewVC 1.1.20