Autor Tema: Rutina para seteo de hora en CCS // DS1302  (Leído 6236 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado pastito

  • PIC10
  • *
  • Mensajes: 21
Rutina para seteo de hora en CCS // DS1302
« en: 29 de Septiembre de 2008, 01:34:48 »

Amigos,

He revivido el vicio por la electronica... baje un nuevo CCS que tiene funciones RTOS, etc. Tengo un board con un DS1302
y me sente a ver si podia escribir un programa para setear la hora... digamos que tengo 4 switches conectados entre
A0 y A3. El tema es que no es trivial hacerlo eficiente. Es de esas cosas que a primera vista parecen tontas pero a la hora
de escribir el codigo, me di cuenta que es relativamente complejo.

Para jugar quería hacerlo con funciones RTOS, pero se complica aun más... hasta ahora tengo una funcion RTOS que
lee si se cierran los switches, otra que resetea el WDT y una tercera que lee el DS1302 y escribe en el display fecha
y hora.

Alguien sabe o tiene alguna rutina de seteo de reloj en C?

El display es un LCD de 2X16.


Muchas gracias por la ayuda!

Desconectado Diego E.

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1086
Re: Rutina para seteo de hora en CCS // DS1302
« Respuesta #1 en: 29 de Septiembre de 2008, 09:34:08 »
Hola pastito, Hace poco hice un programa de prueba para el ds1307, con manejo de LCD 2 x 16, me dices si te sirve.

Desconectado pastito

  • PIC10
  • *
  • Mensajes: 21
Re: Rutina para seteo de hora en CCS // DS1302
« Respuesta #2 en: 29 de Septiembre de 2008, 23:49:09 »

Gracias por el ofrecimiento! Claro que me gustaria leer el codigo.

Mientras tanto escribi un cpdigo propio que a su vez te puedo mandar.


Saludos

Desconectado MLO__

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 4581
Re: Rutina para seteo de hora en CCS // DS1302
« Respuesta #3 en: 29 de Septiembre de 2008, 23:54:52 »
Se podria hacer por aca en el foro y todos podriamos participar

saludos
El papel lo aguanta todo

Desconectado flacoclau

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1692
    • El Micro Reactor
Re: Rutina para seteo de hora en CCS // DS1302
« Respuesta #4 en: 30 de Septiembre de 2008, 03:49:59 »
Hola pastito: en Este enlace tienes bastante material del amigo REDPIC, si bien es con un DS1307, creo que te puede servir.
saludos!!
Las personas con buena ortografía me atraen textualmente.

El Micro Reactor

Córdoba capital - Argentina.

Desconectado Diego E.

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1086
Re: Rutina para seteo de hora en CCS // DS1302
« Respuesta #5 en: 30 de Septiembre de 2008, 13:50:45 »
Hola pastito, acá te pongo el codigo del que te hablé

Código: CSS
  1. #include <16F873A.h>
  2. #use i2c(master, sda=PIN_C1, scl=PIN_C0,force_hw)
  3. #use delay(clock=4000000)
  4.  
  5. #fuses XT,NOWDT
  6.  
  7. #byte   porta=5         //Definicion de variables del pic
  8. #byte   portb=6
  9. #byte   portc=7
  10. #byte   t1con=0x10
  11.  
  12. #define e       porta,0 //Definicion de bits
  13. #define rs      porta,1
  14. #define salida  porta,5
  15.  
  16. int     dec_hora,uni_hora,dec_minu,uni_minu,dec_seg,uni_seg;//Definicion de variables
  17. int dia_sem, dec_dia, uni_dia, dec_mes, uni_mes, dec_ano, uni_ano;
  18. int respaldo;                           //Variable de 8 bit
  19. int i;
  20. int direcc_i2c,dato_i2c;
  21. int con_menu;
  22. int ban_osc;
  23. short ban_05seg;
  24. short ban_tec1;
  25. short ban_tec2;
  26. short ban_tec3;
  27. short ban_tec4;
  28. short ban_osc_seg;
  29. short ban_osc_min;
  30. short ban_osc_hor;
  31. short ban_osc_sem;
  32. short ban_osc_dia;
  33. short ban_osc_mes;
  34. short ban_osc_ano;
  35.  
  36. byte const dom[5]={"Dom-"};     //Tablas de los dias
  37. byte const lun[5]={"Lun-"};
  38. byte const mar[5]={"Mar-"};
  39. byte const mie[5]={"Mie-"};
  40. byte const jue[5]={"Jue-"};
  41. byte const vie[5]={"Vie-"};
  42. byte const sab[5]={"Sab-"};
  43.  
  44. ///////////////////////////////////////////////////////////////////////////////
  45. ///////////////////////////////////////////////////////////////////////////////
  46. #int_timer1                                     //Vector de interrupcion por desbordamiento del
  47. void interrupcion_tmr1()        //timer 1
  48. {
  49.         set_timer1(3036);               //Se carga el timer 1 con valor
  50. ///////////////////////////////////////
  51.         ban_05seg=1;
  52. }
  53. ///////////////////////////////////////////////////////////////////////////////
  54. void c_display_8b()     //Rutina que envia al LCD una palabra de control o dirección
  55. {
  56. set_tris_b(0b00000000);         //Configuracion de entradas y salidas del puerto B
  57. bit_clear(rs);
  58. portb=respaldo;
  59.  
  60. bit_set(e);
  61. delay_cycles(10);
  62. bit_clear(e);
  63. delay_ms(1);
  64. set_tris_b(0b11110000);         //Configuracion de entradas y salidas del puerto B
  65. }
  66. ///////////////////////////////////////////////////////////////////////////////
  67. void d_display_8b()                     //Rutina que envía al LCD un caracter
  68. {
  69. set_tris_b(0b00000000);         //Configuracion de entradas y salidas del puerto B
  70. bit_set(rs);
  71. portb=respaldo;
  72.  
  73. bit_set(e);
  74. delay_cycles(10);
  75. bit_clear(e);
  76. delay_ms(1);
  77. set_tris_b(0b11110000);         //Configuracion de entradas y salidas del puerto B
  78. }
  79. ///////////////////////////////////////////////////////////////////////////////
  80. void disp_dia()         //Rutina que presenta el texto del dia
  81. {
  82. if(ban_osc_sem==1)      //Si esta la bandera de oscilacion activa presenta espacios
  83.         {
  84.         for(i=0;i<=3;i++)
  85.                 {respaldo=' ';
  86.                 d_display_8b();}
  87.                 return;
  88.         }
  89. switch(dia_sem)         //Seleccion del dia
  90.         {
  91.         case 1:
  92.                 for(i=0;i<=3;i++)
  93.                 {respaldo=dom[i];
  94.                 d_display_8b();}
  95.                 break;
  96.         case 2:
  97.                 for(i=0;i<=3;i++)
  98.                 {respaldo=lun[i];
  99.                 d_display_8b();}
  100.                 break;
  101.         case 3:
  102.                 for(i=0;i<=3;i++)
  103.                 {respaldo=mar[i];
  104.                 d_display_8b();}
  105.                 break;
  106.         case 4:
  107.                 for(i=0;i<=3;i++)
  108.                 {respaldo=mie[i];
  109.                 d_display_8b();}
  110.                 break;
  111.         case 5:
  112.                 for(i=0;i<=3;i++)
  113.                 {respaldo=jue[i];
  114.                 d_display_8b();}
  115.                 break;
  116.         case 6:
  117.                 for(i=0;i<=3;i++)
  118.                 {respaldo=vie[i];
  119.                 d_display_8b();}
  120.                 break;
  121.         case 7:
  122.                 for(i=0;i<=3;i++)
  123.                 {respaldo=sab[i];
  124.                 d_display_8b();}
  125.                 break;
  126.         }
  127. }
  128. ///////////////////////////////////////////////////////////////////////////////
  129. void display()
  130. {
  131. respaldo=0x84;  //Dirección donde se escribirá el mensaje
  132. c_display_8b();
  133.  
  134. respaldo=(dec_hora+48); //Se convierte el decimal a ascii
  135. if(ban_osc_hor==1)
  136.         {respaldo=' ';}
  137. d_display_8b();
  138. respaldo=(uni_hora+48); //Se convierte el decimal a ascii
  139. if(ban_osc_hor==1)
  140.         {respaldo=' ';}
  141. d_display_8b();
  142.  
  143. respaldo=':';
  144. d_display_8b();
  145.  
  146. respaldo=(dec_minu+48); //Se convierte el decimal a ascii
  147. if(ban_osc_min==1)
  148.         {respaldo=' ';}
  149. d_display_8b();
  150. respaldo=(uni_minu+48); //Se convierte el decimal a ascii
  151. if(ban_osc_min==1)
  152.         {respaldo=' ';}
  153. d_display_8b();
  154.  
  155. respaldo=':';
  156. d_display_8b();
  157.  
  158. respaldo=(dec_seg+48);  //Se convierte el decimal a ascii
  159. if(ban_osc_seg==1)
  160.         {respaldo=' ';}
  161. d_display_8b();
  162. respaldo=(uni_seg+48);  //Se convierte el decimal a ascii
  163. if(ban_osc_seg==1)
  164.         {respaldo=' ';}
  165. d_display_8b();
  166. ///////////////////////////////////////
  167. respaldo=0xc2;  //Dirección donde se escribirá el mensaje
  168. c_display_8b();
  169.  
  170. //respaldo=(dia_sem+48);        //Se convierte el decimal a ascii
  171. //d_display_8b();
  172.  
  173. disp_dia();
  174.  
  175. respaldo=(dec_dia+48);  //Se convierte el decimal a ascii
  176. if(ban_osc_dia==1)
  177.         {respaldo=' ';}
  178. d_display_8b();
  179. respaldo=(uni_dia+48);  //Se convierte el decimal a ascii
  180. if(ban_osc_dia==1)
  181.         {respaldo=' ';}
  182. d_display_8b();
  183.  
  184. respaldo='/';
  185. d_display_8b();
  186.  
  187. respaldo=(dec_mes+48);  //Se convierte el decimal a ascii
  188. if(ban_osc_mes==1)
  189.         {respaldo=' ';}
  190. d_display_8b();
  191. respaldo=(uni_mes+48);  //Se convierte el decimal a ascii
  192. if(ban_osc_mes==1)
  193.         {respaldo=' ';}
  194. d_display_8b();
  195.  
  196. respaldo='/';
  197. d_display_8b();
  198.  
  199. respaldo=(dec_ano+48);  //Se convierte el decimal a ascii
  200. if(ban_osc_ano==1)
  201.         {respaldo=' ';}
  202. d_display_8b();
  203. respaldo=(uni_ano+48);  //Se convierte el decimal a ascii
  204. if(ban_osc_ano==1)
  205.         {respaldo=' ';}
  206. d_display_8b();
  207. }
  208. ///////////////////////////////////////////////////////////////////////////////
  209. void ini_lcd()
  210. {
  211. //respaldo=0b00101000;  //Codigo para display a 4 bits
  212. //call  c_display_8b;
  213.  
  214. respaldo=0b00111000;    //Codigo para display a 8 bits
  215. c_display_8b();
  216.  
  217. respaldo=0b00001100;    //Codigo que activa el display
  218. c_display_8b();
  219.  
  220. respaldo=0b00000110;    //Codigo que define el cursor para
  221. c_display_8b();                 //Que se desplace hacia la derecha
  222.  
  223. //respaldo=0b00000111;  //Codigo que define el cursor para
  224. //call  c_display_8b;   //que desplace hacia la izquierda
  225.                                                 //todo el mensaje
  226.  
  227. respaldo=1;                             //Limpia el display
  228. c_display_8b();
  229. delay_ms(2);
  230. }
  231. ///////////////////////////////////////////////////////////////////////////////
  232. void leer_ds1307()
  233. {
  234.         if(con_menu!=0)
  235.                 {return;}
  236.  
  237. i2c_start();                    //Start
  238. i2c_write(0b11010000);  //Control
  239. i2c_write(0b00000000);  //Direccion
  240. i2c_stop();                             //Stop
  241. i2c_start();                    //Start
  242. i2c_write(0b11010001);  //Control para lectura
  243.  
  244. respaldo=i2c_read();    //Se lee los segundos
  245. uni_seg=respaldo;
  246. dec_seg=swap(respaldo);
  247. uni_seg=(uni_seg & 0x0f);
  248. dec_seg=(dec_seg & 0x0f);
  249.  
  250. respaldo=i2c_read();    //Se lee los minutos
  251. uni_minu=respaldo;
  252. dec_minu=swap(respaldo);
  253. uni_minu=(uni_minu & 0x0f);
  254. dec_minu=(dec_minu & 0x0f);
  255.  
  256. respaldo=i2c_read();    //Se lee las horas
  257. uni_hora=respaldo;
  258. dec_hora=swap(respaldo);
  259. uni_hora=(uni_hora & 0x0f);
  260. dec_hora=(dec_hora & 0x0f);
  261.  
  262. respaldo=i2c_read();    //Se lee el dia de la semana
  263. dia_sem=respaldo;
  264.  
  265. respaldo=i2c_read();    //Se lee el dia del mes
  266. uni_dia=respaldo;
  267. dec_dia=swap(respaldo);
  268. uni_dia=(uni_dia & 0x0f);
  269. dec_dia=(dec_dia & 0x0f);
  270.  
  271. respaldo=i2c_read();    //Se lee el mes
  272. uni_mes=respaldo;
  273. dec_mes=swap(respaldo);
  274. uni_mes=(uni_mes & 0x0f);
  275. dec_mes=(dec_mes & 0x0f);
  276.  
  277. respaldo=i2c_read();    //Se lee los años
  278. uni_ano=respaldo;
  279. dec_ano=swap(respaldo);
  280. uni_ano=(uni_ano & 0x0f);
  281. dec_ano=(dec_ano & 0x0f);
  282.  
  283. respaldo=i2c_read();
  284.  
  285. i2c_stop();                             //Stop
  286. }
  287. ///////////////////////////////////////////////////////////////////////////////
  288. void conf_ds1307()
  289. {
  290. i2c_start();                    //Start
  291. i2c_write(0b11010000);  //Control
  292. i2c_write(0b00000000);  //Direccion
  293.  
  294. respaldo=(uni_seg | (swap(dec_seg)));   //Se escriben los segundos
  295. i2c_write(respaldo);
  296.  
  297. respaldo=(uni_minu | (swap(dec_minu))); //Se escriben los minutos
  298. i2c_write(respaldo);
  299.  
  300. respaldo=(uni_hora | (swap(dec_hora))); //Se escriben las horas
  301. i2c_write(respaldo);
  302.  
  303. i2c_write(dia_sem);
  304.  
  305. respaldo=(uni_dia | (swap(dec_dia)));   //Se escriben los dias del mes
  306. i2c_write(respaldo);
  307.  
  308. respaldo=(uni_mes | (swap(dec_mes)));   //Se escribe el mes
  309. i2c_write(respaldo);
  310.  
  311. respaldo=(uni_ano | (swap(dec_ano)));   //Se escribe el año
  312. i2c_write(respaldo);
  313.  
  314. i2c_write(0);   //Control de pulsos
  315.  
  316. i2c_stop();                             //Stop
  317. }
  318.  
  319. ///////////////////////////////////////////////////////////////////////////////
  320. void osc_ban_hor()              //Rutina de la bandera que hace oscilar las horas
  321. {
  322. if(con_menu==1)
  323.         {ban_osc_hor=!ban_osc_hor;}
  324. else
  325.         {ban_osc_hor=0;}
  326. }
  327. ///////////////////////////////////////////////////////////////////////////////
  328. void osc_ban_min()              //Rutina de la bandera que hace oscilar los minutos
  329. {
  330. if(con_menu==2)
  331.         {ban_osc_min=!ban_osc_min;}
  332. else
  333.         {ban_osc_min=0;}
  334. }
  335. ///////////////////////////////////////////////////////////////////////////////
  336. void osc_ban_seg()              //Rutina de la bandera que hace oscilar los segundos
  337. {
  338. if(con_menu==3)
  339.         {ban_osc_seg=!ban_osc_seg;}
  340. else
  341.         {ban_osc_seg=0;}
  342. }
  343. ///////////////////////////////////////////////////////////////////////////////
  344. void osc_ban_sem()              //Rutina de la bandera que hace oscilar los segundos
  345. {
  346. if(con_menu==4)
  347.         {ban_osc_sem=!ban_osc_sem;}
  348. else
  349.         {ban_osc_sem=0;}
  350. }
  351. ///////////////////////////////////////////////////////////////////////////////
  352. void osc_ban_dia()              //Rutina de la bandera que hace oscilar los segundos
  353. {
  354. if(con_menu==5)
  355.         {ban_osc_dia=!ban_osc_dia;}
  356. else
  357.         {ban_osc_dia=0;}
  358. }
  359. ///////////////////////////////////////////////////////////////////////////////
  360. void osc_ban_mes()              //Rutina de la bandera que hace oscilar los segundos
  361. {
  362. if(con_menu==6)
  363.         {ban_osc_mes=!ban_osc_mes;}
  364. else
  365.         {ban_osc_mes=0;}
  366. }
  367. ///////////////////////////////////////////////////////////////////////////////
  368. void osc_ban_ano()              //Rutina de la bandera que hace oscilar los segundos
  369. {
  370. if(con_menu==7)
  371.         {ban_osc_ano=!ban_osc_ano;}
  372. else
  373.         {ban_osc_ano=0;}
  374. }
  375. ///////////////////////////////////////////////////////////////////////////////
  376. void menu_limpiar()             //Menu de la tecla limpiar, dependiendo del contador
  377. {                                               //menu limpia los registros correspondientes
  378. switch(con_menu)
  379.                 {
  380.                 case 1:
  381.                         uni_hora=0;
  382.                         dec_hora=0;
  383.                         break;
  384.                 case 2:
  385.                         uni_minu=0;
  386.                         dec_minu=0;
  387.                         break;
  388.                 case 3:
  389.                         uni_seg=0;
  390.                         dec_seg=0;
  391.                         break;
  392.                 case 4:
  393.                         dia_sem=1;
  394.                         break;
  395.                 case 5:
  396.                         uni_dia=1;
  397.                         dec_dia=0;
  398.                         break;
  399.                 case 6:
  400.                         uni_mes=1;
  401.                         dec_mes=0;
  402.                         break;
  403.                 case 7:
  404.                         uni_ano=0;
  405.                         dec_ano=0;
  406.                         break;
  407.                 }
  408. }
  409. ///////////////////////////////////////////////////////////////////////////////
  410. void menu_incre()               //Menu de la tecla incre, dependiendo del contador
  411. {                                               //menu limpia los registros correspondientes
  412. switch(con_menu)
  413.                 {
  414.                 case 1:
  415.                         respaldo=(dec_hora*10)+uni_hora;        //Se pasa los decimales a entero
  416.                         respaldo++;                                                     //Se incrementa
  417.                         if(respaldo==24)                                        //Si horas llego a 24 reinicia
  418.                                 {respaldo=0;}
  419.  
  420.                         dec_hora=respaldo/10;                           //Se pasa nuevamente a BCD
  421.                         uni_hora=respaldo%10;
  422.                         break;
  423.                 case 2:
  424.                         respaldo=(dec_minu*10)+uni_minu;
  425.                         respaldo++;
  426.                         if(respaldo==60)
  427.                                 {respaldo=0;}
  428.  
  429.                         dec_minu=respaldo/10;
  430.                         uni_minu=respaldo%10;
  431.                         break;
  432.                 case 3:
  433.                         respaldo=(dec_seg*10)+uni_seg;
  434.                         respaldo++;
  435.                         if(respaldo==60)
  436.                                 {respaldo=0;}
  437.  
  438.                         dec_seg=respaldo/10;
  439.                         uni_seg=respaldo%10;
  440.                         break;
  441.                 case 4:
  442.                         dia_sem++;
  443.                         if(dia_sem==8)
  444.                                 {dia_sem=1;}10;
  445.                         break;
  446.                 case 5:
  447.                         respaldo=(dec_dia*10)+uni_dia;
  448.                         respaldo++;
  449.                         if(respaldo==32)
  450.                                 {respaldo=1;}
  451.  
  452.                         dec_dia=respaldo/10;
  453.                         uni_dia=respaldo%10;
  454.                         break;
  455.                 case 6:
  456.                         respaldo=(dec_mes*10)+uni_mes;
  457.                         respaldo++;
  458.                         if(respaldo==13)
  459.                                 {respaldo=1;}
  460.  
  461.                         dec_mes=respaldo/10;
  462.                         uni_mes=respaldo%10;
  463.                         break;
  464.                 case 7:
  465.                         respaldo=(dec_ano*10)+uni_ano;
  466.                         respaldo++;
  467.                         if(respaldo==99)
  468.                                 {respaldo=0;}
  469.  
  470.                         dec_ano=respaldo/10;
  471.                         uni_ano=respaldo%10;
  472.                         break;
  473.                 }
  474. }
  475. ///////////////////////////////////////////////////////////////////////////////
  476. void menu_decre()               //Menu de la tecla decre, dependiendo del contador
  477. {                                               //menu limpia los registros correspondientes
  478. switch(con_menu)
  479.                 {
  480.                 case 1:
  481.                         respaldo=(dec_hora*10)+uni_hora;        //Se pasa los decimales a entero
  482.                         respaldo--;                                                     //Se decrementa
  483.                         if(respaldo==255)                                       //Si horas llego a 00 pasa a 23
  484.                                 {respaldo=23;}
  485.  
  486.                         dec_hora=respaldo/10;                           //Se pasa nuevamente a BCD
  487.                         uni_hora=respaldo%10;
  488.                         break;
  489.                 case 2:
  490.                         respaldo=(dec_minu*10)+uni_minu;
  491.                         respaldo--;
  492.                         if(respaldo==255)
  493.                                 {respaldo=59;}
  494.  
  495.                         dec_minu=respaldo/10;
  496.                         uni_minu=respaldo%10;
  497.                         break;
  498.                 case 3:
  499.                         respaldo=(dec_seg*10)+uni_seg;
  500.                         respaldo--;
  501.                         if(respaldo==255)
  502.                                 {respaldo=59;}
  503.  
  504.                         dec_seg=respaldo/10;
  505.                         uni_seg=respaldo%10;
  506.                         break;
  507.                 case 4:
  508.                         dia_sem--;
  509.                         if(dia_sem==0)
  510.                                 {dia_sem=7;}
  511.                         break;
  512.                 case 5:
  513.                         respaldo=(dec_dia*10)+uni_dia;
  514.                         respaldo--;
  515.                         if(respaldo==255)
  516.                                 {respaldo=31;}
  517.  
  518.                         dec_dia=respaldo/10;
  519.                         uni_dia=respaldo%10;
  520.                         break;
  521.                 case 6:
  522.                         respaldo=(dec_mes*10)+uni_mes;
  523.                         respaldo--;
  524.                         if(respaldo==255)
  525.                                 {respaldo=12;}
  526.  
  527.                         dec_mes=respaldo/10;
  528.                         uni_mes=respaldo%10;
  529.                         break;
  530.                 case 7:
  531.                         respaldo=(dec_ano*10)+uni_ano;
  532.                         respaldo--;
  533.                         if(respaldo==255)
  534.                                 {respaldo=99;}
  535.  
  536.                         dec_ano=respaldo/10;
  537.                         uni_ano=respaldo%10;
  538.                         break;
  539.                 }
  540. }
  541. ///////////////////////////////////////////////////////////////////////////////
  542.  
  543. void teclado()          //Rutina general de teclado
  544. {
  545.         portb=(0xff);
  546.         bit_clear(portb,0);
  547.         delay_us(100);
  548. //////////////////
  549.                 if((bit_test(portb,7)==0)&&(ban_tec1==0))
  550.                         {
  551.                         ban_tec1=1;
  552.                         menu_incre();
  553.                         }
  554.                 if(bit_test(portb,7)==1)
  555.                         {
  556.                         ban_tec1=0;
  557.                         }
  558. //////////////////
  559.                 if((bit_test(portb,6)==0)&&(ban_tec2==0))
  560.                         {
  561.                         ban_tec2=1;
  562.                         menu_decre();
  563.                         }
  564.                 if(bit_test(portb,6)==1)
  565.                         {
  566.                         ban_tec2=0;
  567.                         }
  568. //////////////////
  569.                 if((bit_test(portb,5)==0)&&(ban_tec3==0))
  570.                         {
  571.                         ban_tec3=1;
  572.                         menu_limpiar();
  573.                         }
  574.                 if(bit_test(portb,5)==1)
  575.                         {
  576.                         ban_tec3=0;
  577.                         }
  578. //////////////////
  579.                 if((bit_test(portb,4)==0)&&(ban_tec4==0))
  580.                         {
  581.                         ban_tec4=1;
  582.                         con_menu++;
  583.                                 if(con_menu==8)
  584.                                 {
  585.                                 con_menu=0;
  586.                                 respaldo=1;
  587.                                 c_display_8b();
  588.                                 delay_ms(10);
  589.                                 conf_ds1307();
  590.                                 portb=0xfe;
  591.                                 }
  592.                         }
  593.                 if(bit_test(portb,4)==1)
  594.                         {
  595.                         ban_tec4=0;
  596.                         }
  597.  
  598.         bit_set(portb,0);
  599. }
  600. ///////////////////////////////////////////////////////////////////////////////
  601. ///////////////////////////////////////////////////////////////////////////////
  602.  
  603. #zero_ram       //Borrado de la memoria ram
  604. #rom  0x2100={4,3,2,1}  //Datos pre cargados en la rom
  605.  
  606. void main()             //Rutina principal
  607. {
  608. set_tris_a(0b010000);           //Configuracion de entradas y salidas del puerto A
  609. set_tris_b(0b11110000);         //Configuracion de entradas y salidas del puerto B
  610. set_tris_c(0b11111111);         //Configuracion de entradas y salidas del puerto C
  611. //port_b_pullups(true);         //Habilitación de las resistencias pull-ups
  612. t1con=(0b00010101);                     //Configuracion del tmr1
  613. enable_interrupts(global);      //Habilitación de todas las interrupciones
  614. enable_interrupts(int_timer1); //Habilitación de la interrupción del Tmr1
  615.  
  616. porta=0;        //Porta inicia en 0
  617. portb=0;        //Portb inicia en 0
  618. portc=0;        //Portc inicia en 0
  619.  
  620. delay_ms(2);
  621. ini_lcd();
  622. leer_ds1307();
  623. display();
  624.  
  625. while(true)             //Rutina general
  626.         {
  627.         teclado();
  628.         if(ban_05seg==1)        //Bandera que seactiva cada 0,5 seg
  629.                 {
  630.                 ban_05seg=0;
  631.                 leer_ds1307();
  632.                 display();
  633.                 osc_ban_seg();
  634.                 osc_ban_min();
  635.                 osc_ban_hor();
  636.                 osc_ban_sem();
  637.                 osc_ban_dia();
  638.                 osc_ban_mes();
  639.                 osc_ban_ano();
  640.                 }
  641.         }
  642. }
  643. ///////////////////////////////////////////////////////////////////////////////

Editado por RedPic para añadirle la codificación GeSHi.
« Última modificación: 30 de Septiembre de 2008, 18:18:14 por un Moderador »

Desconectado pastito

  • PIC10
  • *
  • Mensajes: 21
Re: Rutina para seteo de hora en CCS // DS1302
« Respuesta #6 en: 01 de Octubre de 2008, 15:16:29 »


Amigo Colombiano,

Aqui pego el codigo que escribi. Creo que esta bastante limpio. Hay que tener en cuenta que mi programa
implementa RTOS (en realidad si no es preemptivo no es un RTOS de verdad --pero esa es otra historia--).

Hubiera sido mas elegante --y economico en codigo y memoria-- hacer los whiles de cada tecla en la misma
subrutina (por ejemplo en la de validacion) pero el problema es que no se puede llamar a rtos_yield () desde
una subrutina si la misma no es a su vez una tarea RTOS.

Mas alla de eso, todo funciona de pelicula. Interesante ver como la subrutina RTOS del WDT funciona
correctamente.


Saludos y espero que sirva
PD. Cuando tenga tiempo miro su codigo!

Desconectado pastito

  • PIC10
  • *
  • Mensajes: 21
Re: Rutina para seteo de hora en CCS // DS1302
« Respuesta #7 en: 01 de Octubre de 2008, 17:17:23 »
Código: [Seleccionar]
#define USAR_WDT // Comentar si no queremos usar WDT
// Ver parametro WDT_TIMEOUT en la inicializacion

