Biblioteca AVR para robots que utilizan el bus I2C y el reloj real PCF8583. Biblioteca AVR para trabajar con un bus I2C y con un reloj real PCF8583 Biblioteca alternativa para trabajar con una pantalla i2c

Wire.requestFrom(dirección, cantidad) — El maestro utiliza Vikory para escribir bytes del dispositivo cerámico. Estos bytes se pueden eliminar utilizando los métodos disponibles() y read(). El tamaño del búfer es el mismo de 32 bytes.

• dirección: agregaré una dirección de 7 bits desde la cual se recibirán los bytes;
• cantidad: número de bytes a recuperar;

Cable.disponible()— Rota el número de bytes disponibles para extracción usando read().

Bueno, aquí tienes un ejemplo de la entrada en la memoria de la fila “Hola Palabra”:

#incluir #define EEPROM_ADDRESS 0x53 dirección de palabra = 0; char data_send = "Hola Palabra"; void setup() ( Wire.begin(); // Serial.begin(9600); Serial.print("Escribir byte en la memoria EEPROM..."); Serial.println (data_send); Wire.beginTransmission(EEPROM_ADDRESS); Wire.write(dirección >> 8); Wire.write(dirección y 0xFF); Wire.write(data_send); delay(10); Serial.println("Leer byte de la memoria EEPROM..."); Wire.endTransmission (); if (status == 0)Serial.println ("Ok"); // dejar de transmitir Wire.requestFrom(EEPROM_ADDRESS, (byte)10); byte de datos = 0; i<10 ;i++) { if (Wire.available()) { data = Wire.read(); } Serial.write (data); } } void loop() { }

Organización de la memoria:

Por tanto, no está claro qué está escrito sobre esto en los registros históricos. Prácticamente estoy intentando salir de aquí. La hoja de datos dice que la memoria de los microcircuitos está organizada como 512 lado a lado 64 byte. ¿Qué quiere decir esto? Si queremos escribir más de 64 bytes por trama, digamos detrás de la dirección 0x40 (direcciones del otro lado), cuando la dirección va más allá del otro lado Doctor en microcircuito interno, comuníquese con la dirección que figura en la página principal.. Y los bytes de las solicitudes se registrarán en la página principal y los datos que se registraron allí se eliminarán.

Para leer dichos límites, no hay límites; la hoja de datos solo dice que cuando llegue a la dirección final, será transferido automáticamente al principio (direcciones 0x00).

Por eso creo que eso es todo. Por supuesto, puede utilizar una biblioteca ya preparada para EEPROM y cree que puede escribir la suya propia. Hemos llegado a comprender los principios básicos del robot.

Descripción de la biblioteca Wire

Esta biblioteca le permite comunicarse con dispositivos I2C/TWI. En las placas Arduino con diseño R3 (diseño 1.0), SDA (línea de datos) y SCL (línea de reloj) se encuentran en los pines del pin AREF. Arduino Due tiene dos interfaces I2C/TWI: SDA1 y SCL1 están ubicadas en el pin AREF, y líneas adicionales están ubicadas en los pines 20 y 21.

La siguiente tabla muestra la desinstalación de TWI en diferentes placas Arduino.

A partir de Arduino 1.0, esta biblioteca introduce las funciones Stream, por lo que funciona muy bien con otras bibliotecas de lectura/escritura. A través de esto, enviar() y recibir() se reemplazan por leer() y escribir().

Nota

Encuentre versiones de 7 y 8 bits de la dirección I2C. 7 bits identifican el dispositivo y el octavo bit indica si el dispositivo se está escribiendo o leyendo. La biblioteca Wire contiene direcciones de 7 bits. Si tiene una descripción técnica o un ejemplo de código que está ganando direcciones de 8 bits, necesitará invertir el bit bajo (para destruir el valor en un bit hacia la derecha), reduciendo la dirección de 0 a 127. Sin embargo, las direcciones del 0 al 7 no salen victoriosos, los fragmentos están reservados, la primera dirección que se puede seleccionar es 8. Tenga en cuenta que al conectar los pines SDA/SCL, se requieren resistencias para levantarse. Informe para maravillarse con el trasero. En la placa MEGA 2560 hay resistencias que deben levantarse en los pines 20 y 21.

