jar und meigrafd: ihr hattet beide Recht, neuen Tiny genommen und kein Bootloader drauf gemacht, bzw Fuses geändert.
klappt jetzt besser
jar und meigrafd: ihr hattet beide Recht, neuen Tiny genommen und kein Bootloader drauf gemacht, bzw Fuses geändert.
klappt jetzt besser
Ein Hello World bekomme ich schonmal vom Tiny zum RPi, aber ich muß in CuteCom/minicom 1200 Baud einstellen obwohl ich dem Tiny sage er soll 9600 nehmen.
liegt das eventuell an den 8Mhz die der macht?
[font="monospace"]#include <SoftwareSerial.h>[/font]
[font="monospace"]int rxPin = 10;[/font]
[font="monospace"]int txPin = 0; [/font]
[font="monospace"]SoftwareSerial mySerial(rxPin,txPin);[/font]
[font="monospace"]void setup() [/font]
[font="monospace"]{ [/font]
[font="monospace"] pinMode(txPin, OUTPUT); [/font]
[font="monospace"] pinMode(rxPin, INPUT); [/font]
[font="monospace"] [/font]
[font="monospace"] mySerial.begin(9600);[/font]
[font="monospace"]}[/font]
[font="monospace"]void loop() [/font]
[font="monospace"]{[/font]
[font="monospace"] mySerial.println("Hello, world?");[/font]
[font="monospace"]}[/font]
dreamshader
Meine Module fuktionieren ja auch direkt am RPi, Sender und Empfänger, aber es beschränkt sich auf den Funksteckdosenbereich.
Im Moment hab ich das drauf, mit ein paar zeilen zusätzlich für Test LED:
// Projekt: TinyNode
// ----------------------------------------------------------
// Sensor: DHT22
// Sketch: Verschicken der Temperatur- und Luftfeuchtigkeit
// Datum: 10.11.2013
// ----------------------------------------------------------
// Basiert zum Teil auf der Arbeit von Nathan Chantrell
//------------------------------------------------------------------------------
// Library-Include
//------------------------------------------------------------------------------
#include <VirtualWire.h> // http://www.airspayce.com/mikem/arduino/
// Fix auf dieser Seite beachten:
#include <JeeLib.h> // https://github.com/jcw/jeelib
#include <DHT22.h> // https://github.com/nathanchantrell/Arduino-DHT22
//------------------------------------------------------------------------------
ISR(WDT_vect) {
Sleepy::watchdogEvent();
}
//---------------------------------------------------------------------------------------------------------
// PIN-Konfiguration
//---------------------------------------------------------------------------------------------------------
const int SENSORID = 1; // Die ID des Sensor-Nodes. Dient zur Identifizierung der Daten.
const int DHT22_DATA_Pin = 0; // PIN, an den das DATA-Bein des DHT-Sensor angeschlossen ist
const int DHT22_VCC_Pin = 1; // PIN, an den das VCC-Bein des DHT22-Sensors angeschlossen ist
const int TX_Pin = 3; // PIN, an den der 433 Mhz Sender angeschlossen ist
const int interval = 5; // Interval x 60 Sekunden = Schlafzeit zwischen Sensordaten-Übermittlung
//---------------------------------------------------------------------------------------------------------
DHT22 myDHT22(DHT22_DATA_Pin); // DHT-Setup
int durchlauf = interval; // Zähler für Schleife; ist gleich dem Interval, damit bei Start des ATTiny direkt ein Temperaturwert übermittelt wird
long temp; long humi; // Variablen für Temperatur/Luftfeuchtigkeit
char msg[26]; // Temperatur-String zum Versand per 433 Mhz
void setup()
{
vw_setup(2000); // VirtualWire und 433 Mhz-Sender initialisieren
vw_set_tx_pin(TX_Pin);
analogReference(INTERNAL); // Set the aref to the internal 1.1V reference
pinMode(DHT22_VCC_Pin, OUTPUT); // VCC-Pin des DHT22 als Ausgang setzen
ADCSRA &= ~ bit(ADEN);
bitSet(PRR, PRADC); // Stromsparen: ADC deaktivieren
}
void loop()
{
while(durchlauf < interval) {
durchlauf = durchlauf +1;
Sleepy::loseSomeTime(60000);
}
DHT22_ERROR_t errorCode;
digitalWrite(DHT22_VCC_Pin, HIGH); // DHT22-Sensor einschalten
Sleepy::loseSomeTime(2500); // DHT22 benötigt mindestens 2 Sekunden für Aufwärmphase nach dem Power-On
errorCode = myDHT22.readData(); // Daten aus Sensor auslesen
if (errorCode == DHT_ERROR_NONE) { // Daten sind OK
temp = myDHT22.getTemperatureC()*100;
humi = myDHT22.getHumidity()*100;
}
digitalWrite(DHT22_VCC_Pin, LOW); // DHT22 ausschalten
// Temperatur/Luftfeuchtigkeit auslesen, mit 100 multiplizieren für Ganzzahl-Umwandlung.
// Wird auf Empfängerseite durch 100 geteilt für korrektes Ergebnis.
// Float-Vars lassen sich nicht mit printf() auf Arduino ausgeben! Das ist ein Workaround!
// http://forum.arduino.cc/index.php?topic=197900.msg1461205#msg1461205
int humiINT = (int)humi;
int tempINT = (int)temp;
int vccINT = (int)readVcc();
// msg-Variable mit Daten zum Versand füllen, die später an das WebScript übergeben werden
snprintf(msg, 26, "s=%d&t=%d&h=%d&v=%d", SENSORID,tempINT,humiINT,vccINT) ;
vw_send((uint8_t *)msg, strlen(msg)); // Daten per VirtualWire-Lib versenden
vw_wait_tx(); // Auf kompletten Versandt warten
durchlauf = 1; // Den Durchlauf-Zähler auf 0 setzen, damit das Interval von vorne beginnt
}
// readVcc()-Lib von Nathan Chantrell
// Gibt die Spannung der Stromversorgung in mV aus
// https://github.com/nathanchantrell/TinyTX/blob/master/TinyTX_DS18B20/TinyTX_DS18B20.ino
long readVcc() {
bitClear(PRR, PRADC);
ADCSRA |= bit(ADEN); // Enable the ADC
long result;
// Read 1.1V reference against Vcc
#if defined(__AVR_ATtiny84__)
ADMUX = _BV(MUX5) | _BV(MUX0); // For ATtiny84
#else
ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); // For ATmega328
#endif
delay(2); // Wait for Vref to settle
ADCSRA |= _BV(ADSC); // Convert
while (bit_is_set(ADCSRA,ADSC));
result = ADCL;
result |= ADCH<<8;
// Kalibrierung der VCC-Anzeige
// http://provideyourown.com/2012/secret-arduino-voltmeter-measure-battery-voltage/
// Abschnitt: Improving Accuracy
// scale_constant = internal1.1Ref * 1023 * 1000
// internal1.1Ref = 1.1 * Vcc1 (per voltmeter) / Vcc2 (per readVcc() function)
// Default: 1125300L
// Meine Konstante: 1070860L, errechnet mit 3x1,5V Batterien als VCC
result = 1070860L / result; // Back-calculate Vcc in mV; Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
ADCSRA &= ~ bit(ADEN);
bitSet(PRR, PRADC); // Disable the ADC to save power
return result;
}
Alles anzeigen
ich google mich ja auch schon zu Tode, aber wie bereits geschrieben empfangen alle mit Arduino, nicht mit RPi, zumindest finde ich sonst nix zu 433Mhz.
Außer natürlich Funkdosen, aber da wird der Empfänger nur zum auslesen des Fernbedienung genutzt, die Sniffer warten nur auf Code den sie verstehen.
dreamshader
ja die meine ich, komme nicht so recht weiter, mein Problem ist das mit den Dingern entweder nur Funkdosen geschaltet werden, was bei mir auch klappt.
Oder es wird Arduino und nicht RPi auf der Empfängerseite genutzt. Ich gehe davon aus das mein Sender wie hier http://www.3bm.de/2013/11/24/att…teln/#more-1510 beschrieben funktioniert, kann es nur leider nicht empfangen.
Ich überlege ob ich nen neuen Beitrag mache, weil es hier zwar im Grunde um das gleiche geht, aber doch unterschiedliche Wege genommen werden.
Edit:
Das flashen des Tiny hat auf jedenfall geklappt, weil meine selbst eingebaute Test LED blinkt wie sie soll
Edit2:
Ich werde wohl als nächstes einen Tiny nehmen und ihn einfachen Text erstellen/verschicken lassen und versuchen mit dem RPi abzugreifen, wenn ich das schaffe werde ich mir den folgenden Code vornehmen, den Netzwerkkram rauslöschen und versuchen so umzuwandeln das nen Tiny zwischen Empfänger und RPi quasi übersetzt und ich endlich meine Daten am RPi bekomme.
#include <VirtualWire.h>
#include <SPI.h>
#include <Ethernet.h>
const int RECEIVERID = 1; // ID des Empfängers
const int RX_Pin = 8; // PIN, an den der 433 Mhz Empfänger angeschlossen ist
const int TX_Pin = 9; // Einen leeren PIN angeben, da die VirtualWire-Lib sonst einen Pin belegt, der für den Ethernet-Chip genutzt wird
const int PTT_Pin = 7; // Einen leeren PIN angeben, da die VirtualWire-Lib sonst einen Pin belegt, der für den Ethernet-Chip genutzt wird
byte mac[] = {
0x00, 0xAB, 0xCB, 0xCD, 0xDE, 0x02 };
byte ip[] = {
192,168,2,177 };
byte subnet[] = {
255,255,255,0 };
byte gateway[] = {
192,168,2,1 };
byte dns1[] = {
192,168,2,1 };
char server[] = "www.3bm.de";
EthernetClient client;
void setup() {
Serial.begin(9600);
// VirtualWire initialisieren
vw_setup(2000); // Bits/Sec
vw_set_rx_pin(RX_Pin); // Empfangs-Pin für den 433-Empfänger setzen
vw_set_tx_pin(TX_Pin); // Wird lediglich benötigt, um den Standard-PIN zu ändern, da dieser im Konflikt mit der Ethernet-Lib steht
vw_set_ptt_pin(PTT_Pin); // Wird lediglich benötigt, um den Standard-PIN zu ändern, da dieser im Konflikt mit der Ethernet-Lib steht
vw_rx_start(); // Empfänger starten
Serial.print(F("Setup LAN ... "));
Serial.println();
// Dem Netzwerk 1 Sekunde zum Initialisierung geben
delay(1000);
Ethernet.begin(mac, ip, dns1, gateway, subnet);
// Ausgabe der Netzwerk-Konfiguration zur Überprüfung
Serial.print(F("IP: "));
Serial.println(Ethernet.localIP());
Serial.print(F("SNM: "));
Serial.println(Ethernet.subnetMask());
Serial.print(F("GW: "));
Serial.println(Ethernet.gatewayIP());
Serial.print(F("DNS: "));
Serial.println(Ethernet.dnsServerIP());
Serial.println(F("-------------------"));
}
void loop(){
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
// Daten-Variable, die die empfangenen Daten hält
char SensorDataTemp[VW_MAX_MESSAGE_LEN+1];
// Daten-Variable, zum Übergeben der Daten an die WebRequest-Funktion
String SensorData;
// Empfang von Daten prüfen
if (vw_get_message(buf, &buflen)) {
int i;
memset(SensorDataTemp, 0, VW_MAX_MESSAGE_LEN+1); // Das ganze Array mit 0en füllen
// Datagramm zusammensetzen
for (i = 0; i < buflen; i++) {
SensorDataTemp = (char)buf;
}
// Char-Variable terminieren
SensorDataTemp[VW_MAX_MESSAGE_LEN+1] = '\0';
// Char to String-Konvertierung zur Übergabe an die connect()-Funktion
SensorData = SensorDataTemp;
// Serial-Output zum Debuggen
Serial.println();
Serial.print(F("Daten empfangen: "));
Serial.print(SensorData);
Serial.println();
Serial.print(F("Daten schicken:"));
StringDataUpload(SensorData);
}
}
void StringDataUpload(String payload){
if (client.connect(server, 80)) {
Serial.println();
Serial.println("GET /xxx/parse.php?"+payload+"&r="+RECEIVERID+"&key=SECRETKEY HTTP/1.0");
client.println("GET /xxx/parse.php?"+payload+"&r="+RECEIVERID+"&key=SECRETKEY HTTP/1.0");
client.println(F("HOST: 3bm.de"));
client.println(F("Connection: close"));
client.println();
client.stop();
Serial.println(F("Daten geschickt."));
}
else {
Serial.println(F("Verbindung fehlgeschlagen"));
}
}
Alles anzeigen
Der erste Beitrag is schon etwas, aber danke für den Hinweis, werd ich dann morgen testen ob es mit der hex geht.
Als nächstes werde ich wohl erstmal diese send.ino und receive.ino ausprobieren
Bei mir sind jetzt die meisten Teile angekommen und ich habe mit kleinen Tests/Vorbereitungen begonnen:
billig 433 Mhz Sender am RPi ohne Antenne schaltet 3-4m entfernte Funkdose im gleichen Raum.
ATtiny84 direkt am RPi angeschlossen und LED-Blinker geflasht.
Ich habe ja keinen Arduino und flashe direkt am RPi mit AVRDude, den hex-file mache ich am Windows-PC mit LunaAVR.
Kann ich am RPi die Arduino IDE so einstellen das ich damit direkt flashen kann?
Bei mir trudeln langsam die Bauteile ein und ich lese hier alles schön erstma mit
Allerdings fehlt immernoch mein Breadboard und die Kabel, also muß ich noch warten bis ich loslegen kann.
Ich werde versuchen meine ATTINY84A-PU mit meinem RPi zu programmieren, allerdings werde ich langsam anfangen (LED blinken) und nicht einfach Code kopieren, damit ich auch verstehe was und warum da im Code steht.
Ich hab jetzt die billigen 433er Sender und Empfänger da und werde auch diese erstmal langsam antesten, zB mit Funksteckdosen (sind eh vorhanden).
http://www.sweetpi.de/blog/258/funks…ilight-schalten
@[font="Tahoma, Verdana, Arial, sans-serif"]meigrafd[/font]
[font="Tahoma, Verdana, Arial, sans-serif"]ich könnte dir hiervon einen Satz zuschicken: http://www.ebay.de/itm/300951544840?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1497.l2649[/font]
Also mal rein von der Theorie her müsste das ganze doch so laufen können:
Messeinheit:
Sensor(z.B. DHT22), Chip(z.B. ATtiny) und Sender(z.B. MX-FS-03V)
Mal ungeachtet der Stromversorgung und anderer Kleinteile, muß man doch nur den Chip so programmieren das er die Daten beim Sensor abfragt und dann an den Sender schickt.
Man könnte ihn z.B. so programmieren das er das alle 5 Min machen soll.
Empfänger:
Empfänger(z.B. MX-05V)
Hier müste der RPi eigentlich nur die Daten vom Empfänger einlesen.
Hab ich das so richtig verstanden?
Alternative für nen einzelnen Chip wäre vielleicht auch:
http://www.ebay.de/itm/Duino-Nano-V3-0-ATmega328P-Free-Mini-USB-Cable-Arduino-Compatible-/181082859003?pt=Wissenschaftliche_Ger%C3%A4te&hash=item2a296125fb
is nur die Frage ob man auch 5-10 für einmalige Versandkosten bekommt
Danke für den Tip [font="Tahoma, Verdana, Arial, sans-serif"]HimbeerFan,[/font] aber das is mir grad zu viel.
hat nich jemand ne neue Version rumliegen und kann sie mir geben?
http://www.rn-wissen.de/index.php/Rasp…_GPIO#Via_Shell
hiermit schaffe ich es den Sensor einmal auzulesen, dann muß ich erst wieder "freischalten"
auch nich die tollste Lösung
naja wenigstens ist der Sensor in Ordnung
[font="Tahoma, Verdana, Arial, sans-serif"]//EDIT:[/font]
das hatte ich auch schon gefunden, mein Problem is aber das ich keine Ahnung hab mit welchen Parametern ich das compilieren soll und ich hab grad kein gcc auf meinem RPi drauf.
[font="Tahoma, Verdana, Arial, sans-serif"]//EDIT2:[/font]
[font="Tahoma, Verdana, Arial, sans-serif"]kann ich die Datei eigentlich auch am Windows PC compilieren?[/font]
was bewirken denn die Befehle?
jetzt hängt er bei Using pin #4
So mein RPi und ein DHT22 sind da, SD-Karte nochnicht, darum hab ich erstmal das hier auf ne 1GB Karte draufgepackt: http://moebiuslinux.sourceforge.net/
habe versucht mit der Adafruit-Anleitung was aus dem Sensor zu bekommen, ich bekomme aber eine Fehlermeldung.
ich habe nicht den git Befehl genommen sondern die zip von Adafruit geladen, entpackt und per SCP auf den RPi kopiert.
ich habe die Befürchtung das C nicht installiert ist
das Problem ist das ich mit dem RPi zurzeit nicht ins Internet kann.
[font="Tahoma, Verdana, Arial, sans-serif"]Programmierung: d[/font]as hört sich recht gut beschrieben und relativ günstig an
http://technik.katzenjens.de/2013/03/billig…-fur-atmel.html
vielleicht hilft dieser Blog:
http://www.3bm.de/2013/09/15/bat…n-fuer-arduino/
Danke für die Antwort, hatte ich mir ja so schon gedacht, auf adafruit bin ich schon gestossen. Hab aber meist nur Pin 4 gesehen.
Nun noch ne Frage, wenn ich einem DTH22 eine eigene Stromversorgung gebe und dann über 1-Wire per Telefondraht an einen RPi anschliessen will, was muß ich beachten bezüglich Kabellänge und würde z.B. eine [font="sans-serif"]CR2032 Knopfzelle ausreichen?[/font]
Hallo,
hab mit der Suche nix gefunden und habe die Frage ob es möglich ist zwei DTH22 mit einem RPi auszulesen?
verwenden werde ich den Sensor: http://www.ebay.de/itm/DHT22-AM2302-Temperatur-Sensor-Board-Arduino-Bascom-usw-Feuchtesensor-/111209638919?pt=Wissenschaftliche_Ger%C3%A4te&hash=item19e49c6c07
da ist der Widerstand ja schon mit dabei und ich würde es so probieren: