GeSHi (csharp):///////////////////////////////////////////////////////////////////////////////////////////////////// Definiciones de configuración/////////////////////////////////////////////////////////////////////////////////////////////////// #include <18f4550.h> ///////////////////////////////////////////////////////////////////////////////////////////////////// Fuses y ajuste de Clock/////////////////////////////////////////////////////////////////////////////////////////////////// #fuses HSPLL, NOMCLR, PUT, BROWNOUT, BORV43, NOWDT, NOPROTECT, NOLVP#fuses NODEBUG, USBDIV, PLL5, CPUDIV1, VREGEN, CCP2B3#use delay(clock=48000000) ///////////////////////////////////////////////////////////////////////////////////////////////////// Canal de Comunicación : usart/////////////////////////////////////////////////////////////////////////////////////////////////// #define TTL_TX PIN_C6#define TTL_RX PIN_C7 #use rs232(baud=115200, xmit=TTL_TX, rcv=TTL_RX)
GeSHi (csharp):///////////////////////////////////////////////////////////////////////////////////////////////////// Definiciones de configuración/////////////////////////////////////////////////////////////////////////////////////////////////// #include <16f876a.h> ///////////////////////////////////////////////////////////////////////////////////////////////////// Fuses y ajuste de Clock/////////////////////////////////////////////////////////////////////////////////////////////////// #fuses XT,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT#use delay(clock=4000000) ///////////////////////////////////////////////////////////////////////////////////////////////////// Canal de Comunicación : usart/////////////////////////////////////////////////////////////////////////////////////////////////// #define TTL_TX PIN_C6#define TTL_RX PIN_C7 #use rs232(baud=9600, xmit=TTL_TX, rcv=TTL_RX)
GeSHi (csharp):void main() { char rec; printf("TyP_Serie_TTL\r\n"); // Al inicio escribe para ver que emite correctamente do{ // Bucle ... if(kbhit()){ // Si hay algo pendiente de recibir .... rec=getc(); // recibe el caracter ... putc(rec); // ... y lo escribes ... } // ... después continúa ... }while(TRUE); // ... hasta el infinito.}
GeSHi (csharp): rec=getc(); // recibe el carácter ... putc(rec); // ... y lo escribes ...
GeSHi (csharp): putc(getc()); // escribe lo que recibas ...
GeSHi (csharp):///////////////////////////////////////////////////////////////////////////////////////////////////// INTERRUPCIONES : RDA Recepción USART///////////////////////////////////////////////////////////////////////////////////////////////////#int_rdavoid rda_handler(void){ putc(getc()); // recibe el caracter y lo reenvía...}///////////////////////////////////////////////////////////////////////////////////////////////////// MAIN///////////////////////////////////////////////////////////////////////////////////////////////////void main() { printf("TyP_Serie_TTL\r\n"); // Al inicio escribe para ver que emite correctamente printf("Method : Interrupt\r\n"); enable_interrupts(int_rda); // Habilitamos la interrupción por recepción serie enable_interrupts(global); // Habilitamos las interrupciones do{ // Bucle ... // Aqui no tenemos nada que hacer ... // pero podemos hacer lo que queramos. }while(TRUE); // ... hasta el infinito.}
GeSHi (csharp):///////////////////////////////////////////////////////////////////////////////////////////////////// RAM/////////////////////////////////////////////////////////////////////////////////////////////////// char Command; ///////////////////////////////////////////////////////////////////////////////////////////////////// INTERRUPCIONES : RDA Recepción USART/////////////////////////////////////////////////////////////////////////////////////////////////// #int_rdavoid rda_handler(void){ Command=getc(); // recibe el comando ... } // Funciones a ejecutar según el comando recibido ///////////////////////////////////////////////// void first_function(void){ printf(" > Exec first_function()\r\n");} void second_function(void){ printf(" > Exec second_function()\r\n");} /////////////////////////////////////////////////////////////////////////////////////////////////// void main() { printf("TyP_Serie_TTL\r\n"); // Al inicio escribe para ver que emite correctamente printf("Method : Interrupt\r\n"); printf("Commands mono-character\r\n"); enable_interrupts(int_rda); // Habilitamos la interrupción por recepción serie enable_interrupts(global); // Habilitamos las interrupciones Command=0x00; // Inicializamos Command para estar seguros de que // su contenido es 0x00 do{ // inicio del Bucle infinito if(Command!=0x00){ // Si hemos recibido un comando ... printf(" < %c\r\n",Command); // Lo mostramos de vuelta para saber que ha sido recibido ... switch(Command){ case '1': // y si éste es el caracter ASCII '1' entonces ... first_function(); // llamamos a la primera funcion. break; case '2': // pero si éste es el caracter ASCII '2' entonces ... second_function(); // llamamos a la segunda funcion. break; default: printf(" < ?\r\n");// y si no es ninguno de los anteriores protestamos ... break; } Command=0x00; // y volvemos a inicializar Command para que no // se vuelva a ejecutar hasta volver a recibirlo. } }while(TRUE); // final del Bucle infinito} // Fin del programa //////////////////////////////////////////////////////////////////////////////
GeSHi (csharp):///////////////////////////////////////// Constantes/////////////////////////////////////// int const lenbuff=32; // Longitud máxima del buffer ///////////////////////////////////////// RAM/////////////////////////////////////// int xbuff=0x00; // Índice: siguiente char en cbuffchar cbuff[lenbuff]; // Buffer de recepción
GeSHi (csharp):///////////////////////////////////////// INTERRUPCIONES : RDA Recepción USART/////////////////////////////////////// #int_rdavoid serial_isr() { // Interrupción recepción serie USART char rcvchar=0x00; // último caracter recibido if(kbhit()){ // Si hay algo pendiente de recibir ... rcvchar=getc(); // lo descargo y ... add_2_cbuff(rcvchar); // lo añado al buffer }} void add_2_cbuff(char c){ switch(c){ case 0x0D: // Enter -> Habilita Flag para procesar comando flagcommand=1; break; default: // Añade caracter recibido al Buffer cbuff[xbuff++]=c; }}
GeSHi (csharp):///////////////////////////////////////// INTERRUPCIONES : RDA Recepción USART/////////////////////////////////////// #int_rdavoid serial_isr() { // Interrupción recepción serie USART char rcvchar=0x00; // último caracter recibido if(kbhit()){ // Si hay algo pendiente de recibir ... rcvchar=getc(); // lo descargo y ... add_2_cbuff(rcvchar); // lo añado al buffer y ... echo_sel(rcvchar); // hago eco selectivo (si procede). }} void add_2_cbuff(char c){ switch(c){ case 0x0D: // Enter -> Habilita Flag para procesar comando flagcommand=1; break; case 0x08: // Del -> Borra último caracter del Buffer if(xbuff>0) cbuff[--xbuff]=0x00; break; case 0x01B: // Esc -> Borra el Buffer completamente init_cbuff(); break; default: // Añade caracter recibido al Buffer cbuff[xbuff++]=c; }} void echo_sel(char c){ switch(c){ case 0x0D: // Si he pulsado la tecla [Intro] printf("\r\n[Ent]\r\n"); break; case 0x08: // Si he pulsado la tecla [Retroceso] printf("\r\n[Del]\r\n>%s",cbuff); break; case 0x1B: // Si he pulsado la tecla [Escape] printf("\r\n[Esc]\r\n>"); break; default: // Echo de cualquier otro caracter putc(c); }}
GeSHi (csharp):void init_cbuff(void){ int i; for(i=0;i<lenbuff;i++){// Bucle que pone a 0 todos los cbuff[i]=0x00; // caracteres en el buffer } xbuff=0x00; // Inicializo el indice de siguiente caracter}
GeSHi (csharp):///////////////////////////////////////// MAIN/////////////////////////////////////// void main() { init_cbuff(); // Borra buffer al inicio enable_interrupts(int_rda); // Habilita Interrupción RDA enable_interrupts(global); // Habilita interrupciones do { if(flagcommand) commad_process(); // Hay algo pendiente de procesar y lo procesa. } while (TRUE); }
GeSHi (csharp):///////////////////////////////////////// Constantes/////////////////////////////////////// int const lenbuff=32; // Longitud máxima del buffer ///////////////////////////////////////// RAM/////////////////////////////////////// int xbuff=0x00; // Índice: siguiente char en cbuffchar cbuff[lenbuff]; // Buffer de recepciónint1 flagcommand=0; // Flag para comando disponible ///////////////////////////////////////// Funciones de Buffer/////////////////////////////////////// // Echo selectivo ---------------------- void echo_sel(char c){ switch(c){ case 0x0D: // Si he pulsado la tecla [Intro] printf("\r\n[Ent]\r\n"); break; case 0x08: // Si he pulsado la tecla [Retroceso] printf("\r\n[Del]\r\n>%s",cbuff); break; case 0x1B: // Si he pulsado la tecla [Escape] printf("\r\n[Esc]\r\n>"); break; default: // Echo de cualquier otro caracter putc(c); }} // Inicia a \0 cbuff ------------------- void init_cbuff(void){ int i; for(i=0;i<lenbuff;i++){// Bucle que pone a 0 todos los cbuff[i]=0x00; // caracteres en el buffer } xbuff=0x00; // Inicializo el indice de siguiente caracter} // Añade a cbuff ----------------------- void add_2_cbuff(char c){ switch(c){ case 0x0D: // Enter -> Habilita Flag para procesar comando flagcommand=1; break; case 0x08: // Del -> Borra último caracter del Buffer if(xbuff>0) cbuff[--xbuff]=0x00; break; case 0x01B: // Esc -> Borra el Buffer completamente init_cbuff(); break; default: // Añade caracter recibido al Buffer cbuff[xbuff++]=c; }} ///////////////////////////////////////// Procesador de Comandos/////////////////////////////////////// void commad_menu(void){ printf("\r\nTyP_Serie_TTL\r\n"); printf("Método : Recibiendo sobre Buffer\r\n\n"); printf("[Enter] Procesa el buffer recibido.\r\n"); printf("[Escape] Borra todo el buffer.\r\n"); printf("[Delete] Borra último carácter del buffer.\r\n"); printf("\r\n\r\n>"); } void commad_process(void){ int i; char cmd[lenbuff]; // Comando flagcommand=0; // Desactivo flag de comando pendiente. printf("Procesando ...\r\n"); strcpy(cmd,cbuff); // Lo copio para procesarlo printf("Rec. Buffer <%s>\r\n",cmd); // ... y lo muestro init_cbuff(); // Borro buffer. printf("Procesado.\r\n\r\n>"); // Monitorizo procesado.} ///////////////////////////////////////// INTERRUPCIONES : RDA Recepción USART/////////////////////////////////////// #int_rdavoid serial_isr() { // Interrupción recepción serie USART char rcvchar=0x00; // último caracter recibido if(kbhit()){ // Si hay algo pendiente de recibir ... rcvchar=getc(); // lo descargo y ... add_2_cbuff(rcvchar); // lo añado al buffer y ... echo_sel(rcvchar); // hago eco selectivo (si procede). }} ///////////////////////////////////////// MAIN/////////////////////////////////////// void main() { delay_ms(2000); // Espero a estabilizar antes de actuar commad_menu(); // Nos presentamos init_cbuff(); // Borra buffer al inicio enable_interrupts(int_rda); // Habilita Interrupción RDA enable_interrupts(global); // Habilita interrupciones do { if(flagcommand) commad_process(); // Hay algo pendiente de procesar y lo procesa. } while (TRUE); } ///////////////////////////////////////// Fin de programa///////////////////////////////////////
GeSHi (csharp):void commad_process(void){ int i; char cmd[lenbuff]; // Comando flagcommand=0; // Desactivo flag de comando pendiente. printf("Procesando ...\r\n"); strcpy(cmd,cbuff); // Lo copio para procesarlo printf("Rec. Buffer <%s>\r\n",cmd); // ... y lo muestro init_cbuff(); // Borro buffer. printf("Procesado.\r\n\r\n>"); // Monitorizo procesado.}
GeSHi (csharp):void commad_process(void){ int n,i; char command[lenparam]; // Comando char param[5][lenparam]; // Parámetros flagcommand=0; // Desactivo flag de comando pendiente. printf("\nProcesando ...\r\n\n"); // Primera Parte: Cuantos n = count_param_number(); // Cuento el número de parámetros if(n==0){ printf("En el Buffer no hay ni comando ni parámetro alguno\r\n\n"); } else{ if(n==1){ printf("En el Buffer hay un comando y ningún parámetro\r\n\n"); } else{ printf("En el Buffer hay un comando y %u parámetro(s)\r\n\n",n-1); } } // Segunda Parte: Cuales if(n>0){ get_param_by_order(0,lenparam,command); printf("Comando <%s>\r\n",command); if(n>1){ for(i=1;i<n;i++){ get_param_by_order(i,lenparam,¶m[i-1][0]); printf("Parámetro %u <%s>\r\n",i,param[i-1]); } } } init_cbuff(); // Borro buffer. printf("\nProcesado.\r\n\n>"); // Monitorizo procesado.}
GeSHi (csharp):char const delimiter = ','; // Delimitador de parametros
GeSHi (csharp):char const disabler = '"'; // Deshabilitador de parametros
GeSHi (csharp):// Cuenta los parametros en el buffer -- int8 count_param_number(void){ int8 ret, i; int1 active; char c; ret=0; active=1; // ¿Hay comando? c = cbuff[0]; // cargo el primer carácter por si acabo antes de empezar if(c != 0x00) ret=1; // Cuenta parámetros for(i=0;i<lenbuff,c!=0x00;i++){ c = cbuff[i]; if(c==disabler && active==1) active=0; else if(c==disabler && active==0) active=1; if(active==1) if(c==delimiter) ++ret; } return ret;}
GeSHi (csharp):// Extrae un Parámetro dado del buffer ------ int1 get_param_by_order(int8 pos, int8 maxlen, char* pP){ int1 ret=0; char tmp[lenparam]; int8 i,j; int8 nDelimiter; int1 active=1; for(i=0,j=0,nDelimiter=0;i<lenbuff;i++){ tmp[j]=0x00; if(nDelimiter==pos){ if(!(j==0 && cbuff[i]==disabler)) tmp[j++]=cbuff[i]; } if(cbuff[i]==disabler && active==1) active=0; else if(cbuff[i]==disabler && active==0) active=1; if(active==1) if((cbuff[i]==Delimiter) || (cbuff[i]==0x00)) ++nDelimiter; if(nDelimiter>pos){ j -= 1; break; } } if(tmp[j-1]==disabler) --j; tmp[j]='\0'; if(j>maxlen){ ret=1; }else{ strcpy(pP,tmp); } return ret;}
GeSHi (csharp):///////////////////////////////////////// Constantes/////////////////////////////////////// int const lenbuff=128; // Longitud máxima del bufferchar const delimiter = ','; // Delimitador de parametroschar const disabler = '"'; // Deshabilitador de parametrosint const lenparam = 32; // Máxima longitud por parámetro ///////////////////////////////////////// RAM/////////////////////////////////////// int xbuff=0x00; // Índice: siguiente char en cbuffchar cbuff[lenbuff]; // Buffer de recepciónint1 flagcommand=0; // Flag para comando disponible ///////////////////////////////////////// Funciones de Buffer/////////////////////////////////////// // Cuenta los parametros en el buffer -- int8 count_param_number(void){ int8 ret, i; int1 active; char c; ret=0; active=1; // ¿Hay comando? c = cbuff[0]; if(c != 0x00) ret=1; // Cuenta parámetros for(i=0;i<lenbuff,c!=0x00;i++){ c = cbuff[i]; if(c==disabler && active==1) active=0; else if(c==disabler && active==0) active=1; if(active==1) if(c==delimiter) ++ret; } return ret;} // Extrae un Parámetro del buffer ------ int1 get_param_by_order(int8 pos, int8 maxlen, char* pP){ int1 ret=0; char tmp[lenparam]; int8 i,j; int8 nDelimiter; int1 active=1; for(i=0,j=0,nDelimiter=0;i<lenbuff;i++){ tmp[j]=0x00; if(nDelimiter==pos){ if(!(j==0 && cbuff[i]==disabler)) tmp[j++]=cbuff[i]; } if(cbuff[i]==disabler && active==1) active=0; else if(cbuff[i]==disabler && active==0) active=1; if(active==1) if((cbuff[i]==Delimiter) || (cbuff[i]==0x00)) ++nDelimiter; if(nDelimiter>pos){ j -= 1; break; } } if(tmp[j-1]==disabler) --j; tmp[j]='\0'; if(j>maxlen){ ret=1; }else{ strcpy(pP,tmp); } return ret;} // Echo selectivo ---------------------- void echo_sel(char c){ switch(c){ case 0x0D: // Si he pulsado la tecla [Intro] printf("\r\n[Ent]\r\n"); break; case 0x08: // Si he pulsado la tecla [Retroceso] printf("\r\n[Del]\r\n>%s",cbuff); break; case 0x1B: // Si he pulsado la tecla [Escape] printf("\r\n[Esc]\r\n>"); break; default: // Echo de cualquier otro caracter putc(c); }} // Inicia a \0 cbuff ------------------- void init_cbuff(void){ int i; for(i=0;i<lenbuff;i++){// Bucle que pone a 0 todos los cbuff[i]=0x00; // caracteres en el buffer } xbuff=0x00; // Inicializo el indice de siguiente caracter} // Añade a cbuff ----------------------- void add_2_cbuff(char c){ switch(c){ case 0x0D: // Enter -> Habilita Flag para procesar comando flagcommand=1; break; case 0x08: // Del -> Borra último caracter del Buffer if(xbuff>0) cbuff[--xbuff]=0x00; break; case 0x01B: // Esc -> Borra el Buffer completamente init_cbuff(); break; default: // Añade caracter recibido al Buffer cbuff[xbuff++]=c; }} ///////////////////////////////////////// Procesador de Comandos/////////////////////////////////////// void commad_menu(void){ printf("\r\nTyP_Serie_TTL\r\n"); printf("Método : Extrayendo parámetros del Buffer\r\n"); printf(" delimitados por [%c]\r\n\n",delimiter); printf("[Enter] Procesa el buffer recibido.\r\n"); printf("[Escape] Borra todo el buffer.\r\n"); printf("[Delete] Borra último carácter del buffer.\r\n"); printf("\r\n\r\n>"); } void commad_process(void){ int n,i; char command[lenparam]; // Comando char param[5][lenparam]; // Parámetros flagcommand=0; // Desactivo flag de comando pendiente. printf("\nProcesando ...\r\n\n"); // Primera Parte: Cuantos n = count_param_number(); // Cuento el número de parámetros if(n==0){ printf("En el Buffer no hay ni comando ni parámetro alguno\r\n\n"); } else{ if(n==1){ printf("En el Buffer hay un comando y ningún parámetro\r\n\n"); } else{ printf("En el Buffer hay un comando y %u parámetro(s)\r\n\n",n-1); } } // Segunda Parte: Cuales if(n>0){ get_param_by_order(0,lenparam,command); printf("Comando <%s>\r\n",command); if(n>1){ for(i=1;i<n;i++){ get_param_by_order(i,lenparam,¶m[i-1][0]); printf("Parámetro %u <%s>\r\n",i,param[i-1]); } } } init_cbuff(); // Borro buffer. printf("\nProcesado.\r\n\n>"); // Monitorizo procesado.} ///////////////////////////////////////// INTERRUPCIONES : RDA Recepción USART/////////////////////////////////////// #int_rdavoid serial_isr() { // Interrupción recepción serie USART char rcvchar=0x00; // último caracter recibido if(kbhit()){ // Si hay algo pendiente de recibir ... rcvchar=getc(); // lo descargo y ... add_2_cbuff(rcvchar); // lo añado al buffer y ... echo_sel(rcvchar); // hago eco selectivo (si procede). }} ///////////////////////////////////////// MAIN/////////////////////////////////////// void main() { delay_ms(2000); // Espero a estabilizar antes de actuar // HARD /////////// output_low(PIN_E2); output_low(PIN_C0); output_low(PIN_D7); output_low(PIN_E1); output_low(PIN_E0); output_high(PIN_D1); output_high(PIN_D0); delay_ms(110); output_low(PIN_D0); /////////////////// commad_menu(); init_cbuff(); // Borra buffer al inicio enable_interrupts(int_rda); // Habilita Interrupción RDA enable_interrupts(global); // Habilita interrupciones do { if(flagcommand) commad_process(); // Hay algo pendiente de procesar y lo procesa. } while (TRUE); } ///////////////////////////////////////// Fin de programa///////////////////////////////////////
Autor