Descripción de métodos

Cable.comenzar()

Inicializa la biblioteca Wire y se conecta al bus I2C como maestro o líder. Como regla general, sólo puedes llamar una vez.

Sintaxis

Cable.comienzo (dirección)

Parámetros

dirección: dirección de 7 bits asignada al dispositivo (no requerida); Si no hay tareas, la placa se conecta al bus como maestro.

El significado de lo que da la vuelta.

culata

Las bases para el dispositivo cerámico son maravillosas en las bases de los métodos onReceive() y onRequest(). Las colillas para dispositivos con cable se diferencian de las colillas en otros métodos. .

Cable.requestFrom()

El maestro utiliza Vikory para escribir bytes desde el dispositivo cerámico. Estos bytes se pueden eliminar utilizando los métodos disponibles() y read().

Si este argumento es verdadero, entonces requestFrom(), después de encenderlo, emite una notificación de DETENER y llama al bus I2C.

Si este argumento es falso, requestFrom() emitirá una notificación REINICIAR después de la solicitud. El neumático no funciona, lo que impide que otro dispositivo maestro se meta entre las conexiones. Esto permite que un dispositivo cableado envíe varias entradas de energía hasta que controle el bus.

Sintaxis

Wire.requestFrom(dirección, cantidad)

Wire.requestFrom(dirección, cantidad, parada)

Parámetros

• dirección: agregaré una dirección de 7 bits desde la cual se recibirán los bytes;
• cantidad: número de bytes a recuperar;
• detener: booleano. true fuerza una notificación DETENER después de una solicitud. false fuerza la notificación REINICIAR después de la solicitud, guardando las conexiones activas.

byte: número de bytes rotados según el dispositivo especificado.

culata

Cable.beginTransmission()

Inicia la transmisión a dispositivos I2C con la dirección especificada. Después de especificar la secuencia de bytes de transferencia usando la función write(), la transferencia se completa usando la llamada endTransmission().

Sintaxis

Wire.beginTransmission(dirección)

Parámetros

dirección: Agregaré una dirección de 7 bits porque es necesaria para transferir datos.

El significado de lo que da la vuelta.

culata

Wire.endTransmission()

Completa la transferencia al dispositivo que se imprimió usando el método startTransmission() y transfiere los bytes que se enviaron al dispositivo usando el método write().

Para usar con la mayoría de los dispositivos I2C, a partir de Arduino 1.0.1, requestFrom() toma un argumento para un tipo de datos booleano, lo que cambia su comportamiento.

Si este argumento es verdadero, entonces requestFrom(), después de la transmisión, emite una notificación DETENER, liberando el bus I2C.

Si este argumento es falso, requestFrom() emite una notificación REINICIAR después de la transmisión. El neumático no funciona, lo que impide que otro dispositivo maestro se meta entre las conexiones. Esto permite que un dispositivo cableado envíe varios engranajes mientras controla el autobús.

En teoría, este argumento es más antiguo que cierto.

Sintaxis

Wire.endTransmission()

Wire.endTransmission(detener)

Parámetros

detener: booleano. true obliga a DETENER la notificación después de la transmisión. false fuerza la notificación REINICIAR después de la transferencia, guardando la conexión activa.

El significado de lo que da la vuelta.

byte, que indica el modo de transferencia:

• 0: éxito;
• 1: se necesitan más datos para llenar el búfer de transmisión;
• 2: NACK recibido a la hora de transmisión de la dirección;
• 3: NACK recibido en el momento de la transmisión de datos;
• 4: reshta perdona.

Mire el ejemplo del método write().

Cable.write()

Escribe datos desde el dispositivo especificado al dispositivo de entrada, o establece bytes que se transferirán desde el maestro al dispositivo especificado (entre las llamadas a startTransmission() y endTransmission()).

