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