theoryCIRCUIT‎ > ‎

Sketch-2

http://sites.prenninger.com/arduino-uno-r3/theorycircuit/sketch-2

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                            Wels, am 2016-11-11

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                            ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
*********************************************************************************************
DIN A4  ausdrucken  (Heftrand 15mm / 5mm)
****************************************************************

20) Home > Arduino Projects > Hall Effect current sensor circuit
ACS712 Strom-Sensor 5..30Amp (pin-A0)    -  Serial

ACS712 hall effekt current sensor module


Hall Effect Current Sensor Module, 5Amps, ACS712T-5
SparkFun Hall-Effect Current Sensor Breakout - ACS712 BOB-08882

Stromsensor für Mikrocontroller
5Amp Stromsensormodul basierend auf dem Hall-Effekt des ACS712TELC-05B Sensorträger auf einer handelsüblichen Platine mit Klemmenleiste zum Anschluss Ihrer Last an Monitor- und Kopfstifte zur Anbindung an Ihren Arduino oder Microcontroller.
Energie: 5Vdc + -0.5V
An Bordstrom-LED
Maßnahmen: positiv zu negativ 5Amps AC oder DC
Empfindlichkeit: 185mV pro Amp
Warnung: Dieser IC verwendet einen Halleffekt und ist anfällig für Magnetfelder!


Die Überwachung des Stromflusses in einem Gerät durch ein Netzgerät ist nur kompliziert.
Da eine kontinuierliche Stromflussüberwachung durch eine Schaltung eine Stromisolation in der Zielvorrichtung erzeugt, müssen wir den Stromfluss messen, ohne die Zielvorrichtung zu beeinflussen.

Wir messen Stromfluss in einer Schaltung, um mehrere Spezifikationen zu berechnen, für einen elektronischen Designer ist es wichtig zu messen und Daten-Protokollierung der aktuellen Ebene in Bezug auf die Zeit, manchmal Multimeter mit Strommessung Glückseligkeit hilft uns, das Gleiche zu messen.
Suchen Sie nach Netzstrom Sensor Schaltung mit Datenprotokollierung, dann ist dieser Artikel hilft Ihnen in besserer Weise.

Die populäre und einfache Methode zur Stromerfassung ist die Hall-Effekt-Stromerfassungsmethode.

Was ist Hall-Effekt?
Wenn ein stromführender Leiter in ein Magnetfeld gebracht wurde, wurde eine Spannung proportional zum Feld erzeugt.
Dies wird als Hall-Effekt bezeichnet.


Fa. Allegro ACS712 Hall Effekt Stromsensor
Hall Effect Current Sensor
Fully Integrated, Hall Effect-Based Linear Current Sensor IC with 2.1 kVRMS Isolation and a Low-Resistance Current Conductor
www.allegromicro.com
http://www.theorycircuit.com/wp-content/uploads/2016/10/ACS712-Datasheet.pdf






Number    Name     Description
1 u. 2    IP+      Terminals for current being sampled; fused internally
3 u. 4    IP–      Terminals for current being sampled; fused internally
5         GND      Signal ground terminal
6         FILTER   Terminal for external capacitor that sets bandwidth
7         VIout    Analog output signal
8         Vcc      Device power supply terminal

Datenblatt ACS721
http://www.theorycircuit.com/wp-content/uploads/2016/10/ACS712-Datasheet.pdf


Strom-Sensor zur AC und DC Strommessung
+/-  5 Ampere ACS712ELCTR-05B-T
+/- 20 Ampere ACS712ELCTR-20A-T
+/- 30 Ampere ACS712ELCTR-30A-T



ACS712 pin-diagramDas ACS712 von Allegro bietet präzise Lösungen für die AC- oder DC-Strommessung, die für Industrie-, Handels- und Kommunikationssysteme geeignet ist.
Das Gerätepaket ermöglicht eine einfache Implementierung durch den Kunden.

Typische Anwendungen sind Motorsteuerung, Lasterkennung und -management, Schaltnetzteile und Überstromschutz.

Das Gerät ist nicht für Automobilanwendungen vorgesehen.

Die Vorrichtung besteht aus einem präzisen, niedrig versetzten linearen Hall-Kreis mit einem Kupferleitungspfad, der sich nahe der Oberfläche der Düse befindet.

Der angelegte Strom, der durch diesen Kupferleitungspfad fließt, erzeugt ein Magnetfeld, das der Hall-IC in eine proportionale Spannung umwandelt.
Die Genauigkeit der Vorrichtung wird durch die Nähe des magnetischen Signals zum Hall-Wandler optimiert.

Eine präzise proportionale Spannung ergibt sich aus dem programmierbaren Low-Offset-Chopper-stabilisierten BiCMOS Hall IC, der für die Genauigkeit (ACS712-datasheet) programmiert ist.

Eigenschaften
▪ Geräuscharmer analoger Signalweg
▪ Die Gerätebandbreite wird über den neuen FILTER-Pin eingestellt
▪ 5 μs Ausgangsanstiegszeit als Reaktion auf Schritt-Eingangsstrom
▪ 80 kHz Bandbreite
▪ Gesamtleistungsfehler 1,5% bei TA = 25 ° C
▪ Kleinstes, flaches SOIC8-Gehäuse
▪ 1.2 mΩ Innenleiterwiderstand
▪ 2.1 kVRMS minimale Isolationsspannung von Stiften 1-4 zu Stiften 5-8
▪ 5,0 V Einzelversorgungsbetrieb
▪ 66 bis 185 mV / A Ausgangsempfindlichkeit
▪ Ausgangsspannung proportional zu AC oder Gleichströmen.


ACS 712 Blockschaltbild




Hier befindet sich der ACS712 Stromsensor ic in einem Breakout Board und verbindet sich mit Current sense Ziellast und Microcontroller.
Der Sensor erkennt den Stromfluss durch IP + und IP- pins (Widerstandsstromleiter), er erzeugt den Hall-Effekt und dann die proportionale Spannungsausgabe über pin-7 (VIout) des ACS712.

Es kann direkt in Mikrocontroller eingegeben werden Analogeingangspin nach den Filteranordnungen.


Differenzstromverstärker

Applikation Nr. 3:
Diese Konfiguration erhöht die Verstärkung auf 610 mV/A  (Getestet mit dem 5 Ampere Sensor  ACS712ELC-05A).

Diese Konfiguration erhöht die Verstärkung auf 610 mV / A.
Für einen oszillierenden Stromausgang hilft diese Differenzverstärkerschaltung, den stationären Zustand Vout zu bringen.

Dies ist eine typische Anwendungsschaltung aus dem Datenblatt.



Interfacing Arduino und ACS712-Anschluss


Hall-Effekt-Strom-Sensor-Arduino


 
ARDUINO Energy Meter
ARDUINO CODE:

// taking 150 samples from sensors with a interval of 2sec and then average the samples data collected
for(int i=0;i<150;i++)
{
sample2+=analogRead(A3); // pin-A3 read the current from sensor
delay(2);
}
sample2=sample2/150;
val =(5.0*sample2)/1024.0;
actualval =val-2.5; // offset voltage is 2.5v
amps =actualval*10;


