- Composants requis:
- Explication de travail:
- Explication du circuit:
- Explication de la programmation:
- Conception de circuits et de circuits imprimés avec EasyEDA:
- Calcul et commande d'échantillons en ligne:
Un tremblement de terre est une catastrophe naturelle imprévisible qui cause des dommages aux vies et aux biens. Cela se produit soudainement et nous ne pouvons pas l'arrêter, mais nous pouvons en être alertés. À l'heure actuelle, il existe de nombreuses technologies qui peuvent être utilisées pour détecter les petits secousses et chocs, afin que nous puissions prendre des précautions avant certaines vibrations majeures dans la terre. Ici, nous utilisons l'accéléromètre ADXL335 pour détecter les vibrations pré-séisme. L'accéléromètre ADXL335 est très sensible aux secousses et aux vibrations avec les trois axes. Ici, nous construisons un détecteur de tremblement de terre basé sur Arduino à l'aide d'un accéléromètre.
Nous construisons ici ce détecteur de tremblement de terre en tant que bouclier Arduino sur PCB et afficherons également le graphique de vibrations sur ordinateur en utilisant le traitement.
Composants requis:
- Arduino UNO
- Accéléromètre ADXL335
- Écran LCD 16x2
- Avertisseur sonore
- Transistor BC547
- Résistances 1k
- POT 10K
- LED
- Alimentation 9v / 12v
- Bâtons de berg mâle / femelle
Accéléromètre:
Broche Description de l'accéléromètre:
- L'alimentation Vcc 5 volts doit se connecter à cette broche.
- X-OUT Cette broche donne une sortie analogique dans la direction x
- Y-OUT Cette broche donne une sortie analogique dans la direction y
- Z-OUT Cette broche donne une sortie analogique dans la direction z
- Terre GND
- ST Cette broche utilisée pour régler la sensibilité du capteur
Consultez également nos autres projets utilisant Accelerometer:
- Jeu de ping-pong utilisant Arduino
- Robot contrôlé par geste de la main basé sur un accéléromètre.
- Système d'alerte d'accident de véhicule basé sur Arduino utilisant le GPS, le GSM et l'accéléromètre
Explication de travail:
Le fonctionnement de ce détecteur de tremblement de terre est simple. Comme nous l'avons mentionné précédemment, nous avons utilisé l'accéléromètre pour détecter les vibrations du tremblement de terre le long de l'un des trois axes de sorte que chaque fois que des vibrations se produisent, l'accéléromètre détecte ces vibrations et les convertit en valeur ADC équivalente. Ensuite, ces valeurs ADC sont lues par Arduino et affichées sur l'écran LCD 16x2. Nous avons également montré ces valeurs sur le graphique en utilisant le traitement. En savoir plus sur Accelerometer en passant par nos autres projets Accelerometer ici.
Nous devons d'abord calibrer l'accéléromètre en prélevant des échantillons de vibrations environnantes chaque fois qu'Arduino s'allume. Ensuite, nous devons soustraire ces exemples de valeurs des lectures réelles pour obtenir les lectures réelles. Cet étalonnage est nécessaire pour qu'il n'affiche pas d'alertes par rapport à ses vibrations environnantes normales. Après avoir trouvé des lectures réelles, Arduino compare ces valeurs avec des valeurs max et min prédéfinies. Si Arduino trouve que les valeurs de changement sont supérieures ou inférieures aux valeurs prédéfinies de n'importe quel axe dans les deux sens (négatif et positif), alors Arduino déclenche le buzzer et affiche l'état de l'alerte sur l'écran LCD 16x2 et une LED également allumée. Nous pouvons ajuster la sensibilité du détecteur de tremblement de terre en modifiant les valeurs prédéfinies dans le code Arduino.
La vidéo de démonstration et le code Arduino sont donnés à la fin de l'article.
Explication du circuit:
Circuit de ce détecteur de tremblement de terre Arduino Shield PCBest également simple. Dans ce projet, nous avons utilisé Arduino qui lit la tension analogique de l'accéléromètre et les convertit en valeurs numériques. Arduino pilote également le buzzer, la LED, l'écran LCD 16x2 et calcule et compare les valeurs et prend les mesures appropriées. La partie suivante est l'accéléromètre qui détecte les vibrations de la terre et génère des tensions analogiques sur 3 axes (X, Y et Z). L'écran LCD est utilisé pour afficher le changement des valeurs des axes X, Y et Z et également afficher un message d'alerte dessus. Cet écran LCD est connecté à Arduino en mode 4 bits. Les broches RS, GND et EN sont directement connectées aux broches 9, GND et 8 d'Arduino et le reste des 4 broches de données de l'écran LCD, à savoir D4, D5, D6 et D7, sont directement connectés aux broches numériques 7, 6, 5 et 4 d'Arduino. Le buzzer est connecté à la broche 12 d'Arduino via un transistor NPN BC547. Un pot de 10k est également utilisé pour contrôler la luminosité de l'écran LCD.
Explication de la programmation:
Dans ce bouclier Arduino de détecteur de tremblement de terre, nous avons créé deux codes: un pour Arduino pour détecter un tremblement de terre et un autre pour le traitement de l'IDE pour tracer les vibrations du tremblement de terre sur le graphique sur ordinateur. Nous allons découvrir les deux codes un par un:
Code Arduino:
Tout d'abord, nous calibrons l'accéléromètre par rapport à sa surface de placement, afin qu'il n'affiche pas d'alertes par rapport à ses vibrations environnantes normales. Dans cet étalonnage, nous prenons quelques échantillons, puis nous en prenons une moyenne et les stockons dans une variable.
pour (int i = 0; i
Désormais, chaque fois que l'accéléromètre prend des mesures, nous soustrayons ces valeurs d'échantillons des lectures afin qu'il puisse ignorer les vibrations environnantes.
int value1 = analogRead (x); // lecture de x out int value2 = analogRead (y); // lecture de y sur int value3 = analogRead (z); // lecture de z out int xValue = xsample-value1; // recherche de changement dans x int yValue = ysample-value2; // recherche de changement dans y int zValue = zsample-value3; // trouver le changement dans z / * déplacer le changement dans les valeurs des axes x, y et z sur lcd * / lcd.setCursor (0,1); lcd.print (zValue); lcd.setCursor (6,1); lcd.print (yValue); lcd.setCursor (12,1); lcd.print (zValue); retard (100)
Ensuite, Arduino compare ces valeurs calibrées (soustraites) avec des limites prédéfinies. Et agissez en conséquence. Si les valeurs sont supérieures aux valeurs prédéfinies, il émettra un bip sonore et tracera le graphique de vibration sur l'ordinateur en utilisant Traitement.
/ * comparaison du changement avec des limites prédéfinies * / if (xValue <minVal - xValue> maxVal - yValue <minVal - yValue> maxVal - zValue <minVal - zValue> maxVal) {if (buz == 0) start = millis (); // démarrage de la minuterie buz = 1; // buzzer / indicateur led activé} else if (buz == 1) // indicateur buzzer activé puis alerte tremblement de terre {lcd.setCursor (0,0); lcd.print ("Alerte au tremblement de terre"); if (millis ()> = start + buzTime) buz = 0; }
Code de traitement:
Vous trouverez ci-dessous le code de traitement ci-joint, vous pouvez télécharger le code à partir du lien ci-dessous:
Code de traitement du détecteur de tremblement de terre
Nous avons conçu un graphique utilisant Processing, pour les vibrations du tremblement de terre, dans lequel nous avons défini la taille de la fenêtre, les unités, la taille de la police, l'arrière-plan, la lecture et l'affichage des ports série, l'ouverture du port série sélectionné, etc.
// définir la taille de la fenêtre: et la taille de la police f6 = createFont ("Arial", 6, true); f8 = createFont ("Arial", 8, vrai); f10 = createFont ("Arial", 10, vrai); f12 = createFont ("Arial", 12, vrai); f24 = createFont ("Arial", 24, vrai); taille (1200, 700); // Liste tous les ports série disponibles println (Serial.list ()); myPort = new Serial (ceci, "COM43", 9600); println (myPort); myPort.bufferUntil ('\ n'); de fond (80)
Dans la fonction ci-dessous, nous avons reçu des données du port série et extrait les données requises, puis les avons mappées avec la taille du graphique.
// extraction de toutes les valeurs requises des trois axes: int l1 = inString.indexOf ("x =") + 2; Chaîne temp1 = inString.substring (l1, l1 + 3); l1 = inString.indexOf ("y =") + 2; Chaîne temp2 = inString.substring (l1, l1 + 3); l1 = inString.indexOf ("z =") + 2; Chaîne temp3 = inString.substring (l1, l1 + 3); // mappage des valeurs x, y et z avec les dimensions du graphique float inByte1 = float (temp1 + (char) 9); inByte1 = carte (inByte1, -80,80, 0, hauteur-80); float inByte2 = float (temp2 + (char) 9); inByte2 = carte (inByte2, -80,80, 0, hauteur-80); float inByte3 = float (temp3 + (char) 9); inByte3 = carte (inByte3, -80,80, 0, hauteur-80); float x = carte (xPos, 0,1120,40, largeur-40);
Après cela, nous avons tracé l'espace unitaire, les limites max et min, les valeurs des axes x, y et z.
// fenêtre graphique de tracé, unité strokeWeight (2); course (175); Ligne (0,0,0,100); textFont (f24); remplir (0,00,255); textAlign (DROITE); xmargin ("EarthQuake Graph By Circuit Digest", 200,100); remplir (100); strokeWeight (100); ligne (1050,80,1200,80);………………
Après cela, nous traçons les valeurs sur le graphique en utilisant 3 couleurs différentes comme bleu pour la valeur de l'axe x, la couleur verte pour l'axe y et z est représenté par la couleur rouge.
course (0,0,255); if (y1 == 0) y1 = hauteur-inByte1-shift; ligne (x, y1, x + 2, hauteur-inByte1-shift); y1 = hauteur-inByte1-shift; course (0,255,0); if (y2 == 0) y2 = hauteur-inByte2-shift; ligne (x, y2, x + 2, hauteur en octet2); y2 = hauteur-inByte2-shift; course (255,0,0); if (y2 == 0) y3 = hauteur-inByte3-shift; ligne (x, y3, x + 2, hauteur-inByte3-shift); y3 = hauteur-inByte3-shift;
En savoir plus sur le traitement en passant par nos autres projets de traitement.
Conception de circuits et de circuits imprimés avec EasyEDA:
EasyEDA n'est pas seulement la solution unique pour la capture schématique, la simulation de circuits et la conception de circuits imprimés, ils offrent également un service d'approvisionnement en prototypes et composants de circuits imprimés à faible coût. Ils ont récemment lancé leur service d'approvisionnement en composants où ils disposent d'un stock important de composants électroniques et les utilisateurs peuvent commander les composants nécessaires avec la commande de PCB.
Lors de la conception de vos circuits et PCB, vous pouvez également rendre publics vos conceptions de circuits et de PCB afin que d'autres utilisateurs puissent les copier ou les modifier et en tirer parti, nous avons également rendu public l'ensemble de nos dispositions de circuits et de PCB pour ce bouclier d'indicateur de tremblement de terre pour Arduino UNO, consultez le lien ci-dessous:
easyeda.com/circuitdigest/EarthQuake_Detector-380c29e583b14de8b407d06ab0bbf70f
Vous trouverez ci-dessous un instantané de la couche supérieure de la disposition du PCB d'EasyEDA, vous pouvez afficher n'importe quelle couche (supérieure, inférieure, Topsilk, Bottomsilk, etc.) du PCB en sélectionnant la couche dans la fenêtre `` Couches ''.
Vous pouvez également voir la vue photo du PCB en utilisant EasyEDA:
Calcul et commande d'échantillons en ligne:
Après avoir terminé la conception du PCB, vous pouvez cliquer sur l'icône de la sortie de fabrication , qui vous mènera sur la page de commande de PCB. Ici, vous pouvez visualiser votre PCB dans Gerber Viewer ou télécharger les fichiers Gerber de votre PCB. Ici, vous pouvez sélectionner le nombre de PCB que vous souhaitez commander, le nombre de couches de cuivre dont vous avez besoin, l'épaisseur du PCB, le poids du cuivre et même la couleur du PCB. Après avoir sélectionné toutes les options, cliquez sur «Enregistrer dans le panier» et terminez votre commande. Récemment, ils ont considérablement baissé leurs taux de PCB et vous pouvez maintenant commander 10 PCB à 2 couches d'une taille de 10 cm x 10 cm juste pour 2 $.
Voici les PCB que j'ai obtenus d'EasyEDA:
Vous trouverez ci-dessous les images du bouclier final après avoir soudé les composants sur PCB:
