SD-Card-Shield

http://sites.prenninger.com/arduino-uno-r3/sd-card-shield

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2014-11-08

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

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************

Untergeordnete Seiten (7):
Adafruit Logger Shield

ARDUINO Ethernet Shield

ARDUINO SD Datalogger

GPS Shield

SD-Card

SD-Card-Datalogger

SDR-Shield
    SDR = Digital-Radio




3,3V
Stabi-IC
Spannungsstabilisator 3,3
Low-Drop-Spannungsregler
Linear Voltage Regulator
Voltage Regulator


RT9193-33  3,3V / 300mA, Ultra-Low Noise, Ultra-Fast CMOS LDO Regulator (SMD) Fa. RICHTEK Inc. USA
http://datasheet.octopart.com/RT9193-33GB-Richtek-datasheet-14171959.pdf
http://forum.arduino.cc/index.php?topic=176518.0

LP2985-50DBVR  = LP2985-5,0V  5,0V

LP2985-33 DBVR  3,3V / 150mA low-noise low-dropout Regulator with shutdown   1,5% (SMD)  2,2V..16V
LP2985   0.15A,  ADJ low=off Rückstromdiode,
PMIC LP2985-33DBVR SOT-5 Texas Instruments  € 0,68  Conrad 1014296-62
300_c_TI-x_LP2985-33DBVR  3,3V-150mA 1,5% low-noise low-dropout Regulator with shutdown (Datenblatt)_1a.pdf


MCP1700-330 3.3V @ 250mA  ( Ue=2,3V..6V )
LDO Spannungs-Regulator 250mA
The highest current output we could find in a TO-92

Linear-IC MCP1700-3302E/TO TO-92-3 Microchip Technology Ausführung REG LDO 3.3V 0.25A
CONRAD 651408-62
http://www.ladyada.net/wiki/partfinder/vreg

MAX756-CPA   MAXIM

3,3V/5V Adjustable-Output, Step-Up DC-DC Converters
http://datasheets.maximintegrated.com/en/ds/MAX756-MAX757.pdf

LT1302 - Micropower High Output Current Step-Up Adjustable and Fixed 5V DC/DC Converters
http://www.linear.com/product/LT1302

HT-7533  HT7533  Spannungsregler 3,3V / 100mA  HT 7533-1 SMD SOT-89 (Ue = 4,5V..24V)
ELV Art.-Nr.: 68-056535
http://www.elv.at/spannungsregler-3-3v-ht-7533-1-smd-sot-89.html

LM1084IT-3.3 Low-Dropout für 5A, TO-220
LM1085IT-3.3 Low-Dropout für 3A, TO-220
LM1086IT-3.3 Low-Dropout für 1,5A, TO-220

LM3940IMP-3.3 Low-Dropout für 1A, SOT-223
LM3940IS-3.3 Low-Dropout für 1A, TO-263
LM3940IT-3.3 Low-Dropout für 1A, TO-220

LM2937ET-3.3 Low-Dropout für 500mA, TO-220
LM2936Z-3.3 Low-Dropout für 50mA, TO-92

LD1117V33  3,3V Stabi-IC  800mA  TO-220   1%  Low-Drop-Spannungsregler 0,8 A, positiv
http://www.ladyada.net/wiki/partfinder/vreg

78L33 Stabi IC 3.3V Voltage Regulator IC TO-92. 

CONRAD Best.-Nr.: 651408-62

http://www.elektronik-kompendium.de/public/schaerer/ureg3pin.htm
http://rn-wissen.de/wiki/index.php/Spannungsregler

de.sci.electronics-FAQ V2.85 Stand: 5.9.2014

http://www.dse-faq.elektronik-kompendium.de/dse-faq.htma
http://de.wikipedia.org/wiki/Spannungsregler



Referenzspannungsquelle - Temperatur stabile Referenzspannung
Bei 10-bit verwende ich zumeist LM336-5.0, bei hiesigem Klima in der Regel ausreichend.
LM336-2,5 mit 20ppm/K. 

ICL8069 von MAXIM (auch Intersil)10ppm/Grad bei 1,25V Uref
http://pdfserv.maxim-ic.com/en/ds/ICL8069.pdf
REF02   REF-02

LTC6655 1ppm/C drift € 10,00
LM336 ist eine hochstabile Zener-Referenz-Diode mit einer Spannung von 2,490V bei 25°C einstellbar.

Hochgenaue Referenzspannungen immer mit Metallfolien Widerstände (keine Metallfilmwiderstand) Vishay S102CT bauen.
Ein guter Metallfilmwiderstand kann nach einem Jahr bei 40°C Oberflächentemperatur bis zu 0,05...0,1% driften.
Das sind 500..1000ppm ? ? ? http://de.wikipedia.org/wiki/Parts_per_million
Referenzspannungsquelle LM285Z-2,5 - Referenzspannungsquelle im TO-92 Gehäuse
Referenzspannungsquelle LM385BZ-1,2 - Referenzspannungsquelle im TO-92 Gehäuse

http://de.wikipedia.org/wiki/Referenzspannungsquelle
http://forum.arduino.cc/index.php/topic,181573.0.html




1. Metallfolien-Widerstände = Präzisions-Widerstände Vishay-Dale
Temperaturkoeffizient: ±5ppm, ±10ppm, ±90ppm/°C
Widerstandstoleranz: 0,005%, 0,01%, 0,02%, 0,025%, 0,05%, 0,1%, 0,25%, 0,5%, 1%
VISHAY VAR Z-Foil (Rausch-Faktor=0,01) sehr induktionsarm
Das ist Wohl das beste, was es zur Zeit gibt. Rauschen fast nicht mehr messbar, bei -40dB. Leider sehr teuer


Metallfilm-Dehnmeßstreifen
2. Metallfilm-Widerstand (Rausch-Faktor=0,07..0,1)
Oxidfilm-Widerstände (Rausch-Faktor=0,1..1)
Carbonfilm-Widerstände (Rausch-Faktor=1)
Karbonfilm-Widerstände (Rausch-Faktor=0,1)

3. Metallschicht-Widerstände 0,6W 1% (Rausch-Faktor=0,3) nicht für HF Anwendungen


Metalloxid-Widerstände 2% (Rausch-Faktor=0,1..1)

4. Kohleschicht-Widerstände 0,25W 5% 10% (Rausch-Faktor=1)  für HF-Anwendungen
Kohlemasse-Widerständen = Kohlepress-Widerstände              für HF-Anwendungen

5. Draht-Widerstände Wickel-Widerstände (wire-wound) fürs Militär

http://www.elektronikinfo.de/strom/widerstand.htm
http://www.megatron.de/kategorie/praezisions-widerstaende.html





*********************************************************
706_d_ARDUINO-x_Benutzen einer SD-Speicherkarte mit dem ATmega328p Mikrocontroller_1a.pdf

Datenverarbeitung
Meßwerterfassung mit ARDUINO UNO rev3
Daten auf SD-Karte speichern
Datenlogger mit microSD-Karte
Data-Logger Shield for Arduino
Data Logging shield for Arduino



BUCH Arduino Praxiseinstieg  Thomas Brühlmann
6.1.3 Daten auf SD-Karte speichern BUCH-Seite 272

Adafruit Assembled Data Logging shield for Arduino € 22,95  BUCH-Seite 276




277 http://iteadstudio.com/store/index.php?main_page=product_info&cPath=18&products_id=232 Shield SD Card ITead Studio  Stackable SD Card Shield  - SD-Card-Schaltung 3,3V - SD-Card-Adapter
341 http://www.seeedstudio.com/depot/sd-card-shield-for-arduino-v21-p-492.html Shield SD-Card & microSD Card Seeed Studio SD card shield SKU: INT106D1P Messwerterfassung mit SD Card Shield V4.0 Seite 341

http://arduino-info.wikispaces.com/SD-Cards Shield SD-Card-Adapter SD CARD MODULE and STACKABLE SD CARD SHIELD

http://www.amazon.com/Stackable-SD-Card-Shield-Arduino/dp/B006LRR0IQ Shield SD-Card-Adapter iTead   Stackable SD Card Shield for Arduino

http://www.ebay.com/itm/SD-Memory-Card-Kartenleser-Module-Slot-Socket-SPI-Reader-fur-Arduino-ARM-MCU-NEU/ Shield SD-Card-Adapter SD Memory Card Kartenleser Module Slot Socket SPI Reader für Arduino ARM MCU NEU

http://www.hwkitchen.com/products/sd-card-shield-v4-0/ Shield SD-Card-Adapter HW Kitchen = Seeed Studio   SD Card Shield V4.0   
022 http://www.instructables.com/id/Arduino-DIY-SD-Card-Logging-Shield/?lang=de Shield SD-Card-Adapter LC Studio  Arduino DIY SD Card Logging Shield

http://www.physicalcomputing.at/shop/article_A-1137000/SD-Card-Shield-%28von-Seeed-Studio%29.html?shop_param=cid%3D1%26aid%3DA-1137000%26 Shield SD-Card-Adapter Seeed Studio  SD Card Shield 

http://www.seeedstudio.com/wiki/SD_Card_Shield_V3.0 Shield SD-Card-Adapter (wiki) Seeed Studio SD Card Shield V3.0      

http://www.seeedstudio.com/wiki/SD_Card_shield_V4.0 Shield SD-Card-Adapter (wiki) Seeed Studio SD Card shield V4.0
277 http://shop.snootlab.com/lang-en/snootlab-shields/86-memoire.html Shield SD-Card-Adapter & RTC SNOTLAB Mémoire 2.0 (DS1307)   - SD-Card-Schaltung 3,3V

http://snootlab.com/shields-snootlab/541-memoire-20-ds1307-fr.html Shield SD-Card-Adapter & RTC SNOTLAB Mémoire 2.0 (DS1307) Log shield pour Arduino sur carte SD avec horloge RTC et zone de prototypage à pastilles carrées

http://www.adafruit.com/products/243 Shield SD-Card-Adapter & RTC Adafruit Data logging shield for Arduino  PRODUCT ID: 243   mit RTC
276 http://www.ladyada.net/make/logshield/index.html Shield SD-Card-Adapter & RTC Adafruit Data Logger Shield  & RTC            
125 http://www.ladyada.net/make/logshield/rtc.html Shield SD-Card-Adapter & RTC Adafruit Data Logger Shield  & RTC            

http://www.makershed.com/products/data-logging-shield-for-arduino-partially-assembled-version Shield SD-Card-Adapter & RTC +++ Maker Shed Data Logging Shield for Arduino - Partially Assembled Version

https://learn.adafruit.com/adafruit-data-logger-shield Shield SD-Card-Adapter & RTC +++ Adafruit Data Logger Shield  & RTC            





*********************************************************
ALT

Logger Shield: Datalogging for Arduino

von

Adafruit Data logging Shield for Arduino

Data Logging Shield v1 (Adafruit) € 17,95