http://www.instructables.com/id/ARDUINO-ENERGY-METER/step4/Current-Measurement/




Wie bei der Breakout-Applikation wird der Hall-Effekt-Stromsensor mit dem Ziel- und Ausgangssignal verbunden mit dem bekannten Arduino pin-A0 (Analogeingang pin-0) verbunden.
Dieser Sensorausbruch verbraucht Strom aus der Arduino-Stromquelle (+5 und GND). Nach dem Hochladen wird der folgende Arduino-Code hochgeladen, um den Stromfluss zur Last zu messen.

DC-Strommessung Arduino-Code / Sketch:

void setup() {
 
  Serial.begin(9600);
}
 
void loop() {
 
  float average = 0;
  for(int i = 0; i < 1000; i++) {
    average = average + (.0264 * analogRead(A0) -13.51) / 1000;
  
  //5A mode, if 20A or 30A mode, need to modify this formula to 
    //(.19 * analogRead(A0) -25) for 20A mode and 
    //(.044 * analogRead(A0) -3.78) for 30A mode
  
    delay(1);
  }
  Serial.println(average);  
}

Wechselstrommessung Arduino Code / Sketch:


#define CURRENT_SENSOR A0  // Define Analog input pin that sensor is attached
 
float amplitude_current;      // Float amplitude current
float effective_value;       // Float effective current
 
void setup()
{
    Serial.begin(9600);
    pins_init();
}
void loop()
{
    int sensor_max;
    sensor_max = getMaxValue();
    Serial.print("sensor_max = ");
    Serial.println(sensor_max);
    
    //the VCC on the Arduino interface of the sensor is 5v
    
    amplitude_current=(float)(sensor_max-512)/1024*5/185*1000000; // for 5A mode,you need to modify this with 20 A and 30A mode;
    effective_value=amplitude_current/1.414;
    
    //for minimum current=1/1024*5/185*1000000/1.414=18.7(mA)
    //Only sinusoidal alternating current
    
    Serial.println("The amplitude of the current is(in mA)");
    Serial.println(amplitude_current,1);
    
    //Only one number after the decimal point
    
    Serial.println("The effective value of the current is(in mA)");
    Serial.println(effective_value,1);
}
void pins_init()
{
    pinMode(CURRENT_SENSOR, INPUT);
}
/*Function: Sample for 1000ms and get the maximum value from the S pin*/
 
int getMaxValue()
{
    int sensorValue;    //value read from the sensor
    int sensorMax = 0;
    uint32_t start_time = millis();
    while((millis()-start_time) < 1000) //sample for 1000ms
    {
        sensorValue = analogRead(CURRENT_SENSOR);
        if (sensorValue > sensorMax)
        {
            /*record the maximum sensor value*/
            
            sensorMax = sensorValue;
        }
    }
    return sensorMax;
}

Warnung:
Mehrere Milliampere (ab 10mA) genug, um Menschen zu verletzen oder bei 100mA zu töten.



http://www.theorycircuit.com/hall-effect-current-sensor-circuit/





21) Home > Arduino Projects > HB100 Microwave Motion sensor Interfacing Arduino
HB100 HF-Bewegungs-Sensor (pin-8)  -  Serial

Für Elektronik-Circuit-Designer, Makler und Hobbyisten Bewegungserkennung & Messung eines Objekts oder einer Person ist eine einfache Aufgabe mit PIR-Sensor oder Ultraschall-Sensor, aber es ist etwas, was schwierig, die Bewegungsgeschwindigkeit zu messen.
PIR-Bewegungs-Sensor HC-SR501   http://www.theorycircuit.com/pir-sensor-with-arduino/
US-Abstands-Sensor     HC-SR04    http://www.theorycircuit.com/interface-ultrasonic-sensor-hc-sr-04-with-arduino/

Der HB100 Miniature Microwave Bewegungssensor macht es einfach, Bewegung und Geschwindigkeit zu messen.

HB Serie von Mikrowellen-Bewegungssensor-Modul sind X-Band Mono-statische DRO Doppler-Transceiver-Front-End-Modul.
Diese Module sind für Bewegungserkennung wie Eindringlingsalarme, Belegungsmodule und andere innovative Ideen konzipiert.

Das Modul besteht aus Dielektrischer Resonatoroszillator (DRO), Mikrowellenmischer und Patchantenne

Sensorbelegung HB100  10,525 GHz  19,49V bei 1km pro Stunde
Hb100-Pinbelegung


Datenblatt:
http://www.theorycircuit.com/wp-content/uploads/2016/09/HB100_Microwave_Sensor_datasheet.pdf


Eigenschaften
* Geringer Stromverbrauch
* CW oder Pulsbetrieb
* Flaches Profil
* Längenerfassungsbereich
* X-Band Frequenz 10,5 GHz
* Betriebsspannung 4,5 V bis 5,2 V
* DC-Pegel (0,01 bis 0,2 Vdc)
* Fd = 19,49 V (Geschwindigkeit in km / Stunde) oder 31,36 V (V in Meile pro Stunde)

* Fd => Dopplerfrequenz (Wenn sich ein Ziel direkt zu oder von HB100 entfernt (Ft = 10,525 GHz))


Strahlungsmuster




              horizontal                                           vertikal


Die Strahlungsmuster der Antenne und ihre halbe Leistungsstrahlbreite (HPBW)

Das zu montierende Modul mit den Antennenflecken, die der gewünschten Erfassungszone zugewandt sind. Der Benutzer kann die Ausrichtung des Moduls variieren, um die beste Abdeckung zu erhalten.

Doppler-Verschiebung

Doppler-Shiftausgang vom ZF-Terminal bei Bewegungserkennung. Die Größe der Doppler-Verschiebung ist proportional zur Reflexion der übertragenen Energie und liegt im Bereich von Mikrovolt (μV). Ein Verstärker mit hoher Verstärkung ist gewöhnlich mit dem ZF-Anschluß verbunden, um die Dopplerverschiebung auf einen verarbeitbaren Pegel zu verstärken. Die Frequenz der Dopplerverschiebung ist proportional zur Geschwindigkeit der Bewegung. Typisches menschliches Gehen erzeugt Dopplerverschiebung unter 100 Hz. (Hb100_microwave_sensor_datasheet)

HB100 Sensor Breakout-Platine


Satcom & Sensor Systems
ST Electronics
Fa. AgilSense  HB100  Applikation Note MSAN-001
http://www.theorycircuit.com/wp-content/uploads/2016/09/HB100_Microwave_Sensor_datasheet.pdf


Hinweis
     Die abgestrahlten Emissionen von HB100 wurden so konzipiert, dass sie den Anforderungen der Federal Communications Commission (FCC) -Regeln, Teil 15, Abschnitt 15.245 MHz (Nutzung innerhalb eines Gebäudes oder einer offenen Bautür)
     Die Empfangs-Signalstärke (RSS) wird an den Gesamtwege-Wegverlusten von 93dB gemessen.
     Die Rauschspannungen werden von 10 Hz bis 100 Hz am Ausgangsport, innerhalb einer schalltoten Kammer gemessen.
     VORSICHT: ELEKTROSTATISCHES SENSITIVGERÄT. Hinweise für die Handhabung und Lagerung beachten. (HB100_microwave_sensor)

Datenblatt:  HB100 Microwave Sensor Modul
10,525GHz Miniature Microwave Motion Sensor Module
http://www.theorycircuit.com/wp-content/uploads/2016/09/HB100_Microwave_Sensor.pdf



Anschluss von HB100 mit Arduino



Arduino Code / Sketch:


#include “FreqPeriod.h”

double lfrq;
long int pp;

void setup() {
Serial.begin(9600);
  FreqPeriod::begin();
  Serial.println(“FreqPeriod Library Test”);
}

void loop() {
  pp = FreqPeriod::getPeriod();
  if (pp) {
    Serial.print (“period: );
    Serial.print(pp);
    Serial.print( 1/16us / frequency: );

  lfrq = 16000400.0 /pp;
  Serial.print(lfrq);
  Serial.print( Hz );
  Serial.print(lfrq/31.36);
  Serial.println(  Mph );
}
}



https://www.youtube.com/watch?v=PpU7R5LMUs4
https://docs.google.com/document/d/1CVdH3UVTROaJ4_Bgsx_-hyg5_LvoNxYiB13pPRN9gzU/edit
http://interface.khm.de/index.php/lab/interfaces-advanced/frequency-measurement-library/
https://www.pjrc.com/teensy/td_libs_FreqMeasure.html
http://www.limpkin.fr/public/HB100/HB100_Microwave_Sensor_Application_Note.pdf
http://www.theorycircuit.com/wp-content/uploads/2016/09/HB100_Microwave_Sensor_datasheet.pdf
http://www.theorycircuit.com/wp-content/uploads/2016/09/HB100_Microwave_Sensor.pdf

http://www.theorycircuit.com/hb100-microwave-motion-sensor-interfacing-arduino/






22) Home > Arduino Projects > Arduino HMC5883L Magnetometer interfacing
HMC5883L Kompass-Sensor  (pin-A5  SLC  pin-A4  SDA - I2C-Schnittstelle) -  Serial
Arduino HMC5883L 3-Achs Magnetometer Interface

Arduino magnetischer Kompass

 
Müssen Sie den Magnetischen Norden für Ihr Projekt zu identifizieren und verwechselt, was zu tun ist?
Und wie man Magnetometer-Sensor wählen? Hier hilft Ihnen dieser Artikel.

Dieses Projekt verwendet HMC5883L Triple-Achs-Magnetometer von Honeywell, es ist ein Surface Mount (Besser als Breakout-Board kaufen) Multi-Chip-Modul für Low-Field-Magnet-Sensing mit einer digitalen Schnittstelle für Anwendungen wie Low-Cost-Kompassing und Magnetometrie.

Es nutzt I²C (inter integrated circuit) Interface-Technik für die Kommunikation mit Microcontrollern und verbraucht 2,16..3,6 VDC bei geringem Stromverbrauch und es gibt 5 Milli-Guass-Auflösung.


3-Achsen Magnetischer Achsensensor  12-bit
2° Grad Kompass

SparkFun Breakout Board HMC5883L

Draufsicht

Schematische Darstellung der internen Schaltung


Beschreibung:
Dies ist ein Breakout Board für Honeywells HMC5883L, ein 3-Achs Digitalkompass.

Die Kommunikation mit dem HMC5883L ist einfach und erfolgt über eine I2C-Schnittstelle.

Es gibt keinen On-Board-Regler, so dass eine geregelte Spannung von 2,16..3,6 VDC geliefert werden sollte.


Das Breakout Board enthält den HMC5883L Sensor und alle Filterkondensatoren wie abgebildet.
Die Strom- und 2-Leiter Schnittstellenpins werden alle zu einem 0.1 "Pitch-Header ausgebrochen.

SparkFun Triple Axis Magnetometer Breakout - HMC5883L   SEN-10530
https://www.sparkfun.com/products/10530

Honeywell Datenblatt  3-Axis Digital Compaß-IC  HMC5883L
http://www.theorycircuit.com/wp-content/uploads/2016/09/HMC5883L-FDS.pdf


ARDUINO UNO R3  Anschluss


Arduino HMC5883L anschließen


Verbinden Sie die Vcc des Breakout Board mit der Arduino 3.3V Stromquelle und GND mit GND von ARDUINO UNO R3

Verbinden Sie SDA (serielle Datenleitung) mit A4 und SCL (serielle Taktleitung) mit A5 von Arduino, das ist die ganze Verbindung ist vorbei.

Jetzt wandte ich mich an Arduino-Code, bevor die HMC5883L-Bibliothek hier.

Dort finden Sie von einfachem Beispiel, um Sensordaten seriell zu grafischem Magnetkompass unter Verwendung des Verarbeitungscodes zu lesen.



Einfaches Beispiel zum Lesen des Sensors HMC5883L

Arduino-Code / Sketch mit I2C Arduino Library  Wire.h


#include <Wire.h> //I2C Arduino Library

#define address 0x1E //0011110b, I2C 7bit address of HMC5883

void setup(){
  //Initialize Serial and I2C communications
  Serial.begin(9600);
  Wire.begin();
  
  //Put the HMC5883 IC into the correct operating mode
  Wire.beginTransmission(address); //open communication with HMC5883
  Wire.send(0x02); //select mode register
  Wire.send(0x00); //continuous measurement mode
  Wire.endTransmission();
}
  void loop(){
  
  int x,y,z; //triple axis data

  //Tell the HMC5883L where to begin reading data
  Wire.beginTransmission(address);
  Wire.send(0x03); //select register 3, X MSB register
  Wire.endTransmission();
  
 
 //Read data from each axis, 2 registers per axis
  Wire.requestFrom(address, 6);
  if(6<=Wire.available()){
    x = Wire.receive()<<8; //X msb
    x |= Wire.receive(); //X lsb
    z = Wire.receive()<<8; //Z msb
    z |= Wire.receive(); //Z lsb
    y = Wire.receive()<<8; //Y msb
    y |= Wire.receive(); //Y lsb
  }
  
  //Print out values of each axis
  Serial.print("x: ");
  Serial.print(x);
  Serial.print("  y: ");
  Serial.print(y);
  Serial.print("  z: ");
  Serial.println(z);
  
  delay(250);
}

https://github.com/jarzebski/Arduino-HMC5883L



Serieller Anschluss Datenbeispiel des 3-Achsen Sensor HMC5883L



http://www.theorycircuit.com/arduino-hmc5883l-magnetometer-interfacing/







23) Home > Arduino Projects > MyoWare Muscle Sensor Interfacing with Arduino
AT-04-001 EMG Muskel-Sensor  (pin-A0) -  Serial

Fa. MyoWare Muskelsensor in Verbindung mit ARDUINO UNO Rev.3

ARDUINO UNO  Myoware Muskelsensor

Muskel-Sensor-Position

In diesem Artikel werden wir Informationen über Elektromyographie und Interfacing Muskelsensor mit Arduino, Elektromyographie-Technik wird in medizinischen Anwendungen, tragbare Elektronik, Robotik & Prothesen etc .. (Fortsetzung) verwendet.
Wir können diese Elektromyographie in vielen Anwendungen enthalten.

Was ist Elektromyographie?

Die Messung der Muskelaktivierung durch elektrisches Potential, die so genannte Elektromyographie (EMG), wurde traditionell für die medizinische Forschung und Diagnose von neuromuskulären Erkrankungen verwendet.
Jedoch, mit dem Aufkommen der immer schrumpfen noch leistungsfähiger Mikrocontroller und integrierte Schaltungen, haben EMG-Schaltungen und Sensoren ihren Weg in Prothetik, Robotik und andere Kontrollsysteme gefunden (www.AdvancerTechnologies.com)

Fa. MyoWare-Muskelsensor (AT-04-001)   Advancer Technologies
3-lead Muscle / Electromyography Sensor for Microcontroller Application
Datenblatt Fa. MyoWave Muscle Sensor (AT-04-001)
http://www.robotshop.com/media/files/pdf/AT-04-001.pdf



EMG-Muskel-Sensor

 

Hier der Sensor, zum des Muskelaktivierungssignals zu lesen, ist es von den Advancer-Technologien.
Es eignet sich für die Herstellung von Roh-EMG-Signal und Analog-Ausgangssignal für Mikrocontroller-basierte Anwendung,
Dieser Sensor für zuverlässige EMG-Ausgang mit geringem Stromverbrauch konzipiert.

Es arbeitet mit einer einzigen Stromversorgung (+2,9 V bis +5,7 V) mit Verpolschutz, zusätzliches Merkmal in diesem Sensor ist, dass wir die Empfindlichkeit Verstärkung einstellen können.



Sensoraufbau



Aufbauanleitung:
Dieser Sensor eignet sich für tragbares Design und ist kompakt, daher können wir mit Leichtigkeit handhaben, um das Muskelaktivierungssignal zu messen, hier die Beispieldarstellung, die für die Bicep-Muskelmessung gegeben ist (wir können sie am Unterarm verwenden.

Schritte die zu befolgen sind
   
1. Den vorgesehenen Bereich sorgfältig mit Seife reinigen, um Schmutz und Öl zu entfernen.
   
2. Snap-Elektroden an den Snap-Anschlüssen des Sensors
    
(Hinweis: Während Sie den Sensor an den Elektroden befestigen können, nachdem sie auf den Muskel platziert wurden, empfehlen wir dies nicht, da die Gefahr besteht, dass die Haut übermäßig stark beansprucht wird.)
   
3. Stellen Sie den Sensor auf den gewünschten Muskel
    
A. Nachdem Sie festgestellt haben, welche Muskelgruppe Sie anvisieren möchten (z. B. Bizeps, Unterarm, Kalb), reinigen Sie die Haut gründlich.
    
B) Setzen Sie den Sensor so ein, dass sich eine der angeschlossenen Elektroden in der Mitte des Muskelkörpers befindet. Die andere Elektrode sollte in Richtung der Muskellänge ausgerichtet sein.
    
C.Peel von den Rückseiten der Elektroden, um den Kleber freizulegen und sie auf die Haut aufzutragen.
    
D.Setzen Sie die Referenzelektrode auf einen knöchernen oder nicht benachbarten muskulösen Teil Ihres Körpers in der Nähe des gezielten Muskels.
   
4. Verbinden Sie sich mit einem Entwicklungsboard (z. B. Arduino, RaspberryPi), Mikrocontroller oder ADC. (Quelle: www.AdvancerTechnologies.com)
http://www.advancertechnologies.com/



Arduino Muskel-Sensor-Schaltplan



Dieser Sensor ist einfach wie andere, die analoge Ausgangsspannung erzeugen, schließen Sie die Batterie an, um eine separate Stromversorgung für den Sensor und den Trennverstärker (ISO124) zwischen der Arduino-Platine bereitzustellen. Hier stellen Trennverstärker und Batterie Isolation zwischen Benutzer und Stromnetz zur Verfügung. (Empfohlen)



Arduino Muskel-Sensor-Anschluss

 


Ohne separate Batteriequelle zum Sensor und Trennverstärker


Arduino Muskelsensor keine Isolation

 

Arduino-Code
/ Sketch:


/*  AnalogReadSerial  Reads an analog input on pin 0, prints the result to the serial monitor.  Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground. This example code is in the public domain. */

// the setup routine runs once when you press reset:
void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
}

// the loop routine runs over and over again forever:
void loop() {
  // read the input on analog pin 0:
  int sensorValue = analogRead(A0);
  // print out the value you read:
  Serial.println(sensorValue);
  delay(1);        // delay in between reads for stability
}



Verwenden Sie diesen einfachen Code aus Arduino Beispiele zum Messen des Messwertes vom Sensor.

Hier können wir Processing IDE verwenden, um das EMG-Diagramm zu zeichnen.

Diagramm unter Verwendung von Arduino & Processing.

http://www.theorycircuit.com/arduino-serial-data-plotter/


Processing Code (paste in processing IDE)

import processing.serial.*;

Serial myPort;        // The serial port
int xPos = 1;         // horizontal position of the graph
float inByte = 0;

void setup () {
  // set the window size:
  size(400, 300);

  // List all the available serial ports
  // if using Processing 2.1 or later, use Serial.printArray()
  println(Serial.list());

  // I know that the first port in the serial list on my mac
  // is always my  Arduino, so I open Serial.list()[0].
  // Open whatever port is the one you're using.
  myPort = new Serial(this, Serial.list()[0], 9600);

  // don't generate a serialEvent() unless you get a newline character:
  myPort.bufferUntil('\n');

  // set inital background:
  background(0);
}
void draw () {
  // draw the line:
  stroke(127, 34, 255);
  line(xPos, height, xPos, height - inByte);

  // at the edge of the screen, go back to the beginning:
  if (xPos >= width) {
    xPos = 0;
    background(0);
  } else {
    // increment the horizontal position:
    xPos++;
  }
}


void serialEvent (Serial myPort) {
  // get the ASCII string:
  String inString = myPort.readStringUntil('\n');

  if (inString != null) {
    // trim off any whitespace:
    inString = trim(inString);
    // convert to an int and map to the screen height:
    inByte = float(inString);
    println(inByte);
    inByte = map(inByte, 0, 1023, 0, height);
  }
}

http://www.theorycircuit.com/myoware-muscle-sensor-interfacing-arduino/






24) Home > Arduino Projects > Add Sound Detector to Your Arduino Project
BOB-12758  ECM Mikrofon (pin-A0) -  LED (pin-13) - Serial
Schalldetektor  / Schallmelder / Geräuschdetektor mit ARDUINO UNO

Klopfen? Klopfen!
Habt ihr diesen Sound gehört, könnt ihr jetzt eine Sounderkennung zu eurem Arduino Projekt hinzufügen, hier habe ich das SparkFun Electret Mikrofon Breakout Board benutzt, das mit einem kleinen Mikrofon (100Hz .. 10kHz) und einem Vorverstärker aufgebaut ist.

Er erkennt und verstärkt die Geräusche von Türklopfen, Klatschen, Stimme oder anderen Geräuschen, die laut genug sind, um vom Mikrofon aufgenommen zu werden.

Microphone Breakout


Beschreibung:
Dieses kleine Breakout-Board koppelt ein Elektret-Mikrofon (100Hz .. 10kHz) mit einem 60x-Mikrofon-Vorverstärker, um die Geräusche von Stimme, Klatschen, Türklopfen oder Geräusche zu verstärken, die laut genug sind, um von einem Analog- / Digital-Wandler eines Mikrocontrollers aufgenommen zu werden.

 Jeder Breakout wird komplett montiert und arbeitet von 2,7V bis 5,5V.

Der Elektret Mic Breakout übersetzt Amplitude (nicht Volumen) durch Erfassen von Schallwellen zwischen zwei leitenden Platten (eine eine vibrierende Membran und die andere fixiert) im Mikrofon und wandelt sie in elektrische Wellen um.
Diese elektrischen Signale werden dann durch den ADC Ihres Mikrocontrollers verstärkt und aufgenommen.


Fa. SparkFun   Electret Microphone Breakout   BOB-12758  € 5,85
https://www.sparkfun.com/products/12758



Hier die Elektret Mic Kapsel (ECM) Erfassung Schallwelle zwischen zwei leitenden Platten (eine eine bewegliche und die andere fixiert) und Wandlung Schallwellen in elektrische Welle.

Microphone Breakout Schematic  Vcc 3,3V bis 5,0V

Schaltplan

Die elektrischen Signale werden verstärkt und erscheinen im "AUD" - pin der Breakout Board.
Er kann vom ADC des Mikrocontrollers aufgenommen werden.

Der Ausgang am AUD-Pin-Ursprung bei der Hälfte der Versorgungsspannung, daher der ADC, liest idealerweise 1/2 der vollen Skala oder im Fall 512 auf einem 10-bit-ADC.

Arduino MIC Breakout Schaltung




Verbinden Sie den Vcc-Pin und den Ground-Pin der Breakout-Platine mit den Arduino-Stromversorgungspins (+5 und Gnd) und verbinden Sie den AUD-Pin des Breakout-
Boards mit dem Analog-Pin A0 von Arduino.

Vcc -> + 5V
GND -> GND
AUD -> pin-A0

Hier habe ich die Arduino's an Bord LED am digitalen pin-13 verwendet, können Sie alle anderen Pins wie pro Ihre Notwendigkeit.

Arduino Code für Klangerkennung / Sketch:



int
led = 13; int threshold = 600; //Change This int volume; void setup() {                  Serial.begin(9600); // Serial port begin  pinMode(led, OUTPUT);      } void loop() {    volume = analogRead(A0); // Reads the value from the Analog PIN A0    //Serial print level        Serial.println(volume);    delay(100);  if(volume>=threshold){    digitalWrite(led, HIGH); //Turn ON Led  }    else{    digitalWrite(led, LOW); // Turn OFF Led  } }


Versuchen Sie klatschen, Snapping, Tür knallend. Blasen, klopfen etc .., und finden Sie die Änderungen der Ebene in seriellen Monitor und Anpassen der if-Anweisung nach dem Niveau in seriellen Monitor gedruckt.


Andere Version des Arduino-Code



/* 
* This code has been adapted from the 
* Example Sound Level Sketch for the 
* Adafruit Microphone Amplifier   
*/

const int sampleWindow = 250; // Sample window width in mS (250 mS = 4Hz)
unsigned int knock;
int ledPin = 13;

void setup() 
{
   Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

void loop() 
{
 unsigned long start= millis();  // Start of sample window
 unsigned int peakToPeak = 0;   // peak-to-peak level

 unsigned int signalMax = 0;
 unsigned int signalMin = 1024;

 // collect data for 250 miliseconds
 while (millis() - start < sampleWindow)
 {
   knock = analogRead(0);
      if (knock < 1024)  //This is the max of the 10-bit ADC so this loop will include all readings
      {
         if (knock > signalMax)
         {
           signalMax = knock;  // save just the max levels
         }
      else if (knock < signalMin)
        {
         signalMin = knock;  // save just the min levels
         }
     }
 }
 peakToPeak = signalMax - signalMin;  // max - min = peak-peak amplitude
 double volts = (peakToPeak * 3.3) / 1024;  // convert to volts


Serial.println(volts);
 if (volts >=1.0)
 {
  //turn on LED
  digitalWrite(ledPin, HIGH);
   delay(500);
  Serial.println("Knock Knock");
 }
 else
 {
 //turn LED off
 digitalWrite(ledPin, LOW);
 }             
}





25) Home > Arduino Projects > RTC DS-1307 with Arduino
DS1307  RTC Uhren-IC  (pin-A5 SCL   pin-A4  SDA) - Serial


RTC DS-1307 DS 1307 DS1307 mit ARDUINO UNO R3

Jede Echtzeitanwendung benötigt einen RTC-Chip.
In diesem Tutorial können Sie sich Ideen und Wissen über RTC DS 1307 (Echtzeit-Clock-Chip) und Schnittstellen mit Arduino Development Board.

Die DS 1307 RTC IC ist 8pin Dual-Inline-Paket-Chip und es ist sehr einfach zu bedienen mit niedrigen Kosten und leicht verfügbar. Normalerweise zählt dieser IC Datum und Zeit perfekt, es zählt weiter, auch wenn der Stromausfall, wenn die Batterie-Backup zur Verfügung gestellt.
3V-Knopfzellenbatterie, die für die individuelle Versorgung des DS 1307 IC sorgt.

DS 1307 RTC Pinbelegung

DS1307 RTC   IC



Blockschaltbild des DS1307

Blockdiagramm rtc DS1307

Dieses RTC-IC enthält mehr als sieben interne Blöcke, wobei das erste ein Oszillator und ein Teiler ist, das mit dem Standard-32,768-KHz-Quarzkristall verbunden ist, wobei die interne Oszillatorschaltung für den Betrieb mit einem Kristall mit einer spezifizierten Kapazität von 12,5 pF ausgelegt ist.
Der Leistungsregelblock hat Vcc-, Gnd- und Vbat-Pins, hier werden die Vcc- und GND-Pins als Primärstromversorgung verwendet.

Wenn die Spannung innerhalb normaler Grenzen angelegt wird, ist das Gerät vollständig zugänglich und können Daten geschrieben und gelesen werden.
Wenn die angeschlossene Batterieversorgung (Vbat) ohne Primärversorgung gelesen und ge- schrieben wird, bleibt die Zeitfunktion erhalten.

Der DS 1307 RTC kommuniziert mit der externen Welt über das serielle Businterface I²C-Protokoll. SCL (Serial Clock), SDA (Serielle Daten).


MAXIM I2C Real-Time Clock  DS1307  serial real-time clock (RTC)
Datenblatt - DS1307
http://www.theorycircuit.com/wp-content/uploads/2016/06/DS1307.pdf

RTC-Modul  Fa. SparkFun Real Time Clock Module  BOB-12708

Beschreibung:
Dies ist die SparkFun Echtzeituhr (RTC) -Modul, diese kleine Ausbruch, der die DS1307 verwendet, um den Überblick über das aktuelle Jahr, Monat, Tag sowie die aktuelle Uhrzeit zu halten.

Das Modul wird komplett zusammengebaut und enthält eine kleine CR1225 Lithium-Knopfzellen-Batterie, die das RTC für mindestens 9 Jahre (17 Jahre typisch) ohne externe 5V-Stromversorgung betreiben wird.

Der Zugriff auf das DS1307 RTC erfolgt über das I2C-Protokoll. Wir haben ein Test-Bett geschrieben, um die Module zu programmieren.
Dieser Code soll Ihnen einen Einblick geben, wie Sie das Modul an einen beliebigen Mikrocontroller mit unseren Beispiel-Software-I2C- und BCD-Routinen anschließen können.

Diese Umdrehung des Real Time Clock-Moduls fügt schließlich I2C-Widerstände und eine größere Batterie-Pad, um die Probleme mit dem Batterie-Kurzschluss auf die Karte zu beheben.

https://www.sparkfun.com/products/12708



Schaltplan des RTC-Moduls

RTC-Modul Schaltplan

 

Diese RTC-Modul-Schaltung hat nur wenige externe Komponenten wie 32.768 KHz Quarzkristallelement, Filterkondensator 0.1uF und Pullup-Widerstände 4.7KΩ, bietet diese RTC I²C-Adresse etwa 0x68. Dieser kleine Ausbruch, der den DS1307 verwendet, um das aktuelle Jahr, den Monat, den Tag sowie die aktuelle Uhrzeit zu verfolgen. Das Modul wird komplett zusammengebaut und enthält eine kleine CR1225 Lithium-Knopfzellen-Batterie, die das RTC für mindestens 9 Jahre (17 Jahre typisch) ohne externe 5V-Stromversorgung betreiben wird. (Sparkfun)
https://www.sparkfun.com/products/12708

ARDUINO UNO  und RTC DS1307 Anschluss

RTC  DS1307  arduino

Verbinden Sie 5V und Gnd Versorgung Form Arduino Power Pins und sorgfältig verbinden SDA Pin von RTC mit Arduino Analog-Pin A4 und dann SCL-Pin von RTC mit Arduino-Analog-Pin A5. Nun ist das Setup bereit, legte den unteren arduino Code auf sie.


Arduino Code / Sketch  für RTC
  DS1307
#include "Wire.h"
#define DS1307_ADDRESS 0x68
byte zero = 0x00; //workaround for issue #527


void setup(){
  Wire.begin();
  Serial.begin(9600);
  setDateTime(); //MUST CONFIGURE IN FUNCTION
}

void loop(){
  printDate();
  delay(1000);
}

void setDateTime(){

  byte second =      45; //0-59
  byte minute =      40; //0-59
  byte hour =        0; //0-23
  byte weekDay =     2; //1-7
  byte monthDay =    1; //1-31
  byte month =       3; //1-12
  byte year  =       11; //0-99

  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero);

  Wire.write(decToBcd(second));
  Wire.write(decToBcd(minute));
  Wire.write(decToBcd(hour));
  Wire.write(decToBcd(weekDay));
  Wire.write(decToBcd(monthDay));
  Wire.write(decToBcd(month));
  Wire.write(decToBcd(year));

  Wire.write(zero); //start 

  Wire.endTransmission();

}

byte decToBcd(byte val){
// Convert normal decimal numbers to binary coded decimal
  return ( (val/10*16) + (val%10) );
}

byte bcdToDec(byte val)  {
// Convert binary coded decimal to normal decimal numbers
  return ( (val/16*10) + (val%16) );
}

void printDate(){

  // Reset the register pointer
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero);
  Wire.endTransmission();

  Wire.requestFrom(DS1307_ADDRESS, 7);

  int second = bcdToDec(Wire.read());
  int minute = bcdToDec(Wire.read());
  int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
  int weekDay = bcdToDec(Wire.read()); //0-6 -> sunday - Saturday
  int monthDay = bcdToDec(Wire.read());
  int month = bcdToDec(Wire.read());
  int year = bcdToDec(Wire.read());

  //print the date EG   3/1/11 23:59:59
  Serial.print(month);
  Serial.print("/");
  Serial.print(monthDay);
  Serial.print("/");
  Serial.print(year);
  Serial.print(" ");
  Serial.print(hour);
  Serial.print(":");
  Serial.print(minute);
  Serial.print(":");
  Serial.println(second);

}

Dieses Programm ist entworfen, um Zeit im seriellen Terminal von arduino IDE anzuzeigen, Sie können dieses bearbeiten, um Zeit auf LCD anzuzeigen.

http://www.theorycircuit.com/arduino-ide-1-6-9-released/






26) Home > Arduino Projects > Arduino Stepper Motor Interface
L293D  Schritt-Motor-IC  (pin-9, 10, 11, 12) - Serial

ARDUINO UNO  Schrittmotor-Schnittstelle mit H-Brücken-IC L293D


In diesem Projekt werden wir steuern Schrittmotor mit Arduino Board und IC L293D (H-Brücke Motor-Controller), ja, diese L293D IC und Shield können verwendet werden, um Schrittmotor steuern, haben zusätzliche DC-Stromquelle hängt von der Nennspannung des Schrittmotors Sie haben.

Schrittmotor-Arduino-Schnittstelle
Schrittmotor



Ein Schrittmotor oder Schrittmotor ist normaler Gleichstrommotor, aber die Drehung der Ankerwelle in gleich geteilten Schritten und hält die aktuelle Position, wenn die Versorgung nicht gegeben wird, haben die Schrittmotoren die Klassifizierung als Unipolar und Bipolar.

Unipolar Schrittmotor

Unipolar Schrittmotor

Der Unipolar wird mit 5, 6 und 8 Leitungen geliefert und betreibt eine Wicklung mit dem Mittelabgriff pro Phase des Eingangs. Dieses Bild zeigt verschiedene Arten von unipolaren Schrittmotor und seine Leitungen Konfiguration, siehe Datenblatt Ihres Schrittmotors, um mehr zu erfahren.

Bipolare Schrittmotor
Schrittmotor bipolar


Der bipolare Schrittmotor hat eine einzelne Wicklung pro Phase und nur 4 Anschlüsse, um zwei interne Elektromagnetspulen anzuschließen, wobei Vorwärts- und Rückwärtsschritte durch Änderung der Richtung des Stroms durch die Motorspulen erreicht werden können, dies könnte komplizierter als unipolar sein, aber die H- Brücke und Schrittmotor-Treiber-Schaltungen macht es sehr einfach.


Schrittmotor-Controller-Platine
     Stepper motor controller shield

Schrittmotor-Modul Mini L293D


Motor Drive Shield Module Expansion Board for Arduino UNO

Arduino and Stepper Motor Drive Controller Shield Modules L298N and L293D

Motorsteuerung mit einem H-Bridge IC


