Batteriebetriebene Funk Sensoren

    Vorwort:


    Fragen usw bitte im Entwicklungs-Thread stellen


    [hr]


    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:


    [hr]


    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 <



    [hr]
    [hr]


    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]


    [hr]
    [hr]



    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/



    [hr]
    [hr]


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



    [hr]
    [hr]
    [hr]


    [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.


    [hr]


    [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)


    [hr]


    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/…/17/rfm12-tutorial-part2/
    Oder hier ein Vergleich zwischen RFM12, RFM22 und RFM23: http://blog.strobotics.com.au/…g-brothers-to-the-rfm12b/


    [hr]


    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)


    [hr]


    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 (Affiliate-Link) ... 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/N…_Sende_Empfangsmodul.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 (Affiliate-Link) ... für 1,15eu
    3x AA Batterie-Halter geschlossen mit Ein-/Aus-Schalter über amazon (Affiliate-Link) ... für 2,10eu


    3x AAA Batterie-Halter geschlossen mit Ein-/Aus-Schalter über amazon (Affiliate-Link) ... für 2,19eu
    3x AAA Batterie-Halter geschlossen über amazon (Affiliate-Link) ... für 1,38eu


    10x Single Reihe Stift- und Buchsenleiste über amazon (Affiliate-Link) ... 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€)


    [hr]


    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)


    Quote


    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:



    [hr]



    Den Receiver kann man auch fertig bestellen: http://shop.openenergymonitor.…berry-pi-expansion-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…de/onlinekurs/eagleboard/

    External Content www.youtube.com
    Content embedded from external sources will not be displayed without your consent.
    Through the activation of external content, you agree that personal data may be transferred to third party platforms. We have provided more information on this in our privacy policy.



    //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:


    [hr]


    Stripboard Plan für Empfänger:


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


    [hr]


    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:


    quelle: http://blog.stevemarple.co.uk/…isp-programmer-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…rduino-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/A…-DHT22/archive/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:



    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)


    [hr]


    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


    [hr]


    Jessie:


    Code
    sudo systemctl disable serial-getty@ttyAMA0.service


    [hr]
    [hr]


    Bezüglich Raspberry Pi 3B siehe hier: http://www.forum-raspberrypi.d…egen?pid=217217#pid217217


    [hr]
    [hr]


    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:




    quellen:
    https://asciich.ch/wordpress/u…f-dem-raspberrypi-nutzen/
    http://kampis-elektroecke.de/?page_id=1682
    https://github.com/lurch/rpi-s…master/rpi-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



    [hr]
    [hr]


    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:



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


    [hr]


    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

    [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:

    [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/


    [hr]


    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:


    Verkabelung und Einrichtung:


    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:



    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:


    [hr]


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



    [hr]
    [hr]


    [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:


    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.


    [hr]


    Sender-Bild:


    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..



    [hr]


    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:



    [hr]
    [hr]


    Quote from dbv

    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..


    [hr]


    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


    [hr]


    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

    Edited once, last by daniu ().