INICIO CONTROL PIC-PIC CONTROL PC-PIC PROCESOS-PIC COMPONENTES-PIC SENSORES-PIC ACTUADORES-PIC ROBOTS-PIC

SOFTWARE-PIC
RobotyPic son proyectos básicos de electrónica con microcontroladores PIC, de aplicación en el
mundo de la robótica didáctica, con archivos fuente creados mediante el compilador CCS PIC C COMPILER en
lenguajeC.

Lectura-Escritura eeprom con PIC por bus I2C

Este proyecto es un ejemplo de lectura-escritura en una memoria eeprom a través de un pic por bus I2C. En
este ejemplo concreto se permite la lectura o escritura de las 10000 primeras posiciones de la eeprom. Al
tratarse de un teclado numérico decimal, las direcciones se enviarán en su valor decimal y los datos
introducidos serán del 0 al 9, pero podrían tratarse perfectamente de datos hexadecimales ( de 0 a F) si
procediesen de otro medio.

Para que el PIC comunique con la memoria eeprom, éste debe “conocer” su dirección ( de la memoria) en el bus
I2C. En concreto, para la eeprom empleada en este ejemplo, una M24512, el byte alto de su dirección está
fijado por el fabricante como Ah, mientras que el byte bajo se establece por el usuario según la combinación de
los niveles lógicos de tensión  en las patillas E0, E1 y E2 además del bit de lectura-escritura que es el de menor
peso. Como aquí todas las patillas se han llevado a 0V, (combinación lógica: 0 : 0 : 0 : W=0/R =1) el byte bajo
será 0 más el valor del bit de lectura o escritura. Es decir, la dirección I2C de la eeprom será A0h para escribir
en ella y A1h para leer. Elige tu idioma

Suscríbete

Recibe actualizaciones gratis por RSS

Feed o si lo pre eres puedes recibirlas
en tu e-mail.

Suscribete vía e-mail:

Suscribete

¿Te ha gustado?
En los comentarios del programa se puede intuir su funcionamiento.
Si lo deseas puedes añadir un enlace
[+/-] Ver / Ocultar programa completo en C en cualquiera de tus blogs de blogger
con un simple "click".
//////////////////////////////////////////////////////////////////////////////// O bien agregarme a los favoritos de
// // tu explorador de internet.
// LECTURA-ESCRITURA EEPROM CON PIC //
// //
// (c) RobotyPic //
// //
////////////////////////////////////////////////////////////////////////////////

#include <16f876a.h> //archivo para control del pic 16f876a

#fuses XT,NOWDT,NOPROTECT,NOLVP //protecciones Enlaza este blog

#use delay(clock=4000000) //frecuencia de reloj 4 MHz
#use i2c(Master,sda=PIN_C4,scl=PIN_C3) //Configuración comunicación I2C Agregar a favoritos

#use fast_io(B)
#define use_portb_lcd TRUE //Configuración puerto b control lcd
#define use_portb_kbd TRUE //Configuración puerto b control teclado
#include <lcd.c> //archivo para control del lcd Síguenos en...
#include <kbd.c> //archivo para control del teclado

#define EEPROM_ADDRESS long int Siguenos en Facebook

char tecla; //Valor de la tecla pulsada
int8 dato=0; //Dato a enviar o leer de memoria
Siguenos por RSS
int16 address; //Dirección de memoria
Siguenos por correo

/******************************************************************************/
/*********************** FUNCIÓN ESCRITURA EN EEPROM *************************/
Buscar en esta web
void escribir_en_eeprom(long int address, BYTE dato){

short int status; Buscar

i2c_start(); //Inicio de la transmisión...

Búsqueda personalizada
i2c_write(0xA0); //... con la dirección I2C correspondiente a la eeprom en modo escritura
i2c_write(address>>8); //Envío parte alta dirección
i2c_write(address); //Envío parte baja direción
i2c_write(dato); //Envío del dato
i2c_stop(); //Finalización de la transmisión

i2c_start(); //Reinicio de la comunicación...

Hojas Técnicas
status=i2c_write(0xa0); //... para lectura de bit ACK (escritura correcta)
PICS/ 16F877A
PIC 16F876A
while(status==1){ //Si es 1 esperar a que responda eeprom
PIC 18F4550
i2c_start();
status=i2c_write(0xa0); PIC 18F4620
}
C.I.s
74LS125
printf(lcd_putc,"\fDato guardado %d\n",dato);
printf(lcd_putc,"Pos%ld Dir%lx", address, address);
M24512
}

L293D

/*****************************************************************************/ MAX232
/*********************** FUNCIÓN LECTURA DE EEPROM ***************************/
LM555
SENSORES
SRF04, SRF05
BYTE lectura_de_eeprom(long int address){
BYTE dato; SRF08
i2c_start(); //Inicio de la transmisión...
TPA81
i2c_write(0xA0); //...con la dirección correspondiente a la eeprom en modo escritura
i2c_write(address>>8); //Envío parte alta dirección SHT10, SHT11, SHT15
i2c_write(address); //Envío parte baja dirección
i2c_start(); //Reinicio... SHT71, SHT75
i2c_write(0xA1); //...con eeprom en modo lectura
GP2Y0D810Z0F
dato=i2c_read(0); //Lectura del dato de la dirección enviada
i2c_stop(); //Fin de la transmisión TSOP1138
return(dato); //La función devuelve el dato leído
SEMICONDUCTORES
TSAL6200
}
PERIFÉRICOS
LCD03
/******************************************************************************/
/************************* PRESENTACIÓN LCD ***********************************/ SP03

void presentacion (){ SD21

EasyVR
lcd_putc("\fIntroduce \n");
lcd_putc("posicion en memo");
}
BÚSQUEDAS
/******************************************************************************/
/******************** FUNCIÓN PRINCIPAL ***************************************/
Software para proyectos

void main(){
Aplicación de software

int unidades=0; //Unidades posición de memoria

int decenas=0; //Decenas posición de memoria
int16 centenas=0; //Centenas posición de memoria
Sugerencias
int16 millares=0; //Millares posición de memoria

int x; //Valor ASCII de la tecla pulsada Ayudanos a mejorar.

lcd_init(); //Inicialización del lcd Haz tu sugerencia o contesta
kbd_init(); //Inicialización del teclado nuestro formulario en este enlace:
port_b_pullups(TRUE); //Habilitación resistencias pull ups puerto b photo
presentacion (); //Muestra mensaje de inicio en lcd interrogante_zpsqatl0wde.png
Formulario de sugerencias
while (true){
x=kbd_getc(); //En "x" valor ASCII de la tecla pulsada
tecla=x-48; //Valor ASCII se pasa a su valor numérico
if(x!=0) { //Si se ha pulsado tecla...
if(x=='*'){ //... si es '*' pide dato a guardar
address=(millares*1000)+(centenas*100)+(decenas*10)+unidades;
lcd_putc("\fEscribe dato\n");
x=0; //Inicializa para leer nueva tecla

while(x!='*'){ //Espera a pulsar '*' para guardar dato

x=kbd_getc(); //En "x" valor ASCII de la tecla pulsada
tecla=x-48; //Valor ASCII se pasa a su valor numérico
if (x!=0&&x!='*'){ //Si se pulsa tecla pero no es '*'...
printf(lcd_putc,"\fDato = %d\n", tecla); //...muestra el valor pulsado
printf(lcd_putc,"* para guardarlo");
dato=tecla; //El valor pulsado será el dato a enviar
}
}
escribir_en_eeprom(address, dato); //Pulsado '*' envia envia el dato Seguidores
delay_ms(3000); //Mantiene mensaje durante 3 segundos...
presentacion (); //...luego muestra mensaje presentación Seguidores (25) Siguiente
unidades=0;decenas=0;centenas=0;millares=0;
}
else if (x=='#'){ //Si tecla es '#' lee dato de la dirección especificada
address=(millares*1000)+(centenas*100)+(decenas*10)+unidades;
printf(lcd_putc,"\fPos%ld Dir%lx\n", address, address);
dato=lectura_de_eeprom(address); //En dato el valor leido de eeprom
printf(lcd_putc,"Dato = %x", dato);
delay_ms(3000);
presentacion();
unidades=0;decenas=0;centenas=0;millares=0;
} Seguir
else{ //lee valores pulsados para direccion eeprom
lcd_putc(tecla); //Muestra tecla pulsada por display
//Cada valor pulsado desplaza al anterior para obtener dirección...
Notas de Consulta
millares=centenas;
centenas=decenas; COMPILADOR CCS
Compilar los archivos fuente
decenas=unidades;
unidades=tecla; LENGUAJE C
Los #fuses del PIC 16F876A
//... y los va mostrando en lcd
printf(lcd_putc,"\f%ld%ld%d%d\n", millares, centenas, decenas, unidades); Las Variables
lcd_putc("# leer * guardar");
Los Operadores
}
} COMPONENTES
Código colores condensadores
}
}   Código colores resistencias