https://learn.adafruit.com/adafruit-arduino-lesson-15-dc-motor-reversing/lm293d
http://www.arduino-tutorial.de/2010/06/motorsteuerung-mit-einem-h-bridge-ic/


Die Schrittmotorspulen benötigen getrennte DC-Spannung, um zu funktionieren, sie kann nicht laufen, indem man die Mikrocontroller DC-Vorspannung benötigt, deshalb benötigen wir getrenntes Motordiversemodul, um Schrittmotorgeschwindigkeit und Richtungssteuerung zu bedienen.
Dieses Modul enthält die H-Brücke L2913D Motor Treiber IC und bietet Anschlüsse für Motor Bias Vin, GND und A-, A + & B-, B + Anschlüsse für bipolaren Schrittmotor. Sie müssen die Schrittmotor-Klemmen zu identifizieren und dann mit diesem Modul ohne Spannung zu verbinden, hat es an Bord Regler und Spannungsbegrenzer Komponenten. Sie können Separate IC L293D ohne Schirm verwenden.

Arduino Schrittmotoranschluss

Arduino Schrittmotorsteuerung

Schließen Sie die ersten Phasenleiter des Schrittmotors A +, A- an das Motortreibermodul an, das die erste Phase des Schrittmotors mit dem Pin3, 6 des IC L293D verbindet.
Dadurch erhalten Sie den Ausgang 1 und 2 für die erste Phase,
B- an das Modul (zweite Phase des Schrittmotors an Pin 11, 14 des IC L293D) verbinden Sie die separate Gleichspannung in Vin, GND Pin des Motortreibers.




 

ST Datenblatt für IC L293D  Push-Pull four Channel Driver with Diodes

http://www.theorycircuit.com/wp-content/uploads/2015/12/H-bridge_motor_driver_L293D-1.pdf
Hinweis: Datenblatt des IC L293D und Schrittmotors zur Erkennung korrekter Phasenleiter.

Endlich können wir die Arduino-Skizze zur Steuerung des Schrittmotors hochladen, die neue Arduino IDE 1.6.9 verfügt über eine eingebaute Bibliothek für Schrittmotor, können Sie diese Beispiel-Programm verwenden, um Schrittmotor laufen, wenn Sie nicht haben dann google es zum Download der Bibliothek und Beispiele.


http://www.arduino-tutorial.de/2010/06/motorsteuerung-mit-einem-h-bridge-ic/Wie in Beispiel (Verwenden Sie diesen Code, wenn Sie Bipolar Stepper und L298N Dual H-Brücke verwenden)

Arduino-Code / Sketch:


#include <Stepper.h>

const int stepsPerRevolution = 200;  // change this to fit the number of steps per revolution
// for your motor

// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
  // set the speed at 60 rpm:
  myStepper.setSpeed(60);
  // initialize the serial port:
  Serial.begin(9600);
}

void loop() {
  // step one revolution  in one direction:
  Serial.println("clockwise");
  myStepper.step(stepsPerRevolution);
  delay(500);

  // step one revolution in the other direction:
  Serial.println("counterclockwise");
  myStepper.step(-stepsPerRevolution);
  delay(500);
}




Arduino Code Wie pro die Hookup gemacht

(Verwenden Sie diesen Code, wenn Sie Bipolar Schrittmotor und L293D IC verwenden)


#include <Stepper.h>
 
int in1Pin = 12;
int in2Pin = 11;
int in3Pin = 10;
int in4Pin = 9;
 
// change this to the number of steps on your motor
#define STEPS 512
 
Stepper motor(STEPS, in1Pin, in2Pin, in3Pin, in4Pin); 
 
void setup()
{
  pinMode(in1Pin, OUTPUT);
  pinMode(in2Pin, OUTPUT);
  pinMode(in3Pin, OUTPUT);
  pinMode(in4Pin, OUTPUT);
 
  // this line is for Leonardo's, it delays the serial interface
  // until the terminal window is opened
  while (!Serial);
   
  Serial.begin(9600);
  motor.setSpeed(20);
}
 
void loop()
{
  if (Serial.available())
  {
    int steps = Serial.parseInt();
    motor.step(steps);
  }
}


ARDUINO-IDE MENU > File > Examples > Stepper > stepper_oneRevolution

Hinweis:
Wenn der Schrittmotor nicht ordnungsgemäß läuft, überprüfen Sie die Motorleitungen, die er in der Polarität vertauschen kann, und stellen Sie die Anschlüsse nach dem Verweis auf das Datenblatt her.



http://www.theorycircuit.com/arduino-stepper-motor-interface/





27) Home > Arduino Projects > Arduino serial data plotter
SEN-09376 Drucksensor (pin-A0) - Serial

Arduino Serieller Datenplotter

Wir können Graph unter Verwendung empfangener serieller Daten von Arduino Serial Monitor erstellen.
Übertragen Sie Arduino oder echte serielle Daten an den Computer, indem Sie das Verarbeitungsprogramm verwenden und das Ergebnis erhalten.


Drucksensor 12,7mm   100g bis 10kg   Pressure Sensor
http://www.watterott.com/de/Drucksensor-127mm
http://www.openobject.org/physicalprogramming/Image:Sensor_rotary.jpg

SparkFun  Force Sensitive Resistor - Square  SEN-09376    https://www.sparkfun.com/products/9376

Force Sensitive Resistor 0.5"

Wetter-Sensoren  -  SparkFun Weather Meters  SEN-08942  https://www.sparkfun.com/products/8942

Dazu müssen Sie arduino programmieren, um einen Sensor zu lesen und die Daten an den seriellen Port zu leiten.
In unserem Fall verwenden wir Force Sensitive Resistor 0.5 "als analogen Eingangssensor und gerichtete Ausgabe an den seriellen Monitor.


Arduino Code / Sketch zum Lesen des analogen Sensors pin-A0



void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}

// the loop routine runs over and over again forever:
void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// print out the value you read:
Serial.println(sensorValue);
delay
(1); // delay in between reads for stability
}


Processing Code (Einfügen in die Verarbeitung von IDE)


import processing.serial.*;

Serial myPort;        // The serial port
int xPos = 1;         // horizontal position of the graph
float inByte = 0;

void setup () {
  // set the window size:
  size(400, 300);

  // List all the available serial ports
  // if using Processing 2.1 or later, use Serial.printArray()
  println(Serial.list());

  // I know that the first port in the serial list on my mac
  // is always my  Arduino, so I open Serial.list()[0].
  // Open whatever port is the one you're using.
  myPort = new Serial(this, Serial.list()[0], 9600);

  // don't generate a serialEvent() unless you get a newline character:
  myPort.bufferUntil('\n');

  // set inital background:
  background(0);
}
void draw () {
  // draw the line:
  stroke(127, 34, 255);
  line(xPos, height, xPos, height - inByte);

  // at the edge of the screen, go back to the beginning:
  if (xPos >= width) {
    xPos = 0;
    background(0);
  } else {
    // increment the horizontal position:
    xPos++;
  }
}


