TODOPIC

Microcontroladores PIC => * PROYECTOS * => Mensaje iniciado por: Abner_emanuel en 23 de Julio de 2016, 15:23:54

Título: EEPROM Hyperterminal
Publicado por: Abner_emanuel en 23 de Julio de 2016, 15:23:54

Un saludo..

Requiero de su ayuda para desarrollar un pequeñito control on off. por medio del hyperterminal y la eeprom interna del PIC18F4550.

- Bueno requiero leer el valor an0 del pic, este con un rango de 0-5 volts y que en la lcd se muestre como de 0-500vcd.
- Tener unos rangos de voltaje definidos en la eeprom del pic un valor min=200.5 y valor max=400.5).
- Cuando la lectura del adc rebase por debajo los 2volts (200.5 en la lcd = valor minimo) encienda un led.
- Cuando la lectura del adc rebase por encima los 4volts (400.5 en la lcd = valor maximo) encienda un led; mientras este en el rango entre 200 y 400 el led apague.
- Con el Hyperterminal comunicar el pic y poder cambiar ese valor maximo y ese valor minimo y dejarlo nuevamente grabado en su eeprom (El dato en la eeprom puede ser de tipo float).

Lo que se me complica es la parte de guardar un float en la eeprom interna del pic por medio del hyperterminal.

Cualquier sugerencia es bienvenida..

 :-/

Título: Re:EEPROM Hyperterminal
Publicado por: KILLERJC en 23 de Julio de 2016, 15:34:33

Citar

- Con el Hyperterminal comunicar el pic y poder cambiar ese valor maximo y ese valor minimo y dejarlo nuevamente grabado en su eeprom (El dato en la eeprom puede ser de tipo float).

Por que guardarlo como float si es mas facil comparar 2 enteros ? Ademas el trabajo maximo lo haria la PC.

Y cual es el problema que tenes? Por que es enviar datos al PIC, recibirlos si es que tiene la trama correcta esperar los datos, recibir los datos, guardarlos y fin.

Tu problema es el programa de la PC o del PIC?, Si es del PIC que lenguaje y compilador?, tenes algo realizado ?

Título: Re:EEPROM Hyperterminal
Publicado por: Abner_emanuel en 23 de Julio de 2016, 19:23:18

Un saludo amigo.

Aquí te anexo el code , esto es lo que llevo. Es tan solo la lectura del adc de 0-500 y la comparación para que enciendan los led.

No se por donde empezar lo de mas de la pc

Título: Re:EEPROM Hyperterminal
Publicado por: KILLERJC en 23 de Julio de 2016, 19:52:54

Código: C

1. #include <18F4550.h>
2. #device adc=10
3. #fuses XT,MCLR,NOWDT,NOPROTECT,NODEBUG                  
4. #use delay(clock=4000000)
5. #use fast_io(a)
6. #use fast_io(b)
7. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8,stream=PC)
8.  
9. #define LED_1           PIN_B1
10. #define MAX_ADDRESS     0x00
11. #define MIN_ADDRESS     0x02
12.  
13. float Vin,Vmin,Vmax,Tension;
14. int16 Maximo, Minimo;
15.          
16. void main()
17. {
18.          // Faltan configurar los TRIS !
19.  
20.         setup_adc_ports(AN0);
21.         setup_adc(adc_clock_internal);
22.         set_adc_channel(0);            
23.         output_low(LED_1);
24.  
25.         Maximo = EEprom_16bits_Read(MAX_ADDRESS);
26.         Minimo = EEprom_16bits_Read(MIN_ADDRESS);
27.  
28.         while(TRUE)
29.         {        
30.                 Vin = read_adc();
31.                 delay_ms(100);
32.                 Tension = Vin*0.4887585532746823;               // Tension = Vin*(5/1023)*100
33.                 printf("Tension: %.1f \n\r", Tension);
34.      
35.                 if(Vin<=Minimo || Vin>=Maximo)
36.                         output_high(LED_1);
37.                 else
38.                         output_low(LED_1);      
39.                 }
40.         }
41. }
42.  
43.  
44. void EEprom_16bits_Write(int8 address, int16 data) {
45.         int i;
46.         write_eeprom(address, *((int 8 *)&data))
47.         write_eeprom(address + 1, *(((int 8 *)&data + 1)))
48. }
49.  
50. int16 EEprom_16bits_Read(int8 address) {
51.         int i = 0;
52.         int16 data;
53.         *(((int 8 *)&data)) = read_eeprom(address);
54.         *(((int 8 *)&data + 1)) = read_eeprom(address + 1);
55.         return(data);
56. }

Falta la parte de la interrupcion del RS232. La cual debe recibir primero un byte para indicarle el comienzo de trama, por ejemplo 0xFF y luego envias los 4 valores pertenecientes al maximo y  minimo, cuando lleguen los 2 valores se guarda en la EEPROM y se actualizan las variables Maximo y minimo con los valores correspondientes.

Flotantes lo unico que haria seria complicar la programacion, primero hacelo con enteros, y que se compare con lo tomade por el read_adc(), que solo el LCD use flotantes.

Tambien te quite muchos decimales, que me parecieron un poco exagerado lo que habia :P

Título: Re:EEPROM Hyperterminal
Publicado por: Abner_emanuel en 25 de Julio de 2016, 21:05:37

Bueno,pues voy por partes..

Lo de la eeprom por lo pronto tiene que esperar..
Hoy e logrado entrar al menu de configuracion,pero no logro entrar a los case.

Código: CSS

1. #include <18F4550.h>
2.          #device adc=10        
3.          #FUSES NOWDT,WDT128,PLL1,CPUDIV1,NOUSBDIV,XT,NOBROWNOUT,NOMCLR,NOLVP,NOXINST            
4.          #use delay(clock=4000000)
5.          #include "lcd4x20.c"
6.          #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8,stream=PC)
7.          #include <string.h>
8.          #define LED1  PIN_B1
9.          INT STRING [];
10.          INT menu [];
11.          char q;
12.          int byte_alto, byte_bajo, direccion_wr=0, direccion_rd=0;
13.          float Volt,Vmin,Vmax;
14.          long data;      
15.          char qIn;
16.          
17.          #int_rda
18.          void capturar ()
19.          {
20.          if (kbhit()!=0)
21.          fgets(string,PC);
22.          if (strcmp(string,menu)== 0)
23.          menu=0;
24.          
25.          while(menu==0)
26.          {
27.          printf("\r\n//////////////////// Menu de configuracion ////////////////////\r\n\r\n");
28.          printf("> n - Cambiar valor minimo \r\n");
29.          printf("> x - Cambiar valor maximo \r\n");
30.          printf("> q - Salir del menu \r\n");
31.          fgets(string,PC);
32.          
33.          switch(string,PC)
34.          {
35.          case 'w':printf("Valor minimo:");
36.                   fgets(string,PC);
37.              
38.                   break;
39.          case 'e':printf("Valor maximo ");
40.                   fgets(string,PC);
41.              
42.                   break;
43.          case 'q':menu=1;
44.                   fgets(string,PC);
45.                   break;
46.          default:break;
47.          }
48.          }
49.          }
50.          
51.          void main()
52.          {
53.          set_tris_a(0xFF);
54.          set_tris_b(0xFF);
55.          menu = 1;
56.          setup_adc_ports(AN0|VSS_VDD);
57.          setup_adc(adc_clock_internal);
58.          set_adc_channel(0);
59.          lcd_init();
60.          enable_interrupts ( int_rda );
61.          enable_interrupts ( global );
62.          
63.          while(TRUE)
64.          {
65.          while(menu==1)
66.          {
67.          data=read_adc();
68.          Volt=(float)data*(float)0.48875855327468230694037145650049;
69.          lcd_gotoxy(1,1); printf(lcd_putc,"Write temp: %0.1f",Volt);        
70.          printf("Tension de entrada: %.1f \n\r",Volt);
71.      
72.          if(Volt<=Vmin || Volt>=Vmax) output_high(LED1);
73.          else output_low(LED1);
74.              
75.          }
76.          
77.          
78.          }
79.          }

Título: Re:EEPROM Hyperterminal
Publicado por: KILLERJC en 25 de Julio de 2016, 23:17:00

Bueno abner tengo un par de cosas para decirte.

El micro cuando entra a la interrupciones es por que recibio 1 caracter nomas. No todo una linea.

Usa identacion, en el codigo, facilita la lectura

En las interrupciones:
Nunca poner delays,
Nunca poner whiles a no ser que estes MUY seguro que va a salir rapidamente,
Nunca pongas funciones del LCD por que normalmente estas tardan demasiado y la mayoria de las veces poseen delays

Siemrpe una interrupcion es entrar y salir.

------------------

Un float o flotante, ocupa 4 bytes, por lo cual si envias "4.123"

NO es lo mismo que un float. Lo anterior son 5 bytes separados para demostrarlo te doy un valor:

En un flotante 4.123 se representaria de esta forma: 0x4083ef9e
Y lo que vos recibirias es 0x34 0x2E 0x31 0x32 0x33

Es decir no tiene ninguna relacion, y por eso mismo te decia que envies un entero ya que es mas facil de tratar

--------------------------------

Si decis como va a ser el string que pensas enviar entonces es posible realizar una maquina de estado, sino es muy dificil saber exactamente como seria. Ejemplo

12347890
1234&7890
1234.7890
etc

En el que 1234 sea el minimo y 7890 el maximo. Y luego al presionar un enter, es decir que se envie el \n o \r\n se proceda a tomar de nuevo los valores.
Cuando este fijado eso mucho mejor.

O si queres que cuando pongas el "w" el numero que le sigue se le asigne al minimo, cuantos digitos serian? imagino que 4 como maximo y quedaria algo asi:

w1234e7890q

eso es lo que queres vos ?

Título: Re:EEPROM Hyperterminal
Publicado por: Abner_emanuel en 27 de Julio de 2016, 09:12:56

Gracias KILLERJC, me ah servido mucho tus aportaciones acerca del tema. Por fin a quedado como lo pensé.

Aquí pongo el code:

- Lee el adc de 0 - 5V
- Con (q) entras a configurar rangos max y min de una ventana de control on off por medio del hyperterminal
- Guarda esos valores modificados   en la EEPROM.C

 Cualquier mejora es bienvenida, amigos.

Código: C

1. #include <18F4550.h>
2.          #device adc=10        
3.          #FUSES NOWDT                  
4.          #FUSES WDT128                  
5.          #FUSES PLL1                    
6.          #FUSES CPUDIV1                  
7.          #FUSES NOUSBDIV                
8.          #FUSES XT                      
9.          #FUSES NOBROWNOUT              
10.          #FUSES NOMCLR
11.          #FUSES NOLVP                    
12.          #FUSES NOXINST                  
13.          #use delay(clock=4000000)
14.          #use FIXED_IO( A_outputs=PIN_A1 )
15.          #use FIXED_IO( B_outputs=PIN_B1 )
16.          #define LED1  PIN_B1
17.          #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8,stream=PORT1)
18.          
19.          float inVolt, voltMinimo, voltMaximo;
20.          float resultado, conversion, conversion1;
21.          char qIn;
22.          int menu;
23.          
24.          void main()
25.          {
26.          setup_adc_ports(AN0);
27.          setup_adc(adc_clock_internal);
28.          set_adc_channel(0);
29.          setup_timer_3(T3_DISABLED | T3_DIV_BY_1);        
30.          output_low(LED1);
31.          menu = 1;
32.    
33.          conversion=(float)(read_eeprom(0))-48;
34.          conversion=conversion*10;
35.            
36.          conversion1=(float)(read_eeprom(1))-48;
37.          conversion1=conversion + conversion1;
38.          voltMinimo=conversion1/10;
39.          
40.          conversion=(float)(read_eeprom(2))-48;
41.          conversion=conversion*10;
42.          
43.          conversion1=(float)(read_eeprom(3))-48;
44.          conversion1=conversion + conversion1;
45.          voltMaximo=conversion1/10;
46.    
47.          while(TRUE)
48.          {
49.          while(menu==1)
50.          {
51.          inVolt = read_adc();
52.          delay_ms(100);
53.          resultado = inVolt*(float)0.004887585532;
54.      
55.          printf("Tension de entrada: %.1f \n\r", resultado);
56.      
57.          if(resultado<=voltMinimo || resultado>=voltMaximo) output_high(LED1);
58.          else output_low(LED1);
59.      
60.          if(kbhit())
61.          {
62.          qIn=getch();
63.          if(qIn=='q'||'Q')
64.          menu=0;
65.          }
66.          }
67.            
68.          while(menu==0)
69.          {
70.          printf("Menu: \r\n");
71.          printf("n - Ingresa valor minimo \r\n");
72.          printf("x - Ingresa valor maximo \r\n");
73.          printf("a - A cerca de... \r\n");
74.          printf("q - Salir del menu \r\n");
75.          qIn=getch();
76.          
77.          switch(qIn)
78.          {
79.          case 'n':printf("\r\nParte entera?: ");
80.                qIn=getch();
81.                write_eeprom(0, qIn);
82.                conversion=(float)(qIn - 48);
83.                conversion=conversion*10;
84.                printf("\r\nParte decimal?: ");
85.                qIn=getch();
86.                write_eeprom(1, qIn);
87.                conversion1=(float)(qIn - 48);
88.                conversion1=conversion + conversion1;
89.                voltMinimo=conversion1/10;
90.                printf("%.1f \r\n", voltMinimo);
91.                break;
92.          case 'x':printf("\r\nParte entera?: ");
93.                qIn=getch();
94.                write_eeprom(2, qIn);
95.                conversion=(float)(qIn - 48);
96.                conversion=conversion*10;
97.                printf("\r\nParte decimal?: ");
98.                qIn=getch();
99.                write_eeprom(3, qIn);
100.                conversion1=(float)(qIn - 48);
101.                conversion1=conversion + conversion1;
102.                voltMaximo=conversion1/10;
103.                printf("%.1f \r\n", voltMaximo);
104.                break;
105.          case 'a':printf("\r\nTODOPIC\r\n");
106.                break;
107.          case 'q':menu=1;
108.                break;
109.                default:break;
110.          }
111.          }
112.          }
113.          }