Varios problemitas con la programación en C

[arielmdq]

IMPECABLE lo suyo killerjc muchas gracias te pasaste con la explicacion, bueno ahora veo la presicion de los calculos, los cuales tendre que revisar nuevamente ,por que ayer estuve intentando modificar tu codigo pero obiamente no me funciono ja ja .Le agregue la grabacion del cero ,elimine la cuenta para calcularlo .Le puse dos costantes (b) y (c) ,(que son constantes despues que se calculan ) y a partir de ahi hice las cuentas ,con una constante para un lado y con otra  para el otro lado ,re confiado que iba a salir andando peroooo nop,ja ja .Bueno voy a revisar nuevamente todos los calculos de  tu explicacion y a seguir probando a ver que pasa .Te agradezco muchisimo tu voluntad ,sos muy claro para explicar .De todos modos te subo el codigo que modifique y me voy a trabajar que se me hace tarde ja ja . Saludos !!!!!

Código: C

1. #include <16f876a.h>
2. #device adc =10
3. #use delay (clock=8M)
4. #fuses XT,NOWDT,NOPROTECT,NOLVP
5. #include <internal_eeprom.c>
6. #use fast_io(B)
7. #use fast_io(c)
8. #use fast_io(a)
9.  
10. //******declaracion de variables******************************
11.  
12. int16 cursor,toper,topbr,cero,ciclo_util,a; // faltaba declarar (a)
13. float c,b;                                             // agregue (b)
14.  
15. //***********************************************************
16. void main()
17. {
18.    set_tris_c(0b00000000);
19.    output_c(0b00000000);
20.    set_tris_b(0b11111111);
21.    output_b(0b00000000);
22. //****************ADC**************************
23.    setup_adc_ports(AN0);//* entrada analogica*//
24.    setup_adc (ADC_CLOCK_INTERNAL);
25.    setup_COUNTERS(RTCC_internal.rtcc_div_8);
26.  
27. // *************PWM**************************************
28.  
29.    setup_ccp1(CCP_PWM);
30.    setup_timer_2(T2_DIV_BY_16,255, 1);
31.    set_pwm1_duty(ciclo_util);
32.    
33. //**************Recupero Valores************************  
34. //Aqui sis se reinicio tomo los valores , los calculo para lo que esta guardado en el EEPROM
35.  
36.  
37.       toper=read_int16_eeprom(0x120);
38.       delay_ms(15);                  
39.    
40.       topbr=read_int16_eeprom(0x122);
41.       delay_ms(15);
42.  
43.       cero=read_int16_eeprom(0x126);      // agregue  lectura de la variable cero
44.       delay_ms(15);
45.      
46.    WHILE (1)
47.    {
48.    
49.       set_adc_channel (0);
50.       delay_us (20);
51.       cursor = read_adc ();
52.      
53.  //*********************************************
54.  // Programacion
55.  //*********************************************
56.  
57.       if (input(pin_b4)==0)                     //
58.       {  
59.         if (input(pin_b3)==1)                  //
60.             {                                        //
61.              delay_ms(20);                  //
62.             while(input(pin_b3));               // Agregue esto para grabar el cero
63.             if(cursor!=cero)
64.             {
65.                write_int16_eeprom(0x126, cursor);      //
66.                cero = cursor;
67.                        
68.             }
69.             }
70.          if (input(pin_b1)==1)                  //switch que habilita para establecer
71.          {                                        // el limite dercho ( toper)  
72.              delay_ms(20);                  //
73.             while(input(pin_b1));               //
74.             if(cursor!=toper)
75.             {
76.                write_int16_eeprom(0x120, cursor);      //
77.                toper = cursor;
78.                
79.                    c = (float)511/(toper - cero );         // toper es el mas grande mas cerca de 1023
80.             }
81.            }
82.  
83.            if (input(pin_b2)==1)                  //switch que habilita para establecer
84.             {                                        // el limite derecho ( topbr)
85.              delay_ms(20);                  //
86.             while(input(pin_b2));               //
87.             if(cursor!=topbr)
88.             {
89.                write_int16_eeprom(0x122, cursor);      //
90.                topbr = cursor;
91.              
92.                    b = (float)511/(cero - topbr );         // topbr es el mas cerca de 0
93.             }
94.             }
95.            
96.           }
97.    
98.  
99.   //********************************************
100.   // Funcionamiento normal
101.   //********************************************
102.  
103.       if (input(pin_b4)==1)//switch que habilita el funcionamiemto
104.       {
105.              
106.          if(cursor<topbr){cursor=topbr;}               // Fijo los limites de la entrada
107.          if(cursor>toper){cursor=toper;}
108.  
109.          if(cursor>cero)                     // Caso que Cursor sea mayor a cero
110.          {
111.             a = ((cursor-cero)*c)+cero;
112.          }
113.          else
114.          {
115.             a = ((cero-cursor)*b)-cero;
116.          }
117.          if(a!=ciclo_util)                  // Luego de los calculos, es necesario volver a cargar el duty ?
118.          {
119.             set_pwm1_duty(a);
120.             ciclo_util=a;
121.          }
122.         }
123.        
124.    }  
125. }