void serialEvent (Serial myPort) {
  // get the ASCII string:
  String inString = myPort.readStringUntil('\n');

  if (inString != null) {
    // trim off any whitespace:
    inString = trim(inString);
    // convert to an int and map to the screen height:
    inByte = float(inString);
    println(inByte);
    inByte = map(inByte, 0, 1023, 0, height);
  }
}



Setzen Sie den Programmcode in der Verarbeitungsanwendung, seien Sie vorsichtig, Konsolennummer zu wählen, wie im Bild gezeigt, wenn Sie mehr als einen Port vorhanden haben, folgen Sie dem Auftrag als


0 = erster Port (com 1)
1 = zweiter Anschluss (com 6)
2 = dritter Anschluß (com 8)
3 = vierte Öffnung (com 14)

Hier werden die Portnummer com 1,6, ... für Beispiele angegeben, bei denen Sie unterschiedliche Nummern haben können.

Sehen Sie sich den seriellen Monitor von arduino an und wählen Sie die Konsolennummer, die der seriellen Portnummer des seriellen Monitors entspricht, und ersetzen Sie den Index in Serial.list () [0].



Schritte folgen
Schritt 1:
Schließen Sie jeden Sensor mit einer Arduino-Platine an.

Schritt 2:
Sensor-Leseskizze auf Arduino-Platine hochladen (hier der Arduino-Code für den analogen Sensor, der in A0-Pin angeschlossen ist), sollte der Arduino-Code die Ausgabe an den seriellen Monitor "serial.println"

Schritt 3:
Fügen Sie den angegebenen Bearbeitungscode in der Verarbeitung von IDE, wenn Sie nicht über die Verarbeitung von IDE google es zu bekommen ein.

Schritt 4:
Wählen Sie die richtige Konsolennummer aus, wie in diesem Tutorial beschrieben.

Schritt 5:
Jetzt nur Verarbeitungslauf-Option verwenden, erhalten Sie die grafische Ausgabe für den Sensorausgang, der mit arduino verbunden ist.



http://www.theorycircuit.com/arduino-serial-data-plotter/





28) Home > Arduino Projects >
Arduino analog pins to digital explained
LED 5mm rot am Analog-Eingang (pin-A0 = k, pin-A1 = a) - Serial


ARDUINO analoge Pins als digitale Pins in Verwendung

Mit Arduino-Boards in Projekten, auf der Suche nach zusätzlichen digitalen Pins dann diesen Artikel hilft Ihnen, zusätzliche digitale Pins erhalten.

Wenn wir arduino uno, echtes oder duemilanove Brett verwenden, erhalten wir 14 digitale Stifte, wenn wir LCD-Anzeigenmittel fast 8 digitale Stifte verwenden, die durch LCD-Anschlüsse besetzt werden. Daher gibt es Mangel an digitalen Pin steigt.
Durch die Verwendung von einfachen Programm können wir leicht konvertieren analogen Eingang Pin als digitalen Ausgangspin.

Analog-to-digital-neuen Analog-Pin-Digital-Pin-neu

Jedes Arduino-Uno-Board hat analoge Pins von 0 bis 5. Geben Sie die entsprechende digitale Pin-Nummer wie angegeben ein


Analog In 0 pin-A0 = pin-14
Analog In 1 pin-A1 = pin-15
Analog In 2 pin-A2 = pin-16
Analog In 3 pin-A3 = pin-17
Analog In 4 pin-A4 = pin-18
Analog In 5 pin-A5 = pin-19


Deklarieren Sie diese Pin-Zahlen als Integer (int) in arduino Skizze, jetzt machen alle Analog-Pin als digitalen Ausgang Pin.
Diese Pins wirken als nicht pwm digitale Pins.

Wenn Sie PWM-Pins in Arduino-Board verwenden möchten, verwenden Sie die softpwm library
http://www.theorycircuit.com/increasing-arduino-pwm-pins/



Arduino-Code / Sketch:


int ledPin = 15; // pin-A1 ist ident mit pin-15 int gndPin = 14; // pin-A0 ist ident mit pin-14 void setup() { pinMode(ledPin, OUTPUT); pinMode(gndPin, OUTPUT); digitalWrite(gndPin, LOW); } void loop() { digitalWrite(ledPin, HIGH); delay(1000); digitalWrite(ledPin, LOW); delay(1000); }


http://www.theorycircuit.com/arduino-analog-pins-to-digital-explained/






29) Home > Arduino Projects > Arduino Internal temperature sensor
ATmega328p Interner Temperatur-Fühler  - Serial

Arduino Interner Temperaturfühler des ATmega328p

Die meisten AVR-Chips (Mikrocontroller) haben einen internen Temperatursensor, daher können wir diese Option verwenden, um Temperaturbereich in seltenen Zustand zu erhalten, dies könnte mehr als äußere Temperatur zeigen.

Innen-Temperatur des ATMEL ATmega328p auslesen

Liste der AVR-Mikrocontroller mit internem Temperaturfühler,
ATmega168A: Ja
ATmega168P: Ja
ATmega328: Ja
ATmega328P: Ja
ATmega32U4 (Arduino Leonardo): Ja


Verweisen Sie Ihren Arduino Board-Chip, um über den internen Temperatursensor zu wissen.
Die Innentemperatur des Mikrocontrollers variiert je nach Arbeitsbelastung.
Zur Messung der Temperatur in Grad Celsius.

Temperatur = (ADCW - 324,31) / 1,22;


Arduino-Code / Sketch:

// Internal Temperature Sensor // Example sketch for ATmega328 types. void setup() {  Serial.begin(9600);  Serial.println(F("Internal Temperature Sensor")); } void loop() {   // Show the temperature in degrees Celcius.  Serial.println(GetTemp(),1);  delay(1000); } double GetTemp(void) {  unsigned int wADC;  double t; // Die Innentemperatur des IC wird verwendet
   // mit der internen Referenz von 1.1V.
   // Kanal 8 kann mit der Funktion analogRead nicht ausgewählt werden
// Setzen Sie die interne Referenz und den Mux.  ADMUX = (_BV(REFS1) | _BV(REFS0) | _BV(MUX3));  ADCSRA |= _BV(ADEN);  // enable the ADC  delay(20);            // wait for voltages to become stable.  ADCSRA |= _BV(ADSC);  // Start the ADC  // Detect end-of-conversion  while (bit_is_set(ADCSRA,ADSC));   // Reading register "ADCW" takes care of how to read ADCL and ADCH.  wADC = ADCW;   // The offset of 324.31 could be wrong. It is just an indication.  t = (wADC - 324.31) / 1.22;   // The returned temperature is in degrees Celcius.  return (t); }




Anwendungsschritte Arduino Interner Temperatursensor:

Schritt 1: Überprüfen Sie den Arduino Board Chip auf den internen Temperatursensor.
Schritt 2: Verbinden Sie Arduino mit dem System.
Schritt 3: Laden Sie den Arduino-Code für den internen Temperatursensor hoch.
Schritt 4: Erfassen Sie die Temperaturanzeige im Arduino Serial Monitor.






http://www.theorycircuit.com/arduino-internal-temperature-sensor/




DIN A4 ausdrucken
*********************************************************
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE










Comments