Autor Tema: Cursillo en C18 para PICS DESDE CERO  (Leído 243228 veces)

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

Desconectado micro_cadaver

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2102
    • blog microembebidos
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #75 en: 23 de Junio de 2007, 03:30:49 »
El Protocolo I2C

Una de las herramientas de comunicación muy usada en el mundo de los microcontroladores es el protocolo serial I2C, el compilador C18 tiene implementado un conjunto de librerias y rutinas para este propósito, sin embargo jijijiji  :mrgreen: no tienen una libreria de aplicación específica por ejemplo para el DS1307 (entre otros...), tiene una libreria para el manejo de memorias eeprom externas pero solo para la 24XX01, pues solo permite ingresar 1 byte de dirección de memoria.
En vista de tales inconvenientes (y para no quedar atrás del CCS) nos aventuraremos en la odisea de implementar nuestras propias rutinas jijiji  :-/, empezaremos con las memorias eeprom, y luego nos daremos un paseito por el DS1307, si alguien propone algún otro chip para hacer su libreria pues bienvenido sea  :-) .

Ah! pero antes estudiemos brevemente el modulo I2C que lleva incorporado el PIC18F2525 (en los demas PICs de esta gama la principal diferencia está en la ubicación de los pines SDA y SCL).


Módulo MSSP en Modo I2C

En el pic 18F2525 el protocolo I2C utiliza los siguientes pines para comunicarse, los cuales deben estar configurados como entradas al inicializar el modo I2C:

Estos pines del pic cuando se configuran como puerto serial del módulo I2C demandan una resistencia de PULL UP en ambos pines, esto se debe al protocolo I2C. Esta resistencia puede ser de 10K -- 2K tirada a 5V, pero en el simulador usaremos un tipo de componente llamado PULL-UP, no olviden que la posicion de estos pines varia segun el modelo del pic18F, tener cuidado al momento de implementarlo si no tienen el 18F2525, no olviden setearlos como entradas.

A continuación tenemos los registros que administran el control del módulo:

Estos registros poseen las diversas configuraciones que puede optar el módulo I2C, para nuestros objetivos vamos a dejarlo habilitado como dispositivo I2C Maestro, bus de 100KHz para cristal de 4MHz, sin interrupciones, y unos detalles más que los podremos ver en sus registros de control:


En este registro se puede configurar lo siguiente:
  • SSPEN:habilita el puerto serial y los pines SCL y SDA.
  • SSPM3-SSPM0: modo de operación del MSSP, escogemos la opción de Modo I2C Master.


En este registro se puede configurar lo siguiente:
  • GCEN: habilita interrupcion para modo esclavo, pero no lo vamos a usar.


En este registro se puede configurar lo siguiente:
  • SMP: velocidad del bus, slew rate, escojemos la opcion 100KHz.
  • CKE: dejarla deshabilitada.

El registro SSPSR es el buffer de desplazamiento usado para enviar o recibir información de forma serial.
El registro SSPBUF es el registro donde se escribe o se guarda el valos a enviar o recibir.

El registro SSPADD es el que guarda el valor de recarga del Generador de Baudios con el cual obtenemos la velocidad del bus I2C, para nuestra experiencia requerimos 100KHz con 4MHz entonces segun la fórmula:

SSPADD = 9
« Última modificación: 23 de Junio de 2007, 06:56:09 por micro_cadaver »
a cosechar!!!... :P
pic32... ahi voy....
aguante el micro 16f84  !!!!

visita mi pagina: http://www.microembebidos.wordpress.com

Desconectado micro_cadaver

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2102
    • blog microembebidos
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #76 en: 25 de Junio de 2007, 01:07:11 »
Rutinas del Módulo I2C
La imagen nos muestra las rutinas que tiene implementado el C18 para realizar la comunicación I2C entres dispositivos que soporten este protocolo. Esta información esta en el MPLAB C18 Libraries.pdf que viene en la carpeta DOC del C18.
La función de cada rutina tiene que ver con el protocolo I2C, es decir que se implementa el bit de Start, de Stop, el ACK, la lectura get o read, la escritura write o put, los retardos, etc... y en base a estas rutinas se ha escrito una libreria que permite el uso de memorias externas eeprom con dos bytes de direccion de datos. Pues como ya comente el C18 tiene una libreria pero para la memoria 24XX01 cuyo adress (direccion de datos) es de 1 byte de tamaño.

Librería  memoria_externa.h
Esta libreria contiene las rutinas que van a desempeñar la comunicación entre el pic y la memoria serial eeprom externa con protocolo I2C con 2 bytes como tamaño de direccion de datos, por ejemplo la 24XX512,....24XX32....., a continuación la libreria:
Código: C
  1. //********************************************************
  2. //********************************************************
  3. signed char putrsI2C( const rom char *wrptr )
  4. {
  5.   while ( *wrptr )                // transmit data until null character
  6.   {
  7.         if ( WriteI2C ( *wrptr ) )   // write 1 byte
  8.     {
  9.         return ( -3 );            // return with write collision error
  10.         }
  11.     IdleI2C();                  // test for idle condition
  12.     if ( SSPCON2bits.ACKSTAT )  // test received ack bit state
  13.     {
  14.         return ( -2 );            // bus device responded with  NOT ACK
  15.         }                           // terminate putsI2C() function
  16.         wrptr ++;                       // increment pointer
  17.   }
  18.   return ( 0 );
  19. }
  20. //********************************************************
  21. //********************************************************
  22. //
  23. //      Escribir en Memoria EEPROM 24LC512
  24. //
  25. //********************************************************
  26. //********************************************************
  27. unsigned char EscribeDato_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2, unsigned char data )
  28. {
  29.   IdleI2C();                      // ensure module is idle
  30.   StartI2C();                     // initiate START condition
  31.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  32.   if ( PIR2bits.BCLIF )           // test for bus collision
  33.   {
  34.     return ( -1 );                // return with Bus Collision error
  35.   }
  36.   else                            // start condition successful
  37.   {
  38.     if ( WriteI2C( control ) )    // write byte - R/W bit should be 0
  39.     {
  40.       return ( -3 );              // set error for write collision
  41.     }
  42.  
  43.     IdleI2C();                    // ensure module is idle
  44.     if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition received
  45.     {
  46.                 if ( WriteI2C( address1 ) )  // write word address for EEPROM
  47.         {
  48.                 return ( -3 );            // set error for write collision
  49.         }
  50.             IdleI2C();                    // ensure module is idle
  51.             if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition received
  52.             {
  53.                 if ( WriteI2C( address2 ) )  // write word address for EEPROM
  54.                 {
  55.                         return ( -3 );            // set error for write collision
  56.                 }
  57.                         IdleI2C();                  // ensure module is idle
  58.                     if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  59.                     {
  60.                         if ( WriteI2C( data ) )   // data byte for EEPROM
  61.                                 {
  62.                           return ( -3 );          // set error for write collision
  63.                         }
  64.                     }
  65.                     else
  66.                     {
  67.                         return ( -2 );            // return with Not Ack error condition  
  68.                         }
  69.                 }
  70.     }
  71.     else
  72.     {
  73.         return ( -2 );              // return with Not Ack error condition  
  74.     }
  75.   }
  76.  
  77.   IdleI2C();                      // ensure module is idle  
  78.   StopI2C();                      // send STOP condition
  79.   while ( SSPCON2bits.PEN );      // wait until stop condition is over
  80.   if ( PIR2bits.BCLIF )           // test for bus collision
  81.   {
  82.     return ( -1 );                // return with Bus Collision error
  83.   }
  84.   return ( 0 );                   // return with no error
  85. }
  86. //********************************************************
  87. //********************************************************
  88. //
  89. //      Escribir Pagina en Memoria EEPROM 24LC512 desde un Cadena en la ROM
  90. //
  91. //********************************************************
  92. //********************************************************
  93. unsigned char EscribeDatos_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2, const rom char *wrptr )
  94. {
  95.   IdleI2C();                      // ensure module is idle
  96.   StartI2C();                     // initiate START condition
  97.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  98.   if ( PIR2bits.BCLIF )           // test for bus collision
  99.   {
  100.     return ( -1 );                // return with Bus Collision error
  101.   }
  102.   else                            // start condition successful
  103.   {
  104.     if ( WriteI2C( control ) )    // write byte - R/W bit should be 0
  105.     {
  106.       return ( -3 );              // set error for write collision
  107.     }
  108.  
  109.     IdleI2C();                    // ensure module is idle
  110.     if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition received
  111.     {
  112.                 if ( WriteI2C( address1 ) )  // write word address for EEPROM
  113.         {
  114.                 return ( -3 );            // set error for write collision
  115.         }
  116.             IdleI2C();                    // ensure module is idle
  117.             if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition received
  118.             {
  119.                 if ( WriteI2C( address2 ) )  // write word address for EEPROM
  120.                 {
  121.                         return ( -3 );            // set error for write collision
  122.                 }
  123. //*******************************************************************************
  124. //*******************************************************************************
  125.                         IdleI2C();                  // ensure module is idle
  126.                     if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  127.                     {
  128.                         if ( putrsI2C( wrptr ) )   // data byte for EEPROM
  129.                                 {
  130.                           return ( -4 );          // set error for write collision
  131.                         }
  132.                     }
  133. //*******************************************************************************
  134. //*******************************************************************************
  135.                     else
  136.                     {
  137.                         return ( -2 );            // return with Not Ack error condition  
  138.                         }
  139.                 }
  140.     }
  141.     else
  142.     {
  143.         return ( -2 );              // return with Not Ack error condition  
  144.     }
  145.   }
  146.  
  147.   IdleI2C();                      // ensure module is idle  
  148.   StopI2C();                      // send STOP condition
  149.   while ( SSPCON2bits.PEN );      // wait until stop condition is over
  150.   if ( PIR2bits.BCLIF )           // test for bus collision
  151.   {
  152.     return ( -1 );                // return with Bus Collision error
  153.   }
  154.   return ( 0 );                   // return with no error
  155. }
  156. //********************************************************
  157. //********************************************************
  158. //
  159. //      Escribir Pagina en Memoria EEPROM 24LC512 desde una Cadena
  160. //
  161. //********************************************************
  162. //********************************************************
  163. unsigned char EscribeCadena_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2, unsigned char *wrptr )
  164. {
  165.   IdleI2C();                      // ensure module is idle
  166.   StartI2C();                     // initiate START condition
  167.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  168.   if ( PIR2bits.BCLIF )           // test for bus collision
  169.   {
  170.     return ( -1 );                // return with Bus Collision error
  171.   }
  172.   else                            // start condition successful
  173.   {
  174.     if ( WriteI2C( control ) )    // write byte - R/W bit should be 0
  175.     {
  176.       return ( -3 );              // set error for write collision
  177.     }
  178.  
  179.     IdleI2C();                    // ensure module is idle
  180.     if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition received
  181.     {
  182.                 if ( WriteI2C( address1 ) )  // write word address for EEPROM
  183.         {
  184.                 return ( -3 );            // set error for write collision
  185.         }
  186.             IdleI2C();                    // ensure module is idle
  187.             if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition received
  188.             {
  189.                 if ( WriteI2C( address2 ) )  // write word address for EEPROM
  190.                 {
  191.                         return ( -3 );            // set error for write collision
  192.                 }
  193. //*******************************************************************************
  194. //*******************************************************************************
  195.                         IdleI2C();                  // ensure module is idle
  196.                     if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  197.                     {
  198.                         if ( putsI2C( wrptr ) )   // data byte for EEPROM
  199.                                 {
  200.                           return ( -4 );          // set error for write collision
  201.                         }
  202.                     }
  203. //*******************************************************************************
  204. //*******************************************************************************
  205.                     else
  206.                     {
  207.                         return ( -2 );            // return with Not Ack error condition  
  208.                         }
  209.                 }
  210.     }
  211.     else
  212.     {
  213.         return ( -2 );              // return with Not Ack error condition  
  214.     }
  215.   }
  216.  
  217.   IdleI2C();                      // ensure module is idle  
  218.   StopI2C();                      // send STOP condition
  219.   while ( SSPCON2bits.PEN );      // wait until stop condition is over
  220.   if ( PIR2bits.BCLIF )           // test for bus collision
  221.   {
  222.     return ( -1 );                // return with Bus Collision error
  223.   }
  224.   return ( 0 );                   // return with no error
  225. }
  226. //********************************************************
  227. //********************************************************
  228. //
  229. //      Lectura en Memoria EEPROM 24LC512
  230. //
  231. //********************************************************
  232. //********************************************************
  233. unsigned int LeeDato_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2 )
  234. {
  235.   IdleI2C();                      // ensure module is idle
  236.   StartI2C();                     // initiate START condition
  237.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  238.   if ( PIR2bits.BCLIF )           // test for bus collision
  239.   {
  240.     return ( -1 );                // return with Bus Collision error
  241.   }
  242.   else
  243.   {
  244.     if ( WriteI2C( control ) )    // write 1 byte
  245.     {
  246.       return ( -3 );              // return with write collision error
  247.     }
  248.  
  249.     IdleI2C();                    // ensure module is idle
  250.     if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition, if received
  251.     {
  252.       if ( WriteI2C( address1 ) )  // WRITE word address for EEPROM
  253.       {
  254.         return ( -3 );            // return with write collision error
  255.       }
  256.           IdleI2C();                    // ensure module is idle
  257.       if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition, if received
  258.       {
  259.         if ( WriteI2C( address2 ) )  // WRITE word address for EEPROM
  260.         {
  261.                 return ( -3 );            // return with write collision error
  262.         }
  263.                 IdleI2C();                  // ensure module is idle
  264.         if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition, if received
  265.         {
  266.                 RestartI2C();             // generate I2C bus restart condition
  267.                 while ( SSPCON2bits.RSEN );// wait until re-start condition is over
  268.                 if ( PIR2bits.BCLIF )     // test for bus collision
  269.                 {
  270.                         return ( -1 );          // return with Bus Collision error
  271.                 }
  272.             if ( WriteI2C( control+1 ) )// write 1 byte - R/W bit should be 1
  273.                 {
  274.                         return ( -3 );          // return with write collision error
  275.                 }
  276.                 IdleI2C();                // ensure module is idle
  277.                 if ( !SSPCON2bits.ACKSTAT )// test for ACK condition, if received
  278.                 {
  279.                   SSPCON2bits.RCEN = 1;       // enable master for 1 byte reception
  280.                   while ( SSPCON2bits.RCEN ); // check that receive sequence is over
  281.                   NotAckI2C();              // send ACK condition
  282.                   while ( SSPCON2bits.ACKEN ); // wait until ACK sequence is over
  283.                   StopI2C();              // send STOP condition
  284.                   while ( SSPCON2bits.PEN ); // wait until stop condition is over
  285.                   if ( PIR2bits.BCLIF )   // test for bus collision
  286.                   {
  287.                         return ( -1 );         // return with Bus Collision error
  288.                   }
  289.                 }
  290.                 }
  291.         else
  292.         {
  293.           return ( -2 );          // return with Not Ack error
  294.         }
  295.       }
  296.       else
  297.       {
  298.         return ( -2 );            // return with Not Ack error
  299.       }
  300.     }
  301.     else
  302.     {
  303.       return ( -2 );              // return with Not Ack error
  304.     }
  305.   }
  306.   return ( (unsigned int) SSPBUF );     // return with data
  307. }
  308. //********************************************************
  309. //********************************************************
  310. //
  311. //              Lee una Cadena en Memoria EEPROM 24LCXX
  312. //
  313. //********************************************************
  314. //********************************************************
  315. unsigned char LeeDatos_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2,unsigned char *rdptr, unsigned char length )
  316. {
  317.   IdleI2C();                      // ensure module is idle
  318.   StartI2C();                     // initiate START condition
  319.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  320.   if ( PIR2bits.BCLIF )           // test for bus collision
  321.   {
  322.     return ( -1 );                // return with Bus Collision error
  323.   }
  324.   else
  325.   {
  326.     if ( WriteI2C( control ) )    // write 1 byte
  327.     {
  328.       return ( -3 );              // set error for write collision
  329.     }
  330.     IdleI2C();                    // ensure module is idle
  331.     if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition, if received
  332.     {
  333.       if ( WriteI2C( address1 ) )  // WRITE word address for EEPROM
  334.       {
  335.         return ( -3 );            // return with write collision error
  336.       }
  337.           IdleI2C();                    // ensure module is idle
  338.       if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition, if received
  339.       {
  340.         if ( WriteI2C( address2 ) )  // WRITE word address for EEPROM
  341.         {
  342.                 return ( -3 );            // return with write collision error
  343.         }
  344.                 IdleI2C();                  // ensure module is idle
  345.         if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  346.         {
  347.                 RestartI2C();             // generate I2C bus restart condition
  348.                 while ( SSPCON2bits.RSEN );  // wait until re-start condition is over
  349.                 if ( WriteI2C( control +1 ) )// WRITE 1 byte - R/W bit should be 1 for read
  350.                 {
  351.                         return ( -3 );          // set error for write collision
  352.                 }
  353.                 IdleI2C();                // ensure module is idle
  354.                 if ( !SSPCON2bits.ACKSTAT )// test for ACK condition received
  355.                 {
  356.                                 if ( getsI2C( rdptr, length ) )// read in multiple bytes
  357.                         {
  358.                                 return ( -1 );        // return with Bus Collision error
  359.                         }
  360.                                 NotAckI2C();            // send not ACK condition
  361.                         while ( SSPCON2bits.ACKEN );// wait until ACK sequence is over
  362.                         StopI2C();              // send STOP condition
  363.                         while ( SSPCON2bits.PEN );// wait until stop condition is over
  364.                         if ( PIR2bits.BCLIF )   // test for bus collision
  365.                         {
  366.                                 return ( -1 );        // return with Bus Collision error
  367.                         }
  368.                 }
  369.                 else
  370.                 {
  371.                                 return ( -2 );          // return with Not Ack error
  372.                 }
  373.                 }
  374.         else
  375.         {
  376.                 return ( -2 );            // return with Not Ack error
  377.         }
  378.     }
  379.     else
  380.     {
  381.         return ( -2 );              // return with Not Ack error
  382.     }
  383.   }
  384.   return ( 0 );                   // return with no error
  385.   }
  386. }
  387. //********************************************************
  388. //********************************************************
  389. //
  390. //      Esperar Ack en Memoria EEPROM 24LC512
  391. //
  392. //********************************************************
  393. //********************************************************
  394. unsigned char Ack_i2c_eeprom( unsigned char control )
  395. {
  396.   IdleI2C();                      // ensure module is idle
  397.   StartI2C();                     // initiate START condition
  398.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  399.   if ( PIR2bits.BCLIF )           // test for bus collision
  400.   {
  401.     return ( -1 );                // return with Bus Collision error
  402.   }
  403.  
  404.   else
  405.   {
  406.     if ( WriteI2C( control ) )    // write byte - R/W bit should be 0
  407.     {
  408.       return ( -3 );              // set error for write collision
  409.     }
  410.  
  411.     IdleI2C();                    // ensure module is idle  
  412.     if ( PIR2bits.BCLIF )         // test for bus collision
  413.     {
  414.       return ( -1 );              // return with Bus Collision error
  415.     }
  416.  
  417.     while ( SSPCON2bits.ACKSTAT ) // test for ACK condition received
  418.     {
  419.       RestartI2C();               // initiate Restart condition
  420.       while ( SSPCON2bits.RSEN ); // wait until re-start condition is over
  421.       if ( PIR2bits.BCLIF )       // test for bus collision
  422.       {
  423.         return ( -1 );            // return with Bus Collision error
  424.       }
  425.  
  426.       if ( WriteI2C( control ) )  // write byte - R/W bit should be 0
  427.       {
  428.         return ( -3 );            // set error for write collision
  429.       }
  430.       IdleI2C();                  // ensure module is idle
  431.     }
  432.   }
  433.        
  434.   StopI2C();                      // send STOP condition
  435.   while ( SSPCON2bits.PEN );      // wait until stop condition is over        
  436.   if ( PIR2bits.BCLIF )           // test for bus collision
  437.   {
  438.     return ( -1 );                // return with Bus Collision error
  439.   }
  440.   return ( 0 );                   // return with no error    
  441. }
« Última modificación: 25 de Junio de 2007, 01:59:00 por micro_cadaver »
a cosechar!!!... :P
pic32... ahi voy....
aguante el micro 16f84  !!!!

visita mi pagina: http://www.microembebidos.wordpress.com

Desconectado micro_cadaver

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2102
    • blog microembebidos
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #77 en: 25 de Junio de 2007, 01:59:37 »
Veamos en detalle las rutinas de la librería memoria_externa.h

putrsI2C
Esta rutina permite enviar al modulo I2C una cadena ubicada en la memoria de program (ROM), su aplicación se encuentra en la rutina EscribeDatos_i2c_eeprom.

EscribeDato_i2c_eeprom
Tiene 4 argumentos de entrada y retorna un valor 0 si no existen errores, de lo contrario devolvera un valor negativo.
Código: C
  1. unsigned char EscribeDato_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2, unsigned char data )
Ejm:
   EscribeDato_i2c_eeprom(0XA0,0X00,0X00,'@');

En este ejemplo queremos escribir el caracter ascii @ en la posicion 0x0000 de la memoria de datos de la eeprom externa cuyo
registro de control es 0XA0.


EscribeDatos_i2c_eeprom
Tiene 4 argumentos de entrada donde uno de ellos es una cadena ubicada en la memoria de programa del pic (ROM), y como salida retorna un valor 0 si no existen errores, de lo contrario devolvera un valor negativo.
Código: C
  1. unsigned char EscribeDatos_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2, const rom char *wrptr )
Ejm:
   EscribeDatos_i2c_eeprom(0XA0,0X00,0X10,"|||PERU|||");

Escribimos la cadena |||PERU||| a partir de la posicion 0x0010 de la memoria de datos de la eeprom externa cuyo registro de control es 0XA0.


EscribeCadena_i2c_eeprom
Tiene 4 argumentos de entrada donde uno de ellos es una cadena ubicada en la memoria de datos del pic (RAM), y como salida retorna un valor 0 si no existen errores, de lo contrario devolvera un valor negativo.
Código: C
  1. unsigned char EscribeCadena_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2, unsigned char *wrptr )
Ejm:
unsigned char    henry[]="*micro_cadaver*",

   EscribeCadena_i2c_eeprom(0XA0,0X00,0X00,henry);

Escribimos la cadena henry a partir de la posicion 0x0000 de la memoria de datos de la eeprom externa cuyo registro de control es 0XA0.


LeeDato_i2c_eeprom
Tiene 3 argumentos de entrada y como argumento de salida nos retorna el contenido del buffer de recepcion SSPBUF, de lo contrario nos dara un valor negativo.
Código: C
  1. unsigned int LeeDato_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2 )
Ejm:
   caracter=LeeDato_i2c_eeprom(0XA0,0X00,0X00);

Con esta rutina podemos leer un byte de la memoria eeprom externa, en el ejemplo estamos leyendo un byte ubicado en 0x0000 de la memoria con registro de control 0xA0.

LeeDatos_i2c_eeprom
Tiene 5 argumentos de entrada y como argumento de salida retorna un 0 y la cadena cargada con la cantidad de bytes solicitados, de lo contrario nos dara un valor negativo.
Código: C
  1. unsigned char LeeDatos_i2c_eeprom( unsigned char control, unsigned char address1, unsigned char address2,unsigned char *rdptr, unsigned char length )
Ejm:
unsigned char    recepcion[16];

   LeeDatos_i2c_eeprom(0XA0,0X00,0X10,recepcion,10);

Con esta rutina podemos leer varios bytes de la memoria eeprom externa, en el ejemplo estamos leyendo 10 bytes ubicados desde 0x0010 de la memoria externa con registro de control 0xA0 y los estamos guardando en la cadena recepcion. Tener en cuenta que la cadena donde se van a cargar los valores debe ser mayor que la cantidad solicitada de bytes, en este ejemplo se ve claramente que recepcion es una cadena con 16 elementos y en la rutina de lectura especificamos que queremos descargar solo 10 bytes.


Ack_i2c_eeprom
Genera un ACK para liberar el bus I2C, hacer esto después de cualquier escritura.
Código: C
  1. unsigned char Ack_i2c_eeprom( unsigned char control )
Ejm:
   EscribeDato_i2c_eeprom(0XA0,0X00,0X00,'@');
   Ack_i2c_eeprom(0XA0);   
« Última modificación: 25 de Junio de 2007, 02:22:37 por micro_cadaver »
a cosechar!!!... :P
pic32... ahi voy....
aguante el micro 16f84  !!!!

visita mi pagina: http://www.microembebidos.wordpress.com

Desconectado micro_cadaver

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2102
    • blog microembebidos
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #78 en: 25 de Junio de 2007, 02:45:42 »
Programa de Aplicacion
Este programa escribe datos a una memoria 24LC32 y luego los vuelve a leer y los muestra por pantalla LCD.
Código: C
  1. #include <p18f2525.h>
  2. #include <delays.h>
  3. #include <i2c.h>
  4. #include "C:\PIC\18F\MEMO\memoria_externa.h"
  5. #include "C:\PIC\18F\MEMO\LCD4b2x16.h"
  6.  
  7. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
  8. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
  9. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
  10. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
  11. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
  12. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
  13. #pragma config CPB = ON,CPD = ON//CONFIG5H
  14. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
  15. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
  16. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
  17. #pragma config EBTRB = ON//CONFIG7H
  18.  
  19. int caracter;
  20. unsigned char   henry[]="*micro_cadaver*",
  21.                                 cadena[16];
  22. void main(void)
  23. {
  24.         TRISA = 0X00;
  25.         TRISB = 0X00;
  26.         TRISC = 0X18;
  27.         LATA = 0X00;
  28.         LATB = 0X00;   
  29.         LATC = 0X00;   
  30.         Delay1KTCYx(100);      
  31.         Inicializa_LCD();
  32.         Comando_LCD(CURSOR_OFF & BLINK_OFF);
  33. //*******************************************************
  34. //      configuración del modulo i2c
  35. //*******************************************************
  36.         OpenI2C(MASTER,SLEW_OFF);//inicializo modulo
  37.         SSPADD = 9;//100KHz para 4MHz
  38. //*******************************************************
  39.         EscribeDato_i2c_eeprom(0XA0,0X00,0X00,'@');
  40.         Ack_i2c_eeprom(0XA0);  
  41.         caracter=LeeDato_i2c_eeprom(0XA0,0X00,0X00);
  42.         Dato_LCD(caracter);
  43.         Delay1KTCYx(500);      
  44.  
  45.         EscribeDatos_i2c_eeprom(0XA0,0X00,0X10,"|||PERU|||");
  46.         Ack_i2c_eeprom(0XA0);  
  47.  
  48.         EscribeCadena_i2c_eeprom(0XA0,0X00,0X00,henry);
  49.         Ack_i2c_eeprom(0XA0);  
  50.  
  51.         Comando_LCD(0X80);
  52.         LeeDatos_i2c_eeprom(0XA0,0X00,0X10,cadena,10);
  53.         Dato_String_LCD(cadena);
  54.  
  55.         Comando_LCD(0XC0);
  56.         LeeDatos_i2c_eeprom(0XA0,0X00,0X00,cadena,15);
  57.         Dato_String_LCD(cadena);
  58.  
  59.         while(1);
  60.  
  61. //*******************************************************
  62. //*******************************************************
  63. }


Programa de Aplicacion
Este programa escribe un mensaje en una pagina de la memoria 24LC512, según el datasheet de esta memoria cada pagina tiene 128 bytes, entonces en el programa enviaremos una cadena con 128 elementos.

Código: C
  1. #include <p18f2525.h>
  2. #include <delays.h>
  3. #include <i2c.h>
  4. #include "C:\PIC\18F\MEMO\memoria_externa.h"
  5. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
  6. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
  7. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
  8. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
  9. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
  10. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
  11. #pragma config CPB = ON,CPD = ON//CONFIG5H
  12. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
  13. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
  14. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
  15. #pragma config EBTRB = ON//CONFIG7H
  16.  
  17. int caracter;
  18. unsigned char   henry[]="Henry Ricardo Laredo Quispe, mas conocido como el micro_cadaver! i wish i was on the top the mountain happy shinny people i want",
  19.                                 cadena[16];
  20. void main(void)
  21. {
  22.         TRISA = 0X00;
  23.         TRISB = 0X00;
  24.         TRISC = 0X18;
  25.         LATA = 0X00;
  26.         LATB = 0X00;   
  27.         LATC = 0X00;   
  28.         Delay1KTCYx(250);      
  29. //*******************************************************
  30. //      configuración del modulo i2c
  31. //*******************************************************
  32.         OpenI2C(MASTER,SLEW_OFF);//inicializo modulo
  33.         SSPADD = 9;//100KHz para 4MHz
  34. //*******************************************************
  35.         EscribeDato_i2c_eeprom(0XA0,0X00,0X00,'@');
  36.         Ack_i2c_eeprom(0XA0);  
  37.         caracter=LeeDato_i2c_eeprom(0XA0,0X00,0X00);
  38.  
  39.         EscribeCadena_i2c_eeprom(0XA0,0X00,0X00,henry);
  40.         Ack_i2c_eeprom(0XA0);  
  41.         while(1);
  42. //*******************************************************
  43. //*******************************************************
  44. }

Todos los archivos:h**p://www.box.net/shared/444hivq5fd
a cosechar!!!... :P
pic32... ahi voy....
aguante el micro 16f84  !!!!

visita mi pagina: http://www.microembebidos.wordpress.com

Desconectado micro_cadaver

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2102
    • blog microembebidos
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #79 en: 26 de Junio de 2007, 01:00:41 »
bueno foreros, lo que sigue es el DS1307.....  :-)
a cosechar!!!... :P
pic32... ahi voy....
aguante el micro 16f84  !!!!

visita mi pagina: http://www.microembebidos.wordpress.com

Desconectado electronando

  • Colaborador
  • PIC18
  • *****
  • Mensajes: 427
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #80 en: 26 de Junio de 2007, 02:38:48 »
si supiera la gente que tu no duermes Henry jaja , bueno a nosostros nos conviene  :-/

Desconectado micro_cadaver

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2102
    • blog microembebidos
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #81 en: 26 de Junio de 2007, 10:09:04 »
jajaj si duermo, poquito, pero luego todo el dia estoy volando.... entiendase por distraido o fuera de la realidad, además este clima me encanta (el invierno y el otoño), a ver si luego del DS1307 hacemos un panelcito de leds en C18 mostrando la hora  :mrgreen:
a cosechar!!!... :P
pic32... ahi voy....
aguante el micro 16f84  !!!!

visita mi pagina: http://www.microembebidos.wordpress.com

Desconectado Kedutpic

  • Colaborador
  • PIC16
  • *****
  • Mensajes: 219
    • Microelectronica
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #82 en: 26 de Junio de 2007, 17:34:46 »
jajaj si duermo, poquito, pero luego todo el dia estoy volando.... entiendase por distraido o fuera de la realidad, además este clima me encanta (el invierno y el otoño), a ver si luego del DS1307 hacemos un panelcito de leds en C18 mostrando la hora  :mrgreen:

 :D  :D  eso me consta jajajaja
Actel  -  VHDL un nuevo mundo por descubrir :D
Grupo de Microelectronica - CIDI - UTP
Visitanos en : http://ue.accesus.com

Desconectado micro_cadaver

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2102
    • blog microembebidos
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #83 en: 28 de Junio de 2007, 03:20:28 »
Libreria  ds1307.h

Ante Uds. querido publico.... la libreria ds1307.h hecha en lenguaje C para el compilador C18, provecho!
Código: C
  1. #define dispositivo  0xD0
  2. //********************************************************
  3. //********************************************************
  4. //
  5. //              Leer Byte en DS1307
  6. //
  7. //********************************************************
  8. //********************************************************
  9. unsigned int LeeDato_ds1307( unsigned char address )
  10. {
  11.   IdleI2C();                      // ensure module is idle
  12.   StartI2C();                     // initiate START condition
  13.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  14.   if ( PIR2bits.BCLIF )           // test for bus collision
  15.   {
  16.         return ( -1 );                // return with Bus Collision error
  17.   }
  18.   else
  19.   {
  20.     if ( WriteI2C( dispositivo ) )    // write 1 byte
  21.     {
  22.         return ( -3 );              // return with write collision error
  23.     }
  24.         IdleI2C();                    // ensure module is idle
  25.     if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition, if received
  26.     {
  27.         if ( WriteI2C( address ) )  // WRITE word address for EEPROM
  28.         {
  29.                 return ( -3 );            // return with write collision error
  30.         }
  31.                 //******
  32.                 IdleI2C();                  // ensure module is idle
  33.         if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition, if received
  34.         {
  35.                 RestartI2C();             // generate I2C bus restart condition
  36.                 while ( SSPCON2bits.RSEN );// wait until re-start condition is over
  37.                 if ( PIR2bits.BCLIF )     // test for bus collision
  38.                 {
  39.                         return ( -1 );          // return with Bus Collision error
  40.                 }
  41.             if ( WriteI2C( dispositivo+1 ) )// write 1 byte - R/W bit should be 1
  42.                 {
  43.                         return ( -3 );          // return with write collision error
  44.                 }
  45.                 IdleI2C();                // ensure module is idle
  46.                 if ( !SSPCON2bits.ACKSTAT )// test for ACK condition, if received
  47.                 {
  48.                   SSPCON2bits.RCEN = 1;       // enable master for 1 byte reception
  49.                   while ( SSPCON2bits.RCEN ); // check that receive sequence is over
  50.                   NotAckI2C();              // send ACK condition
  51.                   while ( SSPCON2bits.ACKEN ); // wait until ACK sequence is over
  52.                   StopI2C();              // send STOP condition
  53.                   while ( SSPCON2bits.PEN ); // wait until stop condition is over
  54.                   if ( PIR2bits.BCLIF )   // test for bus collision
  55.                   {
  56.                         return ( -1 );         // return with Bus Collision error
  57.                   }
  58.                 }
  59.                 }
  60.         else
  61.         {
  62.           return ( -2 );          // return with Not Ack error
  63.         }
  64.     }
  65.     else
  66.     {
  67.       return ( -2 );              // return with Not Ack error
  68.     }
  69.   }
  70.   return ( (unsigned int) SSPBUF );     // return with data
  71. }
  72. //********************************************************
  73. //********************************************************
  74. //
  75. //              Leer Cadena en DS1307
  76. //
  77. //********************************************************
  78. //********************************************************
  79. unsigned char LeeDatos_ds1307( unsigned char address, unsigned char *rdptr, unsigned char length )
  80. {
  81.   IdleI2C();                      // ensure module is idle
  82.   StartI2C();                     // initiate START condition
  83.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  84.   if ( PIR2bits.BCLIF )           // test for bus collision
  85.   {
  86.     return ( -1 );                // return with Bus Collision error
  87.   }
  88.   else
  89.   {
  90.     if ( WriteI2C( dispositivo ) )    // write 1 byte
  91.     {
  92.       return ( -3 );              // set error for write collision
  93.     }
  94.           IdleI2C();                    // ensure module is idle
  95.       if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition, if received
  96.       {
  97.         if ( WriteI2C( address ) )  // WRITE word address for EEPROM
  98.         {
  99.                 return ( -3 );            // return with write collision error
  100.         }
  101.                 IdleI2C();                  // ensure module is idle
  102.         if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  103.         {
  104.                 RestartI2C();             // generate I2C bus restart condition
  105.                 while ( SSPCON2bits.RSEN );  // wait until re-start condition is over
  106.                 if ( WriteI2C( dispositivo+1 ) )// WRITE 1 byte - R/W bit should be 1 for read
  107.                 {
  108.                         return ( -3 );          // set error for write collision
  109.                 }
  110.                 IdleI2C();                // ensure module is idle
  111.                 if ( !SSPCON2bits.ACKSTAT )// test for ACK condition received
  112.                 {
  113.                                 if ( getsI2C( rdptr, length ) )// read in multiple bytes
  114.                         {
  115.                                 return ( -1 );        // return with Bus Collision error
  116.                         }
  117.                                 NotAckI2C();            // send not ACK condition
  118.                         while ( SSPCON2bits.ACKEN );// wait until ACK sequence is over
  119.                         StopI2C();              // send STOP condition
  120.                         while ( SSPCON2bits.PEN );// wait until stop condition is over
  121.                         if ( PIR2bits.BCLIF )   // test for bus collision
  122.                         {
  123.                                 return ( -1 );        // return with Bus Collision error
  124.                         }
  125.                 }
  126.                 else
  127.                 {
  128.                                 return ( -2 );          // return with Not Ack error
  129.                 }
  130.                 }
  131.         else
  132.         {
  133.                 return ( -2 );            // return with Not Ack error
  134.         }
  135.     }
  136.   return ( 0 );                   // return with no error
  137.   }
  138. }
  139. //********************************************************
  140. //********************************************************
  141. //
  142. //              Escribir en DS1307
  143. //
  144. //********************************************************
  145. //********************************************************
  146. //
  147. unsigned char Escribe_ds1307( unsigned char address, unsigned char data )
  148. {
  149.   IdleI2C();                      // ensure module is idle
  150.   StartI2C();                     // initiate START condition
  151.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  152.   if ( PIR2bits.BCLIF )           // test for bus collision
  153.   {
  154.     return ( -1 );                // return with Bus Collision error
  155.   }
  156.   else                            // start condition successful
  157.   {
  158.     if ( WriteI2C( dispositivo ) )    // write byte - R/W bit should be 0
  159.     {
  160.       return ( -3 );              // set error for write collision
  161.     }
  162.  
  163.     IdleI2C();                    // ensure module is idle
  164.     if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition received
  165.     {
  166.                 if ( WriteI2C( address ) )  // write word address for EEPROM
  167.         {
  168.                 return ( -3 );            // set error for write collision
  169.         }
  170.                         IdleI2C();                  // ensure module is idle
  171.                     if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  172.                     {
  173.                         if ( WriteI2C( data ) )   // data byte for EEPROM
  174.                                 {
  175.                           return ( -3 );          // set error for write collision
  176.                         }
  177.                     }
  178.                     else
  179.                     {
  180.                         return ( -2 );            // return with Not Ack error condition  
  181.                         }
  182.                
  183.     }
  184.     else
  185.     {
  186.         return ( -2 );              // return with Not Ack error condition  
  187.     }
  188.   }
  189.  
  190.   IdleI2C();                      // ensure module is idle  
  191.   StopI2C();                      // send STOP condition
  192.   while ( SSPCON2bits.PEN );      // wait until stop condition is over
  193.   if ( PIR2bits.BCLIF )           // test for bus collision
  194.   {
  195.     return ( -1 );                // return with Bus Collision error
  196.   }
  197.   return ( 0 );                   // return with no error
  198. }
  199. //
  200. //********************************************************
  201. //********************************************************
  202. //
  203. //              Inicializar DS1307
  204. //
  205. //********************************************************
  206. //********************************************************
  207. //
  208. unsigned char Inicializa_ds1307( unsigned char segundos,
  209.                                                                  unsigned char minutos,
  210.                                                                  unsigned char horas,
  211.                                                                  unsigned char dia,
  212.                                                                  unsigned char fecha,
  213.                                                                  unsigned char mes,
  214.                                                                  unsigned char ano,
  215.                                                                  unsigned char control)
  216. {
  217.   IdleI2C();                      // ensure module is idle
  218.   StartI2C();                     // initiate START condition
  219.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  220.   if ( PIR2bits.BCLIF )           // test for bus collision
  221.   {
  222.     return ( -1 );                // return with Bus Collision error
  223.   }
  224.   else                            // start condition successful
  225.   {
  226.     if ( WriteI2C( dispositivo ) )    // write byte - R/W bit should be 0
  227.     {
  228.       return ( -3 );              // set error for write collision
  229.     }
  230.  
  231.     IdleI2C();                    // ensure module is idle
  232.     if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition received
  233.         //*************************************************************************************
  234.     {
  235.                 if ( WriteI2C( 0X00 ) )  // write word address for EEPROM
  236.         {
  237.                 return ( -3 );            // set error for write collision
  238.         }
  239.                 //*************************************************************************************
  240.                 IdleI2C();                  // ensure module is idle
  241.             if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  242.             {
  243.                 if ( WriteI2C( segundos ) )   // data byte for EEPROM
  244.                         {
  245.                                 return ( -3 );          // set error for write collision
  246.                 }
  247.                         //*************************************************************************************
  248.                         IdleI2C();                  // ensure module is idle
  249.                     if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  250.                     {
  251.                         if ( WriteI2C( minutos ) )   // data byte for EEPROM
  252.                                 {
  253.                                         return ( -3 );          // set error for write collision
  254.                         }
  255.                                 //*************************************************************************************
  256.                                 IdleI2C();                  // ensure module is idle
  257.                             if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  258.                             {
  259.                                 if ( WriteI2C( horas ) )   // data byte for EEPROM
  260.                                         {
  261.                                                 return ( -3 );          // set error for write collision
  262.                                 }
  263.                                         //*************************************************************************************
  264.                                         IdleI2C();                  // ensure module is idle
  265.                                     if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  266.                                     {
  267.                                         if ( WriteI2C( dia ) )   // data byte for EEPROM
  268.                                                 {
  269.                                                         return ( -3 );          // set error for write collision
  270.                                         }
  271.                                                 //*************************************************************************************
  272.                                                 IdleI2C();                  // ensure module is idle
  273.                                             if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  274.                                             {
  275.                                                 if ( WriteI2C( fecha ) )   // data byte for EEPROM
  276.                                                         {
  277.                                                                 return ( -3 );          // set error for write collision
  278.                                                 }
  279.                                                         //*************************************************************************************
  280.                                                         IdleI2C();                  // ensure module is idle
  281.                                                     if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  282.                                                     {
  283.                                                         if ( WriteI2C( mes ) )   // data byte for EEPROM
  284.                                                                 {
  285.                                                                         return ( -3 );          // set error for write collision
  286.                                                         }
  287.                                                                 //*************************************************************************************
  288.                                                                 IdleI2C();                  // ensure module is idle
  289.                                                             if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  290.                                                             {
  291.                                                                 if ( WriteI2C( ano ) )   // data byte for EEPROM
  292.                                                                         {
  293.                                                                                 return ( -3 );          // set error for write collision
  294.                                                                 }
  295.                                                                         //*************************************************************************************
  296.                                                                         IdleI2C();                  // ensure module is idle
  297.                                                                     if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  298.                                                                     {
  299.                                                                         if ( WriteI2C( control ) )   // data byte for EEPROM
  300.                                                                                 {
  301.                                                                                         return ( -3 );          // set error for write collision
  302.                                                                         }
  303.                                                                         }
  304.                                                                     else
  305.                                                                     {
  306.                                                                         return ( -2 );            // return with Not Ack error condition  
  307.                                                                         }
  308.                                                                 }
  309.                                                             else
  310.                                                             {
  311.                                                                 return ( -2 );            // return with Not Ack error condition  
  312.                                                                 }
  313.                                                         }
  314.                                                     else
  315.                                                     {
  316.                                                         return ( -2 );            // return with Not Ack error condition  
  317.                                                         }
  318.                                                 }
  319.                                             else
  320.                                             {
  321.                                                 return ( -2 );            // return with Not Ack error condition  
  322.                                                 }
  323.                                         }
  324.                                     else
  325.                                     {
  326.                                         return ( -2 );            // return with Not Ack error condition  
  327.                                         }
  328.                                 }
  329.                             else
  330.                             {
  331.                                 return ( -2 );            // return with Not Ack error condition  
  332.                                 }
  333.                         }
  334.                     else
  335.                     {
  336.                         return ( -2 );            // return with Not Ack error condition  
  337.                         }
  338.             }
  339.             else
  340.             {
  341.                 return ( -2 );            // return with Not Ack error condition  
  342.                 }
  343.     }
  344.     else
  345.     {
  346.         return ( -2 );              // return with Not Ack error condition  
  347.     }
  348.   }
  349.   IdleI2C();                      // ensure module is idle  
  350.   StopI2C();                      // send STOP condition
  351.   while ( SSPCON2bits.PEN );      // wait until stop condition is over
  352.   if ( PIR2bits.BCLIF )           // test for bus collision
  353.   {
  354.         return ( -1 );                // return with Bus Collision error
  355.   }
  356.   return ( 0 );                   // return with no error
  357. }

Veamos una descripción de las rutinas de esta libreria:

#define dispositivo 0xD0
Este codigo sirve sólo para el address device del chip ds1307, es decir su nombre o identifcación en la red I2C.

LeeDato_ds1307
Rutina que permite leer un byte de la memoria de datos del ds1307.
Sintaxis:
            unsigned int LeeDato_ds1307( unsigned char address )

Argumento de entrada:
address, refiere a la posición de memoria de que desea leer en el ds1307.

Argumento de salida:
retorna el valor del registro SPBUFF cargado con el byte leido, de lo contrario devolvera un valor negativo como consecuencia de un error durante la lectura.

LeeDatos_ds1307
Rutina que perimite leer una cantidad definida de bytes de la memoria de datos del ds1307.
Sintaxis:
            unsigned char LeeDatos_ds1307( unsigned char address, unsigned char *rdptr, unsigned char length )

Argumentos de entrada:
address, refiere a la posición de memoria de que desea leer en el ds1307.
*rdptr, es una cadena previamente definida en la memoria de datos del pic, en esta cadena se van a alojar los datos leidos desde el ds1307.
lenght, cantida dde bytes a leer, esta cantidad no puede ser mayor que la cantidad de elementos de la cadena donde se va a guardar la informacion.

Argumento de salida: retorna un valor 0 como resultado de una exitosa lectura, de lo contrario devolvera un valor negativo como consecuencia de un error durante la lectura.

Escribe_ds1307
Esta rutina permite escribir un byte a una posicion determinada de la memoria de datos del ds1307.
Sintaxis:
            unsigned char Escribe_ds1307( unsigned char address, unsigned char data )

Argumentos de entrada:
address, refiere a la posición de memoria de que desea escribir en el ds1307.
data, el byte que desea escribir en el ds1307.

Argumento de salida: retorna un valor 0 como resultado de una exitosa lectura, de lo contrario devolvera un valor negativo como consecuencia de un error durante la lectura.

Inicializa_ds1307
Esta rutina sirve para inicializar el ds1307, en ella se puede configurar la hora y la fecha y las opciones que provee el fabricante para este chip ds1307.
Sintaxis:
unsigned char Inicializa_ds1307( unsigned char segundos,
                                                unsigned char minutos,
                                                unsigned char horas,
                                                unsigned char dia,
                                                unsigned char fecha,
                                                unsigned char mes,
                                                unsigned char año,
                                                unsigned char control)



Cada registro tiene su ubicacion segun la tabla de arriba, como pueden ver se trata de valores en codigo BCD, no olvidar los registros que poseen bits de configuracion.
a cosechar!!!... :P
pic32... ahi voy....
aguante el micro 16f84  !!!!

visita mi pagina: http://www.microembebidos.wordpress.com

Desconectado micro_cadaver

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2102
    • blog microembebidos
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #84 en: 28 de Junio de 2007, 03:33:39 »
Programa de aplicacion
En el siguiente programa se implementará un circuito que mostrará a través de un LCD2x16 el tiempo referido por el ds1307.

Código: C
  1. #include <p18f2525.h>
  2. #include <delays.h>
  3. #include <i2c.h>
  4. #include "C:\PIC\18F\RELOJ\ds1307.h"
  5. #include "C:\PIC\18F\RELOJ\LCD4b2x16.h"
  6. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
  7. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
  8. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
  9. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
  10. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
  11. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
  12. #pragma config CPB = ON,CPD = ON//CONFIG5H
  13. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
  14. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
  15. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
  16. #pragma config EBTRB = ON//CONFIG7H
  17.  
  18. #define reloj   PORTBbits.RB0
  19. int caracter,temp;
  20. unsigned char cadena[8];
  21.  
  22. void Mostrar_LCD (unsigned char caracter)
  23. {
  24.    temp = (caracter >> 4)| 0x30;
  25.    Dato_LCD(temp);
  26.    temp = (caracter & 0X0F)| 0x30;
  27.    Dato_LCD(temp);
  28.    Dato_LCD(' ');
  29. }
  30.  
  31. void main(void)
  32. {
  33.    //inicializar puertoA
  34.    //todos los pines
  35.    //seran digitales
  36.    PORTA = 0X00;
  37.    LATA = 0X00;
  38.    ADCON0 = 0X00;
  39.    ADCON1 = 0X0F;
  40.    CMCON = 0X07;
  41.  
  42.    TRISA = 0X00;
  43.    TRISB = 0X01;
  44.    TRISC = 0X18;
  45.    LATA = 0X00;
  46.    LATB = 0X00;  
  47.    LATC = 0X00;  
  48.    Delay1KTCYx(250);  
  49.    Inicializa_LCD();
  50.    Comando_LCD(CURSOR_OFF & BLINK_OFF);
  51. //*******************************************************
  52. //   configuración del modulo i2c
  53. //*******************************************************
  54.    OpenI2C(MASTER,SLEW_OFF);//inicializo modulo
  55.    SSPADD = 9;//100KHz para 4MHz
  56. //*******************************************************
  57. //   configuración del reloj y calendario
  58. //*******************************************************
  59.    Inicializa_ds1307(   0X07,//segundos + ch
  60.                   0X18,//minutos
  61.                   0X45,//horas + configuracion AM/PM
  62.                   0X05,//dia
  63.                   0X07,//fecha
  64.                   0X03,//mes
  65.                   0X81,//año
  66.                   0X10);//control
  67. //*******************************************************
  68. //*******************************************************
  69.    Comando_LCD(0x80);
  70.    Datos_LCD("Hora :");
  71.    Comando_LCD(0xC0);
  72.    Datos_LCD("Fecha:");
  73.  
  74.    LeeDatos_ds1307(0x04,cadena,3);
  75.    Comando_LCD(0xC7);
  76.    Mostrar_LCD(cadena[0]);
  77.    Mostrar_LCD(cadena[1]);
  78.    Mostrar_LCD(cadena[2]);
  79.  
  80.    for(;;)
  81.    {
  82.       if(reloj==1)  
  83.       {
  84.          LeeDatos_ds1307(0x00,cadena,3);
  85.          Comando_LCD(0x87);
  86.          Mostrar_LCD(cadena[2] & 0x1F);
  87.          Mostrar_LCD(cadena[1]);
  88.          Mostrar_LCD(cadena[0] & 0x7F);
  89.          while(reloj==1);
  90.       }
  91.    }
  92. //*******************************************************
  93. //*******************************************************
  94. }

todos los archivos: h**p://www.box.net/shared/1p7re3zpvj
a cosechar!!!... :P
pic32... ahi voy....
aguante el micro 16f84  !!!!

visita mi pagina: http://www.microembebidos.wordpress.com

Desconectado micro_cadaver

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2102
    • blog microembebidos
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #85 en: 28 de Junio de 2007, 10:32:32 »
Bueno, hasta ahi dejaremos de analizar las características del pic para meternos de lleno en un proyecto con el C18 y asi repasar todo lo que hemos aprendido (yo también  :mrgreen:), la inicitiva es la de hacer un panel de leds que muestre la hora jalando dichos datos desde un ds1307.

La verdad que en este momento no se me ocurre mucho jiji, asi que... como todo va a ser simulado vamos primero por hacer arrancar el panel, de eso si tengo información, un amigo Electronando me recomendó usar columnas por desplazamiento con el 4094 que son registros de desplazamiento con latch, y habilitar por las filas. Como se trata simplemente de algo que va a mostrar la hora pues quisiera hacerlo de dos filas donde cada fila sera de 7x32, me imagino que ahi debe entrar la hora y si se puede la fecha del calendario  :-/, hasta se le puede poner alarmas.... jjeje mi cerebro comienza a alucinar..... bueno pero todo sera simulado en el proteus 7.1 y si alguein se anima a armarlo (si es que lo terminamos jijij) pues... sería bacan aunque tengo que la certeza que mi amigo  :twisted:Kedutpic:twisted: de hecho va a quererselo armar con su pic.

Entonces manos a la obra con los paneles....
a cosechar!!!... :P
pic32... ahi voy....
aguante el micro 16f84  !!!!

visita mi pagina: http://www.microembebidos.wordpress.com

Desconectado Kedutpic

  • Colaborador
  • PIC16
  • *****
  • Mensajes: 219
    • Microelectronica
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #86 en: 29 de Junio de 2007, 10:20:14 »
 :D me descubristes ya estaba implementandolo para las pruebas jajajjaja  :mrgreen:
Actel  -  VHDL un nuevo mundo por descubrir :D
Grupo de Microelectronica - CIDI - UTP
Visitanos en : http://ue.accesus.com

Desconectado Kedutpic

  • Colaborador
  • PIC16
  • *****
  • Mensajes: 219
    • Microelectronica
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #87 en: 29 de Junio de 2007, 16:54:53 »
 :mrgreen: FUNCIONA !!!!  :-/
Actel  -  VHDL un nuevo mundo por descubrir :D
Grupo de Microelectronica - CIDI - UTP
Visitanos en : http://ue.accesus.com

Desconectado micro_cadaver

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2102
    • blog microembebidos
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #88 en: 01 de Julio de 2007, 12:25:01 »
le menu d'aujourd'hui :
Reloj con Panel de Leds 2x32

ingrédients:
  • Le Proteus 7.1 o 6.9
  • 1 DS1307 + cristal

  • 8 unidades de 4094

  • 2 paneles de leds de 7x32

  • Y para que de gusto... 1 PIC18F2525 + cristal 4MHz


Acá la foto del plato listo para servir (simular  :mrgreen:)

Ahora lo que sigue es la programación. Es posible que algo cambie durante este proceso, no os preocupeis, las imágenes luego serán actualizadas.
« Última modificación: 06 de Julio de 2007, 00:20:19 por micro_cadaver »
a cosechar!!!... :P
pic32... ahi voy....
aguante el micro 16f84  !!!!

visita mi pagina: http://www.microembebidos.wordpress.com

Desconectado micro_cadaver

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2102
    • blog microembebidos
Re: Cursillo en C18 para PICS DESDE CERO
« Respuesta #89 en: 05 de Julio de 2007, 13:35:27 »
bueno, he modificado en algo el hardware, ya actualize las imágenes, iniciaremos por el hardware... aun estoy definiendo como explicarlo, no es nada complicado,  :mrgreen: se van a sorprender de la simpleza.
a cosechar!!!... :P
pic32... ahi voy....
aguante el micro 16f84  !!!!

visita mi pagina: http://www.microembebidos.wordpress.com


 

anything