Vous êtes sur la page 1sur 12

09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

HABEROCÉAN

Pour quelques conseils techniques drôles et intéressants


Browse: Home » 2015 » Février » Programme pour écrire des données à une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

PROGRAMME POUR ÉCRIRE DES DONNÉES DANS Viw tous les projets
UNE EEPROM 24C08 EN UTILISANT ARDUINO MEGA électroniques
(PARTIE 2 DE 5) intéressants
1er février 2015· Par paulpp644 · en 24C08 , Arduino , Arduino Mega , Atmega328 , débutants Electronique ,
électronique numérique , EEPROM , EEPROM à l' aide Arduino , Electronique , Projets drôles Electronique , Circuits
intégrés , Microcontrôleurs Search this site...

<<<< Lire la partie précédente (partie 1)


Programme Arduino pour écrire des données à 24C08 Used Construction
Complétez le circuit donné dans la partie précédente . Arduino programme à écrire 170 (1 0 1 0 1 0 1 0) à la 1023 Machine
Top Deals at Factory
ème
octet de mémoire (total 1 024 octets de mémoire) de 24C08 est donnée ci - dessous. Le programme comporte
trois parties. Sélection de l'appareil (si plus d'un 24C08 est utilisé), sélection de mots (sélection d'octets de Price. Contact Directly &
mémoire désirée à partir de 1024 octets de mémoire) et écriture de données . Une explication détaillée du
Get Live Quotes!
programme sera donnée dans les prochains blogs. Maintenant, téléchargez le programme suivant sur votre tableau
Arduino. alibaba.com

Pour changer le numéro IC auquel les données doivent être écrites

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 1/12
09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

La valeur de IC_number peut varier de 0 à 1 dans la fonction loop () . Dans ce cas, IC_number devrait être
My Funny Electro…
0. 16K likes

Like Page

Be the first of your friends to like this

ABONNEZ-VOUS

Abonnez-vous pour les dernières mises à


jour.

Enter Your Email ID ALLER

Obtenez ce widget >>

Pour changer l'octet de mémoire auquel les données doivent être écrites
La valeur de Memory_byte_address peut varier de 0 à 1023 dans la fonction loop () . Dans ce cas
Memory_byte_address devrait être 1023 pour écrire des données à la 1023 ème octet de mémoire de 24C08.

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 2/12
09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

Funny Electronics Community


in Google Plus
Join Our Community for Some Funny and
Interesting Electronic Stuffs

Aperçu de la communauté

293 membres
Pour changer les données à écrire
La valeur des données peut varier de 0 à 255 dans la fonction loop () . Dans ce cas, les données doivent être
MESSAGES POPULAIRES
170 (1 0 1 0 1 0 1 0).
Température mesurée sur écran à sept

segments par LM35 et ... (12,169)

Circuit simple pour contrôler la bande LED

en utilisant Arduino Mega ... (9,397)

Circuit pour lire et écrire des données dans

un 24C02 en utilisant Arduino Mega

(8,673)

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 3/12
09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

Circuit simple et fonctionnel pour contrôler

un IC 24C04 en utilisant ... (7,486)

Circuit permettant d'interfacer un clavier 4 *

4 à Arduino en utilisant 4 ... (7,309)

Circuit pour lire et écrire des données dans

une EEPROM 24C08 par Arduino ...

(7,027)

Sirène de police, sirène d'ambulance et

sirène de pompier ... (6,294)

Circuit pour lire et écrire des données dans

EEPROM 24C16 par Arduino ... (6,204)

Programme pour écrire des données à

24C02 EEPROM utilisant Arduino Mega ...

(5,731)
Maintenant, téléchargez le programme suivant sur votre carte Arduino. Télécommande pour un affichage à sept

segments utilisant RF ... (5,619)


int sda = 5;
int scl = 6;
CATÉGORIES

int sda_read;
Arduino
int delay_time = 50;
Arduino Mega
// la fonction d'installation s'exécute une fois lorsque vous appuyez sur Réinitialiser ou
Chronomètre
alimentez la carte
void setup () { Robots Arduino

EEPROM utilisant Arduino


Série . commencer (9600);
Bibliothèques
pinMode (scl, OUTPUT );

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 4/12
09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

}
VirtualWire

void write_to_24C08 ( int IC_number, int Memory_byte_address, int Données) Quine-McCluskey Algorithme
{
Électronique
int reste, je;
int position_in_binary; Débutants Electronics
int binary_of_Memory_byte_address [] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
la communication
int binary_of_Data [] = {0, 0, 0, 0, 0, 0, 0, 0};
DTMF
if (adresse mémoire_byte> 0)
MT8870D
{
position_in_binary = 9; Radio Fréquence 433,92 MHz
while (adresse_mémoire_de_mémoire! = 1)
Électronique numérique
{
reste = adresse_mémoire_de_mémoire% 2; 4 * 4 touche clavier
Memory_byte_address = Memory_byte_address / 2;
Circuits intégrés
binary_of_Memory_byte_address [position_in_binaire] = reste;
position_in_binary--; 4017
}
4511
binary_of_Memory_byte_address [position_in_binaire] = 1; 555
}
Opération astable
if (Données> 0) 74165
{
position_in_binary = 7; 74595
while (Données! = 1) 7490
{
reste = données% 2; BT66
Data = Données / 2;
CD4543
binary_of_Data [position_in_binary] = reste;
position_in_binary--; EEPROM
}
24C02

binary_of_Data [position_in_binaire] = 1; 24C04


}
24C08

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 5/12
09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

pinMode (sda, OUTPUT );


24C16

digitalWrite (sda, HIGH ); // 24C32


délai (delay_time); //
24C64
digitalWrite (scl, HIGH ); //
délai (delay_time); // UM3561
digitalWrite (sda, LOW ); // Début du
Affiche
délai (delay_time); //
digitalWrite (scl, LOW ); // LCD
délai (delay_time); //
16 * 2

/ ************** L'ADRESSE DE L'APPAREIL COMMENCE ICI *************** / CI de pilotes

L293D
digitalWrite (sda, HIGH ); //
délai (delay_time); // ULN2803
digitalWrite (scl, HIGH ); //
Projets électroniques drôles
délai (delay_time); // 1 MSB
digitalWrite (scl, LOW ); // Projets musicaux
délai (delay_time); //
Sirène d'ambulance
digitalWrite (sda, LOW ); // Sirène de pompier
délai (delay_time); //
digitalWrite (scl, HIGH ); //
vive le vent
délai (delay_time); // 2 Son de mitrailleuse
digitalWrite (scl, LOW ); //
délai (delay_time); // Sirene de police

LED
digitalWrite (sda, HIGH ); //
délai (delay_time); // LED bicolore
digitalWrite (scl, HIGH ); //
Cube LED
délai (delay_time); // 3
digitalWrite (scl, LOW ); // 2 * 2 * 2 LED Cube
délai (delay_time); //
3 * 3 * 3 LED Cube

digitalWrite (sda, LOW ); // 6 * 6 * 6 LED Cube


délai (delay_time); //
Bande de LED
digitalWrite (scl, HIGH ); //

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 6/12
09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

délai (delay_time); // 4
LED RVB
digitalWrite (scl, LOW ); //
délai (delay_time); // Microcontrôleurs

ATMega328
digitalWrite (sda, numéro IC); //
délai (delay_time); ATtiny45
digitalWrite (scl, HIGH ); //
ATtiny85
délai (delay_time); // 5
digitalWrite (scl, LOW ); // Des amplificateurs opérationnels
délai (delay_time); //
LM311

digitalWrite (sda, binary_of_Memory_byte_address [0]); // PCB


délai (delay_time);
PCB double face
digitalWrite (scl, HIGH ); //
délai (delay_time); // 6 PCB simple face
digitalWrite (scl, LOW ); //
Foret PCB
délai (delay_time); //
Capteurs
digitalWrite (sda, binary_of_Memory_byte_address [1]); //
IR
délai (delay_time); //
digitalWrite (scl, HIGH ); // Système anti-vol
délai (delay_time); // 7
digitalWrite (scl, LOW ); //
Capteurs de lumière
délai (delay_time); // LDR

digitalWrite (sda, LOW ); // Capteur de mouvement


délai (delay_time); // Capteur de mouvement PIR
digitalWrite (scl, HIGH ); //
délai (delay_time); // 8 LSB Température
digitalWrite (scl, LOW ); //
LM35
délai (delay_time); //
Capteur de débit d'eau
/ ************** L'ADRESSE DE L'APPAREIL SE TERMINE ICI *************** /
Affichage à sept segments

digitalWrite (scl, HIGH ); // Affichage à sept segments de la


délai (delay_time); //
cathode commune
pinMode (sda, INPUT ); //

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 7/12
09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

Série . print ( digitalRead (sda)); //


Transistors
délai d' accusé de réception (delay_time); //
digitalWrite (scl, LOW ); // 2SC9013
délai (delay_time); //
PCB

/ ************** MOT DE L'ADRESSE COMMENCE ICI *************** / PCB double face

Robotique
pinMode (sda, OUTPUT ); //
Robot Voiture
pour (i = 2; i <10; i ++)
Non classé
{
digitalWrite (sda, binary_of_Memory_byte_address [i]); // Vidéos
délai (delay_time); //
digitalWrite (scl, HIGH ); //
AVIS IMPORTANT
délai (delay_time); // 1 MSB
digitalWrite (scl, LOW ); // Tous les circuits, publiés dans ce blog, ne sont
délai (delay_time); //
qu'après avoir testé et obtenu des résultats
}
appropriés dans mon laboratoire privé.
/ ************** L'ADRESSE DE L'APPAREIL SE TERMINE ICI *************** / Lorsque vous essayez ces circuits, vous devez
vérifier la tension d'alimentation, la polarité
digitalWrite (sda, LOW ); // des composants, la présence d'enfants à
délai (delay_time); //
proximité et les courts-circuits dans les
digitalWrite (scl, HIGH ); //
délai (delay_time); //
circuits. Ce site Web ne sera pas responsable
pinMode (sda, INPUT ); // de tout dommage causé à vous ou à vos
Série . print ( digitalRead (sda)); // composants causé par votre négligence.
délai d' accusé de réception (delay_time); //
digitalWrite (scl, LOW ); //
HABEROCÉAN
délai (delay_time); //

Détection de mouvement à l'aide du capteur


/ ************** LES DONNEES COMMENCE ICI *************** /
de mouvement PIR et ATtiny85 26
pinMode (sda, OUTPUT );
septembre 2015

pour (i = 0; i <8; i ++)


{

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 8/12
09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

digitalWrite (sda, binary_of_Data [i]); //


Étapes pour programmer ATtiny45 /
délai (delay_time); //
digitalWrite (scl, HIGH ); // ATtiny85 en utilisant Arduino Uno 26
délai (delay_time); // 1 MSB
septembre 2015
digitalWrite (scl, LOW ); //
délai (delay_time); // Programme pour imprimer "Bonjour,
}
monde!" Dans un LCD 16 * 2 en utilisant

/ ************** DONNÉES TERMINÉES ICI *************** / Arduino Uno (Partie 2 de 2) 30 août 2015

Circuit permettant d'interfacer un écran


digitalWrite (sda, LOW ); //
délai (delay_time); // LCD graphique 16 * 2 avec Arduino Uno
digitalWrite (scl, HIGH ); //
(Partie 1 de 2) 29 août 2015
délai (delay_time); //
pinMode (sda, INPUT ); // Circuit pour détecter le mouvement à l'aide
Série . print ( digitalRead (sda)); //
du capteur de mouvement PIR et arduino
délai d' accusé de réception (delay_time); //
digitalWrite (scl, LOW ); // uno 22 août 2015
délai (delay_time); //

pinMode (sda, OUTPUT ); My Funny Electronics


182 vidéos
digitalWrite (sda, LOW ); //
délai (delay_time); // S'abonner 1k
digitalWrite (scl, HIGH ); //
délai (delay_time); // STOP
digitalWrite (sda, HIGH ); //
délai (delay_time); //

retard (3000);

retour ;
}