Sintaxis

Cable.escritura(valor)

Cable.escribir (cadena)

Wire.write(datos, longitud)

Parámetros

• valor: valor de transmisión, un byte.
• cadena: orden de transmisión, secuencia de bytes.
• datos: matriz de datos de transmisión, bytes.
• longitud: número de bytes a transferir.

byte: write() rota el número de bytes escritos, aunque leer algunos de ellos no es difícil.

trasero #incluir valor de byte = 0; void setup() ( Wire.begin(); // conectar al bus i2c ) void loop() ( Wire.beginTransmission(44); // transferir al dispositivo #44 (0x2c) // dirección del dispositivo para tareas en la descripción técnica Wire. write(val); // envía el valor byte Wire.endTransmission(); // salta la transmisión val++; // aumenta el valor if(val == 64) // cuando el valor 64 (max) es alcanzado ( val = 0; // inicio en la mazorca) retraso (500);

Cable.disponible()

Gira una cantidad de bytes que se pueden recuperar usando read(). Este método debe llamarse en el dispositivo cableado después de la llamada requestFrom(), o en el dispositivo esclavo en medio de la llamada onReceive().

Sintaxis

Cable.disponible()

Parámetros

El significado de lo que da la vuelta.

Número de bytes disponibles para lectura.

culata

Mira el trasero antes del método read().

Cable.read()

Lee un byte que se envía desde el dispositivo enviado al host después de llamar a requestFrom() , o un byte que se envía desde el dispositivo enviado al enviado.

Sintaxis

Parámetros

El significado de lo que da la vuelta.

byte: byte de gusano de aceptaciones.

trasero #incluir valor de byte = 0; void setup() ( Wire.begin(); // conectar al bus i2c (las direcciones para el maestro no son obligatorias) Serial.begin(9600); // configurar el puerto serie para salida ) void loop() ( Wire. .requestFrom( 2, 6);// suministra 6 bytes desde el dispositivo especificado #2 while(Wire.available()) // se puede enviar menos del dispositivo solicitado (char c = Wire.read(); // aceptar el byte como carácter serial .print (c);//envuelve el símbolo) delay(500);

Cable.setClock()

Cambia la frecuencia del reloj de comunicación en el bus I2C. Los dispositivos I2C no tienen una frecuencia de reloj mínima de funcionamiento, que suele ser de 100 kHz.

Sintaxis

Wire.setClock (frecuencia del reloj)

Parámetros

clockFrequency: valor de frecuencia (en hercios) de la señal del reloj. Los valores aceptados son 100.000 (modo estándar) y 400.000 (modo sueco). Cada procesador también admite 10.000 (modo de baja velocidad), 1.000.000 (modo plus de alta velocidad) y 3.400.000 (modo de alta velocidad). Para asegurarse de que se admita el modo requerido, consulte la documentación de un procesador específico.

El significado de lo que da la vuelta.

Cable.onReceive()

Registra una función que se llamará cuando el dispositivo reciba una transferencia del maestro.

Sintaxis

Wire.onReceive(controlador)

Parámetros

controlador: una función que se llamará cuando el dispositivo reciba datos; Debe aceptar un parámetro int (el número de bytes leídos del maestro) y no rotar nada, luego:

anular myHandler (int numBytes)

El significado de lo que da la vuelta.

culata

#incluir void setup() ( Wire.begin(8); // conectar al bus i2c con la dirección #8 Wire.onReceive(receiveEvent); // registrar el subsensor Serial.begin(9600); // configurar el puerto serie para visualización ) void loop() (delay(100); ) // una función que saldrá inmediatamente cuando se reciban datos del maestro // esta función se registra como un procesador de datos, observe setup() void recibirEvent(int howMany) ( while (1< Wire.available()) // пройтись по всем до последнего { char c = Wire.read(); // принять байт как символ Serial.print(c); // напечатать символ } int x = Wire.read(); // принять байт как целое число Serial.println(x); // напечатать число }

Cable.onRequest()

Registra la función que se llamará cuando el maestro solicite datos del dispositivo especificado.

Sintaxis

Wire.onRequest(controlador)

Parámetros

controlador: una función que debe ser llamada, no acepta parámetros y no rota nada, entonces:

anular miHandler()

El significado de lo que da la vuelta.

culata

Código para la placa Arduino, que funciona como dispositivo:

#incluir void setup() ( Wire.begin(8); // conectar al bus i2c con la dirección #8 Wire.onRequest(requestEvent); // registrar el procesador de solicitudes ) void loop() ( delay(100); ) // función, tan pronto como el maestro // consulta datos // esta función se registra como encuestador, consulte setup() void requestEvent() ( Wire.write("hello "); // enviar notificaciones)

Necesitaba crear un chip basado en el microcircuito que sirve como interfaz I 2 C. Microcircuito RTC, llamado "Aniversario de la hora real" PCF8583.

En el medio de los microcircuitos se encuentran: reloj de aniversario, despertador, temporizador, calendario (torcido) y 240 bytes de RAM, donde podrás registrar cualquier información que te apetezca. La RAM es algo muy valioso; cuando se la trata como memoria flash, la RAM no sufre muchos ciclos de reescritura y puede almacenar cualquier dato que haya sido ajustado con la mayor frecuencia posible.

Solo había un problema: realmente no quería escribir código y decidí buscar código ya preparado en Internet. Como sucedió más tarde, ya sabes "por tu propia cabeza". Después de asegurar la culata del robot con I 2 C, lo corrigió y encendió el microcontrolador. Chi no preguntó. Habiendo comenzado a piratear el código, buscando el motivo de la falta de éxito... ¡¡y jadeando!! En algunos casos, la grabación se realizó en todo el puerto a la vez y no en bits específicos. De esta manera, si todavía cuelgas una pantalla en el puerto, por ejemplo, no pagarás por todo. La lectura de datos en el bus también se implementó incorrectamente (sin generación de datos o simplemente sin NACK). Ale tse piv-bidi. El principal problema es otro. La mayoría de las veces, el autor del código establece el puerto en un "1" lógico y, como sabemos, el bus I 2 C está controlado por la "atracción" de los pines SDA y SCL hacia el extremo frontal. Y el "1" lógico en el bus, a su vez, forma una estructura pull-up con más resistencias de 4,7 kiloohmios. Por lo tanto, si la salida del microcontrolador se establece en "1" lógico y el dispositivo es "atraído" hacia su salida, entonces "bang-bang" resultará en un cortocircuito. Ya no pude más y decidí buscar mi bicicleta y escribir mi propia biblioteca, o mejor dicho, escribir dos bibliotecas: una para el robot con el bus I 2 C y otra para el robot con el tiempo real PCF8583. reloj. Entonces, antes de hablar, el código ortográfico es.

Para conectar la biblioteca I 2 C al proyecto, debe escribirla mediante include, como en la imagen, y también copiar la biblioteca a la carpeta con el proyecto.

Después de esto, debe abrir el archivo "i2c.h" y especificar los pines del microcontrolador que actuarán como el bus I 2 C. El bus está conectado a los pines PC0 (SCL) y PC1 (SDA). Y la configuración para ejecutar tímidamente el eje está aquí:

Eso es todo, conectamos la biblioteca I2C, ajustamos las patas y la biblioteca está lista para funcionar. Trasero de Vikoristan:

I2c_init(); //Inicializa el bus I2C i2c_start_cond(); //inicia el bus i2c_send_byte (0xA0); // Agregaré una dirección para colgar en el bus i2c_send_byte (0x10); // byte de datos que se escribe en el dispositivo i2c_send_byte (0x10); // otro byte de datos que se escribe en el dispositivo i2c_stop_cond(); // parada de autobús

