derAngler

Bleibt nur der "Neubau", aber ACHTUNG: 230V ist LEBENSGEFAHERLICH!

Genau deshalb habe ich ja hier nachgefragt was ich genau brauche, sprich welches Relais genau und ob und wenn ja welche Schutzmaßnahmen ich treffen muss.

Vor Strom habe ich schon Respekt.

Das ist eine gute Frage.

Unter Windows habe ich das Ding noch nie benutzt.

Nutze Linux zur Ansteuerung und da gibt es ein Script http://sispmctl.sourceforge.net/ für - denke Treiber brauche ich keine speziellen.

Wie genau die Steckdosenleiste jetzt intern schaltet weiß ich nicht, habe das Ding bisher nicht aufgeschraubt.

Allerdings fehlt mir eh das Vertrauen in diese Billig-Steckdosenleiste.

Deswegen würde ich mir meine Lösung am liebsten selbst basteln, mit Relais und TF.

Nur weiß ich nicht welches Relais (wegen Spannung und Stromstärke) ich nehmen soll, ob das Ganze auf meine Weise überhaupt halbwegs sicher ist und nicht heiß wird.

Warum nimmst Du nicht gleich das RemoteSwitch-Brickle

Hmm, ja die Frage könnte man sich stellen.

Zwei Gründe gibt es warum hier kein RemoteSwitch hin kommt ( habe aber eins zuhause in Betrieb, nur an anderer Stelle):

1. Die Funkwellen

Und zwar nicht weil ich Angst um meine Gesundheit habe, sondern weil in und um meinem PC herum bereits ein derartiges "Gefunke" herrscht das z.Bsp. LED-Strip manchmal von alleine angeht oder das z.Bsp. die Bluetooth-Maus "Hänger" hat, etc .....

Tatsächlich habe ich bereits ein Funk-Chaos und will jetzt nicht noch mehr Probleme bekommen.

2. Platz

Eine Steckdosenleiste braucht Platz, in dem Fall für mindestens 3 x Stecker.

Ich wollte aber mit nur einem Stecker arbeiten und den dann per Kabel "abzweigen" auf die 3 x Monitore.

Wobei Grund 1 ganz klar der ausschlaggebende ist.

Hallo,

ich würde gerne meine Monitore per Relais an- und ausschalten.

Bisher nutze ich dazu ne China-Steckdosenleiste mit USB-Anschluss. Diese Lösung hat aber leider diverse Kinderkrankheiten, nicht zuletzt traue ich der Steckdosenleiste auch nicht in Sachen Sicherheit über den Weg.

Deswegen kam mir jetzt die Idee das mit TF-Hardware zu realisieren.

Im Grunde denke ich mir das folgendermaßen:

Man nehme Master-Brick + Relais (nur welches?), dann zerschneide ich einfach die 3 x Monitorkabel und schließe diese an das Relais an.

Klappt das so?

Und vorallem, was brauche ich noch damit das Ganze halbwegs sicher ist und nicht igrendwann Funken oder Feuer entstehen.

Nice, mit bootsrap arbeite ich derzeit auch.

Steuerst du die TF-Bauteile direkt über js & bootstrap, oder hast du (wie ich) ein Skript auf dem RasPi/PC laufen und kommunizierst dann per js mit diesem Skript?

Sieht nach bootstrap oder node.js aus.

Ich würde die Website direkt mit PHP / MySQL erstellen.

Wird derzeit so gemacht, z.Bsp kann ich schon einen Temperatur-Chart aus der Datenbank erstellen.

Allerdings nutze ich dazu auch noch bootstrap (demnächst eventuell node.js).

Die Bibliothek für PHP bietet ebenfalls TF.

Das Python-Skript und die Website befinden sich auf verschiedenen Rechner und ich will nicht die gesamte Logik in php auf der Website programmieren.

Vorallem würde das nur für den TF-Teil funktionieren, die Abfrage der GPIO-Ports würde so z.Bsp. nicht funktionieren (und bei anderen Teilen des "smartHome"-Projekts muss ich genau das machen).

Ich muss also weiterhin ein Skript auf dem RasPi laufen lassen.

Oder halt nur den letzten Wert aus der Datenbank auslesen und anzeigen.

Außerdem will ich ja auch Buttons auf der HP haben, welche Aktionen im python-Skript auslösen.

Da braucht es dann schon mehr.

Hallo,

nach einigen Fragen von mir hier im Forum und einigen Versuchen meinerseits bin ich jetzt soweit das mein python-Skript fertig ist.

Konkret plane ich eine Art "smartHome", bestehend aus diversen TF-Bauteilen und jeweils einem Raspberry Pi.