// la boucle fonctionne encore et encore pour toujours


void loop () {
// Numéro de l'IC 24C08 sur lequel les données doivent être écrites
int IC_number = 0; // Dans la plage 0 - 1

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 9/12
09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

// Memory Byte Adresse de la 24C08 à laquelle les données doivent être écrites
int Memory_byte_address = 1023; // Dans la plage 0 - 1023

// Données à écrire dans la mémoire spécifiée de 24C08


int Data = 170; // Dans la plage 0 - 255

Série . imprimer ( "Écriture" );


Série . imprimer (données);
Série . imprimer ( "à" );
Série . print (Memory_byte_address);
Série . print ( "Th Memory Byte" ); Funny Electronics
Série . print (IC_number); google.com/+MyfunnyelectronicsBlogspo
otfunnyelectronic…
Série . imprimer ( "th 24C08" );
Electronics, circuits, Linux, Robotics, Integrated
Circuits, IC,
// Fonction pour écrire des données en 24C08
write_to_24C08 (numéro_IC, adresse_mémoire_de_mémoire, données); Suivre

Série . println ( "" );


}

Si le téléchargement est réussi, ouvrez votre moniteur série. Trois zéros seront affichés dans un délai de quelques
secondes qui indique l'écriture réussie des données.

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 10/12
09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

Suite dans la prochaine partie (Partie 3) >>>>


(Visité 2,585 fois, 1 visites aujourd'hui)

paulpp644

Un passionné de l'électronique qui a passé la majeure partie de mon temps pour des expériences
électroniques. Je suis également intéressé par la publication de mes expériences dans mon blog
pour aider d'autres passionnés d'électronique.

Tags: 24C08 , Arduino , arduino mega , ATmega328 , électronique de base , Diagramme , EEPROM , électronique , circuit intégré ,
microcontrôleur , tutoriel

Laisser une réponse

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 11/12
09/04/2018 Programme pour écrire des données dans une EEPROM 24C08 en utilisant Arduino Mega (Partie 2 de 5)

Nom *

Email *

Site Internet

Poster un commentaire →

← Circuit pour lire et écrire des données dans une EEPROM 24C08 par Arduino Mega (Partie 1 de 5)
Programme pour lire les données d'une EEPROM 24C08 en utilisant Arduino Mega (Partie 3 de 5) →

Droit d'auteur © 2018 haberocean


Propulsé par WordPress et Origin

http://www.haberocean.com/2015/02/read-and-write-data-to-a-24c08-eeprom-using-arduino-mega-part-2/ 12/12