Modifique el programa nuevamente ,por que habia un error en el momento de grabar los parametros estaban alrevez los limites asi que aclaro :
toper es el mas cercano a 1023
topbr es el mas cercano a 0
Igual sigue sin funcionar adjunto el cuadro de variables en la simulacion

[KILLERJC]

Bueno recien veo que mi explicacion esta un poco mal en la matematica, la voy a corregir, se me escapo una suma por ahi.

****************      EDIT:
Recien veo que modificaste toper y topbr, yo lo hice como estaba antes. asi que el codigo estan cambiados, pero es basicamente los nombres.
Si queres simularlo comenza primero con la simulacion cuando esta funcionando (RB4=1), y asignale los valores manualmente a topbr/toper/cero.
Esto implica que tengas que cambiar la parte del codigo al comienzo, en vez de leerlo de la EEPROM que directamente le cargues el numero. Una ves funcionando eso, avanzas a el tema de la EEPROM
**************************

En fin aca esta el codigo:

Código: C

1. #include <16f876a.h>
2. #device adc =10
3. #use delay (clock=8M)
4. #fuses XT,NOWDT,NOPROTECT,NOLVP
5. #include <internal_eeprom.c>
6. #use fast_io(B)
7. #use fast_io(c)
8. #use fast_io(a)
9.  
10. //******declaracion de variables******************************
11.  
12. unsigned int16 cursor=0,toper,topbr,cero,ciclo_util=0;
13.  
14. float Ai,Ad,Bi,Bd;
15.  
16. //***********************************************************
17. void main()
18. {
19.  
20.         int i;
21.  
22.         set_tris_c(0b00000000);
23.         output_c(0b00000000);
24.         set_tris_b(0b11111111);
25.         output_b(0b00000000);
26. //****************ADC**************************
27.         setup_adc_ports(AN0);//* entrada analogica*//
28.         setup_adc (ADC_CLOCK_INTERNAL);
29.         setup_COUNTERS(RTCC_internal.rtcc_div_8);
30.  
31. // *************PWM**************************************
32.  
33.         setup_ccp1(CCP_PWM);
34.         setup_timer_2(T2_DIV_BY_16,255, 1);
35.         set_pwm1_duty(ciclo_util);
36.    
37. //**************Recupero Valores************************  
38. //Aqui sis se reinicio tomo los valores , los calculo para lo que esta guardado en el EEPROM
39.  
40.  
41.         toper=read_int16_eeprom(0x120);
42.         delay_ms(15);                  
43.    
44.         topbr=read_int16_eeprom(0x122);
45.         delay_ms(15);
46.  
47.         cero=read_int16_eeprom(0x124);
48.  
49.         Ai = (float)511 / (cero-toper);                         // Valores recta izquierda y derecha:
50.         Bi = ((float)-511*toper)/(cero-toper);                  // Yi = Ai*X +Bi
51.         Ad = (float)512 / (topbr-cero);                         // Yd = Ad*x +Bd
52.         Bd = 511 - (((float)512*cero)/(topbr-cero));
53.    
54.         WHILE (1)
55.         {
56.    
57.                 set_adc_channel (0);
58.                 delay_us (20);
59.  
60.                 for(i=0;i<8;i++)                                //Promediado del ADC
61.                 {
62.                         cursor = read_adc ();
63.                 }
64.                 cursor /= 8;
65.      
66.  //*********************************************
67.  // Programacion
68.  //*********************************************
69.  
70.                 if (input(pin_b4)==0)                                                   // switch que habilita la configuracion de parametros
71.                 {                                                                        
72.                         if (input(pin_b1)==1)                                           // switch que habilita para establecer
73.                         {                                                               // el limite izquierdo ( toper)  
74.                                 delay_ms(20);                                           // Antirebote
75.                                 while(input(pin_b1));                                   // Espero hasta que suelte
76.                                 if(cursor!=toper && cero>toper)
77.                                 {
78.                                         // Introducir comprobacion de rangos
79.                                         write_int16_eeprom(0x120, cursor);              // escribe en la memoria
80.                                         Ai = (float)511 / (cero-toper);                 // Calcula los nuevos coeficientes de la izquierda
81.                                         Bi = ((float)-511*toper)/(cero-toper);
82.                                 }
83.                         }
84.  
85.                         if (input(pin_b2)==1)                                           //switch que habilita para establecer
86.                         {                                                               // el limite derecho ( topbr)
87.                                 delay_ms(20);                                           // Antirebote
88.                                 while(input(pin_b2));                                   // Espero hasta que suelte
89.                                 if(cursor!=topbr && cero<topbr)
90.                                 {
91.                                         // Introducir comprobacion de rangos
92.                                         write_int16_eeprom(0x122, cursor);              // escribe en la memoria
93.                                         Ad = (float)512 / (topbr-cero);                 // Calcula los coeficientes de la derecha
94.                                         Bd = 511 - (((float)512*cero)/(topbr-cero));
95.                                 }
96.  
97.                         if (input(pin_b3)==1)                                           // switch que habilita para establecer
98.                         {                                                               // el centro (cero)
99.                                 delay_ms(20);                                           // Antirebote
100.                                 while(input(pin_b3));                                   // Espero hasta que suelte
101.                                 if(cursor!=cero)
102.                                 {
103.                                         // Introducir comprobacion de rangos
104.                                         write_int16_eeprom(0x124, cursor);              // escribe en la memoria
105.                                         Ai = (float)511 / (cero-toper);                 // Calcula ambos coeficientes ya que
106.                                         Bi = ((float)-511*toper)/(cero-toper);          // cambia el centro y cambian ambas rectas
107.                                         Ad = (float)512 / (topbr-cero);                  
108.                                         Bd = 511 - (((float)512*cero)/(topbr-cero));
109.                                 }
110.                         }
111.                 }
112.    
113.  
114.   //********************************************
115.   // Funcionamiento normal
116.   //********************************************
117.  
118.                 if (input(pin_b4)==1)//switch que habilita el funcionamiemto
119.                 {
120.  
121.                         if(cursor<topbr){cursor=topbr;}                                 // Fijo los limites de la entrada
122.                         if(cursor>toper){cursor=toper;}
123.  
124.                         if(cursor>cero)                                                 // Caso que Cursor sea mayor a cero
125.                         {                                                               // Es decir lado derecho
126.                                 a = (Ad*cursor) + Bd;
127.                         }
128.                         else if (cursor<cero)                                           // Caso Cursor sea menor a 0
129.                         {                                                               // Es decir lado izquierdo
130.                                 a = (Ai*cursor) + Bi;
131.                         }
132.                         else                                                            // Caso que cursor este al medio
133.                         {
134.                                 a=511;
135.                         }
136.                         if(a!=ciclo_util)                                               // Luego de los calculos
137.                         {                                                               // Si cambia lo actualizo al duty
138.                                 set_pwm1_duty(a);
139.                                 ciclo_util=a;
140.                         }
141.                 }
142.         }  
143. }

Funcionamiento?
RB4 tiene una llave.
RB1,RB2,RB3 son botones.

Para el lado que pone a 0 el pin RB4 activa el modo de configuracion, este modo te permite girar tu "cursor" y al presionar RB1 se fija el izquierdo, al presionar RB2 el derecho y RB3 el centro. Una ves posicionado "cursor" se presiona el boton y cuando se suelta comienza a grabarlo en la EEPROM.

No le puse el codigo que limita estas funciones para posibles errores. Eso ya lo comente antes. Igual estan los comments donde se deberian colocar.

Al comienzo del programa se toma los datos de la EEPROM y se calculan los 2 coeficientes de la recta A y B de cada una => Y = Ax + B, siendo el siguiente caracter el lado que corresponden Ai,Bi izquierda y el otro derecha.
Cuando calculo esto ? lo calculo al comienzo del programa y queda guardado en 4 float, el otro caso que tenga que calcularlo es cuando se cambie algun limite, si se cambia el izquierdo entonces debo modificar unicamente la recta izquierda, si es el derecho solo la recta de la derecha, ahora si es el centro, afecta a ambos, por lo tanto calculo las 2.

Finalmente cuando el programa esta marchando se cumple:

Limite izquierda = 0% duty PWM (0)
Centro = 50% duty PWM (511)
Limite derecha = 100% duty PWM ( 1023 )

Sea cual sea el limite de la izquierda, el centro y el limite de la derecha. Siempre y cuando se cumpla que toper < cero < topbr

Visto de otra forma

Lim Izq -------- Centro --------- Lim Der
   0%                 50%                100%

Los calculos del los factores Ai,Bi,Ad,Bd los hice con C en XC8 por que no poseo CCS pero imagino que seran correctos tambien en el otro compilador, los simule y verifique y me dan valores correctos con los que deben ser.
Espero que funcione ya que no posee nada raro el programa, y perdon por haber metido bastante teoria sobre rectas, es que si queres generarlas dinamicamente como vos queres y no con unos valores fijos entonces no le veo otra escapatoria.

Siguiendo un poco mas el tema, esto es para algo que no posea creo que demasiado movimiento.
El principal problema por ahi es el desgaste del potenciometro si es que vas a usar eso.
Si queres eliminar el problema de contacto y desgaste aun mas, ya vas a tener que pensar en un sensor optico.

[arielmdq]

Hola killerjc , ahi estuve probando el programa que me pasaste pero no me funciona ,te cuento : Te falto definir la variable (a) por lo que no compilaba, asi que lo hice con un int16 . Probe eliminando todas las lecturas y escrituras a la eeprom y asignando los valores a toper=205 topbr=818 y cero =511,como para usar valores conocidos  ,pero tampoco funciono .Cuando hago la simulacion veo que me esta leyendo el adc ( cursor ) ,tambien figuran los 3 valores antes mencionados ( toper=205 topbr=818 y cero =511) pero es como que no esta haciendo las cuentas por que no me figuran ni Ai,Bi,Ad,Bd y por logica no sale ni (a) ni ciclo util ,
Comprobe todas las cuentas a mano con calculadora suponiendo ejemplos y estan bien, pero por algun motivo no las hace el programa.Que podra ser???? .

[KILLERJC]

Si me comi la a xD.
Como decis las cuentas estan bien. probar yo probe hacer las cuentas con distintos valores de cursor aplicando las mismas formulas que te pase en el programa ( con XC8 y use valores como 100,400,1000 en toper,cero,topbr ) y siempre obtenia los valores que necesitaba tener. para 100 , a me daba 0, fui incrementando "cursor" de 100 en 100 y fue aumentando hasta llegar a 1023 cuando era 1000.

Por las dudas te dejo un codigo "simplificado" es decir le quite la parte de configuracion, promediado de datos, lectura de EEPROM, incluso ni pregunto por RB4, simplemente uso el PWM. Y ahi deberia andar si o si. Si no es algo con las cuentas, pero me parece raro, como ya dije logre hacer todo bien en mi PC (con XC8). Puede que el proteus este teniendo errores, o vaya muy lento, realmente no se.

Pero no veo el por que no lo hace.

Código: C

1. include <16f876a.h>
2. #device adc =10
3. #use delay (clock=8M)
4. #fuses XT,NOWDT,NOPROTECT,NOLVP
5. #include <internal_eeprom.c>
6. #use fast_io(B)
7. #use fast_io(c)
8. #use fast_io(a)
9.  
10. //******declaracion de variables******************************
11.  
12. unsigned int16 cursor=0,toper,topbr,cero,ciclo_util=0,a;
13.  
14. float Ai,Ad,Bi,Bd;
15.  
16. //***********************************************************
17. void main()
18. {
19.  
20.         int i;
21.  
22.         set_tris_c(0b00000000);
23.         output_c(0b00000000);
24.         set_tris_b(0b11111111);
25.         output_b(0b00000000);
26. //****************ADC**************************
27.         setup_adc_ports(AN0);//* entrada analogica*//
28.         setup_adc (ADC_CLOCK_INTERNAL);
29.         setup_COUNTERS(RTCC_internal.rtcc_div_8);
30.  
31. // *************PWM**************************************
32.  
33.         setup_ccp1(CCP_PWM);
34.         setup_timer_2(T2_DIV_BY_16,255, 1);
35.         set_pwm1_duty(ciclo_util);
36.    
37. //**************Recupero Valores************************  
38. //Aqui sis se reinicio tomo los valores , los calculo para lo que esta guardado en el EEPROM
39.  
40.  
41.         toper=205;
42.         topbr=818;
43.         cero=511;
44.  
45.         Ai = (float)511 / (cero-toper);                         // Valores recta izquierda y derecha:
46.         Bi = ((float)-511*toper)/(cero-toper);                  // Yi = Ai*X +Bi
47.         Ad = (float)512 / (topbr-cero);                         // Yd = Ad*x +Bd
48.         Bd = 511 - (((float)512*cero)/(topbr-cero));
49.  
50.         set_adc_channel (0);
51.         delay_us (20);
52.  
53.    
54.         WHILE (1)
55.         {
56.    
57.                 cursor = read_adc();
58.    
59.  
60.   //********************************************
61.   // Funcionamiento normal
62.   //********************************************
63.  
64.                         if(cursor<topbr){cursor=topbr;}                                 // Fijo los limites de la entrada
65.                         if(cursor>toper){cursor=toper;}
66.  
67.                         if(cursor>cero)                                                 // Caso que Cursor sea mayor a cero
68.                         {                                                               // Es decir lado derecho
69.                                 a = Ad*cursor + Bd;
70.                         }
71.                         else if (cursor<cero)                                           // Caso Cursor sea menor a 0
72.                         {                                                               // Es decir lado izquierdo
73.                                 a = Ai*cursor + Bi;
74.                         }
75.                         else                                                            // Caso que cursor este al medio
76.                         {
77.                                 a=511;
78.                         }
79.                         set_pwm1_duty(a);
80.         }  
81. }

Una pregunta mas... ademas del proteus, CCS no te permite "simularlo" paso a paso ? ahi podes ver si las variables estan mal o que pasa. Si podes simularlo instruccion por instruccion mucho mejor.

[arielmdq]

 Ahora nisiquiera lee el adc ja ja ,que va a ser, hay algo mal que no anda bien    ja ja , un poco de humor por que ya me va a explotar la cabeza.Ahora cursor adopta directamente el valor de  toper osea 205 y ahi queda clavado ,para mi por alguna razon no hace las cuentas con float ,que era lo que me pasaba desde el principio.
La verdad que no se si se puede simular con ccs pero lo voy a googlear a ver que onda

[arielmdq]

Un avance    encontre la solucion a poder ver las variables float en proteus y estaba aca :
 http://www.todopic.com.ar/foros/index.php?topic=37183.0
ahora las veo pero sigue sin hacer las cuentas , asi que sigo investigando

[KILLERJC]

Sinceramente no se que decirte.

Estoy acostumbrado al compilador de Microchip,en ese SI puedo simularlo paso a paso, lo hice para ver los resultados que daban y si me estaba equivocando en alguno, todo bien.
Lo unico que puede llegar a cambiar son los tamaños/definicion de los tipos de variables ( ejemplo que pueda poner uint16_t en ves de unsigned int16, aunque eso viene con stdint.h ) Pero ambos son lo mismo, las operaciones es C, es el mismo C, lo cual deberia realizarlas por igual.

Pero veo que NO quiere realizarlas, ahora aparecen Ai,Ad,Bi y Bd pero no tienen valor, es como si se quedara atrapado ahi..
Lo dejaste simulando un rato para ver si aparecian los valores? Es lo unico que se me puede ocurrir

Es mas aca es lo que tarda en hacer esas operaciones con valores de 100,400,1000 y cursor 300 usando flotante

Ai = Target halted. Stopwatch cycle count = 1033
Bi = Target halted. Stopwatch cycle count = 1723
Ad = Target halted. Stopwatch cycle count = 998
Bd = Target halted. Stopwatch cycle count = 1900
a = Target halted. Stopwatch cycle count = 1213

a 8 Mhz => 0.5us cada ciclo.
con 2000 ciclos es 1ms, asi que ni deberia notarse. Y no creo que corra tan lento la simulacion del proteus para que ocurra eso, o directamente el proteus esta fallando.
Pero lo raro que vi gente hacer cosas con flotante en el proteus y no tuvieron problemas, encima luego lo mandaban a un LCD.
Tampoco tengo el Proteus como para probarlo. Si alguno lo tiene y le subis los archivos .hex/.cof + la simulacion del Proteus pueda ayudarte.

[arielmdq]

Pero veo que NO quiere realizarlas, ahora aparecen Ai,Ad,Bi y Bd pero no tienen valor, es como si se quedara atrapado ahi..

Si, aparecen Ai,Ad,Bi y Bd y con sus valores corespondientes eso ahora esta bien
 Lo que aparecen en 0 son (a ) y ciclo util, lo que me dice , supongo ,que no esta haciendo las cuentas
 

Lo dejaste simulando un rato para ver si aparecian los valores? Es lo unico que se me puede ocurrir

Tengo dos versiones de proteus esta ultima que probe es la 8 y tampoco lo hace (los valores de las cuentas ) .Despues subo todos los archivos

Lo que estoy pensando, si vos decis que deberia andar, es en grabar el pic y probarlo, tal vez funcione ,no?.Total tengo toda la plaqueta armada que ya esta funcionando con el programa rustico ese que hice lleno de if ja ja que puse en el otro post, Lo que no se ahora es cual programa probar ,ya me maree con tantas pruebas ja ja ja .
bueno sigo un poco mas y despues subo los archivos de proteus
Te agradezco un monton todo lo que has hecho eh !!!.Espero poder hacerlo andar, asi no te defraudo, y no es en vano todo tu esfuerzo.Muchas gracias !!!

Los ezfuerzos en vano no son por que aprendi muchas cosas



 

[arielmdq]

Aca van  todos los archivos

[juaperser1]

Hola no estoy siguiendo el hilo por falta de tiempo, pero quería preguntarte si tus proteus son la versión de evaluación? Esque me ha parecido leer por algún sitio que la limitación que tienen es precisamente en el código que se ejecuta en los pic, y si killer dice que le funciona en el mplab, ed muy probable que te este limitando el uso de los flota o algo por el estilo.

Un saludo.

[arielmdq]

Hola juaperser1.La verdad que no se si es la version de evaluacion pero tengo la version 7.6 y la 8 y en los dos hace lo mismo ahora aparecen las variables con sus datos pero por alguna razon el programa no hace las cuentas .Hoy grabe 2 micros y los probe una con el programa simple que no escribe en eeprom y ya tiene los valores asignados y el otro que escribe en eeprom  y ninguno de los dos funciona. Lo que voy a hacer ahora es empezar a probar haciendo un programa con  cuentas sencillas pero con float y probarlo en proteus a ver que hace .
La placa se que funciona por que la tenia andando con el programa primitivo, que ese si que funciona, el problema es que no tiene precision, ademas de que esta horrible  por que lo diseñe yo  .Bueno sabado de frio en mar del plata  ideal para romperme la cabeza pensando como solucionar esto ja ja .Si a alguno se le ocurre algo les estaré muy  agradecido.
                                                                                      Saludos !!!!

[KILLERJC]

Podrias tratar de hacer la formula en varios pasos, para ver si es algo del CCS.

[arielmdq]

Tengo el mplab 8.8 tambien pero nunca lo use , si crees que puede ser el ccs el problema .Podria probar hacerlo en mplab me miro unos tutoriales y lo hago

[juaperser1]

Si tienes oportunidad de dejar CCS y pasar al MPLAB seria estupendo, ya no por este problema en particular, si no por todo en general. CCS esta bien para dar los primeros pasos pero luego se te quedará corto ya que te abstrae mucho del hardware.

pero te llevará tiempo, por ejemplo escribir en rom no es simplemente poner una linea. ni configurar los puertos. aunque cuando aprendes se hace bastante sencillo, pero lo mejor que ganaras es poder debugear tu programa ademas de simularlo, eso es una gozada.

un saludo.

[arielmdq]

Listo empezo a funcionar   , este es el primer avance . Le faltaba  asignar el valor de (a) a ciclo util

                                     ciclo_util = a ;

Y salio andando hace las cuentas y todo ja ja ( podria haber avanzado mas para contarles pero me gano la emocion )

Otra cosa :
               
        // if(cursor<topbr){cursor=topbr;}               //si habilito estas dos instrucciones deja de funcionar
         //if(cursor>toper){cursor=toper;}  

Código: C

1. #include <16f876a.h>
2. #device adc =10
3. #use delay (clock=8M)
4. #fuses XT,NOWDT,NOPROTECT,NOLVP
5. #include <internal_eeprom.c>
6. #use fast_io(B)
7. #use fast_io(c)
8. #use fast_io(a)
9.  
10. //******declaracion de variables******************************
11.  
12. unsigned int16 cursor=0,toper,topbr,cero,ciclo_util=0,a;
13.  
14. float Ai,Ad,Bi,Bd;
15.  
16. //***********************************************************
17. void main()
18. {
19.  
20.    //int i;
21.  
22.    set_tris_c(0b00000000);
23.    output_c(0b00000000);
24.    set_tris_b(0b11111111);
25.    output_b(0b00000000);
26. //****************ADC**************************
27.    setup_adc_ports(AN0);//* entrada analogica*//
28.    setup_adc (ADC_CLOCK_INTERNAL);
29.    setup_COUNTERS(RTCC_internal.rtcc_div_8);
30.  
31. // *************PWM**************************************
32.  
33.    setup_ccp1(CCP_PWM);
34.    setup_timer_2(T2_DIV_BY_16,255, 1);
35.    set_pwm1_duty(ciclo_util);
36.    
37. //**************Recupero Valores************************  
38. //Aqui sis se reinicio tomo los valores , los calculo para lo que esta guardado en el EEPROM
39.  
40.  
41.       toper=205;
42.       topbr=818;
43.       cero=511;
44.  
45.    Ai = (float)511 / (cero-toper);            // Valores recta izquierda y derecha:
46.    Bi = ((float)-511*toper)/(cero-toper);         // Yi = Ai*X +Bi
47.    Ad = (float)512 / (topbr-cero);            // Yd = Ad*x +Bd
48.    Bd = 511 - (((float)512*cero)/(topbr-cero));
49.  
50.    
51.  
52.    
53.    WHILE (1)
54.    {
55.       set_pwm1_duty(ciclo_util);  
56.       set_adc_channel (0);
57.       delay_us (20);
58.       cursor = read_adc ();
59.    
60.  
61.   //********************************************
62.   // Funcionamiento normal
63.   //********************************************
64.  
65.         // if(cursor<topbr){cursor=topbr;}               //si habilito estas dos instrucciones deja de funcionar
66.          //if(cursor>toper){cursor=toper;}
67.  
68.          if(cursor>cero)                     // Caso que Cursor sea mayor a cero
69.          {                        // Es decir lado derecho
70.             a = Ad*cursor + Bd;
71.          }
72.          else if (cursor<cero)                  // Caso Cursor sea menor a 0
73.          {                        // Es decir lado izquierdo
74.             a = Ai*cursor + Bi;
75.          }
76.          else                        // Caso que cursor este al medio
77.          {
78.             a=511;
79.          }
80.          ciclo_util = a ;
81.    }  
82. }