Después de parar, podemos comprobar que todo está bien con el bus I 2 C. Para ello es necesario leer la línea “i2c_frame_error”. Si todo es normal, entonces será 0. Si uno de los pines del bus no "cobra vida" y el "1" lógico no está instalado en el bus, entonces la biblioteca genera un mensaje y escribe el número 1. al cambio "i2c_frame_error". Lea el artículo "i2c_frame_error" » es obligatorio después de detenerse. A continuación le demostraré al pequeño cómo funciona el control de la leche:

Ahora pasemos a conectar la biblioteca de aniversario en tiempo real PCF8583. Para lo cual es necesario hacer lo mismo. Copie el archivo “PCF8583.h” a la carpeta con el proyecto y escríbalo en el include, como en la foto:

Listo. La biblioteca de aniversario en tiempo real PCF8583 está conectada. No requerirá ningún ajuste, por lo que puede comenzar inmediatamente antes de leer los datos en los microcircuitos. Aprecio que la biblioteca PCF8583 funcione con una biblioteca I2C adicional, por lo que si desea trabajar con la PCF8583, ¡debe conectar ambas bibliotecas!

Ejemplo de biblioteca (hora y fecha de registro y lectura):

//Inicializa el bus I2C i2c_init(); // Prepare la hora y la fecha para escribir en el microcircuito PCF8583 PCF_hour=23; // 23 años PCF_min = 59; // 59 horas PCF_day=31; // día 31 PCF_mes=12; // 12.º mes – mama PCF_year=0; // Рік (0 - año no bisiesto) PCF_weekday = 6; // 6to día del año (semana) // Escribe la hora y la fecha en el microcircuito PCF8583 PCF_write_hh_mm_ss(); // Leer la hora y la fecha de los microcircuitos PCF8583 PCF_read_hh_mm_ss(); Parte del robot con RAM (escritura y lectura) // Prepare 5 bytes para escribir en el microcircuito PCF8583 PCF_data_ram_1=255; // byte 1 PCF_data_ram_2=255; // byte 2 PCF_data_ram_3=255; // byte 3 PCF_data_ram_4=255; // byte 4 PCF_data_ram_5=255; // byte 5 // Escribe 5 bytes en el microcircuito PCF8583 PCF_write_ram(); // Lee 5 bytes del microcircuito PCF8583 PCF_read_ram();

Leer microcircuitos es aún más fácil: simplemente haga clic en la funciónPCF_ leer_ S.S_ milímetros_ ss() Después de qué hora y fecha informar a las autoridades, tome únicamente su información. Para leer la RAM, use la función vicorista.PCF_ leer_ RAM() Después de lo cual los datos se recopilan hasta que se realicen los cambios.PCF_ datos_ RAM_ norte

Esta es una lista de los importantes, dónde y qué se guarda:

// hora y fecha PCF_hora = 0; // hora, aniversario (de 0 a 23, protección contra renovación antes de la hora de escritura y lectura) PCF_min=0; // hora, hvilini (de 0 a 59, protección contra renovación antes de la hora de escritura y lectura) PCF_sec=0; // hora, segundos (solo la lectura y la escritura se restablecen a 00) PCF_day=0; // día (del 1 al 31, protegido de renovación bajo la hora de escritura y lectura) PCF_weekday=0 // día del año (0-lunes; 6 semanas, protegido de renovación bajo la hora de escritura y lectura) PCF_mes =0; // Mes (del 1 al 12, protección contra renovación al escribir y leer) PCF_year=0; // r_k (0-leap; 1,2,3-non-leap, protección contra renovación al escribir y leer) // RAM PCF_data_ram_1; //Dani (RAM PCF8583), byte 1 PCF_data_ram_2; //Dani (RAM PCF8583), byte 2 PCF_data_ram_3; //Dani (RAM PCF8583), byte 3 PCF_data_ram_4; //Dani (RAM PCF8583), byte 4 PCF_data_ram_5; // Datos (OSP PCF8583), byte 5