PRODUCT ID: 243   nicht mehr lieferbar  ALT
Adafruit Data logging shield for Arduino
http://www.adafruit.com/products/243  ALT
http://www.watterott.com/de/Adafruit-Data-Logging-Shield  ALT
http://www.instructables.com/id/Logger-Shield-Datalogging-for-Arduino/all/?lang=de    ALT
http://makezine.com/projects/arduino-data-logging-shield-kit/  ALT



*********************************************************
NEU

Assembled Data Logging shield for Arduino  € 19,95

PRODUCT ID: 1141
Hier ist eine handliche Arduino Schild: Wir haben eine Menge Leute auf der Suche nach einem engagierten und gut konzipierte Datenprotokollierung Schild hatte. Wir haben hart gearbeitet, um eine preiswerte und dennoch gut abgerundeten Design Engineer. Es ist nicht nur einfach zu montieren und passen, es kommt auch mit großen Dokumentation und Bibliotheken. Neu! wir jetzt trägst ein 'montiert' Version dieses Schild, mit allen Komponenten vor, verlötet. Hinweis: Sie müssen nur löten entweder auf Ebene 0.1 "...

https://learn.adafruit.com/adafruit-data-logger-shield

Adafruit Industries Logger Shield

http://www.adafruit.com/search?q=Logger+Shield&b=1



Shield URL: Logger Shield
Tags: storage, sd
Maker: Adafruit Industries

SD-Karten-Schnittstelle arbeitet mit FAT16 oder FAT32 formatiert Karten. 3,3V Pegelumsetzer-Schaltung verhindert Schäden an der SD-Karte.
Echtzeituhr (RTC) hält die Zeit gehen, auch wenn der Arduino nicht angeschlossen ist.
Prototyping-Bereich zum Löten Steckverbinder, Schaltkreise oder Sensoren.
Onboard 3.3V Regler ist sowohl eine zuverlässige Referenzspannung und zuverlässig läuft SD-Karten, die eine Menge Energie zu laufen erfordern.

Open Source: Yes, OSHW-compliant
License: CC BY-SA 2.5
Source: Unknown

http://shieldlist.org/adafruit/logger



Schaltplan Logger Shield
http://www.ladyada.net/make/logshield/design.html







http://www.adafruit.com/blog/2012/05/25/handy-arduino-r3-pinout-diagram/




*********************************************************
dazu
SD-Speicherkarten
Speicherkarten SD-Karte  SD-Card-Adapter microSD-Karte    microSDHC-Karte 32 GB SanDisk   SecureDigital Memory Card 
http://www.elektronik-kompendium.de/sites/com/0906031.htm
704_d_ADAFRUIT-x_Messwerterfassung mit dem ARDUINO und dem Data-Logger-Shield (Testmessungen)_1a.pdf

SanDisk  microSD Memory Card (4 GB SDHC)

mit SanDisk ADAPTER  (microSD auf SD)

FAT32 formatiert

SD-Karten funktionieren nur bei 3,3Vdc



*********************************************************

SD-Card-Shield 3,3V

Adafruit Assembled Data Logging Shield für Arduino € 22,95 (vorhanden)


PRODUCT ID: 1141 für ARDUINO Uno / Duemilanove / Diecimila

adafruit_products_2013_04_06_IMG_1551-1024.jpg


http://www.adafruit.com/products/1141
mit SD-Buchse

https://learn.adafruit.com/adafruit-data-logger-shield

BESSER

Light and temperature data-logger pack

PRODUCT ID: 249
$37.50

http://www.adafruit.com/products/249?&main_page=product_info&cPath=17_21&products_id=249


Data Logging Shield für Arduino
von Adafruit
http://www.amazon.de/Data-Logging-Shield-für-Arduino/dp/B00DDZXAHO
http://oomlout.co.uk/products/arduino-datalogging-shield-adafruit
http://www.pololu.com/product/2770

Beschreibung: 

Hier ist eine handliche Arduino Schild, es ist nicht nur einfach zu montieren und anpassen es sind Bibliotheken und Dokumente vorhanden.
A) https://learn.adafruit.com/adafruit-data-logger-shield

Es sind nurmehr die Stecker-Leisten (besser Stacking Headers dazukaufen) einzulöten.

Speichern von Daten auf jeder  FAT32 formatierte SD-Karte, das von jedem Tabellenkalkulation- oder Analyse-Programm gelesen werden.
Es gibt sogar 2 Muster-Anleitung (Software-Programme) wie man mit dem Shield Daten aufzeichnet.
Die im Lieferumfang enthaltene Real Time Clock-Library kann alle Ihre Daten mit der aktuellen Zeit versehen, so dass Sie genau wissen, was wann passiert ist.

Zusätzlich werden noch eine

Arduino UNO R3 Karte  und eine SD-Karte und für den RTC = ReatTimeClock IC eine Knopf-Batterie CR1220   (Lithium-Battery hält 5 Jahre ist dabei).
Die SD-Karten-Schnittstelle arbeitet mit FAT16 oder FAT32 formatiert Karten.
3,3V Pegelumsetzer-Schaltung verhindert eine Beschädigung der SD-Karte.
Echtzeituhr (RTC) läuft weiter auch wenn der Arduino UNO ist nicht angeschlossen ist. Die Batterie CR1220 hält ca. 5 Jahre.
Enthalten Bibliotheken (Library) und Beispielcode für  SD-Card und RTC-Uhr, damit Sie schnell loslegen können.
In der Mitte ein Prototyping-Bereich zum einlöten von Anschlüsse, Schaltkreise ICs oder Sensoren und Aktoren.
Am Print ist auch ein 3,3 V Spannungs-Regler die für die SD-Karten benötigt wird..
Kompatibel mit Arduino UNO, Duemilanove, Diecimila, Leonardo
Für weitere Informationen, einschließlich Bibliotheken, Schaltpläne und Beispiele finden Sie in der Datenlogger Schild Webseite .

Technische Daten:
Abmessungen (montiert): 70mm x 53mm x 17mm, SD-Karte ragt  10mm vor, Gewicht: 22g
Dieses Data Logging shield nutzt I2C 7-Bit-Adresse 0x68.

https://learn.adafruit.com/adafruit-data-logger-shield

Das Data Logging Shield ist bis auf die Stacking Headers fertig aufgebaut. Die beigelegten Stiftleisten sind aber nur sehr bedingt nutzbar.
Man sollte die Stacking Header  immer dazu kaufen.
ACHTUNG: Es sind 4 unterschiedliche Typen der Header notwendig.

Adafruit Stacking Headers PRODUCT ID: 85   für ARDUINO UNO  € 5,99 (dazu bestellt)

1Stk. 2x6,   2Stk. 1x6,   2Stk. 1x8,  1Stk. 1x10

Adafruit bietet exzellente Tutorials, wie man das Shield benutzen kann.


SD-Card Library schon in der Bibliothek (DEFAULT) vorhanden.
Library SD Card
https://github.com/adafruit/SD

RTC-Uhr Library
Library RTC
https://github.com/adafruit/RTClib

 

Data Logging Shield für Arduino

von Adafruit

Viele Entwickler suchen nach einem erschwinglichen  Data Logging Shield für Arduino.

Das neue Data Logging Shield für Arduino macht es einfach Daten auf FAT16 oder FAT32 formatierten SD Karten zu speichern und zu  lesen.
Adafruit bietet exzellente Tutorials, wie das Shield zu nutzen ist.
Die eingebaute RTC Echtzeit-Uhr erzeugt gültige Zeitstempel, so dass jederzeit verfolgt werden kann, welche Daten wann modifiziert wurden.
Es ist aber ein Arduino UNO R3  notwendig, um das Data Logging Shield zu nutzen (und natürlich eine SD Karte 2..32GB ).
Das Data Logging Shield kommt mit allen Bauteilen gelötet und getestet, hat allerdings keine Stacking-Headers und diese sind auch nicht dabei.
Grundkenntnisse im Löten werden benötigt, um die Headers sauber einzulöten.

- SD Karten Schnittstelle funktioniert mit FAT16 oder FAT32 formatierten Karten 3.3 Voltlevel Shifter Circuitry schützt die SD Karte vor Beschhädigung.
- Echtzeituhr (RTC) läuft 5 Jahre mit CR1220 auch wenn das Shield nicht mit Spannung versorgt wird.
- Platz in der Mitte für Prototyping um Schaltkreise ICs, Sensore und mehr anzuschliessen.
- Tutorial Links und Bibliotheken werden von Adafruit bereitgestellt
- Onboard 3.3 V Regulator (Stabi-IC)
- Läuft mit Arduino UNO, Duemilanove, Diecimila, Leonardo

http://www.adafruit.com/products/1141

Data Logger Shield von Adafruit   Physical Computing AUSTRIA
http://physicalcomputing.at/shop/article_A-1127300/Data-Logger-Shield-Kit.html?shop_param=cid%3D2%26aid%3DA-1127300%26


ARDUINO > Examples > SD Datalogger                    
http://arduino.cc/en/Tutorial/Datalogger

Adafruit  Logger Shield   
http://www.ladyada.net/make/logshield/   http://www.ladyada.net/make/logshield/index.html
besser https://learn.adafruit.com/adafruit-data-logger-shield
ITead Studio  Stackable SD Card Shield                                       http://iteadstudio.com/store/index.php?main_page=product_ibfo&cPath=18&products_id=232
Snootlab  Memoire Shield                                                           http://shop.snootlab.com/lang-en/snootlab-shields/86-memoire.html
Grafik-Anzeige mit Prozessing-IDE (ähnlich Arduino-IDE ist Text)   http://processing.org/download/
Die Bibliothek für das ARDUINO-Board heißt FIRMATA                 http://www.arduino.cc/en/Reference/Firmata  
MENU > SKETCH > IMPORT LIBRARY > FIRMATA  #include <Firmata.h>

C:\Processing-Verzeichnis\Libraries   http://www.arduino.cc/playground/Interfacing/Processing    



*********************************************************
A.1 bis A.10
Eine miserable Automaten-Übersetzung

A.1 Überblick (Overview)

https://learn.adafruit.com/adafruit-data-logger-shield/overview

adafruit_products_2013_04_06_IMG_1551-1024.jpg

Das neue und verbesserte Protokollierung Schild (Datenlogger)

Die neueste Version des  Adafruit Assembled Data Logging Shield hat alle Features des beliebten Originales (Data logging Shield), aber es kommt schon vormontiert.
Speichern von Daten in Dateien auf jedem FAT16 oder FAT32 formatierte SD-Karte, das von jedem Tabellenkalkulation- oder Analyse-Programm gelesen werden kann.
Die Tutorial zeigt Ihnen auch, wie Sie mit den 2 Beispiel Sketches,  Ihre Daten aufzeichnen können.
Der auf der Karte  vorhandene Real Time Clock IC kann alle Ihre Daten mit der aktuellen Zeit, versehen !
Der Datenlogger hat ein zuverlässiges und vielseitiges Design.
Es wird mit ausführlicher  Online-Dokumentation und Bibliotheken unterstützt.
Eigenschaften:
SD-Karten-Schnittstelle arbeitet mit FAT16 oder FAT32 formatiert Karten.
Der vorhandene 3,3 V Pegelumsetzer verhindert eine Beschädigung der SD-Karten.
Echtzeituhr (RTC) hält die Zeit, auch wenn der Arduino  nicht angeschlossen ist. (Backup-Batterie)
Vorhandene Bibliotheken und Beispielcode für SD-Karten  und RTC-Echtzeituhr, vorhanden.
Prototyping-Bereich zum Löten von Anschlüsse, Schaltkreise oder Sensoren.
Konfigurierbare Anzeige-LEDs
Onboard 3,3V Regler ist sowohl eine zuverlässige Referenzspannung und auch für die SD-Karten Spannungsversorgung.
INSTALLATION Die Header
Zuletzt aktualisiert am 2014.08.26


A.2 Installation der Header (Installing The Headers)

https://learn.adafruit.com/adafruit-data-logger-shield/installing-the-headers

Der Adafruit Datenlogger Schild kommt  montiert, getesteten, mit allen Komponenten und microSD-Sockel schon drauf, aber Sie müssen noch müssen noch die Stiftleisten RM 2,54 setzen, so dass Sie es in die Arduino-Buchsenleisten stecken können.

Besser und vernünftiger ist es Sie bestellten zusätzlich die

Adafruit Stacking Headers PRODUCT ID: 85     € 5,99 (dazu bestellt)

1Stk. 2x3     1Stk. 1x6     2Stk. 1x8    1Stk. 1x10    zu montieren.

Arduino Schild Stacking-Header .


adafruit_products_2013_04_06_IMG_1544-1024.jpg

Montage mit Stiftleisten
Wenn Sie jedoch die beigelegten Stiftleisten montieren ist es Ihnen nicht mehr möglich ein weiteres Shield aufzustecken.

Schneiden Sie 1x6    2x8    1x10-pol.  Stiftleisten RM2,54 (Vierkant 0,635mm) 


  • adafruit_products_2013_04_06_IMG_1536-1024.jpg


  • Legen Sie die Header-Abschnitte - lange Stifte nach unten - in die Buchsenleisten auf Ihrem Arduino
.
  • adafruit_products_2013_04_06_IMG_1538-1024.jpg
  • Positionieren Sie das Shield:

    Richten Sie das Schild mit den Header-Pins aus und drücken Sie es an.




Vernünftiger ist die Montage mit Stacking Headers.
1Stk. 2x3     1Stk. 1x6     2Stk. 1x8    1Stk. 1x10
Sie können es mit anderen Schilde wie die Kombination RGB / LCD-Display Schutzschild , um eine kompakte Protokollierung Instrument komplett mit einer Benutzerschnittstelle.
Sie können auch Stack mit einem oder mehreren Proto-Shields , um noch mehr Platz für Prototyping Anbindung an Sensoren hinzuzufügen.
Stapelüberschriften werden von der Spitze des Vorstandes statt unten installiert, so dass das Verfahren ist ein wenig anders als für die Installation von einfachen Stiftleisten.


adafruit_products_2013_04_06_IMG_1533-1024.jpg
  • Positionieren Sie die Kopfzeilen:

    Legen Sie die Stacking-Headers von der Spitze des Schildes, dann drehen Sie das Shield und legen Sie es auf eine ebene Fläche. 
  • Gleichen Sie die Überschriften, so dass sie senkrecht stehen

  • adafruit_products_2013_04_06_IMG_1542-1024.jpg
.
Achten Sie darauf, dass die Stacking-Headers von der Spitze des Shieldes legen, so dass sie von der Unterseite verlötet werden.
  • adafruit_products_2013_04_06_IMG_1543-1024.jpg
  • Verlöten Sie alle Stift sauber für eine solide elektrische Verbindung.

    Tipp: Solder einen Pin von jedem Kopfbereich ein. 
  • Wenn einer von ihnen sind krumm, einfach wieder erwärmen die eine Lötstelle und glätten Sie es mit der Hand. 
  • Nachdem alle Überschriften sind gerade, weiterhin Löten der Rest der Stifte.


Zuletzt aktualisiert am 2014.08.26



A.3 Schild Übersicht  (Shield Overview)

https://learn.adafruit.com/adafruit-data-logger-shield/shield-overview


adafruit_products_overview.jpg

Der Datenlogger-Schild hat ein paar Dinge zu machen eine hervorragende Möglichkeit, Daten zu verfolgen
Oben links - gibt es eine Echtzeituhr (RTC)  auf einen DS1307 Chip, mit einer Backup-Batterie -  mit 4..7 Jahren Lebensdauer.
Mitte links - ein On-Board ein 3,3V Stabi-IC (32C229) damit die SD-Karte reibungslos läuft. Es gibt auch eine grüne PWR (Power)  LED.
Oben Mitte - ein großer SD-Kartenhalter damit können SanDisk  SD / MMC-Speicher  bis zu 32GB verwendet werden.
Für MicroSD-Karte gibt es Adapter.
SD-Karten sind weniger leicht zu verlieren als microSD-Speicher.
Oben rechts - Wir haben zwei Benutzerconfigurable LEDs.
Legen Sie ein Kabel von jedem beliebigen Arduino Pin auf Led1 oder Led2 Pad.
Eine Reset-Taste wird den gesamte Arduino zurückgesetzt, wenn Sie das Board neu starten möchten.
Mitte - Ein Level-Shifter HC4050M (74AHC125N)  schützt die SD-Karte sicher vor  schädigenden 5V Signalen aus dem Arduino.
Es wird nur mit 3V-Signalen gut funktionieren.


adafruit_products_pins.jpg

Wir haben auch oben gezeigt, einige zusätzliche Ausbrüche rund um die Breakout-Board-Bereich


  • 3V - dies ist der 3V aus dem Regler. Es ist eine gute Qualität 3,3 V Referenz, die Sie möglicherweise Leistungssensoren möchten. Bis zu 50 mA zur Verfügung
  • SQ - das ist die optionale Rechteckausgang von der RTC. Sie haben den Befehl, dies zu aktivieren, aber es ist ein Weg, der wahlweise immer ein Präzisionsrechteck senden. Wir benutzen es in erster Linie für die Prüfung
  • WP - das ist der Schreibschutz-Pad auf der SD-Karte, können Sie diese nutzen, um festzustellen, ob der Schreibschutz ist auf der Karte, indem Sie diesen Stift
  • CD - das ist die Karte erkennen Pad auf der SD-Karte. Wenn diese mit Masse verbunden ist, wird die SD-Karte eingesetzt ist. Wir schlagen vor, über die interne Pullup auf einem Arduino Pin, wenn Sie diese Unterlage verwenden wollen
  • CS - das ist die Chip-Select-Pin für die SD-Karte. Wenn Sie brauchen, um die Spur zu Pin 10, weil es widersprüchliche geschnitten wird, kann dieses Pad an einen digitalen Stift gelötet werden und die Software neu hochgeladen
  • L2 und L1 - das sind optionale Benutzer-LEDs. Verbindung zu einem beliebigen digitalen Stift, ziehen hoch, um auf die entsprechende LED einzuschalten. Die LEDs haben bereits 470 Ohm-Widerstände in Reihe.
Zuletzt aktualisiert am 2014.08.26



A.4 Mit Hilfe der Real Time Clock  RTC  (Using the Real Time Clock)

https://learn.adafruit.com/adafruit-data-logger-shield/using-the-real-time-clock

Was ist ein Real Time Clock ?
Bei den Aufzeichnungen gespeicherter Daten, ist es oft sehr sehr nützlich, um Zeitstempel zu haben!
So können Sie Daten in 1 Minute-Schritten  auseinander nehmen (durch Überprüfung der Uhr) oder der Feststellung, bei welcher Tageszeit die Daten protokolliert wurde.

Das Arduino hat eine eingebaute Zeitnehmer genannt millis () und hier einen  Timer auch in den RTC-Chip, auf dem längere Zeiträume wie Minuten oder Tage gemessen werden können.
Also warum sollten Sie einen separaten RTC-Chip haben?
Nun, der wichtigste Grund ist, dass millis () nur angezeigt werden wann der  Arduino UNO zuletzt gestartet wurde - das bedeutet, wenn das Gerät eingeschaltet wird, wird der Millisekunden-Timer wieder auf 0gesetzt.
Das Arduino weiß nicht, den Wochentag "Dienstag" oder das Datum "8. März" alles was es zeigen kann ist "Es sind 14.000 Millisekunden seit dem letzte Mal eingeschaltet vergangen".


Sie müssen 1x Datum und Uhrzeit programmieren, und von diesem Zeitpunkt an wird automatisch gezählt.
Wenn die Batterie nach 4..7Jahren leer ist  blinken 00.00

Der RTC-Chip kann Schaltjahre zählen und weiß, wie viele Tage ein Monat hat, aber keine Sommerzeit korrektur (da von Land zu Land anders)


adafruit_products_Realtimeclock_Motherboard_Baby_AT_crop.jpg

Obiges Bild zeigt z.B eine Computer-Hauptplatine mit einem Real Time Clock IC  DS1387  mit einer eingebauten Lithium-Batterie.



adafruit_products_ds1307_t.jpg
Der RTC der auf dem Shield  benutzt wird ist aber ein  DS1307 .
Der DS1307 ist kostengünstig und wird von der beiliegenden kleinen Knopf-Batterie CR1220  (Lithium-Battery) 4..7 Jahre betrieben.



Lithium-Battery in die Knopfzellen-Halterung geben.
adafruit_products_2013_04_06_IMG_1582-1024.jpg

 

Verbindung mit der RTC DS1307
Der RTC_IC ist ein I2C-Gerät, das heißt er kommuniziert mit 2 Leitungen.  Diese beiden Drähte werden verwendet, um die Zeit einzustellen und die Zeit abzurufen.
Auf der Arduino UNO sind der pin-AE4 (SDA) und pin-AE5 (SCL) für den  I2C-BUS vorgesehen.
http://www.instructables.com/id/Arduino-Aquaponics-Real-Time-Clock-Part-I/#step1
Das ist ein bisschen ärgerlich, da wir statt 6 analoge Eingänge, nur mehr 4 haben (AE0..AE3).

Für die RTC-Library (Bibliothek), verwerden wir eine RTC-Bibliothek von JeeLab.
Bitte laden Sie es jetzt.
Dann installieren Sie es in Ihrem Arduino-Verzeichnis in einem Ordner namens RTClib
RTCLib.h
C:\2014 ARDUINO UNO > arduino-1.0.5-r2-windows > libraries > RTClib > RTClib.h



RTC, erster Test
Das erste, was zu machen ist, ist ein Test mit ds1307.ino, mit dem die Zeit von RTC alle 3 Sekunde gelesen wird.
Wir werden auch zeigen, was passiert, wenn Sie den Akku entfernen, dass bewirkt, dass die RTC zu stoppen.

So zu starten, entfernen Sie die Batterie aus der Halterung während der Arduino ist nicht eingeschaltet oder in den USB angeschlossen ist.
3 Sekunden warten und dann die Batterie ersetzen.
Das setzt die RTC-Chip.

Jetzt laden Sie den folgende Sketch
MENU > Datei > Beispiele > RTClib > DS1307
MENU > Tools > Board > Arduino Uno
MENU > Tools > Serieller Port > COM10  (immer den untersten nehmen)

Stecken Sie auf den Arduino UNO  das Data Logging Shield darauf.

  C:\2014 ARDUINO UNO > arduino-1.0.5-r2-windows > examples >                                               

Code   ds1307.ino   kopieren
Datum und Zeitfunktionen mit einem DS1307 RTC via I2C-und Draht-lib verbunden
// Titel: Setzen von Datum und Uhrzeit bei RTC DS1307
// RTC and RTClib.h - connected via I2C and Wire.h Library
// Autor: Fritz Prenninger
// Datum: 2014-09-02
// Sketch: DS1307_1b.ino
// Version: Arduino 1.0.5-r2
// uC: Arduino UNO Rev3
//
// -------------------------------------------------------------------------------------
// Date and time functions using a DS1307 RTC connected via I2C and Wire lib

#include <Wire.h> // I2C-Bibliothek einbinden
#include "RTClib.h" // RTC-Bibliothek Library von Adafruit einbinden

RTC_DS1307 rtc; // Adafruit RTC Modul

void setup () { // Serielle Ausgabe starten
Serial.begin(57600); // Serielle Ausgabe starten
#ifdef AVR
Wire.begin(); // Initialisiere I2C-BUS
#else
Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
rtc.begin(); // Initialisiere RTC DS1307

if (! rtc.isrunning()) { // Prüfen, ob die RTC DS1307 läuft.
Serial.println("RTC läuft NICHT!!");
// folgende Zeile setzt die RTC-Urzeit auf das Datum und die Uhrzeit des Sketch startes
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
// folgende Zeile stellt die RTC-Uhr auf ein explizite Zeit ein
// rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0)); // Startzeit setzen *Beistrich Leerzeichen Zahl*
// entspricht January 21, 2014 at 3am *wenn gewünscht*


}

Serial.println("Setup abgeschlossen.");

}
  •  
  • void loop () {
    DateTime now = RTC.now(); // Holen Sie sich die aktuelle Zeit
    Serial.print("aktuelle Zeit: ");
    Serial.print(now.year(), DEC); // Die aktuelle RTC-Zeit anzeigen
    Serial.print('/');
    Serial.print(now.month(), DEC);
    Serial.print('/');
    Serial.print(now.day(), DEC);
    Serial.print(' ');
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    // Serial.println();

    Serial.println();
    delay(3000);
    }

    C:\2014 ARDUINO UNO > arduino-1.0.5-r2-windows > examples >                                               

    // Titel: Setzen von Datum und Uhrzeit mit RTC DS1307
    // Beschreibung: RTC and RTClib.h - connected via I2C and Wire.h Library
    // Autor: Fritz Prenninger
    // Datum: 2014-09-02
    // Sketch: Forcing_TIMESET_1b.ino
    // Version: Arduino 1.0.5-r2
    // uC: Arduino UNO Rev3
    //
    // -------------------------------------------------------------------------------------
    // Date and time functions using a DS3231 RTC connected via I2C and Wire Lib

    #include <Wire.h> // I2C-Bibliothek einbinden
    #include "RTClib.h" // RTC-Bibliothek Library von Adafruit einbinden

    RTC_DS1307 RTC; // RTC Modul IC-Bezeichnung

    void setup() {

    Serial.begin(9600); // Serielle Ausgabe mit 9.600 Baud starten

    Wire.begin(); // Initialisiere I2C
    RTC.begin(); // Initialisiere RTC DS1307
    // Check if the RTC is running.
    if (! RTC.isrunning()) { // Prüfen, ob die RTC DS1307 läuft
    Serial.println("RTC läuft NICHT!");
    }


    delay(2000);
    Serial.println("TIMESET erzwingen");
    RTC.adjust(DateTime(2014, 9, 2, 15, 57, 0)); // Startzeit setzen *Beistrich Leerzeichen Zahl*

    // Dieser Abschnitt nimmt die aktuelle Rechnerzeit und vergleicht sie mit
    // der Kompilier-Zeit. Wenn nötig, wird die RTC-Zeit aktualisiert.
    DateTime now = RTC.now();
    DateTime compiled = DateTime(__DATE__, __TIME__);
    if (now.unixtime() < compiled.unixtime()) {
    Serial.println("RTC ist aelter als die Kompilierung!");
    Serial.println("Aktualisierung notwendig!");
    RTC.adjust(DateTime(__DATE__, __TIME__));
    }

    Serial.println("Setup abgeschlossen.");
    }

    void loop() {
    usw. usw. usw.
     C:\2014 ARDUINO UNO > arduino-1.0.5-r2-windows > examples >                                                

    Tiny RTC DS1307 Echtzeituhr mit zusätzlichem Temperatursensor DS18B20


    Tiny RTC DS1307 Echzeituhr mit zusätzlichem Temperatursensor DS18B20 - blog.simtronyx.de

    How to add lots o' storage with microSD (and SD) cards
    Micro SD Card Breakout Board Tutorial




    // Titel: Setzen von Datum und Uhrzeit bei RTC DS1307
    // RTC and RTClib.h - connected via I2C and Wire.h Library
    // Autor: Fritz Prenninger
    // Datum: 2014-09-02
    // Sketch: Tiny_RTC_DS1307_1b.ino
    // Version: Arduino 1.0.5-r2
    // uC: Arduino UNO Rev3
    //
    // -------------------------------------------------------------------------------------
    // Tiny RTC (DS1307) Date and time functions using a DS1307
    // http://blog.simtronyx.de/tiny-rtc-ds1307-echtzeituhr
     
    #include <Wire.h>         // I2C-Bibliothek einbinden
    #include "RTClib.h"       // RTC-Bibliothek einbinden
     
    RTC_DS1307 RTC;      // RTC Modul
     
    void setup(void) {         // Serielle Ausgabe starten
      Wire.begin();            // Initialisiere I2C-BUS
      RTC.begin();             // Initialisiere RTC-BUS


      Serial.begin(9600);   // Serielle Ausgabe starten mit 9.600 Baud
      Serial.println("Starte Datum und Zeit - blog.simtronyx.de");    // Begrüßungstext auf seriellem Monitor ausgeben
      if (! RTC.isrunning()) {                                                          // Prüfen ob RTC läuft    
        RTC.adjust(DateTime(__DATE__, __TIME__));                   // Aktuelles Datum und Zeit setzen, falls die Uhr noch nicht läuft
        Serial.println("Echtzeituhr wurde gestartet und auf Systemzeit gesetzt.");
      }
      else Serial.println("Echtzeituhr laeuft bereits.");
     
    }
     
    void loop(){
      
      DateTime now=RTC.now();    // aktuelle Zeit abrufen
      show_time_and_date(now);   // Datum und Uhrzeit ausgeben
      delay(10000);                       // 10 Sekunden warten bis zur nächsten Ausgabe
    }
     

    String get_day_of_week(uint8_t dow){   // Wochentag ermitteln
      
      String dows="  ";
      switch(dow){
       case 0: dows="So"; break;
       case 1: dows="Mo"; break;
       case 2: dows="Di"; break;
       case 3: dows="Mi"; break;
       case 4: dows="Do"; break;
       case 5: dows="Fr"; break;
       case 6: dows="Sa"; break;
      }
      
      return dows;
    }
     

    void show_time_and_date(DateTime datetime){                      // Datum und Uhrzeit ausgeben
      
        Serial.print(get_day_of_week(datetime.dayOfWeek()));      // Wochentag, Tag.Monat.Jahr
        Serial.print(", ");
        if(datetime.day()<10)Serial.print(0);
        Serial.print(datetime.day(),DEC);
        Serial.print(".");
        if(datetime.month()<10)Serial.print(0);
        Serial.print(datetime.month(),DEC);
        Serial.print(".");
        Serial.println(datetime.year(),DEC);
      
        if(datetime.hour()<10)Serial.print(0);     // Stunde:Minute:Sekunde
        Serial.print(datetime.hour(),DEC);
        Serial.print(":");
        if(datetime.minute()<10)Serial.print(0);
        Serial.print(datetime.minute(),DEC);
        Serial.print(":");
        if(datetime.second()<10)Serial.print(0);
        Serial.println(datetime.second(),DEC);
    }

    Anschliessend starten wir den seriellen Monitor (mit 9600 Baud Geschwindigkeit)

    DS1307-Echtzeituhr – Serieller Monitor

    Jetzt ist es uns möglich auch nach einem Stromausfall (oder nach dem Trennen des Arduinos von der Stromversorgung und einem späteren wieder Anschliessen) trotzdem noch die genaue und aktuelle Zeit, als auch das Datum, anzuzeigen und zu verwenden. Sollte die Uhr (was schon mal passieren kann) nach einiger Zeit falsch gehen, so müssen wir leider die Batterie kurzzeitig entfernen, wieder einsetzen und dann den Sketch erneut aufspielen.

    http://blog.simtronyx.de/tiny-rtc-ds1307-echtzeituhr-mit-zusaetzlichem-temperatursensor-ds18b20/




    1. Öffnen Sie nun das Serial Monitor (Rechts Oben)
    2. Stellen Sie sicher, das rechts unten die Baudrate dem Programm entsprechend  eingestellt ist.
      Serial.begin(57600); = 57600 baud

    Ich verwende 115200 baud


    http://playground.arduino.cc/Deutsch/HomePage


    Immer, wenn die RTC-Chip nicht mit Spannung versorgt wird, wird die Zeit als 0 angezeigt 
    und es wird nicht alle 3 Sekunden gezählt  (Zeitanzeige steht).

    Wann immer Sie die Zeit einstellen, wird der RTC arbeiten.

    ACHTUNG: Nie die Batterie  entfernen, sobald Sie die Zeit eingestellt ist.



    Uhrzeit und Kalenderfunktionen mit einem Echtzeituhrmodul auf Basis des DS1307 und einem Arduino

    Tiny RTC (DS1307) Echtzeituhr und ein Arduino Uno

    I2C-BUS
    Arduino
    (NanoUno)
    Arduino
    (Mega, Mega 2560)
    Tiny RTC-Modul
    DS1307
    5V (VCC) 5V (VCC) VCC
    GND GND GND
    A4 (SDA) D20 (SDA) SDA
    A5 (SCL) D21 (SCL) SCL

    http://blog.simtronyx.de/uhrzeit-und-kalenderfunktionen-mit-einem-echtzeituhrmodul-auf-basis-des-ds1307-und-einem-arduino/



    DS1307 RTC problem setting/reading date:time

    http://adafruit.com/forums/viewtopic.php?f=22&p=97252

    http://playground.arduino.cc/Main/DS1307OfTheLogshieldByMeansOfNTP


    Diese Linie ist sehr nett, was es tut, ist das Datum und die Uhrzeit nach dem Computer, den Sie verwenden (rechts, wenn Sie den Code kompilieren) und verwendet diese, um die RTC zu programmieren.
    Wenn Ihr Computer Zeit nicht eingestellt ist, sollten Sie Recht, dass den ersten fix.
    Dann müssen Sie die Schaltfläche Hochladen zu kompilieren drücken und dann sofort hochladen.
    Wenn Sie kompilieren und laden Sie dann später wird die Uhr um die Menge der Zeit zu sein.

    Dann öffnen Sie die Serienmonitorfenster, um zu zeigen, dass die Zeit eingestellt worden ist


    adafruit_products_RTCsettimegif.gif

    Von nun an haben Sie gewohnt, die Zeit immer und immer wieder ein: die Batterie 5 oder mehr Jahre dauern

    Ablesen der Uhrzeit

    Nun, da die RTC wird munter tickt, werden wir es für die Zeit, die abgefragt werden soll. Schauen wir uns die Skizze wieder zu sehen, wie das gemacht wird

    Code kopieren
    1. Leere loop () {
    2. Datetime now = RTC.now ();
    3. Serial.print (now.year (), DEC);
    4. Serial.print ('/');
    5. Serial.print (now.month (), DEC);
    6. Serial.print ('/');
    7. Serial.print (now.day (), DEC);
    8. Serial.print ('');
    9. Serial.print (now.hour (), DEC);
    10. Serial.print (':');
    11. Serial.print (now.minute (), DEC);
    12. Serial.print (':');
    13. Serial.print (now.second (), DEC);
    14. Serial.println ();
    Es ist ziemlich viel, nur ein Weg, um die Zeit zu bekommen mit der RTClib, die jetzt anrufen (ist), eine Funktion, die ein Datetime-Objekt, das Jahr, Monat, Tag, Stunde, Minute und Sekunde, wenn Sie jetzt genannt () beschreibt zurück.
    Es gibt einige Bibliotheken, die RTC stattdessen Sie so etwas wie RTC.year () und RTC.hour () aufrufen, um das aktuelle Jahr und Stunde.
    Allerdings gibt es ein Problem, wo, wenn Sie geschehen, für die Minute, direkt am 03.14.59 kurz vor der nächsten Minute rollt über fragen, und dann die zweite Straße rechts nach der Minute rollt (so zumin 03.15.00) Sie ' ll sehen die Zeit als die 03.14.00 eine Minute ausgeschaltet ist.
    Wenn Sie tat es in die andere Richtung um Sie herum 03.15.59 bekommen konnte - in die andere Richtung, so 1 Minute aus.
    Denn dies ist nicht ein besonders unwahrscheinlich Auftreten - insbesondere, wenn Sie die Abfrage der Zeit sind ziemlich oft - nehmen wir einen "Schnappschuss" der Zeit aus der RTC auf einmal und dann werden wir es in Tag () oder zweiten ziehen auseinander () wie oben steht. Es ist ein klein wenig mehr Aufwand, aber wir denken, es lohnt sich, Fehler zu vermeiden!


    Unixzeit


    Seit Unix Version 6 zählt die Unixzeit die vergangenen Sekunden seit Donnerstag, dem 1. Januar 1970 00:00 Uhr UTC, wobei Schaltsekunden nicht mitgezählt werden. Dieses Startdatum wird auch als The Epoch (siehe Epoche) bezeichnet.

        Serial.print(" since midnight 1/1/1970 = ");
        Serial.print(now.unixtime());
        Serial.print("s = ");
        Serial.print(now.unixtime() / 86400L);
        Serial.println("d");
       
        // calculate a date which is 7 days and 30 seconds into the future
        DateTime future (now.unixtime() + 7 * 86400L + 30);
       
        Serial.print(" now + 7d + 30s: ");
        Serial.print(future.year(), DEC);
        Serial.print('/');
        Serial.print(future.month(), DEC);
        Serial.print('/');
        Serial.print(future.day(), DEC);
        Serial.print(' ');
        Serial.print(future.hour(), DEC);
        Serial.print(':');
        Serial.print(future.minute(), DEC);
        Serial.print(':');
        Serial.print(future.second(), DEC);
        Serial.println();
       
        Serial.println();
        delay(3000);


    Wir können auch einen "Zeitstempel" aus dem Datetime-Objekt durch Aufrufen von Unixzeit, welche die Anzahl der Sekunden (nicht leapseconds Zählen) seit Mitternacht zählt, 1. Januar 1970
    Code kopieren
    1. Serial.print ("seit 2000 =");
    2. Serial.print (now.unixtime ());
    3. Serial.print ("n =");
    4. Serial.print (now.unixtime () / 86400L);
    5. Serial.println ("d");
    Da gibt es 60 * 60 * 24 = 86.400 Sekunden an einem Tag, können wir leicht zu zählen Tage seitdem als gut.
    Dies könnte nützlich sein, wenn Sie den Überblick, wie viel Zeit seit der letzten Abfrage übergeben behalten wollen, so etwas Mathematik viel einfacher (wie zu überprüfen, ob seine schon 5 Minuten später, nur zu sehen, wenn Unixzeit () wurde um 300 erhöht, Sie nicht Gedanken über Änderungen Stunde Sorge)


    http://de.wikipedia.org/wiki/Unixzeit




    Zuletzt aktualisiert am 2014.08.26





    *********************************************************

    A.5 Mit Hilfe der SD-Karte  (Using the SD Card)

    https://learn.adafruit.com/adafruit-data-logger-shield/using-the-real-time-clock-1

    Die 2. Funktion des Adafruit Datenloggers Schild ist die SD-Karte.
    Auf der SD-Karte kann man langfristig Daten speichern.
    Der Arduino-Chip ATmega328p hat zwar eine permanente EEPROM-Speicher mit nur ein paar hundert Bytes - daher winzig im Vergleich zu einer 2GB..32GB SD-Karte.
    SD-Karten sind so billig und leicht zu bekommen, daher sind SD-Karten die erste Wahl für die Langzeit-Speicherung.
    Das Adafruit Data Logging Shield wird ohne SD-Karte geliefert,
    Karten, die garantiert funktionieren  sind  ORIGINAL SanDisk  / microSD-Speicherkarte (2..32GigaByte SDHC)
    Nicht jede SD-Karte funktioniert, es sollte einem aber bewusst sein das  billige Karten Kopfschmerzen verursachen können.
    adafruit_products_SD102_MED.jpg

    Zum lesen braucht man
    ein externes Lesegerät, einen SD-Kartenleser .


    Formatieren unter Windows 

    Formatieren von F:\  SD-Card     Speicherkapazität: 2GByte     Dateisystem: FAT32      Zuordnungseinheiten: 4096Bytes   Dauert: 8 Minuten
    Wenn Sie eine SD-Karte gekauft haben,  ist diese bereits mit einem FAT-Dateisystem vorformatiert.
    Haben Sie alledings mit der vorformatiert die Karte probleme, oder wenn es sich um eine alte Karte handelt, muss diese neu formatiert werden.
    Die Arduino SD-Bibliothek verwenden / unterstützt sowohl FAT16 und FAT32-Dateisysteme.
    Wenn Sie noch sehr kleine SD-Karte haben, mit 8..32 MegaByte diese sind  evtl. FAT12 formatiert, diese sind  af FAT32 zu formatieren.
    Sie müssen also diese Karte neu formatieren.
    So oder so, es währe ohnehin immer ratsam, die Karte zu formatieren, bevor Sie diese verwenden, auch wenn sie neu sind!
    Beachten Sie, dass durch das Formatieren der Karte alles gelöscht wird.
    Wir empfehlen Ihnen dringend das offiziellen SD-Karte Format-Dienstprogramm zu verwenden.

    Laden Sie die Formatierer von https://www.sdcard.org/downloads/formatter_4/

     Wenn Sie ein Leonardo oder Mega Benutzer sind, müssen Sie die SD-Karte Bibliothek zu aktualisieren, um SD-Karte auf Adafruit Datenloggers Schild verwenden zu können.
    Ihrer Bibliothek zu aktualisieren, folgen Sie den Anweisungen auf dieser Seite .

    Als nächstes wählen Sie den Card Beispiel Skatch   SD card test
    MENU > Datei > Beispiele > SD > CardInfo

    adafruit_products_opencardinfo.gif


    Dieser Skatch kann keine Daten auf die Karte schreiben, sagen Sie, wenn es gelang, sie zu erkennen, und einige Informationen über sie.
    Dies kann sehr nützlich sein, wenn Sie versuchen, herauszufinden, ob eine SD-Karte unterstützt Figur.
    Bevor Sie versuchen, eine neue Karte, versuchen Sie bitte diese Skizze!
    Zum Beginn der Skizze und stellen Sie sicher, dass die Chipselect Linie richtig ist, für den Datenlogger Schild wir sind mit digitalen Stift 10, so bis 10 ändern!





    adafruit_products_cardinfocs.gif

     


    // Titel: SD-Card-Test z.B Speicherkarte SanDisk microSD 2GB SDHC
    // Beschreibung: Prüfung einer SD-Karte, wenn man nicht sicher ist, ob diese auch funktioniert. 
    // Autor: Fritz Prenninger
    // Datum: 2014-09-02
    // Sketch: SD_Card_Test_1b.ino
    // Version: Arduino 1.0.5-r2
    // uC: Arduino UNO Rev3
    //
    // -------------------------------------------------------------------------------------
    /*
      SD card test 
      MENU > Datei > Beispiele > SD > CardInfo.ino
       
    Die Schaltung:
    SD-Karte auf SPI-Bus angeschlossen:
      ** MOSI - pin-11 auf Arduino Uno / Duemilanove / Diecimila
      ** MISO - pin-12 auf Arduino Uno / Duemilanove / Diecimila
      **  CLK - pin-13 auf Arduino Uno / Duemilanove / Diecimila
      **   CS - abhängig von der SD-Karte oder Shield bzw. Modul.

    z.B. auf dem Ethernet-Shield ist der CS-Pin der pin-4

     */

    #include <SD.h>                    // SD-Karten-Bibliothek einbinden

     // Einzurichtende Variablen mit den SD-Utility-Bibliothek Funktionen
    Sd2Card card;
    SdVolume volume;
    SdFile root;

     // Dies ist zu ändern, um Ihre SD-Schild oder Modul anzupassen
     // Arduino Ethernet Shield: pin-4
     // Adafruit SD Schilde und Module: pin-10
     // Sparkfun SD Schild: pin-8
    const int chipSelect = 10;   

    void setup()
    {

      Serial.begin(9600);         // Serielle Ausgabe starten mit 9.600 Baud
       while (!Serial) {              // Warten um die serielle Schnittstelle zu verbinden. Dies braucht nur Leonardo
        ;
      }


      Serial.print("\nInitialisierung der SD-Karte ...   ");
       // Auf dem Ethernet-Shield ist CS-Pin pin-4, er ist als Ausgang Default eingestellt.
       // Beachten Sie, dass, auch wenn es nicht als die CS-Pin, der Hardware SS-Pin verwendet
       // (pin-10 auf den meisten Arduino-Boards, pin-53 auf dem Mega-Boards) muß als Ausgang gesetzt werden
       // sonst wird die SD-Bibliotheksfunktionen nicht funktionieren.
      pinMode(10, OUTPUT);        // von pin-10 auf pin-53 bei einem Mega-Board ändern


       // Wir den Code für die Initialisierung von den Utility-Bibliotheken verwenden
       // Es wird nur getesten, ob die SD-Karte funktioniert!
      if (!card.init(SPI_HALF_SPEED, chipSelect)) {
        Serial.println("Initialisierung fehlgeschlagen. Karte ist zu überprüfen:");
        Serial.println("* Ist eine Karte eingelegt?");
        Serial.println("* Ist Ihr Verdrahtung korrekt?");
        Serial.println("* Haben Sie die ChipSelect pin zu den Shield / oder zum Modul passend geändert?");
        return;
      } else {
       Serial.println("Verdrahtung ist korrekt und eine SD-Karte ist gesteckt.");
      }


      Serial.print("\nCard-Type: ");           // Die Art der Karte / Kartentyp
      switch(card.type()) {
        case SD_CARD_TYPE_SD1:
          Serial.println("SD1");
          break;
        case SD_CARD_TYPE_SD2:
          Serial.println("SD2");
          break;
        case SD_CARD_TYPE_SDHC:
          Serial.println("SDHC");
          break;
        default:
          Serial.println("Unknown");
      }

     // Jetzt werden wir versuchen, das 'Volumen' / 'Partition' zu öffnen - es soll eine FAT16 oder FAT32-Format sein
      if (!volume.init(card)) {
        Serial.println("FAT16 / FAT32-Partition konnte nicht gefunden werden.\nStellen Sie sicher, dass Sie die Karte formatiert habe");
        return;
      }



      uint32_t volumesize;                                     // Die Art und Größe der ersten FAT-Typ-Volumen drucken
      Serial.print("\nDateisystem ist: FAT");
      Serial.println(volume.fatType(), DEC);
      Serial.println();
     
      volumesize = volume.blocksPerCluster();       // Cluster sind Sammlungen von Blöcken
      volumesize *= volume.clusterCount();            // Wir eine Menge von Clustern haben
      volumesize *= 512;                                      // SD-Karte Blöcke sind immer 512 Bytes lang
      Serial.print("Volumen-Groesse (Bytes): ");
      Serial.println(volumesize);
      Serial.print("Volumen-Groesse (KBytes): ");
      volumesize /= 1024;
      Serial.println(volumesize);
      Serial.print("Speicherkapazität (MBytes): ");
      volumesize /= 1024;
      Serial.println(volumesize);
     

     
      Serial.println("\nDateien gefunden auf der Karte (Name, Datum, Zeit, Bytes):");
      root.openRoot(volume);
     
      delay(20000);
     
      root.ls(LS_R | LS_DATE | LS_SIZE);                // Liste aller Dateien auf der Karte mit Datum und Größe

    }


    void loop(void) {

    }


    z.B eine leere SanDisk microSD 2MB Speicherkarte


    Formatieren von F:\ SD-Card Speicherkapazität: 2GByte Dateisystem: FAT32 Zuordnungseinheiten: 4096Bytes Dauert: 8 Minuten

    Initialisierung der SD-Karte ...   Verdrahtung ist korrekt und eine SD-Karte ist gesteckt.
    Card-Type: SD2
    Volume Type ist: FAT32
    Volumen-Groesse (Bytes): 2027028480
    Volumen-Groesse (KBytes): 1979520
    Volumen-Groesse (MBytes): 1933
    Dateien gefunden auf der Karte (Name, Datum, Zeit, Bytes):
    SYSTEM~1/     2014-09-03 13:31:40
      INDEXE~1      2014-09-03 13:31:42 76



    Mega und Leonardo Benutzer!

    Vergessen Sie nicht, sd.begin () ändern, um die Pin-Nummern wie unten angeben

    SD.begin (10,11,12,13);
    OK, jetzt legen Sie die SD-Karte in den Arduino und laden Sie die Skizze

    adafruit_products_2013_04_06_IMG_1551-1024.jpg

    Öffnen Sie den Serial Monitor und geben Sie ein Zeichen in das Textfeld ein (& Hit senden), wenn Sie dazu aufgefordert.
    Sie werden wahrscheinlich so etwas wie die folgenden:

    adafruit_products_cardinfook.gif


    Seine meist Kauderwelsch, aber seine Nutzungs zu sehen, die Volume-Typ ist FAT16 Teil als auch die Größe der Karte (ca. 2 GB, die ist, was es sein sollte) usw.
    Wenn Sie eine schlechte Karte, die mehr mit Abzocke Version von guten Marken passieren scheint, könnten Sie sehen:


    adafruit_products_badsdinfo.gif


    Die Karte meist reagiert, aber die Daten sind alle schlecht. Beachten Sie, dass die Produkt-ID ist "N / A" und es gibt keine Hersteller-ID oder OEM-ID.
    Diese Karte zurück einige SD-Fehler. Seine im Grunde eine schlechte Szene, ich diese Karte halten nur etwa als ein Beispiel für eine schlechte Karte zu verwenden!
    Wenn Sie so etwas wie dies (wo gibt es eine Antwort, aber seine beschädigte) bekommen, sollten Sie die Karte werfen
    Schließlich versuchen Herausnehmen der SD-Karte und den Betrieb der Skizze wieder, werden Sie die folgenden zu bekommen,


    adafruit_products_cardinfonone.gif


    1. Es konnte nicht einmal die SD-Karte zu initialisieren.
    2. Dies kann auch passieren, wenn es ein Fehler oder Löten, wenn die Karte wirklich beschädigt
    3. Wenn Sie mit SD-Karte Probleme, empfehlen wir die Verwendung der oben zuerst genannten SD-Formatierer, um sicherzustellen, dass die Karte ist sauber und einsatzbereit!
    4. VERWENDUNG Die Echtzeituhr für den Mega und Leonardo
    5. Zuletzt aktualisiert am 2014.08.26



    A.5.1  fehlt  (For the Mega and Leonardo)


    A.6 Licht und Temperaturlogger  (Light and Temperature Logger)


    adafruit_products_2013_04_06_IMG_1591-1024.jpg

     

    Einführung
    Die RTC-Uhr und die SD-Karte sind überprüft, sie arbeiten wie gewünscht!

    Wir werden  Temperatur und die relativen Lichtstärken messen und auf SD-Karte speichern.



    A.6.1 Build It!


    adafruit_products_templightloggerparts_LRG.jpg


    Light and temperature data-logger pack

    PRODUCT ID: 249

    Die 2 Sensoren
    Wir werden 2  Sensoren verwenden, um Daten zu protokollieren,
    eine CdS Fotozelle Licht zu verfolgen
    ein Halbleiter Temperatursensor TMP36 (od. LM35)  für die Temperatur.
    Wir haben zwei große Tutorien für diese Sensoren auf unserer Website !

    Wir werden die Sensoren  wie in der folgenden Abbildung dargestellt verbinden, am besten auf mini Breadboard 34x45mm.  2x 5x17=170pin.
    Beachten Sie, dass eine Verbindung auf Aref mit dem linken pin des Temperatursensor und des Lichtsensor auf 3,3V (nicht auf 5,0V)
     - wir tun dies, weil die 5,0V Leitung ist störanfälliger und die 3,3V  ist wesentlich besser gefiltert.

    LEDs fehlen im fritzing Schaltbild
    LED rot  pin-A2 - 330R - GND    zeigt Fehler an z.B. SD-Karte fehlt
    LED grün pin-A3 - 220R - GND    zeigt Messungen an



    adafruit_products_Logger_bb.jpg


    Bei Fix-Verdrahtung
    Die Prototyping-Bereich auf der Platine ist eine einfache Anordnung von Löchern mit Lötpads.

    Die folgenden Schritte zeigen, wie wir diese Schaltung gebaut und veranschaulichen einige einige Grundschaltung Prototyping-Techniken.

    Aus Gründen der Übersichtlichkeit werden wir die gleiche Farbe Draht verwenden, wie im Schaltplan oben gezeigt:


    adafruit_products_2013_04_06_IMG_1589-1024.jpg
    Zuletzt aktualisiert am 2014.08.26




    A.6.2 Verwenden Sie es!  ( Use It !)

    Sensortest

      Mit diesen Sketch werden die beiden Sensoren getestet die beiden Beispiele sind zu finden in unseren Tutorials

    C:\2014 ARDUINO UNO > arduino-1.0.5-r2-windows > examples >  


    // Titel: Light and Temperature Logger mit Adafruit Data Logging Shield 1141
    // RTC DS1307 SD-Card TMP36 (LM35) CdS Fotozelle (LDR05)
    // Autor: Fritz Prenninger
    // Datum: 2014-09-02
    // Sketch: Sensor_Test-Sketch_1c.ino
    // Version: Arduino 1.0.5-r2
    // uC: Arduino UNO Rev3
    //
    // -------------------------------------------------------------------------------------
    /* Sensor test sketch
    für weitere Informationen siehe http://www.ladyada.net/make/logshield/lighttemp.html
    */

    #define aref_voltage 3.269 // prüfen der Aref-Spannung mit einem Multimeter = 3,301V
    // Laut Vergleichs-Thermometer aber Eintrag 3.269 notwendig
    int photocellPin = 0; // der CdS und 10k Pulldown-Widerstand wird auf pin-A0 verbunden
    int photocellReading; // analoges Lesen von dem analogen Widerstandsteiler

    // TMP36 Pin Variables
    int tempPin = 1; // der mittlere-pin des TMP36 Vout (sense) ist mit pin-A1 verbunden
    // die Auflösung beträgt 10mV / °C mit einem
    // 500mV Offset für negative Temperaturen
    int tempReading; // pin-A1 Lesen vom Temp-Sensor
    void setup(void) {

    Serial.begin(9600); // Informationen zu dem seriellen Monitor senden mit 9.600 Baud

    analogReference(EXTERNAL); // Wenn Sie die Aref auf etwas anderes als 5,0V einstellen wollen
    }

    void loop(void) {
    photocellReading = analogRead(photocellPin);
    Serial.print("Helligkeit WERT = ");
    Serial.print(photocellReading); // die rohen Analogdaten
    // ein paar Trigger-Schwellen um die Helligkeit zu bewerten
    if (photocellReading < 10) {
    Serial.println(" * dunkel *");
    } else if (photocellReading < 300) {
    Serial.println(" ** Dämmerung **");
    } else if (photocellReading < 600) {
    Serial.println(" *** Licht ***");
    } else if (photocellReading < 800) {
    Serial.println(" **** hell ****");
    } else {
    Serial.println(" ***** sehr hell *****");
    }

    tempReading = analogRead(tempPin);
    Serial.print("Temperatur WERT = ");
    Serial.print(tempReading); // die eingelesenen rohen Analogwerte
    // Umwandlung von rohDaten auf Spannungswerte - Referenzspannung basiert
    float voltage = tempReading * aref_voltage / 1024;

    Serial.print(" = "); // print out the voltage
    Serial.print(voltage); Serial.println(" Volt"); // Spannung ausgeben
    // Temperatur ausgeben
    float temperatureC = (voltage - 0.5) * 100 ; // TMP36 Umwandlung von 10mV/gradC mit 0,5V Offset
    // In Grad ((volatge - 500mV) mal 100)
    Serial.print(temperatureC); Serial.println(" gradC"); // Anzeige in Grad Celsius
    float temperatureF = (temperatureC * 9 / 5) + 32; // in Fahrenheit konvertieren
    Serial.print(temperatureF); Serial.println(" gradF"); // Anzeige in Fahrenheit Grade
    delay(10000); // 10 Sec. Verzoegerung
    }



    Laden Sie obigen Sketch und überprüfen Sie die Daten im Seriellen Monitor.
    Helligkeit WERT = 707 ****  hell  ****
    Temperatur WERT = 218 = 0.70 Volt
    19.59 gradC
    67.27 gradF



    In meinem Arbeitszimmer, ich habe etwa 20 ° C und eine Lichtmessung von etwa 700 -

    der Temperatursensor ist auf +/- 0,3°C genau,

    Der Lichtsensor ist nicht genau und liefert nur grobe Messwerte .


    Wenn bisher alles funktioniert kann man zur Protokollierung kommen.

     

    Protokollierung Skizze

    GitHub

    /Light-and-Temp-logger

    Download the light and temperature logging sketch from GitHub.

    https://github.com/adafruit/Light-and-Temp-logger

    lichttemplogger.pde


    Legen Sie eine  SD-Karte ein. Laden Sie den Sketch   Light_and_Temp_Logger_1a   in Ihren Arduino UNO. 

    Während die ARDUINO UNO  noch angeschlossen ist, er blinkt, legen Sie Ihre Hand über die Fotozelle für ein paar Sekunden,

    dann leuchten Sie mit einer Taschenlampe auf die CdS Fotozelle. 

    Sie sollten auch den Temperatursensor mit den Fingern erwärmen.


    Plotten mit einem Tabellenkalkulations

    Wenn Sie die Daten auslesen möchten, stecken Sie den Arduino UNO ab und entnehmen Sie die SD-Karte un stecken diese in den Kartenleser Ihres Computers. 

    Sie werden einen *.csv-File im Laufwerk SD Card  F:\     vorfinden.

    Logger00.csv

    ; Strich-Punkt           " Anführungsstriche




    // Eine einfacher Datenlogger

    // Analog-Pin / pin-A0 / CdS Fotowiderstand
    finster 33=33,13Vcc
    Dämmerung 414=2,71Vcc
    hell 712 1,58Vcc
    Sonne 1006 1,12Vcc

    // Analog-Pin / pin-A1 / Temperatur-IC TMP36 = LM35
    22,85 °C

    // Datenprotokollierung alle 10000 ms (alle 10 Sekunde)


    milliS UnixZeit
    DateTime Licht
    Temp Vcc
    998 946684800 "2000/1/1 0:0:0" 696 70.78 1.62
    1999 946684800 "2000/1/1 0:0:0" 697 70.78 1.61
    2999 946684800 "2000/1/1 0:0:0" 697 70.78 1.61
    3999 946684800 "2000/1/1 0:0:0" 696 70.78 1.61
    5000 946684800 "2000/1/1 0:0:0" 697 70.78 1.62
    5998 946684800 "2000/1/1 0:0:0" 696 70.78 1.62
    7000 946684800 "2000/1/1 0:0:0" 696 70.78 1.62
    7999 946684800 "2000/1/1 0:0:0" 696 70.78 1.62
    8998 946684800 "2000/1/1 0:0:0" 696 70.78 1.62



                                                                                                                                                                                                                      

    adafruit_products_loggerfiles.gif

    Wir werden die jüngste öffnen. Wenn Sie die gleiche Protokolldatei in der Grafik Demos verwendet verwenden möchten, klicken Sie bitte hier, um es herunterzuladen .

    Der schnellste Weg, um die Daten anschauen wird mit so etwas wie Openoffice oder Excel, in dem Sie die CSV-Datei öffnen können und haben es direkt in die Tabellenkalkulation importiert

    adafruit_products_csvimport.gif

    Sie können dann eine Grafik, indem Sie die Datenspalten

    adafruit_products_dataselect.gif

    Wenn Sie auf die Schaltfläche Diagramm und mit Lines (wir denken, sie sind die besten für solche Graphen)

    adafruit_products_charttype.gif

    Einstellung der ersten Spalte als Etiketten

    adafruit_products_datarange.gif
    adafruit_products_dataseries.gif

    Was wird diese Grafik erzeugen

    adafruit_products_oochart.gif

    Sie können ziemlich klar, wie ich den Sensor und schattiert dann leuchtete mit einer Taschenlampe auf sie zu sehen.

    Sie können die Diagrammanzeige sowohl mit verschiedenen Achsen (zu machen, da die Änderung der Temperatur ist eine andere Gruppe von Einheiten. Wählen Sie die Temp Linie (rot) mit der rechten Maustaste und wählen Datenreihen formatieren. In der Registerkarte Optionen Richten Datenreihe Sekundär Y-Achse.

    adafruit_products_secondary.gif
    Oder Sie können eine andere Grafik mit nur temporären Daten machen


    adafruit_products_ootempchart.gif
    Jetzt können Sie deutlich, indem es zwischen meinen Fingern sehen können, wie ich aufgewärmt den Sensor

    Mit Gnuplot

    Gnuplot ist ein kostenlos (aber nicht Open Source?), Ultra-leistungsstarken Plot-Programm. Es ist auch eine echte Schmerzen zu bedienen! Aber wenn Sie sich nicht leisten können eine professionelle math / Plotten Paket wie Mathematica oder Matlab, Gnuplot kann eine Menge tun!

    Wir sind nicht gut genug, um eine vollständige Anleitung, gnuplot bieten, hier sind ein paar Links, die wir gefunden handlich. Google wird auf jeden Fall helfen, noch mehr Tutorials und Links. Ausmisten etwa ist der beste Lehrer, auch!

    Wir fanden die folgenden Befehle, um eine nette Grafik dieser Daten generieren ausgeführt ist, lesen Sie LOGTEST.CSV im gleichen Verzeichnis wie wgnuplot.exe setzen (oder, wenn Sie wissen, wie man Verzeichnisse verweisen, können Sie es an anderer Stelle setzen)


    adafruit_products_wgnuplot.gif


    Code kopieren
    1. Satz xlabel "Time" # Setzen der unteren X-Achse Etikett "Zeit"
    2.  
    3. Satz xtics drehen durch -270 # haben die Zeitmarken auf ihrer Seite
    4.  
    5.  
    6. gesetzt ylabel "Light-Ebene (qualitativ)" # Setzen der linken Y-Achse Etikett
    7.  
    8. gesetzt ytics nomirror # Tics nur auf der linken Seite
    9.  
    10. gesetzt y2label "Die Temperatur in Fahrenheit" # Setzen der rechten Y-Achse Etikett
    11. gesetzt y2tics Grenze legte # Tics keine rechten Seite
    12.  
    13. gesetzt Schlüsselkasten links oben # Legende-Feld
    14. Schlüsselkasten gesetzt Linienstil 0
    15.  
    16. gesetzt xdata Zeit # die x-Achse ist die Zeit
    17. gesetzt Format x "% H:% M:% S" # Anzeige der Zeit
    18. gesetzt TimeFmt "% s" #, aber lesen Sie sich als "Unix-Timestamp"
    19.  
    20. plot "LOGTEST.CSV" mit 2: 4 Zeilen mit Titel "Light Ebenen"
    21. Replot "LOGTEST.CSV" mit 2: 5 Achsen Größen X1Y2 mit Linien Titel "Temperatur (F)"

    adafruit_products_gnuplotcmd.gif


    Das macht diese:


    adafruit_products_gnuplotted.gif

    Beachten Sie die kühlen y-Achse Skalen beidseitig!
    Sie können sich auf Sachen ziemlich leicht zu vergrößern.

    Andere Plotter

    Unser Freund John schlägt auch Live--Graph als kostenloser Plot-Programm - Wir haben es nicht ausprobiert, aber seine lohnt ein Blick auf, wenn Sie eine Menge tun müssen, Plotten!



    Tragbare Protokollierung
    Natürlich mit einem Datenlogger, das ist auf einem Desktop-Computer gefesselt ist nicht, dass praktisch.
    Wir können ein tragbares Speichergerät mit der Zugabe von einem Batteriepaket zu machen.
    Der billigste Weg, um eine gute Menge an Energie zu erhalten ist, 6 AA-Batterien verwenden.
    Ich hier mit rechargables und machte 6xAA Batteriehalter . Es lief die Arduino einmal Anmeldung eine zweite 18,5 Stunden.
    Wenn Sie Laugen nutzen könnten Sie leicht 24 Stunden oder mehr.


    adafruit_products_6AAholder_MED.jpg

    Kühlschrank Protokollierung

    Mit meinem tragbaren Logger bereit, seine Zeit etwas Kühlschrank Loggin "zu tun! 

    Beide wurden in den Kühlschrank gelegt, in der Mitte des mittleren Regal.

    adafruit_products_2013_04_06_IMG_1599-1024.jpg

    Ich legte sie in rund 22.00 und dann entfernt es gegen Mittag am nächsten Tag.

    Wenn Sie nicht über einen Kühlschrank handlich, können Sie die Daten aus dieser ZIP-Datei packen und verwenden, die .


    Hier ist die protokollierten Daten:

    adafruit_products_bigplot_t.gif

    Sie können in der Mitte zu sehen und am Ende der Temperatur und Lichtverhältnisse sind sehr hoch, weil der Logger war außerhalb des Kühlschranks.

    Die grüne Linie ist die Temperatur, so dass Sie sehen können, die Temperatur langsam steigt und dann der Kompressor treten in jeder halben Stunde oder so.

    Die roten Linien zeigen an, wenn die Tür geöffnet wurde.
    Diese Nacht war eine insominac einem als normal!

    adafruit_products_bigsnack_t.gif

    Zoomen in das Grundstück bei etwa 0.40, können wir auch in ein paar Sekunden zu sehen, wie die Temperatur steigt, wenn die Tür offen ist, kann es sehr schnell 4 Grad klettern!


    adafruit_products_detailsnack.gif

    a
    Fazit!
    OK, das war eine detaillierte Projekt aber es ist ein guter, um Ihre Fähigkeiten zu testen Datalogging, vor allem seit der schwerer zu beheben Fehler in diesem Bereich.
    Im Allgemeinen empfehlen wir versuchen andere Sensoren und testen sie zu Hause, wenn möglich.
    Es ist auch eine gute Idee, mehr Daten für die Anmeldung, als Sie brauchen, und verwenden Sie ein Software-Programm, um alles, was Sie nicht brauchen filtern.
    Zum Beispiel haben wir nicht mit dem VCC-Log, aber wenn Sie mit fremden Sensorverhalten sind, kann es Ihnen Hinweise geben, wenn die Akku-Lebensdauer ist es zu beeinflussen.
    Build It! CODE LÖSUNGSWEG
    Zuletzt aktualisiert am 2014.08.26




    A.7 Komplettlösung (Code Walkthrough)

    Einführung
    Dies ist eine Komplettlösung des Licht und Temperatur Aufzeichnung Sketch.

    für Adafruit Assembled Data Logging Shield


    Adafruit - lighttemplogger.pde
    #include <SD.h>
    #include <Wire.h>
    #include "RTClib.h"
    
    // A simple data logger for the Arduino analog pins
    
    // how many milliseconds between grabbing data and logging it. 1000 ms is once a second
    #define LOG_INTERVAL  1000 // mills between entries (reduce to take more/faster data)
    
    // how many milliseconds before writing the logged data permanently to disk
    // set it to the LOG_INTERVAL to write each time (safest)
    // set it to 10*LOG_INTERVAL to write all data every 10 datareads, you could lose up to 
    // the last 10 reads if power is lost but it uses less power and is much faster!
    #define SYNC_INTERVAL 1000 // mills between calls to flush() - to write data to the card
    uint32_t syncTime = 0; // time of last sync()
    usw usw usw

    Zuletzt aktualisiert am 2014.08.26



    A.9 Herunterladen  (Downloads)

    Download Adafruit SD Library nur für ARDUINO Mega oder ARDUINO Leonardo
    Wenn Sie auf den Tisch oder suchen Sie den Code für den Adafruit SD-Bibliothek wollen überprüfen Sie die Github-Repository - sollten Sie nur herunterladen und ersetzen Sie Ihre SD-Bibliothek,
    wenn Sie einen ARDUINO Mega oder ARDUINO Leonardo mit der Datenaufzeichnung Schild verwenden
    .


    Download Adafruit RTC Library
    adafruit_products_adafruitlogshieldsch.png

    Schaltplan Fa.Adafruit Assembled Data Logging Shield  (Logger shield for Arduino)

    706_ARDUINO-x_adafruit products adafruitlogshieldsch 1_1a.png
    706_Arduino-x_Adafruit products adafruitlogshieldsch 2_2a.png


    SD-Kartenmodul
      / SD-Card-Adapter
    SD Chip-Select bei Adafruit SD Shilde und Module ist pin10

    Zugriff auf die SD-Karte erfolgt über den SPI-BUS (Serial Peripheral Interface)
    ARDUINO-pin auf SD-Modul-pin

    SD-Card-Schaltung mit Pegelwandler von 5 auf 3,3V
    MISO braucht keinen Pegelwandler da die 3,3V die die SD-Karte sendet von Arduino als High gelesen werden.



    3,3V                                zu   pin4       Vdd
    pin-D13 SCK  (System Clock)         zu   pin5       SCLK      (SD_Chip_Clock In)
    pin-D12 MISO (Master In, Slave Out) zu   pin7       DO        (SD_Data_Out)
    pin-D11 MOSI (Master Out, Slave In) zu   pin2       DI        (SD_Data_In)
    pin-D10 SS   (Slave Select)         zu   pin1       CS        (SD_Chip_Select In)
    GND                                 zu   pinGP&3&6  GND&Vss1&Vss2


    SdFAT Bibliothek  SdFATLibrary  FAT32-Dateisystem  und kurze 8.3-Dateinamen
    MENU > Files > Examples > SdFat > QuickStart

    in www.schaltungen.at
    704_d_Adafruit-x_Adafruit Data logging shield for Arduino - Schaltplan § SD-Card - RTC  DS1307 Bat. CR1220_1a.png

    704_d_Adafruit-x_Adafruit Data logging shield for Arduino - MANUAL (63 Seiten)_1a.pdf  


    adafruit_products_2013_04_06_IMG_1586-1024.jpg
    Zuletzt aktualisiert am 2014.08.26 01.27.24 bei PM Veröffentlicht am 2013.04.12 03.22.30 bei PM


    *********************************************************

    Arduino-Bibliotheken sind eine bequeme Möglichkeit, Code wie Gerätetreiber oder häufig verwendete Utility-Funktionen zu teilen. Dieses Handbuch beschreibt, wie Bibliotheken auf Ihrem Computer zu installieren. Für eine hervorragende Einführung in Bibliotheken und was man mit ihnen machen kann Arduino, siehe die Seite von Bibliotheken aus Arduino Tipps, Tricks und Techniken .
    Es gibt zwei allgemeine Arten von Arduino Libraries:

    Standard-Bibliotheken

    Die Arduino IDE kommt mit einer Reihe von Standard-Bibliotheken für häufig verwendete Funktionen. Diese Bibliotheken unterstützen alle mit der IDE enthalten Beispiele. Standardbibliothek Funktionalität umfasst Grundfunktionen der Kommunikation und die Unterstützung für einige der häufigsten Arten von Hardware, wie: Servomotoren und Character LCD-Displays.

    Standard-Bibliotheken sind in der "Bibliotheken"-Ordner der Arduino installieren vorinstalliert. Wenn Sie mehrere Versionen der IDE installiert ist, wird jede Version einen eigenen Satz von Bibliotheken. Zum größten Teil ist es nicht eine gute Idee, um die Standard-Bibliotheken ändern oder installieren Sie Ihre Bibliotheken in den gleichen Ordner.

    Benutzer installiert Bibliotheken

    Es gibt viele andere Bibliotheken mit nützlichen Funktionen und Gerätetreiber für alle Arten von Hardware. Diese Treiber sind von Orten wie Arduino Platz, Github und Google Code. Adafruit bietet über 100 Bibliotheken Bibliotheken, die fast alle unsere Arduino-kompatiblen Produkten. Die meisten unserer Bibliotheken auf gehostete GitHub . Direkte Links sind aus der Produktbeschreibung und / oder Tutorial Seiten.

    Benutzer installiert Bibliotheken sollten in Ihrem Skizzenbuch-Bibliotheken installiert werden Ordner, so können sie mit allen Versionen der IDE verwendet werden. Auf diese Weise, wenn eine neue Version der IDE freigegeben wird, müssen Sie nicht neu installieren alle Ihre Lieblings-Bibliotheken!


    Wo Sie Ihre Bibliotheken installieren

    Urheber Gravatar Bild BILL EARL
    learn_arduino_Capture.jpg
    Es ist wichtig, Ihre Bibliotheken an der richtigen Stelle zu installieren. Ansonsten wird der Compiler nicht in der Lage, sie zu lokalisieren sein, wenn Sie versuchen, kompilieren und laden Sie Ihre Skizzen.

    Suchen Sie Ihre Sketchbook-Ordner und den Ordner Bibliotheken Innen

    Ihr Skizzenbuch-Ordner ist der Ordner, in dem die Arduino IDE speichert Ihre Skizzen. Dieser Ordner wird automatisch von der IDE erstellt, wenn Sie es installieren.

    Auf Linux-Maschinen, wird der Ordner mit dem Namen "Sketchbook", und es wird in der Regel in / home / <Benutzername> befindet

    Auf Windows-und Macintosh-Computern ist der Standardname des Ordners "Arduino" und wird in Ihrem Ordner Dokumente.
    Dies ist eine gemeinsame Quelle der Verwirrung auf Windows und Mac-Maschinen, Ihr Skizzenbuch-Ordner nicht mit dem Namen "Skizzenbuch" ist mit dem Namen "Arduino"!
    Benutzer installiert Bibliotheken sollten in einem Ordner namens "Bibliotheken", in Ihrem Skizzenbuch-Ordner zu gehen. Dies ist, wo die IDE für Benutzer installierten Bibliotheken zu suchen.
    Auf der Version 1.0.2 und später der Arduino IDE ist der Ordner "Bibliotheken" automatisch erstellt. Bei früheren Versionen der IDE, müssen Sie, um es zu erstellen, wenn Sie Ihre erste Bibliothek installieren.

    • learn_arduino_Preferences.png

    Öffnen Sie den Dialog

    Klicken Sie auf "Datei> Einstellungen" in der IDE.
    • learn_arduino_Preferences_Dialog.png

    Finden Sie die Sketch Ort

    Normalerweise wird ein Ordner namens "Arduino" in Ihrem Dokumente-Ordner.

    Nachdem Sie den Speicherort kennen, navigieren Sie zu diesem Ordner im Windows Explorer.
    • learn_arduino_Create_Library.png

    Erstellen Sie einen Ordner Bibliotheken

    Wenn es keine Bibliotheken-Ordner gibt, erstellen.

    Der rechten Maustaste im Windows Explorer und wählen Sie "New-> Ordner".
    • learn_arduino_Rename.jpg

    Umbenennen, um "Bibliotheken"

    Rechtsklick auf den "Neuer Ordner" und wählen Sie "Umbenennen". Geben Sie dann in "Bibliotheken".
    Zuletzt aktualisiert am 2014.08.26



    A.10 Installation einer Bibliothek auf Windows-


    Befolgen Sie diese Schritte, um eine Bibliothek in Windows zu installieren.

    Schließen Sie die Arduino IDE

    Stellen Sie zunächst sicher, dass alle Instanzen des Arduino IDE geschlossen sind. Die IDE scannt nur für Bibliotheken beim Start. Es sehe nicht Ihre neue Bibliothek, so lange eine Instanz der IDE geöffnet ist!
    • learn_arduino_Github.png

    Laden Sie die Zip-Datei

    Klicken Sie auf die "Zip"-Taste auf der Github-Repository-Seite.
    • learn_arduino_Copy.png

    Öffnen Sie die Zip-Datei

    Öffnen Sie die Zip-Datei und kopieren Sie die Bibliothek Master-Ordner.
    • learn_arduino_Paste.png

    Fügen Sie ihn in Ihren Bibliotheken-Ordner

    Öffnen Sie Ihr Skizzenbuch Bibliotheken-Ordner und fügen Sie den Master-Ordner, den Sie aus der Zip-kopiert.
    • learn_arduino_Legal_Name.png

    Geben Sie ihm einen Namen Rechts

    Die IDE wird Ordner mit Bindestrichen im Namen nicht erkennen. So müssen Sie die Github Master-Ordner umbenennen. Unterstriche sind OK!
    • learn_arduino_Example.png

    Re-Start der IDE

    Starten Sie den Arduino IDE und überprüfen Sie, dass die Bibliothek in der Datei-> Beispiele Menü erscheint.

    Laden Sie eines der Beispiele, die Bibliothek zu testen.
    • learn_arduino_No_Errors.png

    Stellen Sie sicher, dass es kompiliert

    Klicken Sie auf das Häkchen-Symbol in der oberen linken und überprüfen, dass das Beispiel Skizze ohne Fehler kompiliert.
    Zuletzt aktualisiert am 2014.08.26

    Quelle:

    https://learn.adafruit.com/adafruit-data-logger-shield

    Aber auch in in www.schaltungen.at
    704_d_Adafruit-x_Adafruit Data logging shield for Arduino - Schaltplan § SD-Card - RTC  DS1307 Bat. CR1220_1a.png

    704_d_Adafruit-x_Adafruit Data logging shield for Arduino - MANUAL englisch (63 Seiten)_1a.pdf




    DIN A4 ausdrucken
    *********************************************************

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