/[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 100 by hedin, Thu Nov 29 13:23:57 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: void AD_init(void)       7:
8       8: {       8: #define LCD_LENGTH 16
9       9:         ADON    = 1;       9: #define LCD_ROWS 2
10      10: }      10: #define SEND_BUFFER 128
11      11:      11:
12      12: void rs232_init(void)      12:
13      13: {      13: unsigned char global_Pot_Hi, global_Pot_Lo;
14      14:         SPEN    = 0;    // Serial Port Enable Bit... 0 = disabled      14: unsigned char global_LCD_Buffer[LCD_ROWS][LCD_LENGTH];
15      15:         TRISC6  = 0;      15: unsigned char global_serial_send[SEND_BUFFER];
16      16:         TRISC7  = 1;      16: unsigned char global_serial_recieve_buffer[LCD_LENGTH];
17      17:         SYNC    = 0;    // SYNC switches between async(0) and sync(1) mode.      17: bit global_recieve_done = 0;
18      18:         SPBRG   = 25;      18: int global_serial_byte_counter = 0;
19      19:         TXSTA   = 0x24;      19:
20      20:         RCSTA   = 0x90;      20: void serial_recieved(void);
21      21:         SPEN    = 1;      21: void serial_send(void);
22      22: }      22: void update_lcd(void);
23      23:      23:
24      24: void interrupt_init(void)      24: // Nicked from H7
25      25: {      25: void ad_init(void)
26      26:         // Assumes that all interrupts default is 0      26: {
27      27:         PEIE    = 1;      27:         // AD Conversion clock
28      28:         GIE             = 1;      28:         ADCS0 = 0;
29      29:         RCIE    = 1;      29:         ADCS1 = 0;
30      30: }            30:         ADCS2 = 0;
31      31:      31:
32      32: void pic18_io_init(void)      32:         //Select AN0/RA0 for AD source
33      33: {      33:                 // In this (000) setup, it's only RA0/AN0 that does ad convertion.
34      34:         TRISA0  = 1;      34:         CHS0=0;
35      35:         TRISB1  = 1;      35:         CHS1=0;
36      36:         TRISB2  = 1;      36:         CHS2=0;
37      37:         TRISB3  = 1;      37:        
38      38:         TRISB4  = 1;      38:         //Only AN0 is selected for AD and with Vdd/Vss as limits
39      39: }            39:         PCFG0=0;
40      40:      40:         PCFG1=1;
41      41: void interrupt_recieve_handler(void)      41:         PCFG2=1;
42      42: {      42:         PCFG3=1;
43      43:         // Handle recieve inputs...      43:        
44      44: }      44:         //Result is left justified
45      45:      45:         ADFM=0;
46      46: void interrupt interrupt_handler(void)      46:        
47      47: // Finds out what interrupt have been trigged, and starts the respective function.      47:         //Fire up for A/D converter module
48      48: {      48:         ADON=1;
49      49:         if(RCIF == 1)      49: }
50      50:         {      50:
51      51:                 interrupt_recieve_handler();      51: void rs232_init(void)
52      52:                 RCIF = 0;      52: {
53      53:         }      53:         SPEN    = 0;    // Serial Port Enable Bit... 0 = disabled
54      54: }                    54:         TRISC6  = 0;    
55      55:              55:         TRISC7  = 1;
56      56:      56:
57      57: void main()      57:         SPBRG   = 207;  // 1200 baud rate... 25 = 9600
58      58: {      58:                                         // x = (Fosc / (16*[baud rate]) )-1
59      59:         AD_init();      59:         TXSTA   = 0x24; // Enables BRGH and TXEN inthe TXSTA register
60      60:         rs232_init();      60:         RCSTA   = 0x90; // 0x90 enables SPEN and CREN in the RCSTA register
61      61:         pic18_io_init();      61: }
62      62:              62:
63      63:         if(GODONE==0)      63: void interrupt_init(void)
64      64:         {      64: {
65      65:                      65:         // Assumes that all interrupts default is 0
66      66:         }      66:         PEIE    = 1;
67      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.100  
changed lines
  Added in v.139
  ViewVC Help
Powered by ViewVC 1.1.20