#if defined(__PCM__)
#include <16F877.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=19200, xmit=PIN_C6, rcv=PIN_C7)

#elif defined(__PCH__)
#include <18F452.h>
  #ifdef USAR_WDT
     #fuses HS,WDT128,NOPROTECT,NOLVP
  #else
     #fuses HS,NOWDT,NOPROTECT,NOLVP
  #endif
#use delay(clock=20000000)
#use rs232(baud=19200, xmit=PIN_C6, rcv=PIN_C7)
#endif

#include <bootloader.h>

#include "C:\docs\pic\picc\18f452\reloj_rtos\lcd.c"      // Cargar driver LCD
#include "C:\docs\pic\picc\18f452\reloj_rtos\ds1302.c"   // Cargar driver DS1302

#define BACKLIGHT PIN_B3

// #use rtos(timer=0,minor_cycle=100ms,statistics)
#use rtos(timer=0,minor_cycle=100ms)

struct nombre {
   char dia[5];
} sem[7];


#ifdef USAR_WDT
#task(rate=500ms,max=100ms)
// Esta tarea RTOS limpia el WDT cada 4 segundos.
// El default del WDT es de 7 segundos.
void tarea_restart_wdt ( )
{
   restart_wdt();
}
#endif


#task(rate=500ms,max=100ms)
void tarea_reloj ( )
{
   byte day,mth,year,dow;
   byte hr,min,sec;

   // Leemos la fecha y hora del chip DS1302
   rtc_get_date (day,mth,year,dow);
   rtc_get_time (hr,min,sec);

   // Imprimimos la hora en el panel de LCD
   printf (lcd_putc, "\f%s %02u/%02u/%02u\n",sem[dow-1].dia,day,mth,year);
   printf (lcd_putc, "%02u:%02u:%02u",hr,min,sec);
   // Descomentar para imprimir la hora en el puerto serial
   // printf ("\f%s %2u/%2u/%2u -- %2u:%2u:%2u\n\r",sem[dow-1].dia,day,mth,year,hr,min,sec);
}

