Wenzlaff.de – Rund um die Programmierung
mit Java, Raspberry Pi, SDR, Linux, Arduino, Sicherheit, Blender, Statistik, Krypto und Blockchain
Wer beim hochladen des Arduino Nano diesen Übertragungsfehler bekommt:
Könnte es mit einem alten Bootlader (Old Bootloader) versuchen. Es gibt seit Anfang 2018 einen neuen, denn man in der IDE auch auswählen kann:
Wichtig ist auch noch ein Update der AVR Boards auf Version 1.6.21 im Boardverwalter: „Neuer Bootloader für Arduino Nano“ weiterlesen
Dies Programm zeigt die 100 am meisten verwendeten englischen Wörte an. Diese 100 Wörter machen die Hälfte alles geschriebenen in Englisch aus. Allein die ersten 25 Wörter aus der Liste, sind schon ein Drittel alles gedruckten in englisch.
Hier C++ Programm mit der Wortliste und einen Fortschrittsbalken, unter Verwendung der U8gLib. „Arduino Nano Programm und Video: Anzeige der 100 am meisten verwendeten Wörter in Englisch“ weiterlesen
Wie können RFID-Tags eingelesen werden?
Das geht ganz einfach mit einem Arduino Nano und ein 125 kHz EM4100 RFID card reader module (RDM630 UART) das keine 5 Euro inkl. Versand kostet.
Die Belegung des RFID-Readers:
Die PINs:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
1．Pin Definition （WEIGAND26）： 2. Pin definition （TTL interface RS232 data format）： P1： P1： PIN1 DATA0 PIN1 TX PIN2 DATA1 PIN2 RX PIN3 PIN3 PIN4 GND PIN4 GND PIN5 +5V(DC) PIN5 +5V(DC) P2: P2: PIN1 ANT1 PIN1 ANT1 PIN2 ANT2 PIN2 ANT2 P3: P3: PIN1 LED PIN1 LED PIN2 +5V(DC) PIN2 +5V(DC) PIN3 GND PIN3 GND |
Spec RDM630: Baud Rate: 9600bps,N,8,1, Frequenze: 125 kHz, DC 5V (+-5%), <50 mA, Empfangsbereich: 2 bis 5 cm, Checksum card 10byte Data mit XOR
So sieht der Aufbau aus:
Es sind nur 3 Verbindungen zwischen dem Arduino und dem RDM630 nötig und zwar:
|
1 2 3 4 5 |
Arduino Nano: D6 auf PIN 1 des RDM630 (TX) +5v auf PIN 5 des RDM630 (+5 Volt) GND auf PIN 4 des RDM630 (GND) Antenne auf P2 PIN 1 und 2 des RDM630 |
Dann folgende Software RFIDReader.ino auf den Arduino laden, die den Vorteil hat, das die serielle Konsole frei bleibt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 |
/* RFIDReader Beschreibung: Dieses Programm liesst RFID-Tags von Transponer ein und ueberprueft die Checksumme (XOR) und gibt die Nummer auf der Seriellen-Konsole aus wenn die Nummer erkannt wurde gefolgt von einem OK. Folgende Verbindungen sind noetig: Arduino Nano: D6 auf PIN 1 des RDM630 +5v auf PIN 5 des RDM630 (+5 Volt) GND auf PIN 4 des RDM630 (GND) Antenne auf P2 PIN 1 und 2 des RDM630 Serielle Konsole auf 57000 Baud stellen. Compile mit Arduino 1.5.8 IDE. Einstellung: Board Arduino Nano, Prozessor Arduino ATMega328, Programmer USBtinyISP Der Sketch verwendet 8.216 Bytes (26%) des Programmspeicherplatzes. Das Maximum sind 30.720 Bytes. Globale Variablen verwenden 378 Bytes (18%) des dynamischen Speichers, 1.670 Bytes für lokale Variablen verbleiben. Das Maximum sind 2.048 Bytes. Dieses Programm basiert auf dem Beispielprogramm von maniacbug https://maniacbug.wordpress.com/2011/10/09/125khz-rfid-module-rdm630/ Copyright (C) 2015 Thomas Wenzlaff http://www.wenzlaff.de This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see {http://www.gnu.org/licenses/}. */ #include <SoftwareSerial.h> // Pin definitions // Specifies a function to call when an external interrupt occurs. Replaces any previous function that was attached to the interrupt. // Most Arduino boards have two external interrupts: numbers 0 (on digital pin 2) and 1 (on digital pin 3). // The Arduino Mega has an additional four: numbers 2 (pin 21), 3 (pin 20), 4 (pin 19), and 5 (pin 18). const int rfid_irq = 0; // PIN 6 ist auf dem Nano der D6 oder der Pin 9 von rechts, wenn die Stecker rechts liegen const int rfid_tx_pin = 6; // RX wird nicht benoetigt const int rfid_rx_pin = 7; // Untertrueckung von Rauschen bzw. leer Ausgaben, evl. aendern const long LEER = 16843009L; // Baud Rate zum Host PC, evl. aendern const long baudRate = 57600L; // For communication with RFID module SoftwareSerial rfid(rfid_tx_pin, rfid_rx_pin); // Indicates that a reading is now ready for processing volatile bool ready = false; // Buffer to contain the reading from the module uint8_t buffer[14]; uint8_t* buffer_at; uint8_t* buffer_end = buffer + sizeof(buffer); void rfid_read(void); void setup(void) { // Oeffnet die Serielle Verbindung zum Host PC um die Ausgabe der RFID-Tags zu sehen // Geschwindigkeit kann angepasst werden Serial.begin(baudRate); Serial.println("Starte RFID-Reader V. 1.0 von wenzlaff.info"); // Open software serial connection to RFID module pinMode(rfid_tx_pin,INPUT); // muss fest fuer das Modul auf 9600 stehen rfid.begin(9600); Serial.println("OK"); // Listen for interrupt from RFID module. Fallingfor when the pin goes from high to low. attachInterrupt(rfid_irq,rfid_read,FALLING); } void loop(void) { if ( ready ) { // Convert the buffer into a 32-bit value uint32_t result = 0; // Skip the preamble ++buffer_at; // Accumulate the checksum, starting with the first value uint8_t checksum = rfid_get_next(); // We are looking for 4 more values int i = 4; while(i--) { // Grab the next value uint8_t value = rfid_get_next(); // Add it into the result result <<= 8; result |= value; // Xor it into the checksum checksum ^= value; } // Pull out the checksum from the data uint8_t data_checksum = rfid_get_next(); // evl. die Nummer anpassen, oder die if abfrage loeschen if (result != LEER){ if ( checksum == data_checksum ){ Serial.print(result); Serial.println(" OK"); } } // We're done processing, so there is no current value ready = false; } } // Convert the next two chars in the stream into a byte and // return that uint8_t rfid_get_next(void) { // sscanf needs a 2-byte space to put the result but we // only need one byte. uint16_t result; // Working space to assemble each byte static char byte_chars[3]; // Pull out one byte from this position in the stream snprintf(byte_chars,3,"%c%c",buffer_at[0],buffer_at[1]); sscanf(byte_chars,"%x",&result); buffer_at += 2; return static_cast<uint8_t>(result); } void rfid_read(void) { // Only read in values if there is not already a value waiting to be // processed if ( ! ready ) { // Read characters into the buffer until it is full buffer_at = buffer; while ( buffer_at < buffer_end ) *buffer_at++ = rfid.read(); // Reset buffer pointer so it's easy to read out buffer_at = buffer; // Signal that the buffer has data ready ready = true; } } |
Compile mit der Arduino 1.5.8 IDE.
Einstellung in der IDE:
Board Arduino Nano, Prozessor Arduino ATMega328, Programmer USBtinyISP
Serielle Konsole auf 57000 Baud stellen
und einen RFID-Tag an die Antenne halten:
Es wird eine Reichweite von ca. 4 cm erreicht. Wenn die Antenne unter der Schreibtischplatte montiert wird, kann der RFID-Tag sicher gelesen werden, wenn der Tag oben drauf liegt (Anwesendheitskennung).
Habt ihr eine Idee, wie die Reichweite vergrößert werden kann?
Oder einen guten Anwendungsfall?
Als ich diesen Beitrag gelesen hatte, hatte ich Lust, auch mal was mit Firmata zu machen. Mit dem Firmata Protokoll kann man einfach auf alle Ein und Ausgänge zugreifen ohne ein eigenes Protokoll zu entwickeln.
Also einen Arduino Nano aus der Bastelkiste geholt und ihn mit dem Firmata Standard Sketch geflasht. Das wird ja ganz gut in dieser Anleitung beschrieben.
Also über die Arduino IDE den Standard Firmata flashen:
Der neue Arduino-Clone „Schokuino“ wurde mir heute von den lieben Kollegen zum Abschied überreicht. Das Arduino-Logo mit den 2 x + gefällt mir auch besser als das Orginal. Welche CPU da wohl verbaut wurde? Bahlsen-CPU aus Hannover oder eine von Dauerbrot.de? Der Kuchen inkl. Leiterbahnen hat auch sehr lecker geschmeckt.
Da bleibt nach 7 Jahren kein Auge trocken 😉 Danke … keeping in touch …
So, der 4-Phasen-Stepp_Motor ist schon mal gekommen für das nächste Projekt.
Diese techn. Daten soll er haben:
Mit dem Arduino kann leicht auch 230 Volt geschaltet werden. Dazu kann ein Relais an den digitalen Pin 7 und + VCC und – Masse verbunden werden.
In diesem Video kann man hören und sehen, wie das Relais alle 5 Sekunden an und wieder aus geschaltet wird.
Folgendes Sketch ist in den Arduino Nano hochzuladen.
/*
TWRelais
Dieses Programm schaltet das Relais alle 5 Sekunden an und aus.
Thomas Wenzlaff 02.07.2013
Das Relais wir an den digitalen Pin 7 angeschlossen und VCC 5 V und Masse verbunden
Größe des compilierten Programm: 1108 Byte
*/
// An Pin 7 ist eine Relais angeschlossen,
const int RELAIS = 7;
// Die setup Methode wird nur einmal ausgeführt und bei reset
void setup() {
// Digitaler PIN 7 mit der RELAIS ist ein Ausgang
pinMode(RELAIS, OUTPUT);
}
// Die Endlosschleife
void loop() {
digitalWrite(RELAIS, HIGH); // RELAIS anschalten
delay(5000); // 5s warten
digitalWrite(RELAIS, LOW); // RELAIS ausschalten
delay(5000); // 5 Sekunden warten
}
Habe heute einen One-Wire DS18B20 Temperatursensor erhalten und ihn mit dem Arduino Nano verbunden. Der Messbereich des Sensors beträgt von -55°C bis +125°C bei ± 0,5°C Genauigkeit.
Mit den OneWire 2.2 und Dallas Temperature Control Library 3.7.2 Bibliotheken ist die
Temperaturmessung schnell zusammengebaut.
Hier das Foto des Aufbaus mit Schaltplan:
Das Programm (8038 byte) gibt zuerst die eindeutige ID des Sensors aus, (28-A2-9D-8A-04-00-00-2B) und dann jede Sekunde den neuen Messwert:
/*
TWTemp Version 1.0 vom 14.06.2013
8038 bytes
Thomas Wenzlaff http://www.wenzlaff.de
Temperature Sensor DS18B20 an Digitalen Port Pin 2 wie folgt verbunden
Links=Masse,
Mitte=Data,
Rechts=+5V,
3300 to 4700 Ohm Widerstand von +5V nach Data.
Es wird erst die Adresse des 1-Wire-Device ausgegeben und dann wird die Temperaturmessung gestartet.
*/
/* Benötigte Bibliotheken importieren */
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 2 /* Digitalport Pin 2 definieren */
OneWire ourWire(ONE_WIRE_BUS); /* Ini oneWire instance */
DallasTemperature sensors(&ourWire);/* Dallas Temperature Library für Nutzung der oneWire Library vorbereiten */
void setup()
{
delay(1000);
Serial.begin(9600);
Serial.println("Temperatur Messprogramm");
Serial.println("TWTemp 1.0 vom 14.06.2013");
Serial.println("http://www.wenzlaff.de");
delay(1000);
sensors.begin();/* Inizialisieren der Dallas Temperature library */
adresseAusgeben(); /* Adresse der Devices ausgeben */
Serial.print("Starte Temperatur abfragen ...");
}
void loop()
{
Serial.println();
sensors.requestTemperatures(); // Temp abfragen
Serial.print(sensors.getTempCByIndex(0) );
Serial.print(" Grad Celsius");
}
void adresseAusgeben(void) {
byte i;
byte present = 0;
byte data[12];
byte addr[8];
Serial.print("Suche 1-Wire-Devices...\n\r");// "\n\r" is NewLine
while(ourWire.search(addr)) {
Serial.print("\n\r\n\r1-Wire-Device gefunden mit Adresse:\n\r");
for( i = 0; i < 8; i++) {
Serial.print("0x");
if (addr[i] < 16) {
Serial.print('0');
}
Serial.print(addr[i], HEX);
if (i < 7) {
Serial.print(", ");
}
}
if ( OneWire::crc8( addr, 7) != addr[7]) {
Serial.print("CRC is not valid!\n\r");
return;
}
}
Serial.println();
ourWire.reset_search();
return;
}
Um die höchstmögliche Genauigkeit des Sensors auszulesen ist im Setup noch dieser Befehl nötig, damit dauert die Messung aber etwas länger: „Temperatur Messung mit dem DS18B20 und Arduino Nano“ weiterlesen
Das erste Video des Arduino Nano mit dem initialen Testprogramm „Blinkende LED“ läuft am USB Port des Mac und Windows:
