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