int teclas ()
{
   int res;
   
   res = 0;
     
   if (input(PIN_A0))
      res = 1;

   if (input(PIN_A1))
      res = 2;

   if (input(PIN_A2))
      res = 3;

   if (input(PIN_A3))
      res = 4;
   
   // Debounce... un poco rustico!
   delay_ms (100);
   
   return (res);
}

byte validar_rango (byte min, byte max, byte valor)
{
   // Si tengo 255 es que se hizo un ovewflow de (0 - 1 = 255)
   // entonces lo primero es poner valor en max
   
   if (valor == 255)
      valor = max;

   if (valor < min)
      valor = max;
   
   if (valor > max)
      valor = min;
   
   return (valor);
}


#task(rate=200ms,max=100ms)
void tarea_teclas ( )
{
   int1 on_off;
   int botones;
   byte day,mth,year,dow;
   byte hr,min,sec;
   
   while (TRUE)
   {
      botones = teclas ();
     
      //if (botones > 0)
      //   printf ("Apretaste el boton %d\n\r", botones);
         
      // Rutina de cambio de hora   
      if (botones == 1)
      {
         rtos_disable (tarea_reloj);
         
         // Leemos la fecha y hora del chip DS1302
         rtc_get_date (day,mth,year,dow);
         rtc_get_time (hr,min,sec);

         botones = 0;

         // Aca cambiamos el dia de la semana
         while (botones != 1)
         {
            botones = teclas ();
                 
            printf (lcd_putc, "\fDia de sem?\n");
            printf (lcd_putc, "%s", sem[dow-1].dia);
                 
            if (botones == 2)
               dow++;
            if (botones == 3)
               dow--;
                 
            dow = validar_rango (1, 7, dow);
                 
            rtos_yield ();   
         }
         
         botones = 0;
         
         // Aca cambiamos el dia del mes
         while (botones != 1)
         {
            botones = teclas ();
                 
            printf (lcd_putc, "\fDia del mes?\n");
            printf (lcd_putc, "%u", day);
                 
            if (botones == 2)
               day++;
            if (botones == 3)
               day--;
                 
            day = validar_rango (1, 31, day);
                 
            rtos_yield ();   
         }

         botones = 0;

         // Aca cambiamos el mes
         while (botones != 1)
         {
            botones = teclas ();
                 
            printf (lcd_putc, "\fMes?\n");
            printf (lcd_putc, "%u", mth);
               
            if (botones == 2)
               mth++;
            if (botones == 3)
               mth--;
                 
            mth = validar_rango (1, 12, mth);
                 
            rtos_yield ();   
         }

         botones = 0;

         // Aca cambiamos el año
         while (botones != 1)
         {
            botones = teclas ();
                 
            printf (lcd_putc, "\fYear?\n");
            printf (lcd_putc, "%u", year);
                 
            if (botones == 2)
               year++;
            if (botones == 3)
               year--;
                 
            year = validar_rango (0, 99, year);
                 
            rtos_yield ();   
         }

         botones = 0;

         // Aca cambiamos la hora
         while (botones != 1)
         {
            botones = teclas ();
                 
            printf (lcd_putc, "\fHora?\n");
            printf (lcd_putc, "%u", hr);
                 
            if (botones == 2)
               hr++;
            if (botones == 3)
               hr--;
                 
            hr = validar_rango (0, 23, hr);
                 
            rtos_yield ();   
         }

         botones = 0;

         // Aca cambiamos los minutos
         while (botones != 1)
         {
            botones = teclas ();
                 
            printf (lcd_putc, "\fMinutos?\n");
            printf (lcd_putc, "%u", min);
                 
            if (botones == 2)
               min++;
            if (botones == 3)
               min--;
                 
            min = validar_rango (0, 59, min);
                 
            rtos_yield ();   
         }
         // Aca seteamos la hora en el DS1302
         rtc_set_datetime (day,mth,year,dow,hr,min);
         rtos_enable (tarea_reloj);
      }
     
      if (botones == 4)
      {
         botones = 0;
         
         on_off++;
     
         if (on_off == 1)
            output_high (BACKLIGHT);
         else
            output_low (BACKLIGHT);
      }
      rtos_yield ();
   }
}


