Es geht jetzt.
Ich musste es zwar mit "Kennwortgeschütztem Freigeben" machen, aber nun geht es.
Nachdem die Quelle eingerichtet war konnte ich das Kennwort wieder entfernen, aber die Quelle blieb bestehen.
Es geht jetzt.
Ich musste es zwar mit "Kennwortgeschütztem Freigeben" machen, aber nun geht es.
Nachdem die Quelle eingerichtet war konnte ich das Kennwort wieder entfernen, aber die Quelle blieb bestehen.
Hab es unter Libreelec auf nem 3er laufen.
Ich bin begeistert. Das läuft richtig sauber und deutlich schneller als auf nem Firestick, was wohl an der besseren Hardware liegt.
Hallo,
ich hatte ewig einen Pi 1 Modell B im Netzwerk als Mediacenter, der funktionierte auch einwandfrei mit meinem PC.
Ich habe den Ordner unter Windows für "Jeder" freigegeben und schon konnte der Pi ihn finden.
Nun hab ich auf den 3er geupgraded und Libreelec (ist ja eine Modifikation von OpenElec) installiert.
Per SMB komme ich zwar auf den Rechner, aber es werden keine Ordner dargestellt nur "...".
Über meinen OSX Rechner funktioniert der SMB Zugriff weiterhin einwandfrei.
Ein Upnp Zugriff auf den Windows-Rechner funktioniert, bringt mir aber nichts.
Kann mir jmd helfen woran es liegt?
ZitatDeine "scroll" Funktion blockiert das Script.
Das weiß ich. Vllt hab ich das oben etwas falsch geschrieben, aber deswegen will ich die Schleife ja abbrechen.
Einen Interrupt würde mir zwar soviel bringen, dass der andere Thread ausgeführt wird, aber die while Schleife läuft dann weiter.
Da sich aber mit dem Drücken des Tasters/Interrupt auch der Inhalt von "scroll" ändert müsste dieses Script ja abgebrochen und neugestartet werden und da liegt mein Problem.
Im Prinzip müsste das Interrupt beinhalten:
"if client.idle(['playlist']):"
-> Scroll abbrechen
-> Scroll wieder starten (damit er sich die neue Version von "title" nimmt, wenn z.B. der Song wechselt)
Ich bin jetzt soweit, dass die Taster erkannt werden und er nach dem Tastendruck auch den Befehl ausführt und das Display aktualisiert.
ABER: Er macht das erst, nachdem der Teil "scroll" durchgelaufen ist. Da dort aber der titel in einer while Schleife läuft, macht er es natürlich nie.
Wenn ich mich nicht irre muss ich jetzt ein Interrupt einbauen, dass die While-Schleife bei Tastendruck unterbricht und dann den "scroll" Teil wieder startet oder?
Meine Überlegung wäre als 2. Prozess das Script für die Taster laufen zu lassen. Ich kann per "if client.idle(['playlist']):" eine Veränderung im MPD abfragen und darüber könnte ich doch dann den "scroll" Teil unterbrechen oder?
Also wenn es eine Änderung gibt, dann unterbreche "scroll" und führe es neu aus. Wäre das soweit richtig?
Anmerkung: Ich weiß, dass ich den Titel immer noch per "os.popen" abfrage, ansonsten bekomme ich jedoch bei einem leeren Titel einen Abbruch. Das ist ein Problem, um das ich mich später noch kümmere.
#! /usr/bin/python
# -*- coding: utf-8 -*-
import time
import os
import RPi.GPIO as GPIO
GPIO.setwarnings(False)
from mpd import MPDClient
client = MPDClient()
client.connect("localhost", 6600)
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
# Zuordnung der GPIO Pins (ggf. anpassen)
DISPLAY_RS = 26
DISPLAY_E = 24
DISPLAY_DATA4 = 22
DISPLAY_DATA5 = 18
DISPLAY_DATA6 = 16
DISPLAY_DATA7 = 12
DISPLAY_BG = 11
T_SHUTDOWN = 5
T_PREV = 7
T_NEXT = 13
T_PLAY = 15
DISPLAY_WIDTH = 16 # Zeichen je Zeile
DISPLAY_LINE_1 = 0x80 # Adresse der ersten Display Zeile
DISPLAY_LINE_2 = 0xC0 # Adresse der zweiten Display Zeile
DISPLAY_CHR = True
DISPLAY_CMD = False
E_PULSE = 0.0005
E_DELAY = 0.0005
#GPIO initialisieren
GPIO.setmode(GPIO.BOARD)
GPIO.setup(DISPLAY_E, GPIO.OUT)
GPIO.setup(DISPLAY_RS, GPIO.OUT)
GPIO.setup(DISPLAY_DATA4, GPIO.OUT)
GPIO.setup(DISPLAY_DATA5, GPIO.OUT)
GPIO.setup(DISPLAY_DATA6, GPIO.OUT)
GPIO.setup(DISPLAY_DATA7, GPIO.OUT)
GPIO.setup(DISPLAY_BG, GPIO.OUT)
GPIO.setup(T_SHUTDOWN, GPIO.IN)
GPIO.setup(T_PREV, GPIO.IN)
GPIO.setup(T_NEXT, GPIO.IN)
GPIO.setup(T_PLAY , GPIO.IN)
#Display Zeilen schreiben
def lcd(zeile,text):
if zeile == 1:
lcd_byte(DISPLAY_LINE_1, DISPLAY_CMD)
elif zeile == 2:
lcd_byte(DISPLAY_LINE_2, DISPLAY_CMD)
message = text.ljust(DISPLAY_WIDTH," ")
for i in range(DISPLAY_WIDTH):
lcd_byte(ord(message[i]),DISPLAY_CHR)
#Daten senden
def lcd_byte(bits, mode):
GPIO.output(DISPLAY_RS, mode)
GPIO.output(DISPLAY_DATA4, False)
GPIO.output(DISPLAY_DATA5, False)
GPIO.output(DISPLAY_DATA6, False)
GPIO.output(DISPLAY_DATA7, False)
if bits&0x10==0x10:
GPIO.output(DISPLAY_DATA4, True)
if bits&0x20==0x20:
GPIO.output(DISPLAY_DATA5, True)
if bits&0x40==0x40:
GPIO.output(DISPLAY_DATA6, True)
if bits&0x80==0x80:
GPIO.output(DISPLAY_DATA7, True)
time.sleep(E_DELAY)
GPIO.output(DISPLAY_E, True)
time.sleep(E_PULSE)
GPIO.output(DISPLAY_E, False)
time.sleep(E_DELAY)
GPIO.output(DISPLAY_DATA4, False)
GPIO.output(DISPLAY_DATA5, False)
GPIO.output(DISPLAY_DATA6, False)
GPIO.output(DISPLAY_DATA7, False)
if bits&0x01==0x01:
GPIO.output(DISPLAY_DATA4, True)
if bits&0x02==0x02:
GPIO.output(DISPLAY_DATA5, True)
if bits&0x04==0x04:
GPIO.output(DISPLAY_DATA6, True)
if bits&0x08==0x08:
GPIO.output(DISPLAY_DATA7, True)
time.sleep(E_DELAY)
GPIO.output(DISPLAY_E, True)
time.sleep(E_PULSE)
GPIO.output(DISPLAY_E, False)
time.sleep(E_DELAY)
#Display initialisieren
def lcd_init():
lcd_byte(0x33,DISPLAY_CMD)
lcd_byte(0x32,DISPLAY_CMD)
lcd_byte(0x28,DISPLAY_CMD)
lcd_byte(0x0C,DISPLAY_CMD)
lcd_byte(0x06,DISPLAY_CMD)
lcd_byte(0x01,DISPLAY_CMD)
def scroll():
f=os.popen("mpc current -f %title%")
for i in f.readlines():
title = i.rstrip().replace("ö", "oe").replace("ä", "ae").replace("ü", "ue").replace("ï", "").replace("»", "").replace("¿", "").decode('utf-8')
a=client.currentsong()['name']
sender = a.rstrip().replace("ö", "oe").replace("ä", "ae").replace("ü", "ue").replace("ï", "").replace("»", "").replace("¿", "").decode('utf-8')
lcd(1, title)
lcd(2, sender)
while True:
if len(title) > 16:
for i in range (0, len(title)):
lcd(1, title[i:(i+15)])
time.sleep(0.4)
lcd_init()
GPIO.output(DISPLAY_BG, 1)
scroll()
try:
while True:
if not GPIO.input(T_NEXT):
client.next()
print("Next gedrueckt!")
scroll()
time.sleep(0.4)
if not GPIO.input(T_PREV):
client.previous()
print("Prev gedrueckt!")
scroll()
time.sleep(0.4)
if not GPIO.input(T_PLAY):
if client.status()['state']=='pause' or client.status()['state']=='stop':
client.repeat(1)
client.play()
print("Play gedrueckt!")
scroll()
elif client.status()['state']=='play':
client.stop()
print("Pause")
lcd(1, "")
lcd(2, "Pause")
time.sleep(0.4)
if not GPIO.input(T_SHUTDOWN):
print("Shutdown gedrueckt!")
lcd(1,"WIRD")
lcd(2,"HERUNTERGEFAHREN")
time.sleep(2)
GPIO.output(DISPLAY_BG, 0)
lcd(1,"")
lcd(2,"")
os.popen("shutdown -h now")
time.sleep(0.4)
except (KeyboardInterrupt, SystemExit):
lcd(1,"")
lcd(2,"")
GPIO.cleanup()
print "Quit"
Alles anzeigen
Hallo,
klar. Sobald das Projekt jetzt wirklich läuft werde ich mal die ersten Schritte zusammenfassen.
Ich muss mir nur noch überlegen wo ich es veröffentliche.
Eventuell lege ich dazu einen kleinen Blog an.
Gruß
Pascal
Hier stand Unsinn...
Stimmt danke.
Kommt auf die Liste. Ich hab jetzt seit Dezember keine Zeit gehabt zum weiterprogrammieren und da gings dann unter
Das könnte auch schon des Rätsels Lösung sein, da ich über das MPD-Script abfragen kann, wenn sich etwas ändert und er dann das Display aktualisiert. Ich schaue morgen mal in die Documentation.
Gut die 150 Zeilen wollte ich euch ersparen
Momentan sind die 2 Codes noch in unterschiedlichen Dateien.
Die Initialisierung des Displays habe ich rausgelassen. Hier der Code für das Display
try:
while True:
f=os.popen("mpc current -f %title%")
for i in f.readlines():
title = i.rstrip().replace("ö", "oe").replace("ä", "ae").replace("ü", "ue").replace("ï", "").replace("»", "").replace("¿", "").encode('utf-8')
f=os.popen("mpc current -f %name%")
for i in f.readlines():
sender = i.rstrip()
lcd(1, title)
lcd(2, sender)
time.sleep(1)
if len(title) > 16:
for i in range (0, len(title)):
lcd_byte(DISPLAY_LINE_1, DISPLAY_CMD)
lcd(1, title[i:(i+15)])
time.sleep(0.4)
lcd_byte(DISPLAY_LINE_1, DISPLAY_CMD)
lcd(1, title[i:(i+15)])
time.sleep(1)
except (KeyboardInterrupt, SystemExit):
GPIO.cleanup()
print "Quit"
Alles anzeigen
Hier der Code für die Taster
import RPi.GPIO as GPIO
import os
import time
GPIO.setmode(GPIO.BOARD)
GPIO.setup(5, GPIO.IN)
GPIO.setup(7, GPIO.IN)
GPIO.setup(13, GPIO.IN)
GPIO.setup(15, GPIO.IN)
while True:
if not (GPIO.input(5)):
os.system("sudo shutdown -h now")
time.sleep(0.3)
if not (GPIO.input(7)):
os.system("mpc next")
time.sleep(0.3)
if not (GPIO.input(13)):
os.system("mpc prev")
time.sleep(0.3)
if not (GPIO.input(15)):
os.system("mpc play")
time.sleep(0.3)
Alles anzeigen
Bei GPIO 7 -> Low schaltet er z.B. einen Titel weiter.
Nun geht es darum, dass er dann auch die While-Schleife des Displays unterbricht und neustartet, so dass der richtige Titel angezeigt wird.
Hallo,
ich habe eine While-Schleife für ein Display, das funktioniert auch einwandfrei.
Er nimmt sich die Kommando Ausgabe von "mpc current" und gibt die auf ein Display aus, ist der Text länger als 16 Zeichen läuft er durch, dann wartet er 1s und aktualisiert dann.
Nun möchte ich diese Schleife allerdings neustarten/unterbrechen bei einem Tastendruck.
Der Taster ist schon programmiert und führt "mpc next" aus.
Kann mir jmd einen Tipp geben, wie ich da rangehen soll?
Meine Idee wäre, dass er neben "mpc next" dann auch das Script "Display.py" neu ausführt, aber allein von der Überlegung klingt das nach keiner sauberen Lösung
Kann ich das mit "expect" machen?
So es sind Semesterferien und somit Bastelzeit:
Das Display zeigt mittlerweile Sender sowie Titel in Laufschrift an.
Das Display hat einen Widerstand sowie Poti verpasst bekommen, wodurch ich die Kontrast-Probleme in den Griff bekommen habe.
Sonderzeichen funktionieren auch.
Die Taster sind frisch aus dem Reich der Mitte angekommen und funktionieren auch.
1. On/Off 2. Play 3. Prev 4. Next
Lautsprecher habe ich auch. Philips USB Lautsprecher 5,80€ inkl Versand auf Ebay geschossen. Diese hab ich aus dem Gehäuse entfernt und werde sie in das Radio-Gehäuse einpassen.
- Jetzt muss das Display nur noch bei jedem Tastendruck aktualisieren.
- Das Wlan hakt ab und zu
- Die Kabel müssen sauber mit Schrumpfschlauch gemacht werden
und dann kann der Raspberry auch schon ein Gehäuse bekommen.
Das Chaos sieht aktuell so aus:
Ich finde das ist gar nicht so schlecht gelaufen bis jetzt für einen BWL-Studenten
Sollte Torx sein.
(Quelle: http://www.schraubenluchs.de/images/product…ges/29480_0.jpg)
Kauf dir einen anständigen Bit-Satz, da ist sowas dabei und Torx braucht man öfters
Ich weiß, das habe ich ja in den Edit geschrieben.
Das war die ganze Zeit mein Denkfehler.
Danke nochmal.
Zitat
ja aber ohne Schaltplan ist das NIX, prosa erklärt keine Schaltung.
Darum war der Schaltplan ja auch verlinkt...
Zitat
denk mal nach wenn alle EINEN pulldown benutzen dann wären alle GPIO zusammengeschaltet und man könnte keinen einzelnen Taster rausfinden!
Ich habe mal eine Skizze gemacht. Oben wie bei ElKo und unten wie ich mir das überlegt habe.
Der Pullop zieht doch den GPIO auf low (0V). Das sollte doch mit allen dann gehen.
Sobald der Taster zum GPIO geschlossen wird, liegt doch VCC auf dem jeweiligen GPIO an und er wird "high".
Warum kann ich sie dann nicht mehr trennen?
Edit: Achso ich umgehe ja eig. den 2. Schalter dann, wenn ich es wie in meiner Skizze mache oder?
Welche Schrauben sind es denn?
Normalerweise sind's doch Kreuz oder Torx.
Danke. Hab das auch gegoogelt und war wohl so ein "Merksatz" aus der Mittelstufe, der später absolut falsch war...
Ich hatte da nur mal was im Kopf, dass
Ich hab ja geschrieben GND mit Widerstand und GPIO parallel.
Also vor GND den Pull-Down-Widerstand und vor dem Widerstand die Parallelschaltung zum GPIO.
Sollte ich jetzt für jeden Taster einen eigenen Pull-Down-Widerstand benutzen oder reicht es für alle den Gleichen zu benutzen?
Das sollte doch eigentlich gehen, da ich ja immer nur einen Taster betätige und dann entweder der Strom am Widerstand abfällt -> low
oder ein Schalter geschlossen ist, dann liegen am GPIO 3,3V an -> high
Dankeschön
Ich habe es mit .decode('ascii') gelöst.
Deine Lösung hat mir leider immer einen Fehler ausgespuckt ("TypeError: str() takes at most 1 argument (2 given)"). Aber jetzt geht alles.
Mein Fehler war, dass ich es zuvor mit "encode" versucht hatte...
Ich glaube, ich habe das Prinzip des GPIO missverstanden.
Wenn ich doch jetzt -wie hier (http://www.elektronik-kompendium.de/sites/raspberry-pi/2006051.htm) - den Aufbau: 3,3V -> Schalter -> GND mit Pull-Down-Widerstand/GPIO (parallel) habe, fließt doch der Strom direkt von 3,3V in GPIO da er sich den Weg des geringsten Widerstandes sucht oder?
Somit hätte ich wieder einen Kurzschluss zwischen GPIO und 3,3V.
Ich hätte jetzt 3,3V -> kleiner Widerstand -> Schalter -> GND mit Pull-Down-Widerstand/GPIO (parallel) geschaltet.
Vielen Dank. Ich hab nur per Google gesucht und hatte da nur andere Beiträge hier gefunden. Mea Culpa
Bleibt die Frage mit dem Pull-Down-Widerstand: Da ich immer nur einen Taster benutze kann ich doch eig. alle parallel geschaltet an den Pull-Down-Widerstand hängen oder?
Der GPIO verträgt wirklich die 3,3V direkt ohne Widerstand? Nicht, dass ich da etwas schieße...
Hallo und frohe Weihnachten,
ich habe eine kurze Frage zum Thema Taster am Raspberry.
Ein Taster wird ja an GPIO sowie 3,3V angeschlossen. Dazwischen kommt dann ein 10kOhm Widerstand, dass ich keinen Kurzschluss habe oder?
Benötige ich jetzt zwingend den Pull-Down Widerstand also vom GPIO an Masse mit 1kOhm Widerstand?
Ich weiß, dass es darum geht, dass er zuverlässig zwischen Hi und Lo schalten kann.
Es gibt doch Pins die schon einen Pull-Down Widerstand eingebaut haben oder?
Kann ich dann alle(=4) Taster/GPIOs an einen Pull-Down Widerstand hängen?