trunk/Embedded/main.c

#include <pic18.h>
#include <stdio.h>
#include <htc.h>
#include <string.h>

#include "lcd.h"
#include "Delay.h"
// Delay.h is included inside lcd.c

#define LCD_LENGTH 16
#define LCD_ROWS 2
#define SEND_BUFFER 128
#define PWRFAIL RB1
#define FIREDET RB2
#define FEEDING RB3
#define EMPTYTANK RB4


unsigned char global_Pot_Hi, global_Pot_Lo;
unsigned char global_LCD_Buffer[LCD_ROWS][LCD_LENGTH];
unsigned char global_serial_send[SEND_BUFFER], global_serial_recieve_buffer[SEND_BUFFER];
bit global_recieve_done = 0, global_interval_changed = 0;
unsigned int global_serial_byte_counter = 0, global_sms_counter = 1, global_time_counter = 0;
unsigned int global_emergency_counter = 600, global_time_interval = 3600;
unsigned char global_temp = 0;

unsigned char cell_nr[15] = ""; // = "21681784";


__EEPROM_DATA( 60, 0, 1, 8, '2', '1', '6', '8');
__EEPROM_DATA( '1', '7', '8', '4',0,0,0,0);

void serial_recieved(void);
void serial_send(void);
void update_lcd(void);
void convertTemp(void);
void timer1_interrupt(void);

// Nicked from H7
void ad_init(void)
{
        // AD Conversion clock
        ADCS0 = 0;
        ADCS1 = 0;
        ADCS2 = 0;

        //Select AN0/RA0 for AD source
                // In this (000) setup, it's only RA0/AN0 that does ad convertion.
        CHS0=0;
        CHS1=0;
        CHS2=0;
        
        //Only AN0 is selected for AD and with Vdd/Vss as limits
        PCFG0=0;
        PCFG1=1;
        PCFG2=1;
        PCFG3=1;
        
        //Result is right justified
        ADFM=1; 
        
        //Fire up for A/D converter module
        ADON=1;
}

void rs232_init(void)
{
        SPEN    = 0;    // Serial Port Enable Bit... 0 = disabled
        TRISC6  = 0;    
        TRISC7  = 1;

        SPBRG   = 207;  // 1200 baud rate... 25 = 9600
                                        // x = (Fosc / (16*[baud rate]) )-1
        TXSTA   = 0x24; // Enables BRGH and TXEN inthe TXSTA register
        RCSTA   = 0x90; // 0x90 enables SPEN and CREN in the RCSTA register
}

void interrupt_init(void)
{
        // Assumes that all interrupts default is 0
        PEIE    = 1;
        GIE             = 1;
        RCIE    = 1;    // Recieve interrupt enable.
        IPEN    = 0;    // Nfo interrupt priority
        TXIE    = 0;    // Serial interrupt enabled
        TMR1IE  = 1;    // Enables timer 1
}       

void timer_init(void)
{
        TMR1CS = 1; //use external clock
        
        T1CKPS1 = 1; //1:8 prescale
        T1CKPS0 = 1;
        
        TMR1H = 0xEF;
        TMR1L = 0xFF;

        T1OSCEN = 1; //enable oscillator circuit        
        RD16 = 0; //normal 8 bit writes
        TMR1ON = 1;
}

void pic18_io_init(void)
{
        TRISA0  = 1;    // analog input
        TRISA1  = 0;    // Output
        TRISB1  = 1;    // TRISB1-4 Digital input
        TRISB2  = 1;
        TRISB3  = 1;
        TRISB4  = 1;
}       

void sms_init(void)
{
        int i;

        sprintf(global_serial_send,"at+cgsn\r");
        serial_send();
        DelaySek(1);
        while(!global_recieve_done) ;


        sprintf(global_serial_send,"%s", "at+cpin=8043\r");
        serial_send();
        DelaySek(30);
        
        update_lcd();
        DelaySek(5);
}


void interrupt interrupt_handler(void)
{
        // Finds out what interrupt have been trigged, and starts the respective function.
        if(RCIF == 1)                   // Serial recieve interrupt
        {
                serial_recieved();
                RCIF = 0;
        }
        
        if(TMR1IF == 1)                 // timer1 interrupt trigger.
        {
                timer1_interrupt();
                TMR1IF = 0;
        }
}               


void serial_send(void)
{
        int i;
        char data_byte;
        for(i = 0; i < SEND_BUFFER; i++)
        {
                data_byte = global_serial_send[i];
                if( data_byte == '\r')
                        i = (SEND_BUFFER - 1);
                TXREG = data_byte;
                while(TRMT==0) ;
                DelayMs(10);
        }
        DelayMs(250);
        DelayMs(250);
}       

void serial_recieved(void)
{
        char data_byte, saved_data[LCD_LENGTH];
        
        data_byte = RCREG;
        
        global_serial_recieve_buffer[global_serial_byte_counter] = data_byte;
        if(data_byte == '\r')
        {
                global_recieve_done = 1;
                global_serial_byte_counter = 0;
        }       
        else
        {
                global_serial_byte_counter++;
        }
        
}

void timer1_interrupt(void)
{
        TMR1H = 0xEF;
        TMR1L = 0xFF;
        global_time_counter++;
        global_emergency_counter++;
        RA1 = !RA1;
}

void update_lcd(void)
{
        lcd_clear();
        lcd_goto(0x00);
        lcd_puts(global_temp);

}
        
void send_update(void)
{
        sprintf(global_serial_send, "at+cmgs=\"%s\"\r", cell_nr);
        serial_send();
        sprintf(global_serial_send, "%d:%d:%d:%d:%d:%d%c", global_sms_counter, global_temp, FIREDET, EMPTYTANK, FEEDING, PWRFAIL, 0x1A);
        lcd_goto(40);
        lcd_puts(global_serial_send);
        serial_send();
        DelayMs(250);
        global_sms_counter++;
}       

void convertTemp()
{
        short adVal;
        adVal = (global_Pot_Hi << 8) | global_Pot_Lo;
        if( adVal >=840 )
                global_temp = 100;
        else
                global_temp = (adVal / 8.3886);
}


void eeprom_writer(void)
{
        char len,i;
        
        len = strlen(cell_nr);
        eeprom_write(0, (global_time_interval/60));
        eeprom_write(1, global_sms_counter>>8);
        eeprom_write(2, global_sms_counter);
        eeprom_write(3, len);
        
        for (i=0; i<len; ++i)
        {
                eeprom_write(i+4, cell_nr[i] );
        }
}

void eeprom_reader(void)
{
        char len,i;
        
        global_time_interval = eeprom_read(0);
        global_time_interval *= 60;
        global_sms_counter = (eeprom_read(1)<<8) | eeprom_read(2);
        len = eeprom_read(3);
        
        for (i=0; i<len; ++i)
        {
                cell_nr[i] = eeprom_read(i+4);
        }
        
        cell_nr[i] = 0; //zero terminated!
}       

void on_recieve(void)
{
        
}

