Batteriebetriebene Funk Sensoren

  • Vorwort:

    Fragen usw bitte im Entwicklungs-Thread stellen


    Ziel dieses Projekts ist es schnurlose Funk Sensoren, die über Batterien versorgt werden, zu betreiben und mit dem RaspberryPI die Daten zu empfangen sowie auszuwerten.

    Als Sensor kann man theoretisch so ziemlich alles verwenden, ob Temperatur, Luftfeuchtigkeit, Luftdruck, Höhenmesser, Anwesenheitssensoren, Magnetschalter, Erschütterungs-Sensoren, Feuchtigkeitsmesser usw also im Prinzip alle arten von Sensoren

    Das Projekt orientiert sich am TinyTX von Nathan Chantrell (auf der Seite findet ihr auch weitere Informationen zu verwendbaren Sensoren)

    Außerdem haben einige User aus diesem Forum bei der Entwicklung mitgewirkt, bei denen ich mich an dieser Stelle bedanken möchte :thumbs1:


    Abgesehen von der Grundausstattung für einen lauffähigen RaspberryPI benötigt man zusätzlich:

    • Empfänger-Modul, welches an die GPIO Pins des RaspberryPI's angeschlossen wird (RX, 3V3, GND)
    • Ein paar Steckbrett-Kabel um den Empfänger an den PI anzuschließen sowie die ATtiny AVR Chips zu flashen (programmiern)
    • Sender-Modul mit Batteriehalter
    • Sensor für Sender-Modul
    • RFM12B Funkmodule für sowohl Empfänger als auch Sender
    • Löt Utensilien

    Bei Empfänger / Sender kommt es dann eben drauf an ob man die selber bauen möchte (Platine selber bestellen/anfertigen sowie Bauteile selber kaufen etc) oder ob man sich an der Sammelbestellung (siehe Ende dieses Beitrags) beteiligen will und somit weitaus weniger Aufwand betreiben müßte..

    Ein weiterer wichtiger Hinweis der sich erst später herausgestellt und von nurazur ermittelt wurde : Batteriebetriebene Funksensoren - Empfindlichkeitsmessungen an TinyTx4 und TinyRx4
    Demnach wäre es besser einen TinyTX4 als Empfänger einzusetzen da dessen Reichweite/Empfindlichkeit besser ist. Hier scheint uns leider bei der Entwicklung des TinyRX4 ein kleiner Fehler unterlaufen zu sein...


    Man kann die Funksender auch recht einfach in FHEM mit der JeeLib einbinden. Der hier entwickelte Empfänger wird als serielle Schnittstelle erkannt und nach Anpassung der JeeLib werden korrekte Werte angezeigt. Siehe dazu > hier <


    Index:

    • [al=AndereProjekte]Projekt Abkopplungen[/al]
    • [al=Technische_Grundlagen]Technische Grundlagen[/al]
    • [al=Bauteil_Liste]Bauteil-Liste der benötigten Teile[/al]
    • [al=Warenkorb]Warenkorb Liste[/al]
    • [al=Fertige_Platinen]Fertige Platinen[/al]
    • [al=Stripboard_Plan]Stripboard Plan[/al]
    • Hinweis für Arduino-IDE ab 1.6.4
    • [al=Flashen_RPI]Programmieren/Flashen über RaspberryPI[/al]
    • [al=Flashen_UNO]Programmieren/Flashen über Arduino UNO[/al]
    • [al=Flashen_Anpassen]Programmieren/Flashen - RFM12B.h anpassen[/al]
    • [al=UART]UART Freischalten[/al]
    • [al=Sketches]Sketches[/al]
    • [al=Empfaenger]Empfänger Script[/al]
    • [al=Einrichten_1]Einrichtung auf RaspberryPI[/al]
    • [al=Einrichten_2]Einrichtung auf RaspberryPI - Teil2[/al]
    • [al=Einrichten_3]Einrichtung auf RaspberryPI - Teil3[/al]
    • Extra SPI Display
    • TinyTX2/3 Platinen
    • TinyTX Hinweise
    • TinyTX4


    [al=Changelog]Changelog dieser Anleitung[/al]


    Warum man sich für 'unsere' v4 Sender/Empfänger entscheiden sollte:

    • Sehr flexible Handhabung durch frei Konfigurierbaren RFM12B Transceiver (kann sowohl Senden als auch Empfangen)
    • Individuell programmierbaren und sehr sparsamen ATtiny84A AVR Chip
    • Möglichkeit bis zu 4 Sensoren pro Senderboard anzuschließen
    • Sensoren können problemlos individuell gewählt/getauscht werden
    • Mindestens ein Jahr wartungsfreie Laufzeit durch boost-converter
    • Sehr kleine Bauform (SMD Bauteile)


    Abmessungen der Platinen:
    Empfangsboard: 26 x 38mm
    Senderboard: 44 x 44mm
    Reine Boosterplatine: 13 x 10,5mm


    Die PCB Layouts sowie Sketches findet ihr hier: https://github.com/meigrafd
    Erklärung zu den unterschiedlichen Sketch Ausführungen:
    "Watchdog" ist für eine bessere Batterie ausbeute.
    "Jeelib" ist für die Kommunikation mit einem Jeelink.
    Wenn Ihr die RPI Lösung mit dem hier angebotenen Empfänger benutzt, dann könnt ihr die JeeLib Variante ignorieren.


    Der Sammelbestellung TinyTX-Blog von Himbeerfreund findet ihr hier: http://himbeerfreund.wordpress.com/category/allgemein/


    [an=AndereProjekte][/an]
    Weitere Projekte die hierauf basieren:


    [an=Changelog][/an]
    Changelog History:

    - 10.05.2014: Send_DS18B20.ino -> readVcc -> Bug behoben
    - 00.00.0000: ATtiny84A Details (freie / belegte pins) im "Technische Grundlagen" beitrag eingefügt
    - 00.00.0000: Warenkorb Liste: RFM12B von Octamex eingepflegt
    - 20.11.2014: Octamex wieder entfernt da der Shop pleite zu sein scheint (Bestellungen kommen nicht an, Servicehotline geht nur die Sprachbox dran, Telefax hat eine andere Vorwahl aber die Nummer ist nicht vergeben)
    - 11.12.2014: Send_DHT22_Watchdog.ino -> Verbraucht solange er nichts sendet nur ~4uA. Der vorherige Sketch verbraucht dahingegen ~1,02mA
    - 12.01.2015: Watchdog Sketches aktualisiert.
    - 14.01.2015: TinyTX2 / TinyTX3 Platinen Vergleich, sowie Allgemeine Hinweise für TinyTX Platinen, und auch eine Zusammenfassung zu den TinyTX4 / TinyRX4 / Booster, hinzugefügt.
    - 01.09.2015: Weiteren PCB Hersteller hinzugefügt. Einige Bilder gefixt.
    - 11.10.2015: [al=Hinweise]Hinweis[/al] bezüglich DHT22 eingefügt.
    - 15.02.2016: Hinweis für Arduino-IDE ab v1.6.4 hinzugefügt.
    - 22.02.2017: Hinweis auf TinyTX3 im ersten Beitrag fett hervorgehoben.

  • [an=Technische_Grundlagen]Technische Grundlagen:[/an]

    Zur Funkübertragung habe ich mich für RFM12B Module entschieden da diese sehr klein, stromsparend, flexibel aber vorallem auch in Deutschland zulässig sind (und man auf bereits vorhandene Libs zurück greifen kann).
    Die Übertragung erfolgt dabei über das ISM-Band und wahlweise 433MHz oder 868MHz (zwei verschiedene Module). (Frequenznutzungsplan Deutschland)
    Das RFM12B hat eine Betriebsspannung von 2.2V bis 3.8V, funktioniert aber problemlos auch mit bis zu 6V und wird dadurch auch (angeblich) nicht beschädigt - habe es selber problemlos längere Zeit mit 5V betrieben aber keine negativen Auswirkungen feststellen können.

    Gesteuert wird das ganze über einen ebenfalls sehr stromsparenden Atmel Microcontroller Chip ATtiny84A-PU der ebenfalls sehr klein und stromsparend ist. Man könnte aber auch einen Atmel Mega nutzen wenn man zB mehr Speicher oder Pins benötigt.. Aufgrund der begrenzten Flash-Speichergröße (8 kB) des ATtiny84A können die Sketches leider nicht soooo umfangreich ausfallen - für die hier genutzten Zwecke ist es aber völlig ausreichend (überwiegend belegen die Sketches ~5kB).
    Der ATtiny84A hat normalerweise eine Betriebsspannung von 1.8V bis max. 5.5V . Da er hierfür aber mit 8 MHz betrieben werden muss liegt die Betriebsspannung bei 2.7V bis 5.5V

    Als Stromversorgung verwende ich 3 x AA Batterien, die im geladenen Zustand eine Spannung von ca. 4.5V liefern (eine hat 1.5V).
    AA Batterien sind eine bessere Wahl als AAA, denn damit ist ein längerer Betrieb möglich da die eine höhere Kapazität haben.
    Der Umwelt zu liebe sollte man aber besser zu Akkus greifen, die dann pro Zelle eine Spannung von 1,2V also insg. 3.6V hätten.
    Um so mehr Kapazität (mAh) um zu besser.

    Im leeren Zustand beträgt die Spannung einer Batterie noch etwa 0.9V bis 1.0V, was also bedeuten würde das bei 3 Batterien noch eine Spannung von ca. 2,7V angezeigt werden würde.
    Das RFM12B Module benötigt mindestens 2.2V und der ATtiny64A mindestens 2.7V - demnach wäre es mit 3 Batterien gerade noch im grünen Bereich. Allerdings nimmt dann selbstverständlich die Reichweite ab, da nicht mehr genug Ampere zur Verfügung stehen.. Deshalb plane ich auch ein Hinweis in die Graphen-Page einzubauen sobald ein Sensor längere Zeit keine Daten mehr übertragen hat, denn die Sensoren übermittelt zusätzlich zu den eigentlichen Werten auch die aktuelle Spannung ihrer Stromversorgung (Supply Voltage). Dadurch liese sich erkennen wann die Batterien ausgetauscht werden müssten.

    Bei den Sensoren sollten Digitale bevorzugt werden da man dann keinen Analog-to-Digital-Wandler bzw Umrechner benötigt und dies somit auch weniger Code und Strom benötigen - außerdem müssen Analoge Sensoren kalibriert werden was ebenfalls individuell bei jedem Standort anders ist.

    Zusätzlich zu den oben genannten Bauteilen benötigt man auch noch ein paar Widerstande und Keramik-Kondensatoren, sowie einen Sockel für den ATtiny Chip, ein bisschen Kabel und einen Kupferdraht für die Antenne des RFM12B Modules. Um das alles irgendwie zusammen zu löten verwende ich eine Streifenrasterplatine.


    [an=Hinweise]Hinweise:[/an]

    • Die Atmel-Chips an sich lassen sich in unterschiedliche Sleep-Modes fahren. So verbrauchen Sie im Schlaf nur 0,3μA – da hält eine Batterie Jahre ohne Wechsel (mikrocontroller.net). Mehr Informationen zum Stromverbrauch und Sleepmodes fand ich in einem Forumbeitrag auf Gammon
    • Die Außensensoren werden nicht sekündlich ein Sensorsignal schicken, sondern in regelmäßigen Abständen aufwachen, den Sensor auslesen, die Daten verschicken, und wieder schlafen gehen. Das spart Strom und erhöht die Langlebigkeit
    • Nach einigen Tests scheint der Empfänger unbedingt die NodeID 22 haben zu müssen damit es funktioniert! Wieso das so ist konnte ich bisher nicht herausfinden. Die Sender können aber nach belieben eine NodeID von 1 bis 30 haben (also insg. 29 Sender)
    • Wichtig ist auch die Wahl der richtigen Batterie, was sowohl Größe (AA oder AAA) als auch Kapazität betrifft. Es muss auch darauf geachtet werden das die maximalen Spannungen der hier verwendeten Bauteile nicht überschritten werden. Also die Anzahl der Batterien nicht über 3 liegen sollte, da die Batterien in Reihe geschaltet werden und sich somit die Spannung addiert (zB 3 x 1,5V = 4,5V). Wie lange die Batterien halten hängt aber natürlich auch vom Intervall der Datenübermittlung ab: Alle 60 Sekunden oder alle 300 Sekunden macht schon einen nicht zu unterschätzenden Unterschied aus.
    • 10µH Drosseln (Spulen) sind in ihrer Bauform so groß wie Widerstände. In den AVR-Eingangsbeschaltungen werden sie nur benötigt, um Störimpulse zu unterdrücken (tiefpassfilter).
    • Der DHT22 ist nicht betauungsresistent und somit im Aussenbereich ungeeignet. Stattdessen sollte man einen aus der SHT Baureihe verwenden, wie zum Beispiel SHT21 mit Filterkappe. (quelle)


    Die Reichweite:

    Oft werde ich gefragt: “Wie weit gehen die denn?” Diese Frage lässt sich nicht mit einer einfachen Angabe von x km beantworten.

    Die erzielbare Reichweite aller Funklösungen ist hauptsächlich abhängig von der Antenne, Antennenaufstellungsort, Empfängerempfindlichkeit, Sendeleistung und der Frequenz.
    Auf die Empfängerempfindlichkeit haben wir meist keinen Einfluss.. Wir konzentrieren uns also auf die Antenne und die Frequenz.
    Für mobile Lösungen setzen wir kurze (ca.50 mm) oder lange (100 bis 200 mm), auf die Frequenz abgestimmte Stabantennen ein. Die Antennen sollten möglichst parallel angeordnet sein, was aber beim Kopter meist nicht der Fall ist.
    Wenn es weiter reichen soll müssen wir bei der Bodenstation mit einer Richtantenne arbeiten. Bei einem Modul mit 25 mW Leistung auf 868 MHz können wir damit die Reichweite von ca. 800 m auf über 4 km erhöhen.

    Bei der Frequenz gilt: je tiefer desto besser.

    Zum Beispiel ein XBee mit 100mW auf 2,4 GHz sieht alt aus, verglichen mit 10 mW auf 433 MHz. Hier haben wir bei der Wahl der Module den größten Einfluss auf die erzielbare Reichweite.

    Die maximal erlaubte Sendeleistung ist länderspezifisch.
    Die maximale zugelassene Sendeleistung mit einem Duty cycle von 100 % beträgt bei 433 MHz ERP 10 mW, bei 868 MHz dürfen es 25 mW sein.

    Mit dem 433 MHz Funkmodul lassen sich, aufgrund der besseren Ausbreitungsbedingungen, enorme Reichweiten erzielen. Aber auch das 868 MHz Modul schlägt das 433Mhz Module in der maximalen Reichweite.

    Es gibt Module für die ISM Frequenzen 433/470/868 und 915 MHz. Hier in Europa sind allerdings nur die Frequenzen 433 MHz und 868 MHz interessant bzw zugelassen.


    Ein paar genauere Details zu den RFM12 Modulen kann man auch hier (auf Englisch) nachlesen: http://blog.strobotics.com.au/2008/06/17/rfm12-tutorial-part2/
    Oder hier ein Vergleich zwischen RFM12, RFM22 und RFM23: http://blog.strobotics.com.au/2009/07/30/int…-to-the-rfm12b/


    Antennen Länge:

    Bezüglich der Antennen-Länge habe ich folgendes gefunden:
    433MHz 1/4 wave = 164.7mm
    433MHz 1/2 wave = 329.4mm
    433MHz full wave = 692.7mm

    868MHz 1/4 wave = 82.2mm
    868MHz 1/2 wave = 164.3mm
    868MHz full wave = 345.5mm


    Die Formel zur Berechnung lautet: Wellenlänge = Lichtgeschwindigkeit / Frequenz
    Also zum Beispiel:
    Wellenlänge = 300000km / 433 MHz = ca. 0,693 Meter

    Die Ideallänge der Antenne, sagt man, sollte gleich der Wellenlänge sein, also 0,693 Meter.
    Da das in der Praxis nicht immer möglich ist (je kleiner die Frequenz, desto grösser die Wellenlänge und damit Länge der Antenne) nimmt man eben Lambda/2 oder Lambda/4-Antennen. Wäre in diesem Fall: 0,693 / 4 = 0,17325 Meter = 17,325cm
    (Stichwort: Lambda)


    Details zum AVR Chip:

    Derzeit freie Pins beim ATtiny84A wären:
    Pin#2 (PB0)
    Pin#4 (RESET) (kann aber nicht verwendet werden)
    Pin#6 (PA7) (PWM, Analog Input 7)
    Pin#11 (PA2) (Analog Input 2)
    Pin#10 (PA3) (Analog Input 3)

    Derzeit belegte Pins beim ATtiny84A wären:
    Pin#1 (VCC)
    Pin#3 (PB1)
    Pin#5 (PB2) (PWM)
    Pin#7 (PA6) (PWM, MOSI)
    Pin#8 (PA5) (PWM, MISO)
    Pin#9 (PA4) (SCK)
    Pin#12 (PA1) (VCC für Sensor)
    Pin#13 (PA0) (DATA für Sensor)
    Pin#14 (GND)


    Die Orangen Pins können verwendet werden, die Gelben nicht.

    Details zum Stromverbrauch kann man hier auf Seite#2 nachlesen (wir flashen den ATtiny84A auf 8 MHz)

  • [an=Bauteil_Liste]Bauteil-Liste der benötigten Teile:[/an]

    pro Sender-Sensor:

    Basis:

    • Atmel ATtiny 84A-PU (Pico-Power) - oder alternativ: ATtiny 84V-10PU (Low-Voltage) .. plus Sockel (um die AVR Chips später ggf neu programmieren zu können)
    • RFM12B Funkmodule (433Mhz oder 868Mhz, 2.2V-3.8V)
    • 2x AA / AAA Batterie Halter für ATtiny 84V-10PU, oder 3x AA / AAA für ATtiny 84A-PU
    • Streifenplatine: 15 x 16 Löcher
    • Plastikgehäuse (50x50x20mm müsste theoretisch reichen)
    • 2x 100nF Keramikkondensator, einer zwischen VCC und GND des ATtiny (Pin 1 und 14) und einer zwischen VDD und GND des RFM12B [für bessere Messwerte]
    • 1x 10µH Spule zwischen 5V und AVcc [für bessere Messwerte]ATtiny 84V-10PU (Low-Voltage)
    • Kupfer/Klingel-Draht für 165mm lange 1/4W Antenne (allgemeine detailierte Beschreibung)


    Je nach verwendetem Sensor:

    • DS18B20 - Digital Temperatur Sensor + 4,7k Ω Widerstand
    • DHT22 - Digital Temperatur & Luftfeuchtigkeits Sensor + 10k Ω Widerstand (liefert bei einer Spannung unter 2,96V falsche Werte)
    • TMP36 - Analog Temperatur Sensor, ohne Widerstand (2,7V - 5,5V)
    • BMP085 - Digitaler Temperatur & Luftdruck & Höhen Sensor (1,8V - 3,6V) (liefert genauere Werte als DHT22)
    • LDR - Analoger Licht Sensor (Fotowiderstand) + 10k Widerstand


    Optional:

    • 3 pol [font="Tahoma, Verdana, Arial, sans-serif"]Präzisions-[/font]Buchsenleiste - oder 3 pol Stiftleiste plus Pfostenstecker ... für austauschbaren Sensor
    • 2 pol [font="Tahoma, Verdana, Arial, sans-serif"]Präzisions-[/font]Buchsenleiste - oder 2 pol Stiftleiste plus Pfostenstecker ... für austauschbaren Widerstand


    Empfänger:
    Bei dem Empfänger würde ein Sensor und somit auch die Spulen wegfallen, aber trotzdem sollten die Kondensatoren auch hier verbaut werden. Zusätzlich werden aber auch noch 2x 10k Ω Widerstände benötigt

    • Atmel ATtiny 84A-PU (Pico-Power) - oder alternativ: ATtiny 84V-10PU (Low-Voltage) .. plus Sockel (um die AVR Chips später ggf neu programmieren zu können)
    • RFM12B Funkmodule (433Mhz oder 868Mhz, 2.2V-3.8V)
    • Streifenplatine: 20 x 21 Löcher
    • 2x 100nF Keramikkondensator, einer zwischen VCC und GND des ATtiny (Pin 1 und 14) und einer zwischen VDD und GND des RFM12B [für bessere Messwerte]
    • 2x 10k Ω Widerstände
    • Kupfer/Klingel-Draht für 165mm lange 1/4W Antenne (allgemeine detailierte Beschreibung)


    Antennenlänge, sowie ein Bild zur Verlötung des RFM12B Modules auf eine Streifenrasterplatine wird > hier < beschrieben.

  • [an=Warenkorb]Warenkorb Liste:[/an]

    Reichelt Warenkorb für 5 Sensoren - exkl. AVR & Sensor & Funkmodule: http://www.reichelt.de/?ACTION=20;AWKID=821034;PROVID=2084 .. Warenkorb-Kosten: 17,51eu plus 5,60eu VSK

    Ansonsten die Bauteile einzeln bestellen, nachfolgend eine kleine Ansammlung:

    5x ATtiny 84A-PU über eBay für insg. 6,99eu plus 1,80eu VSK ... einer kostet dann 1,758eu inkl. VSK
    Alternative:
    ATtiny 84A-PU über guloshop.de .. für je 1,00eu plus 2,40eu VSK ... bei 5 Stück würde einer 1,48eu inkl. VSK kosten (2,40eu VSK bis 10eu Warenwert, über 10eu: 4,80eu VSK)

    10x IC Sockel 14 polig über ebay für 1,00eu plus 1,75eu VSK


    DS18B20 über amazon [Anzeige] ... 5 Stück für 6,79eu inkl. VSK

    DHT22 über eBay .. für je 4,48eu inkl. VSK

    TMP36 über eBay .. 2stk. für insg. 3,53eu plus 1,85eu VSK


    RFM12B 433Mhz Transceiver Sende Emfangs Modul über eBay .. für je 6,45eu plus 0,95eu VSK .. 5 Stück würden 38,70eu kosten (plus 1x VSK)
    RFM12B 868Mhz Transceiver Sende Emfangs Modul über eBay .. für je 6,45eu plus 0,95eu VSK
    Alternativ:
    6x 433Mhz von JeeLabs für insg. 29,50eu (einzelpreis normalerweise: 6,50eu) plus 3eu VSK .. einer kostet dann 5,416eu inkl. VSK
    6x 868Mhz von JeeLabs für insg. 29,50eu (einzelpreis normalerweise: 6,00eu) plus 3eu VSK
    oder:
    RFM02 433Mhz Transmitter Sende Modul über eBay .. für je 4,85eu plus 0,95eu VSK .. 5 Stück würden 24,25eu kosten (plus 1x VSK)
    RFM02 868Mhz Transmitter Sende Modul über eBay .. für je 4,85eu plus 0,95eu VSK

    Wichtig: RFM02 ist nicht kompatible mit der TinyTX Platine!

    Es gibt verschiedene RFM12 Module also Vorsicht:

    RFM12B von HopeRF -> http://www.hoperf.com/rf_fsk/fsk/21.htm
    Die haben eine Betriebsspannung von 2.2V bis 3.8V

    RFM12 von Pollin -> http://www.pollin.de/shop/dt/Njg4OT…fangsmodul.html
    Die haben eine Betriebsspannung von 2.2V bis 5.4V

    Beide Module haben aber laut Datenblatt eine maximal zulässige Vdd Spannung von 6V


    Kupferdraht über eBay, 1x10m (0,80mm²) .. für 1,69eu plus 1,90eu VSK (alternativ in Schwarz)

    100nF Keramik Kondensatoren über ebay ... 20 Stück für 1,88eu inkl. VSK
    oder:
    100nF Keramik Kondensatoren über ebay ... 100 Stück für 3,09eu inkl. VSK

    10k Ω Widerstände über ebay ... Metallschicht, 100 Stück für 2,79eu plus 1eu VSK
    (ob Kohleschicht oder Metallschicht ist relativ egal. Metallschicht haben eine niedrigere Toleranz, sind höher belastbar und geringeres rauschen aber mittlerweile nur minimal teurer als Kohleschicht..)

    AAA Batterien über Pearl ... 20 Stück für 3,90eu ... Spannung: 1,5 V , Kapazität: 1250 mAh
    oder
    AA Batterien über Pearl ... 20 Stück für 3,90eu ... Spannung: 1,5 V , Kapazität: 2800 mAh

    2x AA Batterie-Halter geschlossen mit Ein-/Aus-Schalter über amazon [Anzeige] ... für 1,15eu
    3x AA Batterie-Halter geschlossen mit Ein-/Aus-Schalter über amazon [Anzeige] ... für 2,10eu

    3x AAA Batterie-Halter geschlossen mit Ein-/Aus-Schalter über amazon [Anzeige] ... für 2,19eu
    3x AAA Batterie-Halter geschlossen über amazon [Anzeige] ... für 1,38eu

    10x Single Reihe Stift- und Buchsenleiste über amazon [Anzeige] ... für 4,98eu

    Optional: Wer den Empfänger nicht an den PI anschließen will aber keine UART Schnittstelle hat, der kann sich zum Beispiel solch ein UM2102 (USB<->UART) besorgen (5,95€)


    Kosten für ein Sender-Sensor (berechnet für insg. 5 Module) liegt zwischen 12,43eu und 16,79eu (jenachdem wo oder was man aus der obigen Liste bestellt)

  • [an=Fertige_Platinen]Fertige Platinen:[/an]


    Für die Sender gäbe es auch fertige (nackte) Platinen die man aber erst in Auftrag geben müsste und Verhältnismässig viel kosten: http://www.circuits.io/circuits/1932 ... 3 x nackte PCB's für $15,21 inkl. VSK

    Oder nachfolgendes lesen bzw nach dem Quote: (wäre wesendlich günstiger aber ist eben auch etwas umständlicher)

    Zitat


    If you want to get PCBs made up I can recommend the Chinese site SeeedStudio, for 10 boards in green (other colours are more expensive) it costs 9.90 USD + shipping which worked out at £9.01 including UK delivery (90p each) and it will only take a couple of weeks. They don’t take Eagle files directly but Eagle can export the Gerber files that they need and they have an Eagle design rules file that makes it easy to check that your board fits with what they are capable of producing and a job file for the Gerber export to make sure everything is setup correctly for them. It’s still worth double checking the resulting Gerber files in a viewer such as Gerbv to make sure everything has come out as intended, I found that some of the silkscreen text that looked fine in Eagle had overflowed the board in the Gerber files. If you don’t want to get 10 boards made up you could always build the stripboard version or the guys at Circuits.io were also kind enough to import the Eagle files into their site for me so you can order boards in a pack of 3 from them for $14.67 plus $5 for international shipping. Unfortunately they don’t support adding text to the silkscreen so you will lose all the labelling with their boards. I’m not selling any boards myself at the moment but might have something in the pipeline soon.

    Siehe dazu auch > hier < bzw im folgenden Spoiler:

    Spoiler anzeigen

    Über http://iteadstudio.com
    Oben im Menü auf OPEN PCB dann links auf PCB prototyping anschliesend:
    PRICE: $0.00 - $9.99
    PCB QUANTITY: 10 pcs
    Smaller than 5cm x 5cm
    Und dann rechts auf ADD TO CART ... anschliesend:

    nqz6uh5g.pnghttp://imall.iteadstudio.com/im120418001.html

    Es kommen dann noch $3,90 Versandkosten für den Standardversand hinzu - also insg. $13,80 für 10 nackte Platinen

    Nach Bestellung erhaltet ihr eine Bestätigungsmail.
    Nun müsst ihr leider die Eagle Dateien vom Empfänger noch in Gerber Dateien umwandeln (wie das geht wird hier beschrieben (runter scrollen bis 'Gerber Files' erwähnt wird) - oder die RFM2Pi_rev3_gerber.zip von mir nutzen)
    Vom Sender (TinyTX v3) gibt es bereits Gerber Dateien.

    Anschliesend die Gerber Dateien, von der PCB die ihr haben wollt (entweder, oder) in einem gepackten Zip mit folgenden Dateinamen an die Adresse pcb@iteadstudio.com mailen:

    <eure.OrderID>_pcb.zip

    Ersetzt dabei <eure.OrderID> mit eurer OrderID also zB: 0123456789


    Leider kann man pro Order nur jeweils Sender oder Empfänger beauftragen - wer also die Empfänger-Platine haben möchte muss sich 10 Stück davon anfertigen lassen!

    Wenn ihr "Open Source" auf Yes gestellt habt, bedeutet das dass ihr 10 eurer bestellten Platinen kriegt und eure 2 zusätzlich jemand X-beliebiges der auch bei ITeadStudio bestellt - ihr kriegt stattdessen 2 andere Platinen (ich hab zB einmal Arduino Leonardo und ein mal Iteaduino BT 1.1 gekriegt - nur die Platinen - ohne Aufpreis).
    Alle Platinen sehen übrigends sehr gut und hochwertig aus.


    Zitat


    Prototyping PCB Order Steps:
    1. Purchase Prototyping PCB Service from depot and check out.
    2. An order number will be provided in confirmation email from iStore (info@iteadstudio.com)
    3. Send the gerber file to pcb@iteadstudio.com with the order number in title - this file will be processed and please make sure it's your final design.
    4. If the file and design meets requirements, they will be processed and shipped in 4-6 days, and we will not reply you. If the files have any issue pcb@iteadstudio.com will contact you.

    Hier meine EMail die ich schrieb:

    Zitat


    My Order Numer: ...

    I've selected "Open Source: Yes" so i'll guess to get 2 additional pcs

    Please use the attached Files:
    1 x PCB of: ...__1_PCS.zip (RFM2Pi_rev3)
    11 x PCBs of: ...__11_PCS.zip (tinytx3)

    If this is not possible than please inform me befor you process
    Thanks!


    Den Receiver kann man auch fertig bestellen: http://shop.openenergymonitor.com/rfm12pi-v2-ras…xpansion-board/ für 20,78eu plus 4,15eu VSK ...
    Oder: http://jeelabs.com/products/rfm12b-board für 11,50eu plus 3eu VSK (funktioniert nur mit Arduino's!)

    Oder mit den selben Bauteilen wie für den Sender selber löten, nur das kein Sensor verbaut wird ;)


    Gute Video Tutorial's für Eagle:
    http://service.projektlabor.tu-berlin.de/onlinekurs/eagleboard/

    Externer Inhalt www.youtube.com
    Inhalte von externen Seiten werden ohne deine Zustimmung nicht automatisch geladen und angezeigt.
    Durch die Aktivierung der externen Inhalte erklärst du dich damit einverstanden, dass personenbezogene Daten an Drittplattformen übermittelt werden. Mehr Informationen dazu haben wir in unserer Datenschutzerklärung zur Verfügung gestellt.


    //EDIT:
    Noch ein sehr günstiger PCB Hersteller, aber mit sehr guter Qualität: http://dirtypcbs.com oder http://de.vrint-pcb.com
    Nach Eingabe einiger Eckdaten kriegt man auf der folgenden Seite weitere PCB-Hersteller aufgelistet: http://pcbshopper.com (zu den Anbietern sollte man sich die Kommentare in den entsprechenden Foren durchlesen, denn manche sind nicht zu empfehlen)

  • [an=Stripboard_Plan][/an]Stripboard Plan für Sender Sensoren:

    Spoiler anzeigen

    tinytx_stripboard_ds18b20.png


    Stripboard Plan für Empfänger:

    Spoiler anzeigen

    Zum verlöten des RFM12B auf eine Streifenrasterplatine (Stripboard) siehe Spoiler > hier <


    An den RaspberryPI muss der Empfänger dann so angeschlossen werden wie auf dem Bild oben zu sehen.
    Dabei ist darauf zu achten das der RX vom Empfänger an den TX vom PI geht, und der TX vom Empfänger zum RX vom PI!

    Code
    Receiver   RaspberryPI
    ---------|-------------
    RX         TX
    TX         RX

    Der Receiver sendet über TX und der PI empfängt das über RX

    Pinbelegung passend zu den Sketches:

    Code
    Receiver ATtiny     RaspberryPI
    ------------------|---------------
    rxPin 7 (D7, PA3)   TXD (GPIO-14 pin#8)
    txPin 3 (D3, PA7)   RXD (GPIO-15 pin#10)

    Zusätzlich natürlich noch 3V3 oder 5V (am besten wäre letzteres da dort mehr Ampere zur Verfügung stehen) und GND zur Stromversorgung.

    Der TX Pin vom PI ist optional und wird derzeit nicht benötigt, erst wenn jemand den Receiver-Sketch umbaut um auch Befehle zu senden wird dieser benötigt.

  • [an=Flashen_RPI][/an]Zum flashen des ATtiny84a (mit 14 Pins) über den RaspberryPI folgendermassen über ein Steckbrett verkabeln:
    (Achtung: Spannungsspitze an RESET kann den Chip beschädigen, deshalb ggf den RPI vorher ausschalten, oder zumindest VCC/GND erst zum Schluss anschließen)

    Code
    ATtiny AVR            RaspberryPI
    ----------------|--------------------
    RESET  (pin#4)      GPIO-8 (pin#24)
    SCK  (pin#9)        GPIO-11 (pin#23)
    MOSI  (pin#7)       GPIO-10 (pin#19)
    MISO  (pin#8)       GPIO-9 (pin#21)
    VCC  (pin#1)        3V3
    GND  (pin#14)       GND

    Anschluss-Plan:

    Spoiler anzeigen

    quelle: http://blog.stevemarple.co.uk/2012/07/avrard…mmer-using.html

    • Benötigte Pakete installieren:

      Code
      wget http://project-downloads.drogon.net/files/avrdude_5.10-4_armhf.deb
      wget http://project-downloads.drogon.net/files/avrdude-doc_5.10-4_all.deb
      
      
      dpkg -i avrdude_5.10-4_armhf.deb
      dpkg -i avrdude-doc_5.10-4_all.deb
      
      
      apt-get update
      apt-get install arduino git-core gcc-avr lxde
    • Optional: Signatur des Chips prüfen:

      Code
      avrdude -P gpio -c gpio -p attiny84
    • Folgende Verzeichnisse erstellen:

      Code
      mkdir -p /root/sketchbook/hardware/tiny/variants/tiny8
      mkdir -p /root/sketchbook/hardware/tiny/variants/tiny14
      mkdir -p /root/sketchbook/libraries
    • RFM12B lib laden:

      Code
      git clone https://github.com/LowPowerLab/RFM12B /root/sketchbook/libraries/RFM12B
    • JeeLib laden:

      Code
      git clone https://github.com/jcw/jeelib /root/sketchbook/libraries/JeeLib
    • OneWire Library laden:

      Code
      wget -O/root/sketchbook/libraries/OneWire.zip http://www.pjrc.com/teensy/arduino_libraries/OneWire.zip
      unzip /root/sketchbook/libraries/OneWire.zip -d /root/sketchbook/libraries/ && rm /root/sketchbook/libraries/OneWire.zip
    • Arduino TemperatureControl Library laden:

      Code
      mkdir -p /root/sketchbook/libraries/ArduinoTemperatureControl
      git clone https://github.com/milesburton/Arduino-Temperature-Control-Library.git /root/sketchbook/libraries/ArduinoTemperatureControl/
    • arduino-tiny-0150-0018.zip laden und entpacken:

      Code
      cd /root/sketchbook/hardware/
      wget http://arduino-tiny.googlecode.com/files/arduino-tiny-0150-0018.zip
      unzip arduino-tiny-0150-0018.zip && rm arduino-tiny-0150-0018.zip
      mv -f attiny tiny
      
      
      cd tiny && [ -d avr ] && cd avr; mv -f * ../; cd ..; rm -rf avr
    • Folgende Dateien anlegen:

      • /root/sketchbook/hardware/tiny/boards.txt

      • /root/sketchbook/hardware/tiny/variants/tiny8/pins_arduino.h

      • /root/sketchbook/hardware/tiny/variants/tiny14/pins_arduino.h

    • Standardmässig öffnet ArduinoIDE ein Sketch unter /usr/share/arduino/ , also am besten einfach die Send.ino und Receive.ino dort hin kopieren.
    • Unter LXDE -> ArduinoIDE starten und besagte Dateien öffnen
    • In ArduinoIDE auf das Menü Tools -> Board gehen und dort ATtiny84 (internal 8 MHz clock) auswählen
    • In ArduinoIDE auf das Menü Tools gehen und dann auf Bootloader installieren (damit wird er auf 8 MHz eingestellt - nur einmal nöitg)
    • In ArduinoIDE auf das Menü Datei -> Einstellungen gehen und dort einstellen: Ausführliche Ausgabe anzeigen während: [x] Kompilierung
    • Auf den "abgehakt" Haken klicken (Überprüfen)
    • ..Leider wird das *.hex File in ein zufällig erstelltes Verzeichnis in /tmp/ abgelegt. Da dies also bei euch anders lautet macht ihr einfach folgendes um den Code auf den ATtiny zu flashen:

      Code
      avrdude -P gpio -c gpio -p attiny84 -U flash:w:/tmp/build*/Receive.cpp.hex -v


    dragoner2k hat herausgefunden wie man den Sketch über den RaspberryPI anschließend auch direkt über ArduinoIDE flashen kann:

    In der /usr/share/arduino/hardware/arduino/programmers.txt die folgenden Zeilen einfügen:

    Code
    gpio.name=Raspberry Pi GPIO (on-board)
    gpio.communication=gpio
    gpio.protocol=gpio


    dann kann man die ATtiny's mit der Direktverdrahtung flashen.

  • [an=Flashen_UNO][/an]Zum flashen über einen Arduino wie zum Beispiel den UNO unter Windows:

    Benötigt wird ArduinoIDE und WinAVR

    Vor dem flashen müsst ihr euren ArduinoUNO noch zu nem ISP machen, das geht wie folgt:

    • ArduinoIDE starten
    • Datei -> Beispiele -> ArduinoISP
    • Es öffnet sich ein neues Fenster in dem ihr folgendes macht:
    • Tools -> Board -> Arduino Uno
    • Tools -> Programmer -> AVR ISP
    • Anschliesend auf den "Pfeil nach rechts" klicken (Upload)

    Dann zunächst http://arduino-tiny.googlecode.com/files/arduino-tiny-0150-0018.zip herunterladen und den darin befindlichen Ordner "tiny" in euren Sketchbook Ordner nach " hardware " entpacken:
    Euren "Sketchbook Ordner" könnt ihr wie folgt festlegen:

    • ArduinoIDE starten
    • Datei -> Einstellungen
    • Ganz oben: Sketchbook Speicherort zum Beispiel auf C:\Sketches ändern (Verzeichnis muss existieren)

    In eurem Sketchbook Ordner muss es folgende Verzeichnisse geben:

    • hardware

      • tiny
    • libraries

      • RFM12B
      • JeeLib
      • DHT22


    Die Libs könnt ihr auf folgenden Links herunterladen:
    https://github.com/LowPowerLab/RFM12B/archive/master.zip
    https://github.com/jcw/jeelib/archive/master.zip
    https://github.com/nethoncho/Ardu…hive/master.zip

    Nun müsst ihr leider noch mal in den Ordner " hardware\tiny\avr\ " gehen und die Datei " Prospective Boards.txt " in -> " boards.txt " umbenennen

    Wem das zu kompliziert ist kann auch einfach mein Sketchbook verwenden ;)

    Zum Kompilieren und Hochladen des Sketches geht ihr wie folgt vor.
    Einmalig:

    • In ArduinoIDE auf das Menü Tools -> Board gehen und dort ATtiny84 (internal 8 MHz clock) auswählen
    • In ArduinoIDE auf das Menü Tools -> Programmer gehen und dort Arduino as ISP auswählen
    • In ArduinoIDE auf das Menü Datei -> Einstellungen gehen und dort einstellen: Ausführliche Ausgabe anzeigen während: [x] Kompilierung
    • In ArduinoIDE auf das Menü Tools gehen und dann auf Bootloader installieren (damit wird er auf 8 MHz eingestellt - nur einmal nötig)


    Anschliesend:

    • Entweder auf den "abgehakt" Haken klicken (Überprüfen) - damit wird der Code kompiliert
    • Oder zum kombinierten kompilieren und anschliesenden Hochladen auf den "Pfeil nach rechts" klicken


    Anschlussplan zum Flashen des ATtiny84 über einen ArduinoUNO:

    Spoiler anzeigen
    Spoiler anzeigen

    *OLD*

    • Arduino 5V an ATtiny84 Pin 1 (VCC +)
    • Arduino GND an ATTiny84 Pin 14 (GND -)
    • Arduino Pin 10 an ATtiny84 Pin 4 (Reset)
    • Arduino Pin 11 an ATTiny84 Pin 7 (Pin 6, PWM, Analog Input 7)
    • Arduino Pin 12 an ATTiny84 Pin 8 (Pin 5, Analog Input 5, PWM, MISO)
    • Arduino Pin 13 an ATTiny84 Pin 9 (Pin 4, Analog Input 4, SCK)
    Code
    Arduino    ATtiny AVR
    --------|------------------
    5V         VCC  (pin#1)
    GND        GND  (pin#14)
    pin#10     RESET  (pin#4)
    pin#11     MOSI  (pin#7)
    pin#12     MISO  (pin#8)
    pin#13     SCK  (pin#9)


    Offensichtlich ist das WinAVR (von 2008) welches bei ArduinoIDE dabei ist, fehlerhaft

    Die Lösung ist relativ einfach:

    • Ladet euch die aktuelle WinAVR-Suite (aktuell von 2010) von SourceForge herunter, installiert sie z.B. nach C:\WinAVR
    • Benennt den Ordner “avr” im Verzeichnis “C:\Program Files (x86)\Arduino\hardware\tools” in “avr.old“ um
    • Erstellt das Verzeichnis “avr” neu und kopiert dorthin alle Dateien und Ordner unterhalb von C:\WinAVR\
    • Aus dem alten und umbenannten Ordner “avr.old“ muss nun noch das Verzeichnis “etc“ ins neue kopiert werden (genauer gesagt die avrdude.conf)


    Danach funktioniert auch das kompilieren der Sketches wieder!

  • [an=Flashen_Anpassen][/an]Wer mit der RFM12B lib einen Sketch kompilieren möchte, oder eine Fehlermeldung "error: 'SLEEP_MODE_STANDBY' was not declared in this scope" kriegt, muss die RFM12B.h anpassen und zwar so:

    Zeile 202:

    Code
    void SendStart(uint8_t toNodeId, const void* sendBuf, uint8_t sendLen, bool requestACK=false, bool sendACK=false, uint8_t waitMode=SLEEP_MODE_STANDBY);


    Ändern in:

    Code
    void SendStart(uint8_t toNodeId, const void* sendBuf, uint8_t sendLen, bool requestACK=false, bool sendACK=false, uint8_t waitMode=SLEEP_MODE_PWR_DOWN);

    Zeile 204:

    Code
    void Send(uint8_t toNodeId, const void* sendBuf, uint8_t sendLen, bool requestACK = false, uint8_t waitMode=SLEEP_MODE_STANDBY);


    Ändern in:

    Code
    void Send(uint8_t toNodeId, const void* sendBuf, uint8_t sendLen, bool requestACK = false, uint8_t waitMode=SLEEP_MODE_PWR_DOWN);


    quelle: http://lowpowerlab.com/forum/index.php?topic=108.0

  • [an=UART][/an]UART:

    Die UART-Schnittstelle wird bei Raspbian Standardmässig als serielle Konsole genutz. Damit die UART-Schnittstelle anderweitig genutzt werden kann, ist diese Funktion zu deaktivieren...


    Wheezy:

    Dazu in der Datei /boot/cmdline.txt folgende Parameter löschen:

    Code
    console=ttyAMA0,115200 kgdboc=ttyAMA0,115200

    Anschliessend sollte die Zeile wie folgt aussehen:

    Code
    dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait


    Ausserdem muss in der Datei /etc/inittab folgende Zeile durch voranstellein eines # auskommentiert werden:

    Code
    # T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

    Anschließend rebooten und dann kann man UART verwenden


    Jessie:

    Code
    sudo systemctl disable serial-getty@ttyAMA0.service


    Bezüglich Raspberry Pi 3B siehe hier: Raspi 3 - wie Uart umbiegen?


    Wenn man etwas von UART auslesen möchte kann man entweder minicom nutzen:

    Code
    minicom -b 9600 -o -D /dev/ttyAMA0

    Oder direkt die UART Schnittstelle öffnen:

    Code
    cat /dev/ttyAMA0


    ggf muß man vorher ein mal die Geschwindigkeit von UART einstellen:

    Code
    stty 9600 -F /dev/ttyAMA0

    Oder auch mithilfe von screen:

    Code
    screen /dev/ttyAMA0 9600


    Alternativ könnt ihr auch folgendes bash Script verwenden um alle nötigen Schritte zum freischalten vornehmen zu lassen:

    &quot;rpi-serial-console.sh&quot;


    quellen:
    https://asciich.ch/wordpress/uart…berrypi-nutzen/
    http://kampis-elektroecke.de/?page_id=1682
    https://github.com/lurch/rpi-seri…-serial-console

  • [an=Sketches][/an]Sketches für Sender und Receiver


    Die Sketches sind über github verfügbar - so muss ich nicht immer mehrere Orte up2date halten...

    TinyRX: https://github.com/meigrafd/TinyRX4

    TinyTX: https://github.com/meigrafd/TinyTX4


    Watchdog: Verbraucht solange er nichts sendet nur ~4uA. Der vorherige Sketch verbraucht dahingegen ~1,02mA (Vergleich siehe > hier < von > diesen < überarbeiteten Sketches)

    Kompilierte Sketch Größen:

    Spoiler anzeigen


    Send_DHT22.ino mit RFM12B lib --> Binäre Sketchgröße: 5.254 Bytes
    Send_DHT22_Watchdog.ino mit RFM12B lib --> Binäre Sketchgröße: 5.512 Bytes
    Send_DHT22_Watchdog_JeeLib.ino mit JeeLib --> Binäre Sketchgröße: 5.082 Bytes

    Send_DHT22.ino mit RFM12B lib & Verschlüsselung --> Binäre Sketchgröße: 6.896 Bytes
    Send_DHT22_Watchdog.ino mit RFM12B lib & Verschlüsselung --> Binäre Sketchgröße: 7.154 Bytes
    Send_DHT22_Watchdog_JeeLib.ino mit JeeLib & Verschlüsselung --> Binäre Sketchgröße: 6.746 Bytes

    Send_DS18B20.ino mit RFM12B lib --> Binäre Sketchgröße: 7.342 Bytes
    Send_DS18B20_Watchdog.ino mit RFM12B lib --> Binäre Sketchgröße: 7.590 Bytes
    Send_DS18B20_Watchdog_JeeLib.ino mit JeeLib --> Binäre Sketchgröße: 7.160 Bytes

    Send_DS18B20.ino mit RFM12B lib & Verschlüsselung --> ... 768 bytes zu groß
    Send_DS18B20_Watchdog.ino mit RFM12B lib & Verschlüsselung --> ... 1012 bytes zu groß
    Send_DS18B20_Watchdog_JeeLib.ino mit JeeLib & Verschlüsselung --> ... 578 bytes zu groß

    Send_ReedSwitch_Watchdog.ino mit RFM12B lib --> Binäre Sketchgröße: 4.312 Bytes
    Send_ReedSwitch_Watchdog_JeeLib.ino mit JeeLib --> Binäre Sketchgröße: 3.870 Bytes

    Send_ReedSwitch_Watchdog.ino mit RFM12B lib & Verschlüsselung --> Binäre Sketchgröße: 5.954 Bytes
    Send_ReedSwitch_Watchdog_JeeLib.ino mit JeeLib & Verschlüsselung --> Binäre Sketchgröße: 5.534 Bytes

    Send_BMP085_Watchdog_JeeLib.ino mit JeeLib --> Binäre Sketchgröße: 6.266 Bytes
    Send_BMP085_Watchdog_JeeLib.ino mit JeeLib & Verschlüsselung --> Binäre Sketchgröße: 7.894 Bytes

    Hinweis: Module mit JeeLib sind nicht kompatibel zu jenen ohne JeeLib.


    Hier sind auch die Sketches von Nathan Chantrell zu finden: https://github.com/nathanchantrell/TinyTX

  • [an=Empfaenger][/an]Das Perl Script welches die Daten vom UART entgegen nimmt und an ein PHP Script weiterreicht:

    Sensor.pl

    Spoiler anzeigen
  • [an=Einrichten_1][/an]Auf dem RaspberryPI muss folgendes eingerichtet werden:

    Vorraussetzung für nachfolgendes ist:

    Code
    apt-get update
    apt-get install apache2 php5 php5-gd php5-sqlite
    apt-get install libdevice-serialport-perl libwww-mechanize-perl libproc-daemon-perl

    Dann muss ein Verzeichnis im apache2 DocumentRoot sowie dort ein paar PHP Script angelegt werden:

    Code
    mkdir /var/www/Sensor

    In dem neu erstellten Verzeichnis müssen dann noch folgende Script ( add.php , index.php , functions.php , config.php ) abgelegt werden


    //EDIT:

    Mit Wheezy zeigt die DocumentRoot Einstellung auf /var/www/
    Mit Jessie zeigt die DocumentRoot Einstellung auf /var/www/html/
    Ihr müsst den "mkdir" Befehl also entsprechend erweitern/anpassen.

  • [an=Einrichten_2][/an]Es gibt 2 Besonderheiten für die Version mit Plot:

    • Leider ist JPGraph 3.5.0b1 leicht fehlerhaft und eine Datei aus dem Paket müsste bearbeitet werden:

      • jpgraph/src/gd_image.inc.php bearbeiten und die folgende Zeile, in der function SetAntiAliasing, auskommentieren ( // vor die ganze Zeile setzen ) (weiter unten steht auch ein sed Befehl um das zu bewerkstelligen)

        Code
        JpGraphError::RaiseL(25128);//('The function imageantialias() is not available in your PHP installation. Use the GD version that comes with PHP and not the standalone version.')
    • Für das Verzeichnis in dem die plot Bilder abgelegt werden, habe ich ein tmpfs erzeugt um die SD mit Schreibvorgängen zu entlasten, da bei jedem Aufruf der Seite neue Bilder erstellt werden. Also meine PHP Dateien usw habe ich im Verzeichnis /var/www/Sensor/ abgelegt und dadrin erstelle ich ein Verzeichnis graphs - wenn ihr das Zeuchs woanders hin legen wollt müsst ihr das halt entsprechend abändern...
      Ihr solltet auf jeden Fall darauf achten das www-data die nötigen Rechte in dem Sensor/ Verzeichnis hat:
      Code
      chown -R www-data:www-data /var/www/Sensor


      Eigentlich (..eigentlich..) müsste die index.php das graphs Verzeichnis sowie tmpfs selber anlegen und mounten aber falls das nicht funktioniert hier der manuelle Weg:

      Code
      mkdir graphs
      mount -t tmpfs tmpfs graphs -o defaults

    Es werden 4 Dateien benötigt.

    add.php:

    Spoiler anzeigen


    Dieses Script ist fürs eintragen der Sensor-Daten in die SQLite Datenbank zuständig. Es wird über das Perl Script Sensor.pl angesprochen


    Das sieht dann so aus:

    Spoiler anzeigen

    ydgz20wbypm.png


    Fehlersuche:

    In /var/www/ ( bzw seit Raspbian Jessie /var/www/html/ ) liegen erst mal nur ganz normale Webseiten-Dateien.
    Wenn noch keine Datensätze in der Datenbank vorhanden sind (oder allgemein die Datenbank Datei noch nicht existiert) wird ausschließlich folgendes angezeigt:

    Code
    need input! :)

    Wenn aber selbst das bei Dir nicht angezeigt wird, liegt das Problem wo anders:
    - Liegen die Dateien im DocumentRoot deines Webservers? -> Mit apache2 prüft man das in der "default" Konfigurationsdatei: /etc/apache2/sites-available/default
    - Wem gehören die Dateien? Der Webserver läuft über den Benutzer "www-data", welcher auch die Datei- und Verzeichnis-Rechte haben muss.
    - Tritt evtl. ein anderer Fehler auf? Apache2 protokolliert Fehler in die Datei /var/log/apache2/error.log

  • [an=Einrichten_3][/an]Anschließend sicherstellen das der apache2 Benutzer in den Verzeichnissen auch schreiben darf bzw ihm die Dateien gehören:

    Code
    chown -R www-data:www-data /var/www/Sensor/

    Dann das Sensor.pl ausführbar machen und anschließend ausführen:

    Code
    chmod +x Sensor.pl
    ./Sensor.pl

    Sender und Empfänger Module einschalten und den RaspberryPI WebServer ansurfen:

    Code
    http://raspberrypi.ip/Sensor/


    Damit die Sensor.pl im Hintergrund weiter läuft muss noch ein Programm installiert werden:

    Code
    apt-get install screen

    Anschließend würdet ihr das Script dann wie folgt starten können:

    Code
    screen -dmS sensor /path/to/Sensor.pl

    Also zum Beispiel: screen -dmS sensor /root/Sensor.pl


    Desweiteren ist es ratsam ein Watchdog einzurichten, der jede Minute überprüft ob das Sensor.pl Script noch läuft und falls nicht wird das Script neu gestartet:
    nano watchdog_Sensor.sh && chmod +x watchdog_Sensor.sh


    Dann den watchdog in die Crontab eintragen. Wer anstatt vi lieber nano benutzen möchte gibt ein mal vorher export EDITOR=nano ein und ruft anschliesend den Befehl zur bearbeiten der Crontab auf:

    Code
    crontab -e


    Der Eintrag sähe dann zum Beispiel so aus:

    Code
    * * * * *  /root/watchdog_Sensor.sh >/dev/null 2>&1

    ...Pfade ggf anpassen...

  • [an=Display][/an]Als nettes Gimmick kann noch ein SPI Display genutzt werden, um die Sensordaten anzuzeigen.

    Ich habe mich dazu entschieden ein 2,8" Touchscreen Display (Model: HY28B) zu verwenden, um zum einen das Display bei Bedarf Ein-/Aus- zuschalten und zum anderen durch Druck auf einen bestimmten Bereich durch die Sensoren wechseln zu können.
    Das Display kostet zZt ca. 10,77€ über eBay inkl. VSK (wie es auch hier bzw hier aufgelistet wird), also ein 8-bit SPI was allerdings ein Rastermaß von 2mm hat! Man kriegt dort also nicht ohne weiteres normale Steckbrett-Kabel drauf gesteckt da dafür der Abstand zwischen den Pins zu knapp ist - aber auch hierfür gibt es eine einfache Lösung: 2mm Rastermass Adapter oder Steckbrett-Kabel - 2.54mm zu 2.0mm
    Evtl. ist auch >das hier< identisch nur mit 2,54mm Rastermaß, zumindest sind die Daten Ähnlich und es steht HY28B dran... Genau wissen tu ichs aber nicht


    Bei der Installation bzw späteren Betrieb ist allerdings darauf zu achten das eine bestimmte rpi-firmware genutzt werden muss, in der Unterstützung fürs FBTFT Module vorhanden ist.

    Treiberinstallation:

    Spoiler anzeigen


    Quellen der Installations-Anleitung:
    https://github.com/notro/fbtft/wiki#install
    http://www.raspberrypirobot.com/tft-2-8-lcd-ra…isplay-monitor/


    (alle Befehle benötigen root Rechte! Also ggf sudo davor setzen!)

    • nano /etc/modprobe.d/raspi-blacklist.conf und blacklist spi-bcm2708 auskommentieren:

      Code
      #blacklist spi-bcm2708
    • Aktuelles RaspberryPI Update-Script laden:

      Code
      wget https://raw.github.com/Hexxeh/rpi-update/master/rpi-update -O /usr/bin/rpi-update && chmod +x /usr/bin/rpi-update
    • Installation der aktuellen Firmware sowie Kernel mit FBTFT Support (FBTFT drivers as loadable modules):

      Code
      REPO_URI=https://github.com/notro/rpi-firmware rpi-update


      ODER: FBTFT drivers built into the kernel proper

      Code
      REPO_URI=https://github.com/notro/rpi-firmware BRANCH=builtin rpi-update


      ODER eine bestimmte Firmware revision laden:

      Code
      REPO_URI=https://github.com/notro/rpi-firmware rpi-update afe7e2abbf5cd7b8a25931e0eb2ca52a42bab7f6

      (siehe dazu Changelog)

    • Neustarten:

      Code
      reboot
    • Nach neustart Treiber-Module laden:

      Code
      modprobe fbtft dma
      modprobe fbtft_device name=hy28b rotate=90
    • Die letzten Zeilen von dmesg prüfen ob das Display erkannt wurde..

    Beachten müsst ihr auch das apt-get upgrade u.U. dafür sorgen kann dass das hier nicht mehr funktioniert (da dann das Paket raspberrypi-bootloader ersetzt werden würde).
    Um dieses Problem zu umgehen müsstet ihr wie folgt vorgehen:

    Code
    apt-mark hold raspberrypi-bootloader
    apt-get update
    apt-get upgrade

    Verkabelung und Einrichtung:

    Spoiler anzeigen

    Quelle: [Eure Meinung ist gefragt] Immer auf die Kleinen: von LCDs und TFT-Displays

    Wie die Verkabelung vermuten läßt, könnte man über den BL_CTRL -> GPIO18 die Hintergrundbeleuchtung, über den einen PWM Pin des RPI's, beliebig hell einstellen :)

    Software Installation:
    SPI aktivieren ist überall gleich, das beschreib ich hier also nicht noch mal :)
    Nur der Treiber für das Display und's Touchpanel ist natürlich anders. Also /etc/modules bearbeiten und folgendes einfügen (sofern noch nicht vorhanden!):

    Code
    fbtft dma
    fbtft_device name=hy28b rotate=90
    ads7846_device pressure_max=255 y_min=190 y_max=3850 gpio_pendown=17 x_max=3850 x_min=230 x_plate_ohms=100 swap_xy=1 verbose=3

    Um das Touchpanel zu kalibrieren und später auch über Python oder X benutzen zu können, muss man ein paar Pakete installieren:

    Code
    apt-get update
    apt-get install libts-bin evtest xinput python-dev python-pip

    Dann pip benutzen um evdev zu installieren:

    Code
    pip install evdev

    Und anschließen die eigentliche Kalibrierung:

    Code
    sudo TSLIB_FBDEVICE=/dev/fb1 TSLIB_TSDEVICE=/dev/input/event0 ts_calibrate


    Wenn ihr andere Eingabegeräte angeschlossen habt, wie eine Maus oder Tastatur, dann müsst ihr /dev/input/event0 anpassen also zB auf /dev/input/event1 oder /dev/input/event2 etc.
    Dieser Schritt ist wichtig damit die Abmasse erkannt werden und die berührbare Fläche dem System bekannt sind! Benutzt am besten einen Stift ohne Spitze (auf keinen Fall eine Kugelschreibermine sonst verkratzt die Displayoberfläche!), oder eben einen speziellen Touchscreen-Pen.

    Beachtet auch das ihr nicht nur das Display rotiert sondern auch das TouchPanel. Also wenn ihr die Darstellung des Displays um 90° dreht dann müsst ihr auch die Touch Fläche mit drehen sonst sind die Achsen vertauscht ;)


    Der Installations/Einrichtigs-Prozess ist auch noch mal auf folgenden Links gut beschrieben:
    http://www.raspberrypi.org/forums/viewtopic.php?f=45&t=64993
    http://www.raspberrypirobot.com/tft-2-8-lcd-ra…isplay-monitor/


    PS: Hier steht zu Displays allgemein btw auch was: http://elinux.org/RPi_Screens#TFT_LCD_Modules


    /EDIT: Um die ts_calibrate Einstellungen nicht nach jedem Reboot erneut machen zu müssen kann man folgende Schritte durchführen:

    • Sicherstellen das in /etc/ts.conf folgendes aktiviert ist:

      Code
      module_raw input
      module pthres pmin=1
      module variance delta=30
      module dejitter delta=100
      module linear
    • /etc/profile bearbeiten und ans Ende folgendes einfügen:

      Code
      export TSLIB_TSDEVICE=/dev/input/event0
      export TSLIB_TSEVENTTYPE=INPUT
      export TSLIB_CONFFILE=/etc/ts.conf
      export TSLIB_CALIBFILE=/etc/pointercal

      Achtet auf /dev/input/event0 und passt es euren Gegebenheiten an. Um das Device zu finden (muss bei euch ja nicht /dev/input/event0 sein) probiert einfach die event Devices in /dev/input/event<nummer> durch, zB: cat /dev/input/event0
      Sobald Zeichen in der Console auftauchen wenn ihr den Touchscreen berührt, habt ihr das richtige Device gefunden.

    Optional:

    Um die Start Konsole auf dem SPI Display zu haben muss die /boot/cmdline.txt wie folgt angepasst werden und dann ungefähr so aussehen:

    Code
    dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait fbcon=map:10 fbcon=font:VGA8X8


    letzteres legt den Font fest. SUN8x16 sieht wie ich finde ganz gut aus aber ansonsten gingen auch: MINI4x6 , VGA8x8 , Acorn8x8 , PEARL8x8 , ProFont6x11 , 7x14 , VGA8x16 , SUN8x16 , 10x18 , SUN12x22

    Script Features:

    • Das Backlight kann durch einfaches antippen irgendwo* auf dem Display Ein- und Aus-geschaltet werden
      :* ca. 1/3 des oberen Teils vom Displays ist aber für Schaltflächen vorgesehen, also das Backlight kann nur im unteren 2/3 Bereich des Displays gesteuert werden.
    • Jedesmal wenn man auf das Display tippt um das Backlight aus und wieder ein zu schalten werden die aktuellen Werte des ausgewählten Sensors ausgelesen.
    • Oben rechts in der Ecke ist ein rotes Rechteck auf dem mit schwarzer Schrift "Next" steht. Darüber kann man die Werte des nächsten Sensors anzeigen lassen.
    • Wurde die Liste der Sensoren ein mal durch geblättert, wird die Liste neu erstellt - falls man wärend des Betriebs einen neuen Sensor hinzugefügt hat brauch man das Script nicht neu starten


    Script Einrichtung:

    Spoiler anzeigen

    touchTiny.py

    Script ausführbar machen:

    Code
    chmod a+x touchTiny.py

    Script starten mit:

    Code
    nohup ./touchTiny.py


    somit läuft es im Hintergrund weiter auch wenn ich mich abmelde..


    Desweiteren hab ich ein nützliches Script erstellt um das BackLight ein-/aus-zuschalten: nano /sbin/disp && chmod +x /sbin/disp

    Bash
    #!/bin/bash
    [ -z "$1" ] && echo "Usage: $0 [on|off]" && exit 1
    [ "$1" == "on" ] && echo 0 > /sys/class/backlight/fb_ili9325/bl_power
    [ "$1" == "off" ] && echo 1 > /sys/class/backlight/fb_ili9325/bl_power

    Und auch ein Crontabeintrag gemacht um das SPI Display (bzw BackLight) zur Schlafenszeit auszuschalten sowie morgens dann wieder einzuschalten:

    Code
    # turn off spi display
    30 23 * * *    /sbin/disp off
    #turn on spi display
    00 07 * * *    /sbin/disp on

    (Die Daten werden aber nicht aktualisiert, das kommt in der nächsten Version des Scripts :))


    Eine Installationsanleitung für ein 2,2" SPI Display ohne Touch für ca. 4€ findet ihr > hier < und das dazugehörige Tiny.py Script findet ihr > hier <

  • [an=TinyTX_Platinen][/an]
    TinyTX Platinen:

    Leider sorgen unterschiedliche Platinen immer wieder für Verwirrung.. Deshalb hier noch mal ein Vergleich aller mir bekannten TinyTX Platinen:


    Es gibt eine ältere Entwicklung, die TinyTX2. Hier ein vergleich zwischen TinyTX2 und TinyTX3:

    Spoiler anzeigen

    TinyTX3_Comparison_s.jpg

    Hier sollte nicht nur der Größenunterschied auffallen sondern auch die beiden Kondensator Anschlussmöglichkeiten. Beim TinyTX3 kann der Widerstand bei Bedarf oben beim kleine "Breadboard" untergebracht werden.


    Von den TinyTX3 Platinen gibt es aufgrund von unterschiedlichen PCB Herstellern auch noch 2 weitere Platinen:

    Spoiler anzeigen


    TinyTX3 Platine die über SeeedStudio gefertigt wird:

    (10 Stück für $9,90 plus VSK)

    TinyTX3 Platine die über circuits.io gefertigt wird:

    (3 Stück für $14,67 plus VSK)

    Bei den PCB's von circuits.io sollte auffallen das dort die Beschriftung fehlt, ansonsten sind die Platinen (abgesehen der PCB-Farbe) identisch zueinander.


    [an=TinyTX_Hinweise][/an]
    TinyTX Hinweise:


    Es kamen auch immer wieder Fragen auf, ob man eine TinyTX3 Senderplatine auch als Empfänger nutzen könnte.
    Hier die Auflösung:

    Der RFM12B kann sowohl Senden als auch Empfangen. Der RFM12B wird bei sowohl Empfänger- als auch Sender-Platine fast identisch an den ATtiny84A angeschlossen.

    Allerdings gibts eine Ausnahme beim Anschluss/Beschaltung des ATtiny84A beim Empfänger:
    Pin#4 wird beim Empfänger mit einem Widerstand vor Vcc versehen, was beim Sender nicht der Fall ist... In der Entwicklungsphase stellten wir fest dass das vorhanden sein dieser Widerstände besser wäre, aber nicht zwingend erforderlich. Die können also notfalls, wenns denn unbedingt sein muss, auch weg gelassen werden.

    Bei der Empfänger-Platine (TinyRX) wird pin#6 vom ATtiny für den RX-Kanal zum PI verwendet.
    Dieser Pin ist bei sowohl TinyTX3 als auch TinyTX4 oben über das 2.Lötauge von links zugänglich und ist mit einer 3 beschriftet, was für D3 steht. Dieser Pin wird im Sketch als txPin verwendet und muss also auf 3 gestellt sein.
    Was der ATtiny sendet (tx) muss der PI empfangen (rx).

    Man könnte also zumindest Theoretisch daher gehen und eine gekaufte TinyTX3 Platine, die eigentlich als Sender gedacht ist, auch als Empfänger nutzen indem man oben das 2.Lötauge fürs Kabel zum RaspberryPI verwendet und natürlich auch den richtigen Sketch flasht.

    Fazit: Ja das ist möglich ;)

  • [an=TinyTX4][/an]
    TinyTX4:

    Allgemein zu unserem "Sammelbestellungs" Tiny RX/TX 4 PCB's:

    Der ISP Sockel (bzw ICSP) ist standardisiert, die Belegung steht aber auch jeweils neben dem Pin auf der Platine ;) Eine 1 markiert den ersten Pin, eine 2 den zweiten..

    Code
    Arduino        ICSP
    ------------|----------
    pin#12        pin#1 (MISO)
    5V            pin#2 (VCC)
    pin#13        pin#3 (SCK)
    pin#11        pin#4 (MOSI)
    pin#10        pin#5 (RESET)
    GND           pin#6 (GND)
    Code
    RaspberryPI        ICSP
    ----------------|----------                  
    pin#21 (GPIO-9)   pin#1 (MISO)
    pin#1  (3V3)      pin#2 (VCC)
    pin#23 (GPIO-11)  pin#3 (SCK)
    pin#19 (GPIO-10)  pin#4 (MOSI)
    pin#24 (GPIO-8)   pin#5 (RESET)
    pin#6  (GND)      pin#6 (GND)


    Empfänger-Bild:

    Spoiler anzeigen

    TinyRX4_large.png


    Beim Empfänger haben wir uns am RFM2Pi_rev3 orientiert, nur eben mit SMD Bauteilen ;)
    Beim Empfänger sind für den Anschluss an den PI folgende Pins wichtig:

    • GND
    • RX
    • TX (optional, nur wenn das Module auch etwas senden soll)
    • 3V3


    Entweder man bringt eine 5x2 Buchsenleiste an und steckt den Empfänger direkt auf die P1 GPIO Leiste vom RaspberryPI (die 1 markiert erneut den ersten Pin wie es auch beim PI der Fall ist) , oder man verlötet direkt Kabel bzw eleganter wäre eine Stiftleiste und dann Brückenkabel.
    Der Empfänger wird so auf den PI gesteckt dass die Platine über dem PI ist und nicht heraus ragt - also kann nur oben links in der Ecke pin#1 sein.

    Alle Pins sind nochmals daneben ausgeführt damit man beim aufstecken via Buchsenleiste ggf unbenutzte Pins trotzdem noch weiter verwenden kann, oder die Pins auch mehrmals nutzen könnte.
    Ebenso bei den nicht benutzten Pins des RFM12B Modules, die sind ebenfalls über separate Lötaugen zugänglich (bei sowohl Empfänger als auch Sender Platinen) (*)

    JP1 dient zur Überbrückung des 3V3 Anschlusses vom ISP Sockel. Ist der nicht geschlossen und kein 3V3 am regulären PI-pin gegeben, kriegt das PCB kein Strom..
    JP2 ist 3 polig und beeinflusst folgende Pins des ATTiny's (von rechts nach links des Jumpers): pin#2 D0 , pin#12 A1 und pin#13 A0 (AREF). Das sind die unbenutzten Pins und könnten anderweitig verwendet werden.


    Sender-Bild:

    Spoiler anzeigen

    TinyTX4_large.png


    Der Sender passt genau in das 1551RBK :: Mini-ABS-Gehäuse, 50x50x20mm von Reichelt. Links oben und rechts unten sind Befestigungslöcher. Die Aussparungen in den Ecken sind für die Schauben des Gehäuses und da noch genug Platz war wurde auf Userwunsch rechts ein Breadboard eingefügt, bei dem die Pins horizontal miteinander verbunden sind aber keine Verbindung zum Rest des PCB's besteht.

    Wer eine Senderplatine ohne Booster bestellt hat, der muss unten bei den beiden Lötaugen wo "No Booster" drüber steht eine Brücke setzen damit das PCB mit Strom versorgt werden kann. Jene mit Booster sollten das aber nicht machen da sonst der Booster keinen Zweck mehr erfüllt :)

    Auch hier ist wieder ein Standard ISP Sockel angebracht, der aber um 180° gedreht ist (Ausgehend von der restlichen Beschriftung) da das mit den Leiterbahnen besser passte (weniger Überkreuzungen).
    Über dem ISP sind die Lötaugen für die Sensoren. Die unterste Reihe ist durchgängig GND. Die zweite Reihe ist mit der ersten (oberste) verbunden, also der Pin-0 mit dem aus der zweiten Reihe - also vertikale Verbindung nicht horizontal ;)[an=TinyTX_Loetaugen][/an]

    Die Pins 0 bis 10 sind jeweils zu einem Pin des ATTiny verbunden: 0, 3, 7, 8, 9, 10 -> 6 mögliche Data Pins. Primär sollte man aber Pin#10 nutzen da genau daneben auch GND und VCC liegen, was den Anschluss des Sonders (ggf direkt auflöten oder über eine Buchsenleiste einstecken) vereinfacht.
    Die Nummerierung der Lötaugen auf unserer Senderplatine (TinyTX4) beziehen sich auf was anderes, nicht auf die Pins des ATtiny84 ... Man muss pin# und pin-Bezeichnung unterscheiden:
    Lötauge # 0 auf der TinyTX4 Platine geht an pin#2 vom ATtiny und trägt die Bezeichnung: D0 / PB0
    Lötauge # 3 auf der TinyTX4 Platine geht an pin#6 vom ATtiny und trägt die Bezeichnung: D3 / PA7
    Lötauge # 7 auf der TinyTX4 Platine geht an pin#10 vom ATtiny und trägt die Bezeichnung: D7 / PA3
    Lötauge # 8 auf der TinyTX4 Platine geht an pin#11 vom ATtiny und trägt die Bezeichnung: D8 / PA2
    Lötauge # 9 auf der TinyTX4 Platine geht an pin#12 vom ATtiny und trägt die Bezeichnung: D9 / PA1
    Lötauge # 10 auf der TinyTX4 Platine geht an pin#13 vom ATtiny und trägt die Bezeichnung: D10 / PA0

    Wie auch schon beim Empfänger sind derzeit unbenutzte Pins des RFM12B Modules ebenfalls nochmals separat über Lötaugen verfügbar(*)


    (*) -> Das haben wir deshalb gemacht da es in seltenen Fällen vorkommen kann das zB FSK oder nINT benutzt werden muss, was aber normalerweise vom TinyTX3 Projekt nicht vorgesehen war..


    Booster:

    Beim "LTC3525 boost regulator chip" handelt es sich um einen 3V3 StepUP und dient dazu noch das letzte quentchen Saft aus den Batterien/Akkus raus zu quetschen. Aktiv wird er mit einer Eingangsspannung von mind. 0.8V ; arbeitet runter bis zu 0.3V und liefert derweiln eine konstante Ausgangsspannung von 3.3V - und das bei einer sehr guten Effizient von 95% sowie einem sehr geringen Eigenverbrauch.

    Es ist aber kein Step-DOWN! Wenn also die Einspeisung über 3V3 liegt macht er nichts und reguliert das auch nicht runter! Deshalb unbedingt darauf achten nicht mehr als 5.5V auf die TinyTX4 zu jagen!


    Größenvergleich unserer 3 PCB's sowie ein Bild des Boosters und eine Beschreibung des Boosters ist auch unter dem booster-only Bild zu finden:

    Spoiler anzeigen

    ist etwas unscharf aber hierfür eigentlich auch unwichtig..

    Von links nach rechts: Sender(TinyTX4) ; Empfänger(TinyRX4) ; Booster-only ; DHT22
    https://app.box.com/s/vh9z13rkyxx1yvmgfvb2dpwtgj34g24t
    Liegen btw auf einem Blatt Klopapier

    Und hier noch mal nur der Booster-Only, leicht von der Seite mit Blitz:
    https://app.box.com/s/teat4x7cvxoe0t53msogm8nksgcaor9h

    Auf den obersten oder den 2.pin schließt man plus von der Stromversorgung an.
    Der zweite + Pin ist optional und dient zur Messung wieviel Volt die Stromversorgung noch hat. Das müsste man dann zum ATtiny Chip verkabeln
    In der mitte sind 2x GND für minus der Stromversorgung und Weiterführung zum PCB.
    Der unterste 3V3 pin ist dann der geregelte Step-Up Output fürs PCB.

    Der Booster wird zwischen die SpannungsVersorgung und dem Rest (pcb) angebracht


    Kurze Zwischenfrage. Ist der Sender neben 5V auch 9V resistent (was sehr genial wäre)?

    Nein.
    Der verbaute Boost-Converter ist nur ein Step-Up, kein Step-Down.

    Der ATtiny Chip verträgt maximal 5,5V.
    Das RFM12B Modul verträgt maximal 6V laut Datenblatt (Seite 8).
    Der LTC3525 boost regulator chip verträgt maximal 5,5V.
    Die anderen Bauteile (Kondensatoren und Spule) vertragen afaik maximal 6V

    Also liegt die Grenze bei maximal 5,5V -> man kann also maximal 3 x AA Batterien (á 1,5V) oder 4 x AA Akkus (á 1,2V) verwenden.

    Beachtet auch das volle Batterien/Akkus meistens minimal mehr Spannung haben, also geht lieber sicher und setzt euch ein Limit von 5V um nichts zu beschädigen.

  • [an=ide16][/an]Hinweis für Arduino-IDE ab v1.6.4

    Seit der Arduino-IDE 1.6.4 hat sich ein bisschen was verändert - bin aber noch nicht dazu gekommen diese Neuerung in meine Anleitung hier zu integrieren... Da aber im Entwicklungsthread immer wieder Fragen hierzu auftreten habe ich mich dazu entschlossen eine grobe Beschreibung hier anzuhängen, und hoffentlich bald genug Zeit zu haben das in die bisherige Anleitung an passender Stelle zu integrieren..


    Wer noch eine ältere Arduino-IDE als 1.6.4 verwendet kann diese Beschreibung ignorieren und muss weiterhin eine zip manuell herunterladen.
    Mittlerweile empfehle ich allerdings:
    - Für Arduino-IDE 1.0.x => https://github.com/damellis/attiny/archive/ide-1.0.x.zip
    - Für Arduino-IDE 1.6.x => https://github.com/damellis/attiny/archive/ide-1.6.x.zip


    Ab Arduino-IDE 1.6.4 ist es nun möglich mithilfe des sog. " Boards Manager"s Unterstützung für andere Boards in die IDE zu integrieren.
    In meiner derzeitigen Anleitung wird noch beschrieben eine "arduino-tiny-0150-0018.zip" herunter zu laden etc. Wer also vor hat Arduino-IDE zu verwenden, der muss diesen Schritt mit dem folgenden ersetzt:

    Zunächst müsst ihr in die Preferences (File => Preferences) gehen und dort folgendes unter Additional Boards Manager URLs eintragen:

    Code
    http://drazzy.com/package_drazzy.com_index.json


    In der Deutschen Version wäre das: Datei => Voreinstellungen => Zusätzliche Boardverwalter-URLs

    Klickt anschließend auf OK.

    Dann geht ihr auf den Menüpunkt Tools und dann auf Boards Manager...
    In einer deutschen Version entspricht das: Werkzeuge => Boardverwalter

    Anschließend scrollt ihr vollständig nach unten bis attiny oder ATTinyCore auftaucht... Das hängt davon ab welche URL ihr zuvor eingefügt habt, es gibt nämlich verschiedene 3rd Party Erweiterungen
    Wählt das an und kontrolliert am besten unten rechts die zu installierende Version; bei mir stand da 1.0.1 kann aber sein das mittlerweile eine neuere raus ist. Klickt anschließend rechts daneben auf Install und schließt das "Boards Manager" Fenster.

    Nun sollte unter Tools => Boards etwas neues auswählbar sein, also entweder ATtiny oder aber auch ATtiny x4 wobei das x ein Platzhalter ist also für zB 84.

  • Hi,
    Vielleicht wäre eine Anfrage hier passend:
    ich bin gerade am überlegen, wie ich die TX3 Platine (da ich keine Lust auf fitzelige SMD-Bauteile hab) am Besten bestellen kann. Dabei ist mir aufgefallen, dass man bei itead z. B. Pauschal für Platinen bis 5cmx5cm bezahlt - da ginge die TX3 Platine 2 Mal rein. Aus dem Grund die Frage:
    ist jemand in der Lage und so nett, die Platinendaten auf einem Layout zu doppeln, sodas man am Ende doppelt so große Platinen bekommt, die man durch auftrennen (Säge) dann zu einzelnen Platinen machen kann?

    Oh ... gerade gesehen: bei Seeed geht sogar bis 100mm x 100mm - das heißt: man könnte noch deutlich effektiver Platinen ordern - aus 1 mach 8 - kann da jemand helfen? Eine Bestellung über 10 Stück wären dann 80 TinyTx Platinen ...

    Wäre echt super!
    Grüße

    Einmal editiert, zuletzt von daniu (6. September 2017 um 18:06)

Jetzt mitmachen!

Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!