Patillaje PIC16F876A
CONECTORES
Pines conector USB
Para verificar que el funcionamiento es correcto, tal como se muestra en esta simulación bajo proteus,
primeramente se lee el valor de una posición de memoria. Después se escribe un dato diferente en dicha
posición. Y finalmente se vuelve a leer para verificar que realmente leemos el dato introducido.

Chat del Blog

Lectura-Escritura Eeprom con PIC
Ver más tarde Compartir 28 Apr 18, 09:42 PM
Mario: reinstale el ccs a la version
4.104 y anda maravilloso! el problema
son los de ccs que cambian todo
version a version. gracias de corazon
por tu conocimiento. Dios te bendiga.
27 Apr 18, 10:36 PM
Mario: ya lo probe, los archivos
compilados funcionan perfectamente
(con los .hex), pero al compilar los
archivos .c solo funcionan los
esclavos, tengo problemas con el
archivo .c del master. no se que sera
27 Apr 18, 08:29 PM
Mario: Buen dia, se ve interesante, lo
probare, y te contesto cuanto finalice
la prueba.
10 Nov 17, 08:27 PM
oti: No entendí!
21 Jul 17, 12:25 AM
juan: me pueden ayudar? intento
controlar un servo, pero las
condiciones deben ser que sea
controlado con dos pulsadores y
estos deben ir en el esclavo y en el
[Upgrade Cbox] actualizar
Todos los archivos; archivo fuente, hex para el pic, esquema para proteus y una animación de la simulación se nombre e-mail / url
pueden descargar en este enlace (contraseña robotypic): mensaje ok
ayuda · emoticonos · cbox

Descargar lectura escritura eeprom I2C

¿Qué PIC te interesa más?

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes
16F84 0 (0%)
versiones de software:
16F876 0 (0%)
- Windows xp y windows 7
16F877 0 (0%)
- Proteus V7.7 SP2
18F4550 0 (0%)
- CCS PIC C COMPILER v4.084

_________________________________________________________________________________

TUTORIAL BÁSICO PIC C COMPILER

Las variables
Olvídate de pagar por tu antivirus.
Avast! es totalmente gratis y su
Las variables deben declararse antes de ser usadas para que el procesador sepa que cantidad de memoria
rendimiento es excelente.
reservar para su uso.
Descárgalo y pruebalo tu mismo:
Se declaran según el siguiente formato:

TIPO_DATO  NOMBRE_VARIABLE [=VALOR_INICIAL];

Ejemplos:
Webs Similares
int entrada = 5; //Declara la variable “entrada” como entero
(8 bits)y valor inicial 5
float resultado; //Declara “resultado” como flotante (32 bits)
y valor inicial 0

En esta tabla se pueden ver todos los tipos de variables que pueden ser empleadas

Tipo de Tamaño Rango Descripción

variable
int1 1 bit 0, 1 Entero de 1 bit Compra tu Proyecto
short
int8 8 bits -128 a 127 Entero de 8 bits
int Solicita un proyecto o servicio
int16 16 bits 0 a 65535 bits Entero de 16 bits personalizado.
long int
long Haz click aquí.
int32 32 bits 0 a 4294967295 Entero de 32 bits
float 32 bits Coma flotante
char 8 bits 0 a 255 Carácter
signed int8 8 bits -128 a 127 Entero con signo
signed int16 16 bits -32768 a 32767 Entero largo con
signo
signed int32 32 bits Entero 32 bits con
signo

Además de los tipos definidos por defecto por el compilador CCS, también se pueden definir tipos
estandarizados mediante la directiva #Type:

#Type short=8
#Type int=16
#Type long=32

Serán variables de ámbito LOCAL cuando se emplean sólo en la función en la que son declaradas. De ámbito
GLOBAL cuando se emplean en cualquier función del programa, declaradas antes y fuera de cualquier
función.
directorio de blogs
Ejemplo:
directorio y promoción de blogs
#include <16f876a.h>
Directorio de Blogs
#use delay (clock=4000000)

int inicio = 7; //Variable GLOBAL tipo entero llamada

'inicio' e inicializada a 7

void funcion () { //Función secundaria Descarga Demos

int temporal; //Variable LOCAL tipo entero llamada
'temporal' e inicializada a 0
}

void main() { //Función principal

float resultado; //Variable tipo flotante llamada 'resultado'
e inicializada a 0
char dato; //Variable tipo carácter llamada 'dato' e
inicializada a 0
}

Publicado por Robotypic

No hay comentarios:
Publicar un comentario

Instalar Flash

CONTACTA - (Haz referencia del artículo sobre el que trata la consulta o comentario)

Nombre*

Email*

Título del artículo

para consulta*

Mensaje*

Veri cation*

Enviar

Report abuse

RobotyPic (c)