void main()
{
////////////////////
// Running Init's //

        // Running init for various components.
        pic18_io_init();
        rs232_init();
        ad_init();
        lcd_init(0);
        interrupt_init();
        sms_init();
        //eeprom_init();
        timer_init();
        eeprom_reader();
///////////////
// Main loop //
send_update();
        while(1)
        {
        // If there happends to be a critical state on the system, we send a sms.
                if( (global_temp >= 90 || PWRFAIL == 1 || FIREDET == 0 || FEEDING == 1 || EMPTYTANK == 1) && global_emergency_counter >= 600 )
                {
                        send_update();
                        global_emergency_counter = 0;
                }
        // Every X sec. a status sms is send.
                if(global_time_counter >= 3600)
                {
                        send_update();
                        global_time_counter = 0;
                }
        // To avoid buffer overrun.
                if( global_emergency_counter > 7200 )
                        global_emergency_counter = 600;

        // Checks if there has been recieved a config sms.
                if(global_interval_changed )
                {
                        eeprom_writer();
                        global_interval_changed = 0;
                }
        // Checking if A/D convertion is done, and save the data in global_Pot_??
                if(GODONE==0)
                {
                        global_Pot_Hi = ADRESH;
                        global_Pot_Lo = ADRESL;
                        convertTemp();
                        update_lcd();
                        GODONE = 1;
                }
        }
}
1	hedin	82	#include <pic18.h>
2			#include <stdio.h>
3	hedin	148	#include <htc.h>
4	hedin	82	#include <string.h>
5	hedin	148
6	hedin	82	#include "lcd.h"
7	hedin	137	#include "Delay.h"
8	hedin	109	// Delay.h is included inside lcd.c
9	hedin	82
10	hedin	109	#define LCD_LENGTH 16
11			#define LCD_ROWS 2
12	hedin	139	#define SEND_BUFFER 128
13	hedin	148	#define PWRFAIL RB1
14			#define FIREDET RB2
15			#define FEEDING RB3
16			#define EMPTYTANK RB4
17	hedin	109
18
19	hedin	137	unsigned char global_Pot_Hi, global_Pot_Lo;
20	hedin	109	unsigned char global_LCD_Buffer[LCD_ROWS][LCD_LENGTH];
21	hedin	148	unsigned char global_serial_send[SEND_BUFFER], global_serial_recieve_buffer[SEND_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	hedin	137
27	hedin	148	unsigned char cell_nr[15] = ""; // = "21681784";
28
29
30			__EEPROM_DATA( 60, 0, 1, 8, '2', '1', '6', '8');
31			__EEPROM_DATA( '1', '7', '8', '4',0,0,0,0);
32
33	hedin	137	void serial_recieved(void);
34	hedin	139	void serial_send(void);
35			void update_lcd(void);
36	hedin	148	void convertTemp(void);
37			void timer1_interrupt(void);
38	hedin	137
39	hedin	109	// Nicked from H7
40			void ad_init(void)
41			{
42			// AD Conversion clock
43			ADCS0 = 0;
44			ADCS1 = 0;
45			ADCS2 = 0;
46	hedin	82
47	hedin	109	//Select AN0/RA0 for AD source
48			// In this (000) setup, it's only RA0/AN0 that does ad convertion.
49			CHS0=0;
50			CHS1=0;
51			CHS2=0;
52
53			//Only AN0 is selected for AD and with Vdd/Vss as limits
54			PCFG0=0;
55			PCFG1=1;
56			PCFG2=1;
57			PCFG3=1;
58
59	hedin	148	//Result is right justified
60			ADFM=1;
61	hedin	109
62			//Fire up for A/D converter module
63			ADON=1;
64			}
65
66	hedin	82	void rs232_init(void)
67			{
68			SPEN = 0; // Serial Port Enable Bit... 0 = disabled
69	hedin	137	TRISC6 = 0;
70	hedin	82	TRISC7 = 1;
71	hedin	137
72			SPBRG = 207; // 1200 baud rate... 25 = 9600
73			// x = (Fosc / (16*[baud rate]) )-1
74			TXSTA = 0x24; // Enables BRGH and TXEN inthe TXSTA register
75			RCSTA = 0x90; // 0x90 enables SPEN and CREN in the RCSTA register
76	hedin	82	}
77
78			void interrupt_init(void)
79			{
80			// Assumes that all interrupts default is 0
81			PEIE = 1;
82			GIE = 1;
83	hedin	137	RCIE = 1; // Recieve interrupt enable.
84			IPEN = 0; // Nfo interrupt priority
85			TXIE = 0; // Serial interrupt enabled
86	hedin	148	TMR1IE = 1; // Enables timer 1
87	hedin	82	}
88
89	hedin	148	void timer_init(void)
90			{
91			TMR1CS = 1; //use external clock
92
93			T1CKPS1 = 1; //1:8 prescale
94			T1CKPS0 = 1;
95
96			TMR1H = 0xEF;
97			TMR1L = 0xFF;
98
99			T1OSCEN = 1; //enable oscillator circuit
100			RD16 = 0; //normal 8 bit writes
101			TMR1ON = 1;
102			}
103
104	hedin	82	void pic18_io_init(void)
105			{
106	hedin	109	TRISA0 = 1; // analog input
107	hedin	148	TRISA1 = 0; // Output
108	hedin	109	TRISB1 = 1; // TRISB1-4 Digital input
109	hedin	82	TRISB2 = 1;
110			TRISB3 = 1;
111			TRISB4 = 1;
112			}
113
114	hedin	137	void sms_init(void)
115	hedin	82	{
116	hedin	148	int i;
117
118			sprintf(global_serial_send,"at+cgsn\r");
119			serial_send();
120			DelaySek(1);
121			while(!global_recieve_done) ;
122
123
124	hedin	139	sprintf(global_serial_send,"%s", "at+cpin=8043\r");
125			serial_send();
126	hedin	148	DelaySek(30);
127	hedin	139
128			update_lcd();
129			DelaySek(5);
130	hedin	82	}
131
132	hedin	148
133	hedin	82	void interrupt interrupt_handler(void)
134			{
135	hedin	109	// Finds out what interrupt have been trigged, and starts the respective function.
136	hedin	137	if(RCIF == 1) // Serial recieve interrupt
137	hedin	82	{
138	hedin	137	serial_recieved();
139	hedin	82	RCIF = 0;
140			}
141	hedin	148
142			if(TMR1IF == 1) // timer1 interrupt trigger.
143			{
144			timer1_interrupt();
145			TMR1IF = 0;
146			}
147	hedin	82	}
148	hedin	109
149	hedin	137
150			void serial_send(void)
151			{
152			int i;
153	hedin	148	char data_byte;
154	hedin	139	for(i = 0; i < SEND_BUFFER; i++)
155	hedin	109	{
156	hedin	148	data_byte = global_serial_send[i];
157			if( data_byte == '\r')
158	hedin	139	i = (SEND_BUFFER - 1);
159	hedin	148	TXREG = data_byte;
160	hedin	139	while(TRMT==0) ;
161	hedin	148	DelayMs(10);
162	hedin	109	}
163	hedin	148	DelayMs(250);
164			DelayMs(250);
165	hedin	137	}
166
167			void serial_recieved(void)
168			{
169	hedin	148	char data_byte, saved_data[LCD_LENGTH];
170	hedin	137
171	hedin	148	data_byte = RCREG;
172	hedin	137
173	hedin	148	global_serial_recieve_buffer[global_serial_byte_counter] = data_byte;
174			if(data_byte == '\r')
175	hedin	137	{
176			global_recieve_done = 1;
177			global_serial_byte_counter = 0;
178			}
179	hedin	109	else
180			{
181	hedin	137	global_serial_byte_counter++;
182	hedin	109	}
183
184	hedin	137	}
185	hedin	148
186			void timer1_interrupt(void)
187			{
188			TMR1H = 0xEF;
189			TMR1L = 0xFF;
190			global_time_counter++;
191			global_emergency_counter++;
192			RA1 = !RA1;
193			}
194
195	hedin	139	void update_lcd(void)
196			{
197	hedin	148	lcd_clear();
198			lcd_goto(0x00);
199			lcd_puts(global_temp);
200
201			}
202
203			void send_update(void)
204			{
205			sprintf(global_serial_send, "at+cmgs=\"%s\"\r", cell_nr);
206			serial_send();
207			sprintf(global_serial_send, "%d:%d:%d:%d:%d:%d%c", global_sms_counter, global_temp, FIREDET, EMPTYTANK, FEEDING, PWRFAIL, 0x1A);
208			lcd_goto(40);
209			lcd_puts(global_serial_send);
210			serial_send();
211			DelayMs(250);
212			global_sms_counter++;
213			}
214
215			void convertTemp()
216			{
217			short adVal;
218			adVal = (global_Pot_Hi << 8) \| global_Pot_Lo;
219			if( adVal >=840 )
220			global_temp = 100;
221			else
222			global_temp = (adVal / 8.3886);
223			}
224
225
226
227			void eeprom_writer(void)
228			{
229			char len,i;
230
231			len = strlen(cell_nr);
232			eeprom_write(0, (global_time_interval/60));
233			eeprom_write(1, global_sms_counter>>8);
234			eeprom_write(2, global_sms_counter);
235			eeprom_write(3, len);
236
237			for (i=0; i<len; ++i)
238	hedin	139	{
239	hedin	148	eeprom_write(i+4, cell_nr[i] );
240	hedin	139	}
241			}
242	hedin	148
243			void eeprom_reader(void)
244			{
245			char len,i;
246	hedin	109
247	hedin	148	global_time_interval = eeprom_read(0);
248			global_time_interval *= 60;
249			global_sms_counter = (eeprom_read(1)<<8) \| eeprom_read(2);
250			len = eeprom_read(3);
251
252			for (i=0; i<len; ++i)
253			{
254			cell_nr[i] = eeprom_read(i+4);
255			}
256
257			cell_nr[i] = 0; //zero terminated!
258			}
259
260			void on_recieve(void)
261			{
262
263			}
264
265	hedin	82	void main()
266			{
267	hedin	148	////////////////////
268			// Running Init's //
269	hedin	109
270			// Running init for various components.
271	hedin	148	pic18_io_init();
272			rs232_init();
273	hedin	109	ad_init();
274			lcd_init(0);
275	hedin	137	interrupt_init();
276	hedin	139	sms_init();
277	hedin	148	//eeprom_init();
278			timer_init();
279			eeprom_reader();
280			///////////////
281			// Main loop //
282			send_update();
283	hedin	109	while(1)
284	hedin	100	{
285	hedin	148	// If there happends to be a critical state on the system, we send a sms.
286			if( (global_temp >= 90 \|\| PWRFAIL == 1 \|\| FIREDET == 0 \|\| FEEDING == 1 \|\| EMPTYTANK == 1) && global_emergency_counter >= 600 )
287			{
288			send_update();
289			global_emergency_counter = 0;
290			}
291			// Every X sec. a status sms is send.
292			if(global_time_counter >= 3600)
293			{
294			send_update();
295			global_time_counter = 0;
296			}
297			// To avoid buffer overrun.
298			if( global_emergency_counter > 7200 )
299			global_emergency_counter = 600;
300
301			// Checks if there has been recieved a config sms.
302			if(global_interval_changed )
303			{
304			eeprom_writer();
305			global_interval_changed = 0;
306			}
307	hedin	109	// Checking if A/D convertion is done, and save the data in global_Pot_??
308			if(GODONE==0)
309			{
310			global_Pot_Hi = ADRESH;
311			global_Pot_Lo = ADRESL;
312	hedin	148	convertTemp();
313			update_lcd();
314	hedin	112	GODONE = 1;
315	hedin	109	}
316	hedin	100	}
317	hedin	82	}