Fabrication industrielle
Internet des objets industriel | Matériaux industriels | Entretien et réparation d'équipement | Programmation industrielle |
home  MfgRobots >> Fabrication industrielle >  >> Manufacturing Technology >> Processus de fabrication

Localisateur de métal de poche

Composants et fournitures

SparkFun Arduino Pro Mini 328 - 5V/16MHz
× 1

Outils et machines nécessaires

Imprimante 3D (générique)

À propos de ce projet

Intro : Pocket Metal Locator - Arduino

Ce petit localisateur de métal de poche est assez sensible pour identifier les petits clous et les punaises dans le bois et assez compact pour s'adapter aux espaces difficiles, ce qui le rend pratique à transporter et à utiliser pour la localisation de métal.

L'unité dispose de quatre bobines de recherche indépendantes et d'indicateurs LED de couleur, ce qui permet de couvrir rapidement une zone de recherche plus large tout en étant capable d'identifier avec précision la cible.

Ce petit appareil soigné s'auto-calibrant avec un seul bouton, rechargeable via un port USB et utilise des LED de couleur, des sons et des vibrations pour indiquer la force de la cible.

Le didacticiel comprend toutes les conceptions, les tests, le code et les fichiers 3D nécessaires pour créer vous-même. J'espère que vous prendrez autant de plaisir à le construire et à l'utiliser que moi !!

Étape 1 : Liste des matériaux et comment cela fonctionne

1. Comment ça Fonctionne

Le Pocket Metal Locator utilise quatre bobines de recherche à induction d'impulsions indépendantes alimentées par un Arduino Pro Mini. Chaque bobine de recherche est composée d'une bobine TX et RX séparée où une impulsion est induite dans la bobine TX qui crée un champ électromagnétique autour de la bobine RX. Le champ changeant induit une tension dans la bobine RX qui est détectée et amplifiée avant que la largeur d'impulsion du signal ne soit lue par l'Arduino.

Un algorithme de lissage dans le code Arduino est utilisé pour supprimer le bruit des impulsions valides, ce qui le rend très stable.

Un algorithme d'étalonnage dans le code prend une moyenne des lectures sur une courte période de démarrage et définit une série de seuils pour comparer le signal.

Lorsqu'un objet métallique se trouve à portée du champ électromagnétique, le champ est perturbé et une partie de l'énergie est détournée de la bobine RX vers des « courants de Foucault » qui se forment dans l'objet cible. Cet effet parasite de l'objet cible entraîne une réduction de la largeur d'impulsion détectée dans la bobine RX. Essentiellement, nous mesurons la perte de puissance dans l'objet cible.

Lorsque la largeur d'impulsion détectée dans la bobine RX tombe en dessous du seuil, les LED s'allument, le buzzer retentit et le moteur de retour haptique déclenché - en fonction d'une taille prédéterminée du signal cible.

Le circuit pour cela a évolué au cours de l'année dernière pour devenir un détecteur très stable et fiable. La configuration et l'orientation de la bobine ont été délibérément conçues pour maximiser la stabilité et la détection de profondeur.