// Descomentar abajo para estadisticas de una tarea RTOS
// Ojo que #rtos tiene que tener statistics !
/*
struct rtos_stats {
   int32 task_total_ticks;       // number of ticks the task has used
   int16 task_min_ticks;         // the minimum number of ticks used
   int16 task_max_ticks;         // the maximum number of ticks ueed
   int16 hns_per_tick;           // us = (ticks*hns_per_tic)/10
};

#task(rate=500ms,max=250ms)
void tarea_control ( )
{
   struct rtos_stats stats;
   rtos_stats(tarea_reloj,&stats);
   printf ( "\n\r" );
   printf ( "task_total_ticks : %Lius\n\r" ,
            (int32)(stats.task_total_ticks)*stats.hns_per_tick );
   printf ( "task_min_ticks   : %Lius\n\r" ,
            (int32)(stats.task_min_ticks)*stats.hns_per_tick );
   printf ( "task_max_ticks   : %Lius\n\r" ,
            (int32)(stats.task_max_ticks)*stats.hns_per_tick );
   printf ("\n\r");

   if(rtos_overrun(tarea_reloj)) {
         printf("tarea_reloj has Overrun\n\r\n\r");
   }
}
*/


void main(void) {

   #ifdef USAR_WDT
//     #define WDT_TIMEOUT 4 // default es de 7 segundos
     setup_wdt (WDT_ON);
   #endif

   // Inicializamos la semana
   strcpy (sem[0].dia, "Lun");
   strcpy (sem[1].dia, "Mar");
   strcpy (sem[2].dia, "Mier");
   strcpy (sem[3].dia, "Jue");
   strcpy (sem[4].dia, "Vie");
   strcpy (sem[5].dia, "Sab");
   strcpy (sem[6].dia, "Dom");


   lcd_init (); // Inicializar Display LCD
   rtc_init();  // Inicializar DS1302

   // Encendemos el backlight!
   output_high (BACKLIGHT);

   // void rtc_set_datetime(BYTE day, BYTE mth, BYTE year, BYTE dow, BYTE hr, BYTE min)
   // rtc_set_datetime (40,9,8,7,21,88);
   // Ejemplo 28 = 40 en decimal del 9 del 08
   // 15 hrs (21 en decimal) 58 minutos (88 en decimal)

   // Ejecutamos el RTOS!!!
   rtos_run ();
}


 

anything