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

Diff of /trunk/Embedded/main.lst

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

revision 82 by hedin, Wed Nov 28 17:00:45 2007 UTC revision 139 by hedin, Mon Dec 3 17:19:35 2007 UTC
# Line 1  Line 1 
1       1: #include <pic18.h>       1: #include <pic18.h>
2       2: #include <stdio.h>       2: #include <stdio.h>
3       3: #include <string.h>       3: #include <string.h>
4       4:       4: #include "lcd.h"
5       5: #include "lcd.h"       5: #include "Delay.h"
6       6:       6: // Delay.h is included inside lcd.c
7       7:       7:
8       8: void rs232_init(void)       8: #define LCD_LENGTH 16
9       9: {       9: #define LCD_ROWS 2
10      10:         SPEN    = 0;    // Serial Port Enable Bit... 0 = disabled      10: #define SEND_BUFFER 128
11      11:         TRISC6  = 0;      11:
12      12:         TRISC7  = 1;      12:
13      13:         SYNC    = 0; // SYNC switches between async(0) and sync(1) mode.      13: unsigned char global_Pot_Hi, global_Pot_Lo;
14      14:         SPBRG   = 25;      14: unsigned char global_LCD_Buffer[LCD_ROWS][LCD_LENGTH];
15      15:         TXSTA   = 0x24;      15: unsigned char global_serial_send[SEND_BUFFER];
16      16:         RCSTA   = 0x90;      16: unsigned char global_serial_recieve_buffer[LCD_LENGTH];
17      17:         SPEN    = 1;      17: bit global_recieve_done = 0;
18      18: }      18: int global_serial_byte_counter = 0;
19      19:      19:
20      20: void interrupt_init(void)      20: void serial_recieved(void);
21      21: {      21: void serial_send(void);
22      22:         // Assumes that all interrupts default is 0      22: void update_lcd(void);
23      23:         PEIE    = 1;      23:
24      24:         GIE             = 1;      24: // Nicked from H7
25      25:         RCIE    = 1;      25: void ad_init(void)
26      26: }            26: {
27      27:      27:         // AD Conversion clock
28      28: void pic18_io_init(void)      28:         ADCS0 = 0;
29      29: {      29:         ADCS1 = 0;
30      30:         TRISA0  = 1;      30:         ADCS2 = 0;
31      31:         TRISB1  = 1;      31:
32      32:         TRISB2  = 1;      32:         //Select AN0/RA0 for AD source
33      33:         TRISB3  = 1;      33:                 // In this (000) setup, it's only RA0/AN0 that does ad convertion.
34      34:         TRISB4  = 1;      34:         CHS0=0;
35      35: }            35:         CHS1=0;
36      36:      36:         CHS2=0;
37      37: void interrupt_recieve_handler(void)      37:        
38      38: {      38:         //Only AN0 is selected for AD and with Vdd/Vss as limits
39      39:         // Handle recieve inputs...      39:         PCFG0=0;
40      40: }      40:         PCFG1=1;
41      41:      41:         PCFG2=1;
42      42: void interrupt interrupt_handler(void)      42:         PCFG3=1;
43      43: {      43:        
44      44:         if(RCIF == 1)      44:         //Result is left justified
45      45:         {      45:         ADFM=0;
46      46:                 interrupt_recieve_handler();      46:        
47      47:                 RCIF = 0;      47:         //Fire up for A/D converter module
48      48:         }      48:         ADON=1;
49      49: }                    49: }
50      50:              50:
51      51:      51: void rs232_init(void)
52      52: void main()      52: {
53      53: {      53:         SPEN    = 0;    // Serial Port Enable Bit... 0 = disabled
54      54:         rs232_init();      54:         TRISC6  = 0;    
55      55:         pic18_io_init();      55:         TRISC7  = 1;
56      56: }      56:
57        57:         SPBRG   = 207;  // 1200 baud rate... 25 = 9600
58        58:                                         // x = (Fosc / (16*[baud rate]) )-1
59        59:         TXSTA   = 0x24; // Enables BRGH and TXEN inthe TXSTA register
60        60:         RCSTA   = 0x90; // 0x90 enables SPEN and CREN in the RCSTA register
61        61: }
62        62:
63        63: void interrupt_init(void)
64        64: {
65        65:         // Assumes that all interrupts default is 0
66        66:         PEIE    = 1;
67        67:         GIE             = 1;
68        68:         RCIE    = 1;    // Recieve interrupt enable.
69        69:         IPEN    = 0;    // Nfo interrupt priority
70        70:         TXIE    = 0;    // Serial interrupt enabled
71        71: }      
72        72:
73        73: void pic18_io_init(void)
74        74: {
75        75:         TRISA0  = 1;    // analog input
76        76:         TRISB1  = 1;    // TRISB1-4 Digital input
77        77:         TRISB2  = 1;
78        78:         TRISB3  = 1;
79        79:         TRISB4  = 1;
80        80: }      
81        81:
82        82: void sms_init(void)
83        83: {
84        84:         int i = 1;
85        85:         sprintf(global_serial_send,"%s", "at+cpin=8043\r");
86        86:         serial_send();
87        87:         DelaySek(60);
88        88:        
89        89:         update_lcd();
90        90:         DelaySek(5);
91        91:        
92        92:         sprintf(global_serial_send,"%s%s", "at+cmgs=","\"22337617\"\r");
93        93:         serial_send();
94        94:         DelayMs(5000);
95        95:        
96        96:         sprintf(global_serial_send,"%s%d%c","Dette er test nr: ", i, 0x1A);
97        97:         serial_send();
98        98:         DelayMs(5000);
99        99:         i++;
100       100:        
101       101: }
102       102:
103       103: void interrupt interrupt_handler(void)
104       104: {
105       105:         // Finds out what interrupt have been trigged, and starts the respective function.
106       106:         if(RCIF == 1)                   // Serial recieve interrupt
107       107:         {
108       108:                 serial_recieved();
109       109:                 RCIF = 0;
110       110:         }
111       111: }              
112       112:
113       113:
114       114:
115       115: void serial_send(void)
116       116: {
117       117:         int i;
118       118: //      char tosend[3];
119       119:         char data;
120       120: //      sprintf(tosend,"%s", "at\r");
121       121:         for(i = 0; i < SEND_BUFFER; i++)
122       122:         {
123       123:                 data = global_serial_send[i];
124       124:                 if( data == '\r')
125       125:                         i = (SEND_BUFFER - 1);
126       126:                 TXREG = data;
127       127:                 while(TRMT==0) ;
128       128:                 DelayMs(1000);
129       129:         }
130       130: }      
131       131:
132       132: void serial_recieved(void)
133       133: {
134       134:         char data, saved_data[LCD_LENGTH];
135       135:        
136       136:         data = RCREG;
137       137:        
138       138:         global_serial_recieve_buffer[global_serial_byte_counter] = data;
139       139:         if(data == '\r')
140       140:         {
141       141:                 global_recieve_done = 1;
142       142:                 global_serial_byte_counter = 0;
143       143:         }      
144       144:         else
145       145:         {
146       146:                 global_serial_byte_counter++;
147       147:         }
148       148:        
149       149: }
150       150: void update_lcd(void)
151       151: {
152       152:         if( global_recieve_done == 1 )
153       153:         {
154       154:                 lcd_clear();
155       155:                 lcd_goto(0x00);
156       156:                 lcd_puts(global_serial_recieve_buffer);
157       157:                 global_recieve_done = 0;
158       158:         }
159       159: }
160       160:        
161       161: void main()
162       162: {
163       163: /////////////////////////////////////////////
164       164: // Running Init's
165       165:
166       166:         // Running init for various components.
167       167:         //AD_init();
168       168:         ad_init();
169       169:         rs232_init();
170       170:         pic18_io_init();
171       171:         lcd_init(0);
172       172:         lcd_clear();
173       173:         interrupt_init();
174       174:         sms_init();
175       175: /////////////////////////////////////////////
176       176: // Main loop
177       177:
178       178:         while(1)
179       179:         {
180       180:         // Checking if A/D convertion is done, and save the data in global_Pot_??
181       181:                 if(GODONE==0)
182       182:                 {
183       183:                         global_Pot_Hi = ADRESH;
184       184:                         global_Pot_Lo = ADRESL;
185       185:                         GODONE = 1;
186       186:                 }
187       187:                 update_lcd();
188       188:         }
189       189: }
Legend:
Removed from v.82  
changed lines
  Added in v.139
  ViewVC Help
Powered by ViewVC 1.1.20