2. Liste des matériaux

  • Taille de la batterie LiPo 3,7 v 350 mAh :38 mm x 20 mm x 7,5 mm
  • Fiche technique du chargeur de batterie LiPo USB TP4056
  • Résistance de 4,7 K pour limiter le courant de charge de la batterie LiPo à moins de 300 mA
  • Arduino Pro Mini
  • Module FTDI USB vers série pour programmer le Mini Pro
  • Circuit intégré comparateur différentiel quad LM339
  • Planche Vero - 2 pièces découpées à 20x9 trous et 34x9 (voir photo pour une orientation correcte)
  • BC548 NPN Transistor x 4
  • Commutateur MOSFET 2N7000 x 5
  • Sonnerie piézo
  • Moteur de vibration de pièces pour rétroaction haptique
  • Module LED RVB WS2812 x 4
  • Résistance 1k x 4
  • Résistance 10k x 4
  • Résistance 47 Ohm x 4
  • Résistance 2,2K x 4
  • Condensateur céramique 150pf x 8
  • Condensateur en polyester 0,18 uF x 4
  • Rouleau de fil de cuivre émaillé de 0,3 mm (normalement livré en rouleaux d'environ 25 g de poids)
  • Interrupteur à bouton-poussoir monté sur PCB
  • Pistolet à colle chaude
  • Mèche de 10 mm
  • Perceuse portative
  • Pistolet d'étiquetage ou ruban adhésif adapté pour étiqueter 16 fils distincts Fil de raccordement
  • Accès à une imprimante 3D

3. Fonctionnement du comparateur

J'ai eu un certain nombre de questions sur le fonctionnement du LM339 alors j'ai pensé donner une explication plus claire.

Le LM339 fonctionne uniquement comme un comparateur de tension, comparant la tension différentielle entre les broches positives et négatives et produisant une impédance logique basse ou haute (logique haute avec pullup) en fonction de la polarité différentielle d'entrée.

Dans ce circuit, l'entrée positive du comparateur est connectée à la ligne Vcc et une résistance de rappel à Vcc est appliquée à la sortie du comparateur. Dans cette configuration, en pratique, la tension de sortie du comparateur reste élevée, jusqu'à ce que la tension d'entrée sur l'entrée négative dépasse 3,5v

Le fonctionnement peut être expliqué à partir de la fiche technique LM339 qui décrit la "plage de tension d'entrée" comprise entre 0 V et Vsup-1,5 V

Lorsque IN– et IN+ sont tous deux dans la plage de mode commun, si IN– est inférieur à IN+ et à la tension de décalage, la sortie est à haute impédance et le transistor de sortie n'est pas conducteur

Lorsque IN– est supérieur au mode commun et IN+ est en mode commun, la sortie est faible et le transistor de sortie absorbe le courant. Lien vers la fiche technique et explication ci-dessous http://www.ti.com/lit/ds/symlink/lm2901.pdf

lm2901.pdf

Étape 2 :Imprimez le boîtier

Le boîtier imprimé en 3D a été réalisé à l'aide de 5 impressions distinctes. Les dimensions et les fichiers 3D peuvent être trouvés ici sur Thingiverse. La conception visait à rendre l'appareil facile à tenir tout en garantissant que les bobines de recherche étaient aussi proches de la zone recherchée.

Imprimez soigneusement le boîtier et retirez l'excès de plastique. Il est important de faire cette étape maintenant afin que les composants électroniques puissent être alignés dans le boîtier avant le raccordement final et les tests.

Étape 3 : Construire et monter les bobines de recherche

Prenez les formeuses de bobines imprimées et enroulez 25 tours de fil de cuivre sur chacune d'elles. Assurez-vous de laisser un bon 20 cm de fil de cuivre supplémentaire pour le raccordement à l'unité principale.

Utilisez les trous imprimés dans les gabarits pour permettre un enroulement et une orientation cohérents des bobines pour chaque gabarit. Pendant que vous faites cela, retournez le gabarit et collez progressivement le gabarit dans l'unité de base.

Suivez l'assemblage photo comme fourni, le résultat étant 8 bobines montées dans l'assemblage de bobines avec tous les fils orientés de manière cohérente et suffisamment longs pour se connecter à l'unité de carte principale dans le boîtier supérieur.

Utilisez les deux blocs de guidage de fil qui ont des trous pour chaque bobine et la base imprimée pour garder une trace de chaque bobine spécifique.

J'ai placé les fils des bobines intérieures le long du haut et les bobines extérieures le long du bas du bloc de fils afin que je puisse garder une trace de chaque bobine spécifique, ce qui facilite la connexion à la carte principale.

Étape 4 : Construisez le circuit

L'unité dispose de quatre circuits clés à construire indépendamment :carte de commande, carte principale, ensemble LED et alimentation rechargeable. Dans cette étape, nous allons construire la carte pilote et la carte principale.

1. Carte pilote

Utilisez un cutter pour couper un morceau de Vero Board le long des trous 22x11, le résultat étant un morceau de Vero Board avec 20x9 trous orientés selon l'image incluse. Il est préférable de marquer plusieurs fois les trous des deux côtés de la planche, puis de casser doucement l'excès de planche. Vérifiez que la carte repose dans la base du boîtier avec suffisamment d'espace libre de chaque côté.

À l'aide des photos et d'un foret de 10 mm à la main, cassez soigneusement les punaises indiquées au bas de la planche Vero. Suivez le schéma de circuit et la disposition photo des composants pour assembler la carte de circuit imprimé en veillant à ce qu'il n'y ait pas de courts-circuits.

Mettez cette carte de côté pour un test ultérieur.

2. Carte principale

Utilisez un cutter pour couper un morceau de Vero Board le long des trous 36x11, le résultat étant un morceau de Vero Board avec 34x9 trous orientés selon l'image incluse. Il est préférable de marquer plusieurs fois les trous des deux côtés de la planche, puis de casser doucement l'excès de planche. Vérifiez que la carte repose dans la base du boîtier avec suffisamment d'espace libre de chaque côté.

À l'aide des photos et d'un foret de 10 mm à la main, cassez soigneusement les punaises indiquées au bas de la carte Vero.

Suivez le schéma de circuit et la disposition des photos des circuits intégrés Arduino et LM339 et des autres composants pour assembler la carte de circuit imprimé en veillant à ce qu'il n'y ait pas de courts-circuits.

Mettez cette carte de côté pour un test ultérieur.

Étape 5 : ajouter des indicateurs LED

J'ai utilisé des LED WS2182 qui ont un circuit intégré qui leur permet d'être adressés par l'Arduino à l'aide de trois fils séparés, mais une large gamme de couleurs et de couleurs de luminosité peut être créée en envoyant une commande à la LED. Cela se fait via une bibliothèque spéciale chargée dans l'IDE Arduino couvert dans la section de test.

1. Montage des LED dans le couvercle du boîtier de bobine

Positionnez soigneusement les quatre LED de manière à ce qu'elles soient correctement orientées afin que les connexions VCC et GND soient alignées et qu'elles se trouvent au centre des trous.

Utilisez de la colle chaude pour fixer les LED en position.

2. Câblage des LED

Dénudez et positionnez soigneusement trois longueurs de 25 cm de fil de raccordement monoconducteur sur les contacts des LED.

Soudez-les en place et assurez-vous que le fil de données central est connecté aux contacts IN et OUT conformément à la photo.

3. Vérification de l'alignement des cas

Vérifiez que le couvercle du boîtier affleure le boîtier de la bobine, puis utilisez de la colle chaude pour maintenir les fils en place à l'extrémité inférieure du couvercle.

Mettez-le de côté pour un test ultérieur.

Étape 6 :Assemblage et test de l'unité

1. Préparation de l'assemblage

Avant l'assemblage, nous testerons progressivement chaque carte pour faciliter la résolution des problèmes.

L'Arduino Pro Mini nécessite une carte série USB pour être programmé par votre PC. Cela permet à la carte d'être plus petite car elle n'a pas d'interface série dessus. Pour programmer ces cartes, vous devrez investir pour en obtenir une, comme indiqué dans la liste des pièces.

Avant de charger le code Arduino, vous devrez ajouter la bibliothèque "FastLED.h" en tant que bibliothèque pour piloter les LED WS2182. Une série de traces d'oscilloscope a été fournie pour le dépannage en cas de problème.

Il y a aussi une capture d'écran de la sortie de données série IDE utilisant la fonction Graph Plot qui montre la sortie de largeur d'impulsion de chacun des canaux ainsi que la valeur de seuil. Ceci est utile pendant les tests car vous pouvez voir si chaque canal fonctionne à des niveaux de sensibilité similaires.

J'ai inclus deux copies du code. L'un d'eux permet de tester la diffusion de données en série à des fins de dépannage.

REMARQUE : Ne connectez pas l'unité de batterie LiPo avant la toute dernière étape, car un court-circuit accidentel lors de l'assemblage peut entraîner une surchauffe de l'unité ou même un incendie.

2. Testez la carte principale

Avant de connecter la carte principale à quoi que ce soit, il est conseillé de connecter le câble série Arduino et de vérifier que le code se charge.

Cela testera simplement que l'Arduino est physiquement correctement câblé et que l'IDE et les bibliothèques sont chargés. Chargez le code via l'IDE qui devrait se charger sans erreur et aucune fumée ne devrait sortir d'aucun des composants !

3. Connectez la carte pilote

Suivez le schéma de circuit pour connecter la carte de commande à la carte principale et positionnez physiquement l'unité dans le boîtier pour vous assurer que les éléments rentrent dans le boîtier. Il s'agit d'un cas d'essais et d'erreurs et nécessite de la persévérance.

Chargez le code via l'IDE qui devrait se charger sans erreur et aucune fumée ne devrait sortir d'aucun des composants !

4. Connectez les bobines Suivez le schéma de circuit pour connecter les bobines à la carte principale et positionnez physiquement l'unité dans le boîtier pour vous assurer que les éléments s'adaptent correctement. Assurez-vous soigneusement que les bobines sont alignées avec les entrées de la carte de commande et de la carte principale conformément au schéma de circuit.

Une fois le code de test chargé, le port série affichera la largeur d'impulsion sur la bobine de réception quelque part entre 5000 et 7000uS. Cela peut également être visualisé à l'aide du traceur de graphes IDE.

Cela vous permettra de dépanner chacun des canaux et de voir également l'effet du déplacement d'une pièce près de la bobine de recherche, ce qui devrait réduire la largeur d'impulsion à mesure que la cible se rapproche de la bobine de recherche.

Si vous avez un oscilloscope, vous pouvez également vérifier les formes d'onde à différentes étapes du circuit pour diagnostiquer les problèmes.

Une fois que tous les canaux fonctionnent comme prévu, positionnez les fils de sorte que le boîtier du boîtier s'assemble et se ferme correctement.

5. Connectez les LED

Prenez soigneusement les trois fils des LED du boîtier de la bobine et connectez-les à la carte principale. Chargez le code et vérifiez que les LED fonctionnent correctement. Utilisez de la colle pour fixer le couvercle du boîtier de la bobine en place.

Pocket_Metal_Locator_V11__TEST_CODE.zip Pocket_Metal_Locator_V11.zip

Étape 7 : connexion de la batterie rechargeable

REMARQUE :

1. Ne connectez pas l'unité de batterie LiPo jusqu'à la toute dernière étape, car un court-circuit accidentel lors de l'assemblage peut entraîner une surchauffe de l'unité ou même un incendie.

2. Lorsque vous manipulez la batterie et le chargeur, veillez à ne pas court-circuiter les connexions de la batterie.

3. Les batteries LiPo sont différentes des autres batteries rechargeables et la charge par surintensité peut être dangereuse, alors assurez-vous de configurer correctement le circuit de charge.

4. Ne connectez pas le câble série Arduino à l'unité lorsque le bouton d'alimentation est enfoncé, sinon la batterie pourrait être endommagée.

1. Modifier la limite de courant du chargeur

Le Pocket Metal Locator utilise une batterie LiPo qui peut être chargée à l'aide d'un chargeur de téléphone Micro USB. La carte de chargeur USB LiPo TP4056 est d'abord modifiée avec une résistance de 4,7 K pour limiter le courant de charge à moins de 300 mA. Des instructions sur la façon dont cela peut être fait peuvent être trouvées ici.

TP4056.pdf

Cela vous oblige à retirer la résistance montée en surface existante et à la remplacer par une résistance comme indiqué sur la photo. Une fois en place, protégez tout mouvement imprévu de la résistance avec un pistolet à colle chaude.

Avant de vous connecter à la carte principale, vérifiez que le chargeur fonctionne correctement en connectant un chargeur de téléphone portable avec un port Micro USB. Le voyant de charge rouge doit s'allumer lorsqu'il fonctionne correctement.

2. Installez l'interrupteur d'alimentation à bouton-poussoir

Assurez-vous que le bouton-poussoir est monté dans la bonne position afin qu'il dépasse du centre du couvercle du boîtier, puis soudez le bouton-poussoir en place. Installez les fils entre l'interrupteur à bouton-poussoir et la sortie du chargeur et la ligne VCC sur l'Arduino conformément au schéma de circuit.

Lorsqu'il est installé correctement, appuyez sur l'interrupteur pour activer l'unité.

Fixez la batterie en place à l'aide de colle chaude et assurez-vous que la prise Micro USB est alignée sur le trou du couvercle du boîtier afin qu'elle puisse être chargée.

Étape 8 : tests finaux et exploitation

1. Assemblage physique

La dernière étape consiste à réarranger soigneusement les fils afin que le boîtier se ferme correctement. Utilisez de la colle chaude pour fixer la carte mère dans le couvercle, puis fermez le couvercle en position.

2. Fonctionnement de l'unité

L'unité fonctionne en calibrant après avoir appuyé et maintenu le bouton d'alimentation. Toutes les LED clignotent lorsque l'appareil est prêt à être utilisé. Maintenez le bouton poussoir enfoncé pendant la recherche. Les LED changent de bleu-vert, rouge, violet en fonction de la force de l'objet cible. Le retour haptique se produit lorsque les LED deviennent violettes.

Vous n'êtes pas prêt à utiliser pour des applications pratiques !!

Code

  • Pocket_Metal_Locator_V11.ino
Pocket_Metal_Locator_V11.inoC/C++
Ce petit localisateur de métal de poche cool est suffisamment sensible pour identifier les petits clous et les punaises dans le bois et suffisamment compact pour tenir dans des espaces difficiles, ce qui le rend pratique à transporter et à utiliser pour la localisation de métal.

L'unité dispose de quatre bobines de recherche indépendantes et d'indicateurs LED de couleur, ce qui permet de couvrir rapidement une zone de recherche plus large tout en étant capable d'identifier avec précision la cible.

Ce petit appareil soigné s'auto-calibrant avec un seul bouton, rechargeable via un port USB et utilise des LED de couleur, des sons et des vibrations pour indiquer la force de la cible.

L'instructable comprend toutes les conceptions, les tests, le code et les fichiers 3D nécessaires pour construire vous-même. J'espère que vous prendrez autant de plaisir à construire et à utiliser cela que moi ! "// Combien de leds dans votre bande ? #define NUM_LEDS 4 // Remarque :La première LED est l'adresse 0#define DATA_PIN 11 // Remarque :D11 utilisé pour contrôler la chaîne de LED// Définir le tableau de ledsCRGB leds[NUM_LEDS] ;/ / Variables de lissage pour LPFconst float alpha =0.85; float smoothedvalue1 =1000;float smoothedvalue2 =1000;float smoothedvalue3 =1000;float smoothedvalue4 =1000;int sthreshold =100; // La lecture minimale de la fonction pulseIn garantit un échantillonnage supérieur à noisefloat ledthreshold1 =0,93 ; // Pourcentage en dessous de la ligne de base avant le réglage des LED Purplefloat ledthreshold2 =0.96; // Pourcentage en dessous de la ligne de base avant le réglage des LED Redfloat ledthreshold3 =0.99; // Pourcentage en dessous de la ligne de base avant le réglage des LED Greenfloat ledthreshold4 =0.998; // Pourcentage en dessous de la ligne de base avant de régler les voyants bleus// Variables d'étalonnage échantillon booléen =false ; // si vrai alors ne pas rappeler les seuilsint calcounter =0; // Utilisé pour compter le nombre de fois qu'un échantillon a été prélevéint scount =200; // Nombre de lectures avant l'étalonnage une seule fois après la mise sous tension numsamples =20 ; // Nombre d'échantillons prélevés avant d'en faire la moyenneint t1 =100; // Durée en microsecondes que les LED s'allument pendant l'étalonnagelong calav1 =0; // Utilisé pour calculer la moyenne de dix échantillonslong calav2 =0; // Utilisé pour calculer la moyenne de dix échantillonslong calav3 =0; // Utilisé pour calculer la moyenne de dix échantillonslong calav4 =0; // Utilisé pour calculer la moyenne de dix échantillonsint div1 =0;// Compteur diviseur pour le nombre d'échantillons prélevésint div2 =0;int div3 =0;int div4 =0;// Quatre canaux notés A,B,C,Dint divA =0;long tempA =0;long pcounterA =0; // Largeur d'impulsion non filtrée du canal 1int divB =0;long tempB =0;long pcounterB =0; // Largeur d'impulsion non filtrée du canal 2int divC =0;long tempC =0;long pcounterC =0; // Largeur d'impulsion non filtrée du canal 1int divD =0;long tempD =0;long pcounterD =0; // Largeur d'impulsion non filtrée du canal 1int pwindow =7500 ; // Valeur de timeout maximum pour pulsewidth// ******************************************* ***********int dly1 =4; // Période pendant laquelle la broche TXR reste élevée (typiquement 4uS)int dly2 =1 ; // Délai après que la broche TXR passe au niveau BAS avant que la lecture ne commence à lire la durée d'impulsion - généralement 1 uS int dly3 =500 ; // Délai en microsecondes après l'échantillonnage de la largeur d'impulsion avant de démarrer le cycle suivant // ************************************ ****************int threshdiff =15; // Ajouter à la moyenne pour devenir un seuil spécifique où la LED s'allumera (V21 modifié de 25 à 20) pulsation longue =0 ; // Stocke la valeur de sortie pour l'étalonnage// Vibration Motor boolean haptic =false; // Drapeau utilisé pour activer le moteur de vibration pendant une période de temps int vduration =1; // Nombre de cycles de programme activés par le moteur de vibration int vcounter =vduration; // v cycle counter void setup() {// Vibration Motor/Haptic Feedback pinMode (12, OUTPUT); // Pilote de moteur de vibration d'Arduino - D10 digitalWrite (12,LOW); // Éteindre le moteur Serial.begin(115200); // Configuration de l'interface série pour les sorties de données de test// Configuration du pilote de LED WS2182 LEDS.addLeds(leds,NUM_LEDS); // Par défaut si RVB pour cela peut cependant varier en fonction du fabricant de LED LEDS.setBrightness(5); //Définir la luminosité des LED ici // limiter ma consommation à 1A à 5v de consommation d'énergie FastLED.setMaxPowerInVoltsAndMilliamps(5 100); FastLED.setDither(0); // Désactive la fonction de tramage automatique pour supprimer le scintillement // Affectations de broches logiques Arduino Mini Pro // Nom de broche logique 2,3,4,5,6,7,8,9 équivaut au nom de broche D2-D9 imprimé sur la carte // Nom de broche logique 10,11,12,13,14,15,16,17 équivaut à D10-D13, A0-A3 Nom de broche imprimé sur la carte // Mode de broche du buzzer piézo (10, SORTIE); // Pilote Piezo Buzzer d'Arduino - D10 // Transmit pinMode (2, OUTPUT); // Sortie d'impulsions d'Arduino - D2 pinMode (4, OUTPUT); // Sortie d'impulsions d'Arduino - D4 pinMode (6, OUTPUT); // Sortie d'impulsions d'Arduino - D6 pinMode (8, OUTPUT); // Sortie d'impulsion d'Arduino - D8 // Canal A pinMode (3, INPUT); // Entrée de signal vers Arduino à partir de la broche 2 sur LM339 - D3//canal B pinMode (5, INPUT); // Entrée de signal vers Arduino à partir de la broche 1 sur LM339 - D5//canal C pinMode (7, INPUT); // Entrée de signal vers Arduino à partir de la broche 14 sur LM339 - D7 // Canal D pinMode (9, INPUT); // Entrée de signal vers Arduino à partir de la broche 13 sur LM339 - D9 }boucle vide (){// Impulsion et lecture de la bobine ------------------------- --------------------// Canal 1 (pointe de la baguette)digitalWrite(2,HIGH); // Définir la broche TX sur highdelayMicroseconds(dly1) ; // Délai avant le réglage bas sur la sortie pindigitalWrite(2,LOW); // Définir la broche TX sur lowdelayMicroseconds(dly2) ; // Délai avant échantillonnage de la largeur d'impulsionpcounterA =pulseIn(3,LOW,pwindow);digitalWrite(2,LOW); // Définissez la broche TX sur LOWdelayMicroseconds(dly3) ; // Délai avant échantillonnage de la largeur d'impulsion // Appliquer un filtre passe-bas au signal pour lisser le canal 1 if (pcounterA>=sthreshold) { smoothedvalue1 =(alpha * smoothedvalue1) + ( (1 - alpha) * pcounterA); } pcounterA =smoothedvalue1;// Channel 2digitalWrite(4,HIGH); // Définir la broche TX sur highdelayMicroseconds(dly1) ; // Délai avant le réglage bas sur la sortie pindigitalWrite(4,LOW); // Définir la broche TX sur lowdelayMicroseconds(dly2) ; // Délai avant échantillonnage de la largeur d'impulsionpcounterB =pulseIn(5,LOW,pwindow);digitalWrite(4,LOW); // Définissez la broche TX sur LOWdelayMicroseconds(dly3) ; // Délai avant échantillonnage de la largeur d'impulsion // Appliquer un filtre passe-bas au signal pour lisser le canal 2 if (pcounterB>=sthreshold) { smoothedvalue2 =(alpha * smoothedvalue2) + ( (1 - alpha) * pcounterB); } pcounterB =smoothedvalue2;// Channel 3digitalWrite(6,HIGH); // Définir la broche TX sur highdelayMicroseconds(dly1) ; // Délai avant le réglage bas sur la sortie pindigitalWrite(6,LOW); // Définir la broche TX sur lowdelayMicroseconds(dly2) ; // Délai avant échantillonnage de la largeur d'impulsionpcounterC =pulseIn(7,LOW,pwindow);digitalWrite(6,LOW); // Réglez la broche TX sur LOW//delayMicroseconds(dly3) ; // Délai avant échantillonnage de la largeur d'impulsion // Appliquer un filtre passe-bas au signal pour lisser le canal 3 if (pcounterC>=sthreshold) { smoothedvalue3 =(alpha * smoothedvalue3) + ( (1 - alpha) * pcounterC); } pcounterC =smoothedvalue3;// Canal 4 digitalWrite(8,HIGH); // Définir la broche TX sur highdelayMicroseconds(dly1) ; // Délai avant le réglage bas sur la sortie pindigitalWrite(8,LOW); // Définir la broche TX sur lowdelayMicroseconds(dly2) ; // Délai avant échantillonnage de la largeur d'impulsionpcounterD =pulseIn(9,LOW,pwindow);digitalWrite(8,LOW); // Définissez la broche TX sur LOWdelayMicroseconds(dly3) ; // Délai avant échantillonnage de la largeur d'impulsion // Appliquer un filtre passe-bas au signal pour lisser le canal 4 if (pcounterD>=sthreshold) { smoothedvalue4 =(alpha * smoothedvalue4) + ( (1 - alpha) * pcounterD); } pcounterD =smoothedvalue4;// Imprimer la valeur puis réinitialiser le compteur/* Serial.print(pcounterA); Serial.print(" "); Serial.print(calav1) ; Serial.print(" "); Serial.print(pcounterB); Serial.print(" "); Serial.print(calav2); Serial.print(" "); Serial.print(pcounterC); Serial.print(" "); Serial.print(calav3) ; Serial.print(" "); Serial.print(pcounterD); Serial.print(" "); Serial.println(calav4);*/// Callibation des seuils à la mise sous tension // Attendre un certain temps pour définir la ligne de base pour chaque bobine if (sample ==false){ calcounter++; } if ( calcounter> (scount-numsamples) ) { // Attendez 90 puis additionnez les échantillons pour préparer le calcul de la moyenne if (pcounterA> sthreshold) { calav1 =calav1 + pcounterA; div1++ ; } if (pcounterB> sthreshold) { calav2 =calav2 + pcounterB; div2++ ; } if (pcounterC> seuil) { calav3 =calav3 + pcounterC; div3++ ; } if (pcounterD> seuil) { calav4 =calav4 + pcounterD; div4++ ; } } if ((calcounter> scount)&&(sample ==false)){ // Définir les seuils calav1 =calav1/div1; calav2 =calav2/div2; calav3 =calav3/div3; calav4 =calav4/div4; // Flash LED pour indiquer que le calibrage est terminé // 0-3 LED bleues[3] =CRGB::Blue; FastLED.show(); retard(t1) ; leds[3] =CRGB::Noir; leds[2] =CRGB::Bleu; FastLED.show(); retard(t1) ; leds[2] =CRGB::Noir; leds[1] =CRGB::Bleu; FastLED.show(); retard(t1) ; leds[1] =CRGB::Noir; leds[0] =CRGB::Bleu; FastLED.show(); retard(t1) ; leds[0] =CRGB::Noir; // 3-0 Leds vertes[3] =CRGB::Vert; FastLED.show(); retard(t1) ; leds[3] =CRGB::Noir; leds[2] =CRGB::Vert; FastLED.show(); retard(t1) ; leds[2] =CRGB::Noir; leds[1] =CRGB::Vert; FastLED.show(); retard(t1) ; leds[1] =CRGB::Noir; leds[0] =CRGB::Vert; FastLED.show(); retard(t1) ; leds[0] =CRGB::Noir; FastLED.show();// Avertisseur sonore // digitalWrite(10,HIGH); // Réglez la broche de sortie sur high pour activer la LED // delay (t1 * 2); digitalWrite(10,LOW); // Réglez la broche de sortie sur high pour activer la LED // Réinitialisez l'indicateur d'échantillon sample =true; compteur =0 ; } if (sample ==true) { updateLEDs(); }// Retour haptique - Si le seuil est dépassé, activez le moteur de vibration pour les cycles de "vduration" if(haptic ==true) { // Si l'indicateur est défini, activez le moteur digitalWrite(12,HIGH); // Réglez la broche de sortie sur high pour activer le moteur de vibration if (vcounter>=1){ vcounter--; // décrémente le compteur }else{ digitalWrite(12,LOW); // Réglez la broche de sortie sur LOW pour désactiver le moteur de vibration haptique =false; // Réinitialiser le drapeau de vibration après le nombre de cycles vcounter =vduration; // Réinitialiser le compteur de vibrations } } }// Subroutinesvoid updateLEDs() {// Afficher les résultats// Violet - Signal cible le plus fort + (Beep Piezo et Haptic Feedback)// Rouge - High + (Haptic Feedback)// Vert - Modéré + (Rétroaction haptique)// Bleu - Signal cible le plus faible// Éteignez toutes les LEDsleds[0] =CRGB::Black;leds[1] =CRGB::Black;leds[2] =CRGB::Black;leds[3] =CRGB::Black;digitalWrite(10,LOW); // Réglez la broche de sortie sur LOW pour désactiver le Piezo SpeakerdigitalWrite(12,LOW); // Réglez la broche de sortie sur LOW pour désactiver le moteur vibrant // *************** Channel 1 if (pcounterA <(calav1*(ledthreshold1))) { // Affichage violet si fort leds cibles[3] =CRGB::Purple; écriture numérique (10, ÉLEVÉ); // Réglez la broche de sortie sur high pour activer le Piezo Speaker haptic =true; } elseif (pcounterA <(calav1*(ledthreshold2))) { // Affichage bleu pour les leds cibles de force modérée[3] =CRGB::Red; haptique =vrai; } elseif (pcounterA <(calav1*(ledthreshold3))) { // Affichage bleu pour les leds cibles de force modérée[3] =CRGB::Green; haptique =vrai; } elseif (pcounterA <(calav1*(ledthreshold4))) { // Ajoute un point de pourcentage supplémentaire au seuil en raison de la sensibilité des leds[3] du canal 1 =CRGB::Blue; } // Affichage du canal 2 if ((pcounterB

Pièces et boîtiers personnalisés

Thingiverse
This cool little Pocket Metal Locator is sensitive enough to identify small nails and tacks in wood and compact enough to fit into awkward spaces making it convenient to carry and use for metal locating.The unit has four independent search coils and color LED indicators making it easy to cover a larger search area quickly while being able to accurately identify the target.This neat little device is self-calibrating with one button operation, rechargeable through a USB port and uses color LEDs, sound and vibration to indicate target strength.Included in the instructable is all of the designs, testing, code and 3D files required to build on your own. I hope you enjoy building and using this as much as I have!!CAD file on thingiverse.com

Schémas

This cool little Pocket Metal Locator is sensitive enough to identify small nails and tacks in wood and compact enough to fit into awkward spaces making it convenient to carry and use for metal locating.

The unit has four independent search coils and color LED indicators making it easy to cover a larger search area quickly while being able to accurately identify the target.

Processus de fabrication

  1. Life Saver
  2. Cisaillage des métaux
  3. Rentabilité du poinçonnage de tôle
  4. Qu'est-ce que le poinçonnage de tôle ?
  5. Machine de métal perforé et applications
  6. Qu'est-ce qu'une Fonderie ?
  7. La formation de bobines métalliques :le refendage de bobines
  8. Un aperçu de la tôle mince
  9. Qu'est-ce que le redressage de la tôle?