Ahora hablemos de la protección contra el repavimentación. Es posible que nos hayamos olvidado de conectar el microcircuito. Los datos de los microcircuitos son legibles y ... se lee el byte 11111111, o el número 255. Todo el asunto es que en la base del bus I 2 C hay 2 resistencias que se levantan, el eje de esos y vemos los “unos” lógicos como micro. No están conectados. Para protegerme contra este tipo de fallas, de la biblioteca PCF8583 he obtenido una protección contra re-reemplazo, que puedes seguir para que el aniversario no te muestre 62 años de 81 años... La detección de re-reemplazo se puede hacer leyendo el flujo de cambios PCF_over. Si hay 0, significa que no hubo indultos. Si hay 1 o más, entonces se renuevan los beneficios. Debe leer el cambio "PCF_overflow" después de leer la función de fecha y horaPCF_ leer_ S.S_ milímetros_ ss()

Para más detalles, el proyecto AVR Studio 6 para ATmega32 está disponible. Puedes recompilarlo para cualquier AVR. El proyecto también incluye un display para control visual. Al alimentar, el microcontrolador establece 23 años, 59 días, 31 días, Semana. Y durante una semana son 00 años, 00 días, 1 día, lunes.

Ahora entendamos por qué estaba hablando del calendario "torcido" de estos microcircuitos. A la derecha está el hecho de que el microcircuito no puede guardar el calendario actual, solo guarda el símbolo del año bisiesto. En resumen, aparentemente:
0 – año bisiesto
1 – no es un año bisiesto
2 – no es un año bisiesto
3 – no es un año bisiesto

Y así después del ciclo 0-1-2-3-0-1-2-3-0...

Para crear un calendario normal, es necesario implementar el diseño del software y guardar el destino, por ejemplo, la misma RAM es PCF8583, pero no es fácil. Y es una pena que la memoria detrás del circuito defectuoso, desafortunadamente, no pueda ser reescrita por nadie...

También me gustaría añadir un breve informe en vídeo. Puedes decir que eres nuevo en el programa, incluso si ya lo has programado durante 3 años (poco a poco), no puedes juzgar el código con dureza, ya que es adicional y respetuoso, escrito, correcto. ¡Lejos de ser cohibidos con todos!

Lista de elementos de radio

¿Por qué otra biblioteca I2C?

La biblioteca I2C estándar para Arduino es la biblioteca Wire. Si bien esta biblioteca es suficiente la mayor parte del tiempo, hay situaciones en las que no se puede utilizar:

• Pines I2C A4/A5 (o SDA/SCL) – para otros fines,
• El código se ejecutará tanto en el procesador ATmega con 16 MHz como en el procesador ATtiny con 1 MHz,
• y falta de memoria (flash y RAM).

Características

• compatible con todos los MCU AVR de 8 bits
• puede hacer uso de casi cualquier pin
• Se admite el estiramiento del reloj (por esclavos)
• tiempo de espera en el estiramiento del reloj
• tiempo de espera en el sondeo ACK para dispositivos ocupados (¡nuevo!)
• Se pueden utilizar resistencias pullup internas de MCU (¡nuevas!)
• muy liviano (250 bytes de flash y 0 bytes de RAM, excepto la pila de llamadas)
• muy rápido (modo estándar y rápido en UNO, 33 kHz con reloj de CPU de 1 MHz)
• Interfaz compatible con la biblioteca Wire opcional
• sin arbitraje en el autobús (es decir, excepto un maestro permitido en el autobús)
• solo admite el modo maestro
• licencia GPL

Usando la biblioteca

Interfaz alternativa

Mientras tanto, estoy ejecutando un corredor de correo como SoftI2CMaster, que emula la biblioteca Wire (solo modo maestro). Hay otro archivo de encabezado C++ llamado SoftWire. Inmediatamente después de esta declaración de inclusión, debe crear una instancia de Wire.

Esta sección hace sacrificios de varias maneras al original, en particular de alguna manera pequeña, pero hay necesidades que necesitarás para decodificar el original. La siguiente tabla enumera los requisitos de memoria.