Im Detail geht es hier und jetzt um den "Badezimmerspiegel" im "smartHome".

Dieser erfasst diverse Werte und steuert das Licht.

Das Skript ist zu einem Großteil fertig, es fehlt nur noch die Möglichkeit zur direkten Kommunikation mit einer Website (zwecks Darstellung aktueller Werte, bzw. um über die Website Aktione des python-Skripts auszulösen.

Ansonsten ist aber alles fertig und scheint nach mehreren Tagen im Probebetrieb auch ohne Fehler zu laufen.

Da ich leider noch blutiger Anfänger in Sachen python bin und mir auch beim Thema smartHome und TinkerForge die Erfahrung fehlt, wollte ich mein Skript hier online stellen und fragen ob irgendwer einen Fehler findet.

Oder, noch besser, ob jemand Teile des Codes findet die verbessert werden könnten.

Also hier der Source-Code

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

__author__ = 'Mausbiber'

HOST = "localhost"
PORT = 4223
DATABASE = True
MYSQL_HOST = "192.168.16.1"
MYSQL_PORT = 3306
MYSQL_DB = "database"
MYSQL_USER = "user"
MYSQL_PW = "password"

import logging
import time
import threading
import signal
import sys

from tinkerforge.bricklet_led_strip import LEDStrip
from tinkerforge.bricklet_motion_detector import MotionDetector
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_ambient_light import AmbientLight
from tinkerforge.bricklet_temperature import Temperature
from tinkerforge.bricklet_humidity import Humidity


import pymysql


def set_exit_handler(func):
    signal.signal(signal.SIGTERM, func)


def on_exit(sig, func=None):
    logger.info('... Exit Handler')
    sys.exit(1)


class BrickletHumidity:
    humidity = 0.0
    __timer_is_running = False
    __timer_intervall = 0

    def __init__(self, uid):
        self.bricklet = Humidity(uid, tf_connection)
        logger.debug('Humidity ........... Bricklet initialisiert')

    def set_callback(self, timeframe):
        self.bricklet.set_humidity_callback_period(timeframe)
        self.bricklet.register_callback(self.bricklet.CALLBACK_HUMIDITY, self.__humidity_changed)

    def set_timer(self, intervall):
        if intervall == 0:
            self.__timer_is_running = False
            self.__timer_intervall = 0
        else:
            self.__timer_is_running = True
            self.__timer_intervall = intervall
            __timer = threading.Timer(intervall, self.__timer_tasks).start()

    def read(self):
        self.__humidity_changed(self.bricklet.get_humidity())

    def __timer_tasks(self):
        uhrzeit = time.strftime('%Y-%m-%d %H:%M:%S')
        if DATABASE:
            mysql_cursor.execute(
                "INSERT INTO sensor_data_humidity (timestamp , data , sensors_id) VALUES (%s , %s , %s)",
                (uhrzeit, self.humidity, 2))
        if self.__timer_is_running:
            __timer = threading.Timer(self.__timer_intervall, self.__timer_tasks).start()

    def __humidity_changed(self, rh):
        self.humidity = (rh / 10.0)
        logger.debug('Humidity ........... Luftfeuchtigkeit %s %%', self.humidity)


class BrickletTemperature:
    temperature = 0.0
    __timer_is_running = False
    __timer_intervall = 0

    def __init__(self, uid):
        self.bricklet = Temperature(uid, tf_connection)
        logger.debug('Temperature ........ Bricklet initialisiert')

    def set_timer(self, intervall):
        if intervall == 0:
            self.__timer_is_running = False
            self.__timer_intervall = 0
        else:
            self.__timer_is_running = True
            self.__timer_intervall = intervall
            __timer = threading.Timer(intervall, self.__timer_tasks).start()

    def __timer_tasks(self):
        uhrzeit = time.strftime('%Y-%m-%d %H:%M:%S')
        if DATABASE:
            mysql_cursor.execute(
                "INSERT INTO sensor_data_temperature (timestamp , data , sensors_id) VALUES (%s , %s , %s)",
                (uhrzeit, self.temperature, 1))
        if self.__timer_is_running:
            __timer = threading.Timer(self.__timer_intervall, self.__timer_tasks).start()

    def set_callback(self, timeframe=5000):
        self.bricklet.set_temperature_callback_period(timeframe)
        self.bricklet.register_callback(self.bricklet.CALLBACK_TEMPERATURE, self.__temperature_changed)

    def read(self):
        self.__temperature_changed(self.bricklet.get_temperature())

    def __temperature_changed(self, te):
        self.temperature = (te / 100.0)
        logger.debug('Temperatur ......... Temperatur %s °C', self.temperature)


class BrickletAmbientLight:
    ambient_light = 0.0
    __timer_is_running = False
    __timer_intervall = 0

    def __init__(self, uid):
        self.bricklet = AmbientLight(uid, tf_connection)
        logger.debug('Ambient Light ...... Bricklet initialisiert')

    def set_timer(self, intervall):
        if intervall == 0:
            self.__timer_is_running = False
            self.__timer_intervall = 0
        else:
            self.__timer_is_running = True
            self.__timer_intervall = intervall
            __timer = threading.Timer(intervall, self.__timer_tasks).start()

    def __timer_tasks(self):
        uhrzeit = time.strftime('%Y-%m-%d %H:%M:%S')
        if DATABASE:
            mysql_cursor.execute(
                "INSERT INTO sensor_data_ambient_light (timestamp , data , sensors_id) VALUES (%s , %s , %s)",
                (uhrzeit, self.ambient_light, 3))
        if self.__timer_is_running:
            __timer = threading.Timer(self.__timer_intervall, self.__timer_tasks).start()

    def set_callback(self, timeframe=5000):
        self.bricklet.set_illuminance_callback_period(timeframe)
        self.bricklet.register_callback(self.bricklet.CALLBACK_ILLUMINANCE, self.__ambient_changed)

    def read(self):
        self.__ambient_changed(self.bricklet.get_illuminance())

    def __ambient_changed(self, il):
        self.ambient_light = (il / 10.0)
        logger.debug('Ambient Light ...... Lichtstärke %s lx', self.ambient_light)


class BrickletLED:
    led_anzahl = 0
    __led_value_new = [0, 0, 0]
    __led_value_old = [0, 0, 0]
    __led_timer = 0
    __frame_duration = 0
    __difference_red = 0
    __difference_green = 0
    __difference_blue = 0
    __verlauf_schritte = 0
    __timer_is_running = False
    __timer_intervall = 0

    def __init__(self, uid):
        # generate object
        self.bricklet = LEDStrip(uid, tf_connection)
        logger.debug('LED-Strip .......... Bricklet initialisiert')

    def set_timer(self, intervall):
        if intervall == 0:
            self.__timer_is_running = False
            self.__timer_intervall = 0
        else:
            self.__timer_is_running = True
            self.__timer_intervall = intervall
            __timer = threading.Timer(intervall, self.__timer_tasks).start()

    def __timer_tasks(self):
        if not Motion_bricklet.motion_detected:
            self.set_color(self.__led_value_new[0], self.__led_value_new[1], self.__led_value_new[2])
        if self.__timer_is_running:
            __timer = threading.Timer(self.__timer_intervall, self.__timer_tasks).start()

    def set_color(self, r, g, b):
        # sending color information to the LED's
        __value_red = [r] * 16
        __value_green = [g] * 16
        __value_blue = [b] * 16
        # set LED Color, one call for maximum 16 LED's
        for x in range(0, self.led_anzahl, 16):
            # count LED's, maximum is 16
            length = min(self.led_anzahl - x, 16)
            # sending data
            self.bricklet.set_rgb_values(x, length, __value_red, __value_green, __value_blue)

    def set_callback(self, frames_per_second):
        # calculating frame duration in ms
        self.__frame_duration = int(1000 / frames_per_second)
        # setting frame duration
        self.bricklet.set_frame_duration(self.__frame_duration)
        # setting Callback
        self.bricklet.register_callback(self.bricklet.CALLBACK_FRAME_RENDERED, self.__frame_rendered)
        logger.debug('LED-Strip .......... Callback gesetzt')

    def __frame_rendered(self, arg):
        if self.__led_timer < self.__verlauf_schritte:
            self.__led_timer += 1
            if self.__difference_red >= 0:
                rgb_faktor_red = ((self.__difference_red + 1) ** (self.__led_timer / self.__verlauf_schritte)) - 1
                rgb_faktor_red = round(self.__led_value_old[0] + rgb_faktor_red)
            else:
                rgb_faktor_red = ((abs(self.__difference_red) + 1) ** (
                    1 - (self.__led_timer / self.__verlauf_schritte))) - 1
                rgb_faktor_red = round(self.__led_value_new[0] + rgb_faktor_red)
            if self.__difference_green >= 0:
                rgb_faktor_green = ((self.__difference_green + 1) ** (self.__led_timer / self.__verlauf_schritte)) - 1
                rgb_faktor_green = round(self.__led_value_old[1] + rgb_faktor_green)
            else:
                rgb_faktor_green = ((abs(self.__difference_green) + 1) ** (
                    1 - (self.__led_timer / self.__verlauf_schritte))) - 1
                rgb_faktor_green = round(self.__led_value_new[1] + rgb_faktor_green)
            if self.__difference_blue >= 0:
                rgb_faktor_blue = ((self.__difference_blue + 1) ** (self.__led_timer / self.__verlauf_schritte)) - 1
                rgb_faktor_blue = round(self.__led_value_old[2] + rgb_faktor_blue)
            else:
                rgb_faktor_blue = ((abs(self.__difference_blue) + 1) ** (
                    1 - (self.__led_timer / self.__verlauf_schritte))) - 1
                rgb_faktor_blue = round(self.__led_value_new[2] + rgb_faktor_blue)
            logger.debug('LED-Strip .......... (%s) r=%s g=%s b=%s', self.__led_timer, rgb_faktor_red, rgb_faktor_green,
                         rgb_faktor_blue)
            self.set_color(rgb_faktor_red, rgb_faktor_green, rgb_faktor_blue)

    def set_verlauf(self, r, g, b, seconds):
        self.__led_value_old = [self.__led_value_new[0], self.__led_value_new[1], self.__led_value_new[2]]
        self.__led_value_new = [r, g, b]
        self.__difference_red = self.__led_value_new[0] - self.__led_value_old[0]
        self.__difference_green = self.__led_value_new[1] - self.__led_value_old[1]
        self.__difference_blue = self.__led_value_new[2] - self.__led_value_old[2]
        self.__verlauf_schritte = seconds * (1000 / self.__frame_duration)
        self.__led_timer = 0
        logger.info('LED-Strip .......... Verlauf gestartet - %s Schritte (%s Sekunden)', self.__verlauf_schritte,
                    seconds)
        logger.debug('LED-Strip .......... Start %s|%s|%s >> Ziel %s|%s|%s', self.__led_value_old[0],
                     self.__led_value_old[1], self.__led_value_old[2], self.__led_value_new[0], self.__led_value_new[1],
                     self.__led_value_new[2])
        self.set_color(self.__led_value_old[0], self.__led_value_old[1], self.__led_value_old[2])

    def set_uhrzeit_farbe(self):
        timestamp = time.gmtime()
        stunde = timestamp.tm_hour
        if (stunde >= 4) and (stunde < 10):
            # ORANGE     6.00 - 12.00 =>  4.00 - 10.00
            self.set_verlauf(175, 120, 0, 6)
            logger.info('LED-Strip .......... Farbeinstellung auf ORANGE')
        elif (stunde >= 10) and (stunde < 16):
            # WEISS     12.00 - 18.00 => 10.00 - 16.00
            self.set_verlauf(150, 175, 150, 6)
            logger.info('LED-Strip .......... Farbeinstellung auf WEISS')
        elif (stunde >= 16) and (stunde < 22):
            # GRÜN      18.00 -  0.00 => 16.00 - 22.00
            self.set_verlauf(0, 175, 0, 6)
            logger.info('LED-Strip .......... Farbeinstellung auf GRÜN')
        elif ((stunde >= 22) and (stunde < 24)) or ((stunde >= 0) and (stunde < 4)):
            # BLAU       0.00 -  6.00 => 22.00 -  4.00
            self.set_verlauf(0, 0, 175, 6)
            logger.info('LED-Strip .......... Farbeinstellung auf BLAU')


class BrickletMotion:
    motion_detected = False

    def __init__(self, uid):
        self.bricklet = MotionDetector(uid, tf_connection)
        logger.debug('Motion Detection ... Bricklet initialisiert')

    def set_callback(self):
        self.bricklet.register_callback(self.bricklet.CALLBACK_MOTION_DETECTED, self.__motion_on)
        self.bricklet.register_callback(self.bricklet.CALLBACK_DETECTION_CYCLE_ENDED, self.__motion_off)

    def __motion_on(self):
        logger.info('Motion Detection ... Jemand BETRITT das Bad - Licht %s Lux', BrickletAmbientLight.ambient_light)
        uhrzeit = time.strftime('%Y-%m-%d %H:%M:%S')
        if DATABASE:
            mysql_cursor.execute("INSERT INTO sensor_data_motion (timestamp , data , sensors_id) VALUES (%s , %s , %s)",
                                 (uhrzeit, True, 4))
        self.motion_detected = True
        if BrickletAmbientLight.ambient_light < 100.0:
            LED_bricklet.set_uhrzeit_farbe()
        else:
            logger.debug('Motion Detection ... keine LED weil zu hell - Licht %s Lux',
                         BrickletAmbientLight.ambient_light)

    def __motion_off(self):
        logger.info('Motion Detection ... Jemand VERLAESST das Bad')
        uhrzeit = time.strftime('%Y-%m-%d %H:%M:%S')
        if DATABASE:
            mysql_cursor.execute("INSERT INTO sensor_data_motion (timestamp , data , sensors_id) VALUES (%s , %s , %s)",
                                 (uhrzeit, False, 4))
        self.motion_detected = False
        if Ambient_bricklet.ambient_light < 100.0:
            LED_bricklet.set_verlauf(0, 0, 0, 1)
        else:
            LED_bricklet.set_color(0, 0, 0)


def set_logging(logging_daemon):
    # Logging auf Console
    #console_handler = logging.StreamHandler()
    #formatter = logging.Formatter('%(asctime)s : %(message)s', '%Y-%m-%d %H:%M:%S')
    #console_handler.setFormatter(formatter)
    #logging_daemon.addHandler(console_handler)
    # Logging in Datei
    file_handler = logging.FileHandler("/var/log/raspi_badezimmer.log", mode='w', encoding=None, delay=False)
    formatter = logging.Formatter('%(asctime)s : %(message)s', '%Y-%m-%d %H:%M:%S')
    file_handler.setFormatter(formatter)
    logging_daemon.addHandler(file_handler)


if __name__ == "__main__":
    set_exit_handler(on_exit)

    # Logging Deamon erzeugen
    logger = logging.getLogger('raspi_server')
    logger.setLevel(logging.INFO)
    set_logging(logger)

    # MySQL Verbindung herstellen
    if DATABASE:
        mysql_connection = pymysql.connect(host=MYSQL_HOST, port=MYSQL_PORT, user=MYSQL_USER, passwd=MYSQL_PW,
                                           db=MYSQL_DB, autocommit=True)
        mysql_cursor = mysql_connection.cursor()
        logger.info('... mySQL Verbindung online')

    # Tinkerforge Objekt erzeugen
    tf_connection = IPConnection()

    # TF Bricklets initialisieren
    LED_bricklet = BrickletLED("jGU")
    Motion_bricklet = BrickletMotion("jX1")
    Ambient_bricklet = BrickletAmbientLight("jy1")
    Temperature_bricklet = BrickletTemperature("dXW")
    Humidity_bricklet = BrickletHumidity("kdt")

    # Mit Tinkerforge berbinden
    tf_connection.connect(HOST, PORT)

    # TF Bricklets konfigurieren
    LED_bricklet.led_anzahl = 60

    Motion_bricklet.set_callback()
    Ambient_bricklet.set_callback(10000)
    Temperature_bricklet.set_callback(10000)
    Humidity_bricklet.set_callback(10000)
    LED_bricklet.set_callback(25)

    Ambient_bricklet.read()
    Temperature_bricklet.read()
    Humidity_bricklet.read()

    Ambient_bricklet.set_timer(300)
    Temperature_bricklet.set_timer(120)
    Humidity_bricklet.set_timer(120)
    LED_bricklet.set_timer(60)

    logger.info('... Tinkerforge online')

    input('Press key to exit\n')

    tf_connection.disconnect()
    if DATABASE:
        mysql_cursor.close()
        mysql_connection.close()

Ich habe versucht Daten+Logik jeweils in Klassen zu kapseln.

Zum einen finde ich den Code dadurch besser zum lesen, zum anderen ist es so leichter den Code wiederzuverwenden (bei den anderen Teilen meines "smartHome").

Was mir wirklich helfen würde wären wie gesagt Verbesserungsvorschläge.

Und, richtig toll wäre es, wenn mir jemand sagen könnte wie ich es schaffe das Skript mit meiner Website kommunizieren zu lassen.

Hmm, versuche das nachher nochmal zu verstehen.

Tatsache ist aber, das ich kein einziges "nfc.request_tag_id" weglassen kann.

Nehme ich nur eines raus (egal wo), dann funktioniert das Programm nicht mehr.

Wenn kein Tag zu lesen ist, ist dein Programm in einer request_tag_id/Callback-STATE_REQUEST_TAG_ID_ERROR Schleife und wartet darauf, dass ein Tag auftaucht. Daher bekommst du ständig Callbacks, da dein Program ständig nach dem Vorhandensein eins Tags fragt.

Ist doch logisch das das RFID-Bricklet die ganze Zeit auf das auftauchen eines neuen Tags wartet, wie sonst sollte es funktionieren.

Was ich störend finde ist, das wenn ich ein Tag auf das Bricklet lege, dieses ständig wieder erkannt wird.

Müsste das Bricklet nicht erkennen das das gleiche Tag aufliegt und dementsprechend keine Änderungen des Status haben?

Ich mache mir Gedanken das ich durch das ständige auslösen des Callback Timingprobleme bekomme.

Immerhin sollen in einem späteren Schritt noch die LED-Beleuchtung und Hardware-Interrupts für Tastendrücke hinzukommen.

Nabend mal wieder,

ich programmiere wie immer in python und bin dabei mir eine Routine zu schreiben die bestimmte Aktionen auslöst.

Im Detail soll das so aussehen das ich eine Karte über das Bricklet ziehe und dann eine Aktion gestartet wird.

Die auszulösende Aktion ist auf der Karte selbst gepeichert.

Das Skript funktioniert auch so wie es soll

#!/usr/bin/env python
# -*- coding: utf-8 -*-  

HOST = "192.168.127.84"
PORT = 4223
UID = "owX"
rfid_tag_befehl=""

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_nfc_rfid import NFCRFID


def cb_state_changed(state, idle):
    global rfid_tag_befehl

    if state == nfc.STATE_REQUEST_TAG_ID_READY:
        ret = nfc.get_tag_id()
        nfc.request_page(5)
    elif state == nfc.STATE_REQUEST_PAGE_READY:
        data = nfc.get_page()
        befehl = (''.join(map(chr, data)))
        if befehl != rfid_tag_befehl:
            rfid_tag_befehl=befehl
            if "led_green" in rfid_tag_befehl:
                print('led_green')
            elif "led_blue" in rfid_tag_befehl:
                print('led_blue')
            elif "led_red" in rfid_tag_befehl:
                print('led_red')
            elif "led_on" in rfid_tag_befehl:
                print('led_on')
            elif "led_off" in rfid_tag_befehl:
                print('led_off')
            else:
                print('Daten ' + rfid_tag_befehl)
            nfc.request_tag_id(nfc.TAG_TYPE_TYPE2)
        else:
            nfc.request_tag_id(nfc.TAG_TYPE_TYPE2)
    else:
        nfc.request_tag_id(nfc.TAG_TYPE_TYPE2)


if __name__ == "__main__":
    ipcon = IPConnection()
    nfc = NFCRFID(UID, ipcon)
    ipcon.connect(HOST, PORT)
    nfc.register_callback(nfc.CALLBACK_STATE_CHANGED,cb_state_changed)
    nfc.request_tag_id(nfc.TAG_TYPE_TYPE2)
    input('Press key to exit\n')
    ipcon.disconnect()

Das Problem sehe ich nur darin das die Callback-Funktion konsequent ausgelöst wird.

Ich hatte mir mal den Spass gemacht und jede Möglichkeit für "state" ausgeben lassen und dann gesehen das im Terminal im Millisekunden-Takt Meldungen einliefen.

Deswegen frage ich mich ob ich irgendwo etwas falsch gemacht habe?

Danke

So, ist eine Weile her das ich mich gemeldet habe, aber ich glaube habe ich das Problem jetzt im Griff zu haben.

Es hat etwas länger gedauert da ich so gut wie jedes Teil (RasPi, MasterBrick, LED-Bricklet, LED-Streifen und Kabel) testweise ausgetauscht habe, manche Teile wie die Kabel habe ich sogar mehrfach gewechselt.

Nur durch diesen Test-Marathon bin ich dem Fehler auf die Spur gekommen - es waren die Stromkabel für die Monitore.

Eine kleine Erklärung dazu, ich habe meinen PC in einen selbstgebauten Schreibtisch eingebaut (kein PC-Gehäuse sondern direkt im Tisch verbaut), aufgrund dessen hatte ich die Monitorkabel (3 x Monitore) auch durch das Fach für den PC gezogen.

Diese 3 x Netzkabel haben in Verbindung mit dem Kabel des Netzteils ein dermassen starkes Magnetfeld erzeugt (zumindest nehme ich das an) das nicht nur die LED's gestört worden sind, sondern sogar mein PC und die USB-Anschlüsse.

Z.Bsp. war das Feld so stark das die LED's selbst dann gesponnen haben wenn ich den MasterBrick direkt am PC (über USB) angeschlossen hatte und die Leitung zu den LED-Streifen nur 2cm lang war.

Daran habe gemerkt das das Problem nichts mit den LED's zu tun haben kann.

Naja, lange Rede kurzer Sinn, nachdem ich aus 4 x Stromkabel 2 x Stromkabel gemacht habe und die Steckerleiste unterhalb des Tisches angebracht habe läuft die LED-Leiste zu 99% richtig.

Ab und an spinnt nochmal die erste LED's (geht alleine an), das bekomme ich aber sehr wahrscheinlich noch auf die Reihe wenn ich die Kabel nochmal etwas besser verteile.

Was ich sagen kann ist, das ein abgeschirmtes Kabel null gebracht hat, selbst ein Kabel mit einzel geschirmten Leitungen hat nichts gebracht (im Gegenteil, wenn ich USB oder Monitorkabel genommen habe ging noch weniger), so das ich jetzt wieder 4 x ganz normale, einzelne Kabel nutze.

Aber vielen Dank an alle hier die versucht haben mir zu helfen.

War ein hartes Stück Arbeit.

Nabend,

ich möchte gerne in python die Farbe der LED's auslesen.

Soweit ich das sehe, geht das mit dem Befehl

LEDStrip.get_rgb_values(index, length)

Nur leider bekomme ich es einfach nicht auf die Reihe.

Kann mir jemand, oder besser, könnte das TF-Team dazu nicht ein kleines Beispiel auf der Homepage veröffentlichen?

Ja, ich habe noch LED-Streifen rumliegen.

Den habe ich auch genommen, Kabel angelötet und siehe da, wieder flackert zuerst die erste LED.

Also dachte ich mir, hey, vielleicht hast du beim löten den Chip zerstört.

Also die erste LED abgemacht und mit weniger Hitze (250°C) neu gelötet.

Wieder das gleiche ... die erste LED spinnt, dann nach ner Weile auch die zweite und dritte.

Ich versteh es nicht, im Bad habe ich ein LED-Streifen, der ist an vier Ecken gelötet und da flimmert nichts. Also bin am Ende ...

Hast du mal alles weggelassen?

Yep, habe ich gemacht.

Habe den Kram abgebaut und das Ganze nach dem Muster PC -> MasterBrick -> LED-Bricklet -> LED-Leiste angeschlossen.

Dabei habe ich sowohl MasterBrick als auch das LED-Bricklet ausgetauscht (und damit Defekt eines Teils ausgeschlossen) und das Kabel vom LED-Bricklet zur LED-Leiste möglichst kurz gehalten (und auch darauf geachtet das das Kabel keine anderen Kabel kreuzt).

Sie auch das Foto.

Trotzdem flackern immernoch die ersten 1-3 LED's ... der Rest scheint dann zu 99% zu funktionieren.

Auch wenn ich alle Bluetooth und Wifi-Dongle aus dem PC ziehe ändert sich leider nichts.

Irgendwie ist das alles rätselhaft, wenn ich den "laufenden Punkt" starte, dann klappt das 1a. Ob rot, blau oder grün - der Punkt rennt von Seite zu Seite ohne Flackern, ohne Farbabweichungen.

Das sieht einfach nur richtig aus. Sowie ich aber mehr als eine Farbe setze wird es bunt.

Selbst wenn ich das LED-Bricklet direkt an den LED-Streifen setze habe ich immer noch flackern.

Deswegen meine letzte Idee. Ich binde das Bricklet direkt an die LED's an (maximal 3-4 cm Kabellänge) und verbinde dann das Bricklet per abgeschirmten Kabel von euch mit dem MasterBrick.

Jetzt möchte ich nur ungern wieder meinen ganzen Tisch auseinander nehmen wenn ich nicht weiß ob es überhaupt was bringt.

Daher meine Frage:

Schafft euer abgeschirmtes Brickletkabel den Weg durch meinen Computer ohne das Signale überspringen? Ist die Abschirmung gut genug um sich nicht von Bluetooth und Wifi beeinflussen zu lassen?

Nabend,

also bei mir würde auch eine Art "Funksteuerung" für die Sensoren an erster Stelle stehen.

Irgendeine Lösung um die Sensoren überall einzel anbringen zu können und sie gleichzeitig mit Batterien laufen zu lassen.

Wäre schon schön wenn man an verschiedenen Punkten die Temperatur (oder was auch immer) messen und diese dann per Funk an einen Master senden könnte.

Also so langsam verliere ich den Glauben und die Hoffnung.

Ich kann nicht jeden Tag meinen Schreibtisch auf und abbauen um neues Kabel zu ziehen, das ist alles irgendwie kacke.

PS: Ich habe auch schon mal die 2 x Adern für die Daten getauscht, dann geht aber gar keine LED mehr an.

Bin ehrlich komplett am verzweifeln ....

So jetzt wird es leider interessant 

Also ich habe ein altes USB-Kabel genommen welches sogar an beiden Enden Ferritkern hat (soll ja besser sein).

Dann habe ich auf der einen Seite die 4 x Adern mit dem LED-Streifen verlötet.

Auf der anderen Seite habe ich dann die Abschirmung mit der Ader für GND zusammengedreht und dann alle 4 x Adern (+ Abschirmung) in den 4 x Klemmleisten am LED-Bricklet verschraubt.

Vom Bricklet zum MasterBrick sind es nur 5 cm, deswegen dort keine Abschirmung.

Damit sollte ich doch zumindest von der Verkablung und der Abschirmung schon einmal auf der sicheren Seite sein.

Desweiteren habe ich dann noch am LED-Bricklet ein zusätzliches 5V 2A Netzteil angeschlossen.

Und achja, die Firmware ist auf allen Teilen (Brick + Bricklets) auf dem aktuellen Stand.

Als nächstes habe ich dann meinen BrickViewer gestartet und wollte sehen ob alles geht.

Dabei musste ich feststellen das die LED's ein Eigenleben entwickeln.

Beispiel: Ich setzte die RGB-Werte alle 50 und die Anzahl LED's auf 10, danach klicke ich dann auf "Show color" und was passiert? Falsch, die LED's leuchten nicht schwach weiß sondern abwechselnd rot,grün,blau ....

Beispiel: Ich versuche die LED's mit "Clear" im Viewer auszuschalten.

Was passiert, richtig, nichts.

Ich klicke nochmal und auf einmal geht die Hälfte aus.

Okay denke ich mir, irgendwas stimmt nicht, versuch mal die anderen Optionen im Viewer. Also klicke ich einfach mal "moving color dot" an und stelle 25 LED's ein - oh Wunder - das klappt prima. Der Punkt läuft hin und her.

Von daher muss also eigentlich alles richtig angeschlossen sein, nur einzelne Farben einstellen, das klappt gar nicht.

Es ist mir also nicht möglich alle LED's auf eine bestimmte Farbe zu setzen.

Es wird immer bunt.

DANKE 

oder USB Kabel

perfekt, warum bin ich nicht darauf gekommen.

Hat auch genau 4 x Adern - passt

Eine letzte dumme Frage, die Abschirmung löte ich auf beiden Seiten mit dem Minusanschluß zusammen oder nur auf einer?

Erst einmal Danke, ich hatte schon etwas in der Art befürchtet.

Nun nur noch eine dumme Frage: Wie schirme ich das Kabel am besten ab, bzw. die 4 x Kabel.

Hallo mal wieder,

ich habe schon wieder ein kleines Problem.

Und zwar arbeite ich mit einem LED-Streifen und dem LED-Bricklet.

An den LED-Streifen habe ich vier einfache Kabel gelötet und diese quer durch meinen Computer gezogen (ca. 40-50cm Kabellänge) und dort schließlich am LED-Bricklet befestigt.

Ansich kann ich damit auch die einzelnen LED's ansteuern, ABER auch wenn ich alle LED's auf 0 stelle fangen früher oder später die ersten 5-10 LED's an zu leuchten.

Das sieht dann so aus, das ich z.Bsp. am PC sitze, alle LED's per BrickViewer ausschalte und nach 30 Sekunden bis 5 Minuten fangen auf einmal verschiedene LED's an zu leuchten, manchmal blinken Sie auch.

Oder sie fangen an rot zu leuchten und wechseln dann langsam Richtung weiß.

Komischerweise sind es immer nur die ersten 10 LED's, manchmal sogar nur die erste.

Woran kann das liegen?

Störungen am Kabel?

Hallo,

ich habe mir das NFC/RFID Bricklet gekauft und dazu diverse Tags (zum kleben, als Karte) mitbestellt.

Lege ich nun ein RFID-Tag über den Leser, so kann ich im BrickViewer dieses auch auslesen.

Danach stehen dann irgendwelche Zahlen im HEX-Format in den diversen Zellen (Page 0-3).

Diese kann ich nun per Hand abändern, aber leider nicht die geänderten Daten schreiben.

Wenn ich auf "Write page ..." klicke dann werden die Zahlen "grau" (also sieht es danach aus als ob der Viewer irgendetwas machen würde) und das war es dann auch.

Es bleibt dabei, die Zahlen bleiben grau und wenn ich nach 5 Minuten wieder auf "load Page ..." klicke stehen wieder die alten Zahlen in den Zellen.

Warum?

Und ich frage mich, ob es irgendwie möglich ist über den Viewer eine Zahlenkette auf ein Tag zu schreiben? Also z.Bsp. den String "tag=color|content=red"?