NeuronC y EEPROM I2C

En algunas ocasiones es interesante incorporar en un nodo Lonworks una memoria del tipo EEPROM I2C, fácil de conectar ya que solo precisa de dos hilos y que puede ser muy útil para registros, data-logger simple o como buffer temporal para un sistemas más complejo de adquisición de datos.

A continuación se incluye el código necesario para implementar operaciones simples de memoria, de la misma forma se pueden realizar registros de variables del tipo SNVT, en algunos programas lo he implementado. Este código es una pequeña introducción y quizás pueda servir de orientación a programadores de NeuronC / NodeBuilder.

  1. //--------------------------------------------------
  2. // Operaciones básicas memoria EEPROM I2C
  3. // Es necesario definir una UNVT del tipo struct
  4. // para las operaciones de memoria, tipo: op_memo
  5. // typedef struct // { unsigned int operacion;
  6. // unsigned long direccion;
  7. // unsigned long valor;
  8. // } op_memo;
  9. //
  10. //--------------------------------------------------
  11. #define eep_addr 0x50   // dirección I2C de la EEPROM 24C32 o 64
  12. #define ESIZE 8192      // Tamaño EEPROM ( 24C32->4096, 24C64->8192 )  
  13. // Variables EEPROM - Ver tamaño real y procesos lógicos
  14. far unsigned int eepbuff[9];
  15. far unsigned int eepboff[9];  
  16. //***********************************************************//
  17. // Operaciones EEPROM
  18. unsigned short lee_byte(unsigned long direcc);
  19. unsigned long  lee_long(unsigned long direcc);
  20. void esc_byte(unsigned long direcc, unsigned short dat_s);
  21. void esc_long(unsigned long direcc, unsigned long dat_l); /
  22. /***********************************************************//  
  23. // Errores I2C
  24. network output sd_string("Fallos Lect./Esc. I2C EEPROM") SNVT_count I2CFails;
  25. network input  op_memo nviOpMemo;
  26. network output op_memo nvoOpMemo;  
  27. //--------------------------------------------------------------------------
  28. // Memoria EEPROM IO_8 i2c io_i2c_bus;
  29. //--------------------------------------------------------------------------  
  30. //*******************************************
  31. // Operaciones de Memoria de cara al Exterior
  32. //*******************************************
  33. // Operación (ui), direccion (ul), valor (ul)
  34. when(nv_update_occurs(nviOpMemo)){    
  35.   // Seleccionar por Operación    
  36.   switch (nviOpMemo.operacion) {
  37.     case 0:              
  38.       // Leer byte              
  39.       nvoOpMemo.operacion=nviOpMemo.operacion;
  40.       nvoOpMemo.direccion=nviOpMemo.direccion;
  41.       nvoOpMemo.valor=lee_byte(nviOpMemo.direccion);
  42.       break;
  43.     case 1:              
  44.       // Leer long
  45.       nvoOpMemo.operacion=nviOpMemo.operacion;              
  46.       nvoOpMemo.direccion=nviOpMemo.direccion;              
  47.       nvoOpMemo.valor=lee_long(nviOpMemo.direccion);              
  48.       break;          
  49.     case 128:            
  50.       // Escribir byte
  51.       nvoOpMemo.operacion=nviOpMemo.operacion;
  52.       nvoOpMemo.direccion=nviOpMemo.direccion;
  53.       nvoOpMemo.valor=nviOpMemo.valor;
  54.       esc_byte(nviOpMemo.direccion,(short)nviOpMemo.valor);
  55.       break;
  56.     case 129:
  57.       // Escribir long
  58.       nvoOpMemo.operacion=nviOpMemo.operacion;
  59.       nvoOpMemo.direccion=nviOpMemo.direccion;
  60.       nvoOpMemo.valor=nviOpMemo.valor;
  61.       esc_long(nviOpMemo.direccion,nviOpMemo.valor);
  62.       break;      } }
  63.     //*******************************************  
  64. // **************************************************************************
  65. ///////////////////////////////// Funciones /////////////////////////////////
  66. // **************************************************************************  
  67. //****************************************************************
  68. // Devuelve byte leido de EEPROM - pasar dirección (24C32 y 24C64)
  69. //****************************************************************
  70. unsigned short lee_byte(unsigned long direcc) {
  71.  unsigned int i2c_add;
  72.  unsigned long eep_cont;
  73.  eep_cont=(direcc & (ESIZE-1));
  74.  i2c_add=(short)((direcc/ESIZE)+eep_addr);
  75.  // Calcular dirección base i2c memoria  
  76.  eepbuff[0]=high_byte(eep_cont);
  77.  eepbuff[1]=low_byte(eep_cont);
  78.  if (!io_out(io_i2c_bus,&eepbuff,i2c_add,2)) I2CFails++;
  79.  if (!io_in(io_i2c_bus,eepboff,i2c_add,1)) I2CFails++;
  80.  return eepboff[0];
  81.  }
  82. // **************************************************************
  83. //*****************************************************************
  84. // Escribe byte en EEPROM - pasar dirección y valor (24C32 y 24C64)
  85. //*****************************************************************
  86. void esc_byte(unsigned long direcc,
  87.  unsigned short dat_s) {  
  88.  unsigned int i2c_add;  
  89.  unsigned long eep_cont;
  90.  eep_cont=(direcc & (ESIZE-1));
  91.  i2c_add=(short)((direcc/ESIZE)+eep_addr);
  92.  // Calcular dirección base i2c memoria
  93.  eepbuff[0]=high_byte(eep_cont);
  94.  eepbuff[1]=low_byte(eep_cont);
  95.  eepbuff[2]=dat_s;
  96.  if (!io_out(io_i2c_bus,&eepbuff,i2c_add,3)) I2CFails++;
  97.  delay(500);
  98.  }
  99. // ****************************************************************
  100. //*****************************************************************
  101. // Devuelve long leido de EEPROM - pasar dirección - (24C32 y 24C64)
  102. //******************************************************************
  103. unsigned long  lee_long(unsigned long direcc) {
  104.  unsigned int i2c_add;
  105.  unsigned long eep_cont;
  106.  eep_cont=(direcc & (ESIZE-1));
  107.  i2c_add=(short)((direcc/ESIZE)+eep_addr);
  108.  // Calcular dirección base i2c memoria
  109.  eepbuff[0]=high_byte(eep_cont);
  110.  eepbuff[1]=low_byte(eep_cont);
  111.  if (!io_out(io_i2c_bus, &eepbuff, i2c_add, 2)) I2CFails++;
  112.  if (!io_in(io_i2c_bus, eepboff, i2c_add,2)) I2CFails++;
  113.  return ((eepboff[0]*256)+eepboff[1]);
  114.  }
  115. // ************************************************
  116. //*************************************************
  117. // Escribe long en EEPROM - pasar dirección y valor
  118. //*************************************************
  119. void esc_long(unsigned long direcc, unsigned long dat_l) {
  120.  unsigned int i2c_add;
  121.  unsigned long eep_cont;
  122.  eep_cont=(direcc & (ESIZE-1));
  123.  i2c_add=(short)((direcc/ESIZE)+eep_addr);
  124.  // Calcular dirección base i2c memoria
  125.  eepbuff[0]=high_byte(eep_cont);
  126.  eepbuff[1]=low_byte(eep_cont);
  127.  eepbuff[2]=high_byte(dat_l);
  128.  eepbuff[3]=low_byte(dat_l);
  129.  // Prevenir roll-on de grabación en EEPROM I2C
  130.  if((eep_cont & 0x001F)==31){
  131.     if (!io_out(io_i2c_bus,&eepbuff,i2c_add,3)) I2CFails++;
  132.     eep_cont++;
  133.     eepbuff[0]=high_byte(eep_cont);
  134.     eepbuff[1]=low_byte(eep_cont);
  135.     eepbuff[2]=eepbuff[3];
  136.     delay(400);
  137.     if (!io_out(io_i2c_bus, &eepbuff, i2c_add, 3)) I2CFails++;
  138.     }
  139.  else if (!io_out(io_i2c_bus, &eepbuff, i2c_add, 4)) I2CFails++;
  140.  delay(600);
  141.  }
  142. // *************************************************************

Podría también gustarte...

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *