Guten Tag,
Wenn man auf das INT Signal reagiert, also eine I/O Interrupt-Handler aufruft, kann man kurz in der Schleife Pollen, alle betreffenden Ports abfragen, und die 0 oder 1 Werte in einer Tabelle / Liste pro Register erfassen. Das geht sehr bequem, wenn man den PCF8574 nicht über diese Fertig-Bibliothek anspricht, sondern nur die Port Register Zahl ausliest, des jeweilige Port BIT dann durch Bit-Verschiebung zwischen speichert. Damit kann man mit einem Auslesevorgang über den Wert Registerinhalt.copy() nacheinander auf alle möglichen und beliebig belegten Ports zugreifen. Wenn dann nach der Zeit 20 ms ( INT Release ) eine Überzahl an 0 in der Liste des jeweiligen Posts findet, kann man davon zu 99,98 % Wahrscheinlichkeit ausgehen, der Taster an Port XYZ wurde betätigt. Das kann man dann zusammengefasst, als Return zurückgeben.
Eigentlich überhaupt kein Problem mit der Portvermischung. Man muss halt nur aufpassen, das man keinen Output Port erwischt. Jedoch sollte das mit der Aufgabenstellung Port x bis y für den Input klar definiert sein. Und natürlich darf man nicht diese Input Ports mit einem aktiven LOW überschreiben sonst werden diese zu Output-Ports.
Posts by WillyR_aus_C
Mach mit und werde Teil unserer Community!
-
-
-
Guten Tag,
das kann so nicht funktionieren.
Du setzt im ersten Schritt alle Port auf LOW, und fragst dann einen Taster ab, der den Stromkreis auf Null ziehen soll.
Für den PCF8574 der sowohl LEDs wie auch Taster angeschlossen hat musst du dazu entweder über BIT-Verschiebung die Ports auf LOW schalten, an denen eine LED angeschlossen ist, oder du schaltest jeden LED Port einzeln auf LOW.
Mit der Definition als Input hat der Pegel an diesen Taster-Pins High zu sein. Dazu muss man eine externen Pull-Up schalten. In diesem Fall reagiert auch der INT Pin des PCF8574 mit einem to Loow Wechseln, diesen kann man über einen weiteren GPIO mit Pin.IRQ_FALLING() abfragen und den Ausleseprozess der mit den Taster beschalteten Ports starten.
Mit Polling und der Gewalthammer-Methode alle Port Registereinträge auf LOW zu setzen wird das nie funktionieren. Ich glaube mich erinnern zu können, dass es zu diesem Thema der Nutzung des INT Ports an diesen Portexpandern schon eine sehr umfangreiche Abhandlung u.a. jar gegeben hat. -
-
Guten Tag fred0815
Lt einer Messung benötigen die Sensoren 0,005mA Strom im "Leerlauf", 0,2mA beim "Senden", aber bis zu 10mA beim "Starten".
Wer vom Wort "Senden" Gebrauch macht, sollte deren Deutung kennen
Andernfalls hätte man wohl auch das Wort Übertragung wählen können.
Falls dann doch schon eine Drahtübertragung genutzt werden sollte, kommt hierIch habe mir überlegt die Sensoren mit Klingeldraht zu verbinden und Zentral mit Energie zu versorgen.
für meine Begriffe fast unlogische Aussage zustande. Wenn man schon einmal Kabel von den Sensoren zu diesem zentralisierten Raspberry gezogen hat oder möchte, warum dann nicht gleich mit einem Draht mehr für die Stromversorgung. Denn egal welche drahtgebundene Übertragung hierfür genutzt werden könnte, muss es schließlich auch eine Masseverbindung geben. Denn ohne gemeinsame Masse mit einem Batteriebetriebenen Endgerät kommt keine wirklich zuverlässige Übertragung "OneWire ohne Masse" zustande.
mein Haus mit einer Reihe Fenstersensoren etc. auszustatten.
Das schließt jedoch aus, das eine Vorinstallation vorhanden ist. Somit muss man bei einer Drahtübertragung, ohnehin Kabel ziehen, falls man das möchte, und muss zudem auf die Spannungen achten. Nur macht dann wiederum das Wort "Senden" keinen wirklichen Sinn. Und das Thema Versorgungsspannung dieser Sensoren etc. ist damit auch noch vollkommen ergebnisoffen.
Aber wenn du der Meinung bist, dass geht zu 100% ohne zu wissen mit welcher Spannung diese Sensoren betrieben werden, dann wünsche ich dem Fragesteller viel und maximales Grück bei dieser eher waghalsigen Bastelei. -
Guten Tag,
Würde auch mal jemand die Frage stellen über welche Spannung diese Sensoren mit diesen Batterien versorgt werden.
Funksensoren alles gut und schön, nur ist mir kein einziger Sensor - Hauptaugenmerk Batterien - bekannt der mit 5 Volt glatt betreiben wird.
Deswegen fred0815 mal die Frage, wie du aus einer der Spannungen des RasPi 3,3 Volt oder 5,0 Volt einen Sensor versorgen willst, der z.B. mit einem 9 Volt-Block im Original betrieben wird ?
Wohl dem, der dann auch noch glaubt mit Klingeldrähtchen ein ganzes Hause umgarnen zu können, um damit eine Vielzahl uns unbekannter Funksensoren zentral versorgen zu können.
-
Guten Tag,
erst einmal herzlich Willkommen
Wenn die Arbeitsspannung des MCP23017 auch 3,3 Volt beträgt, dann kannst du diese auf jeden freien GPIO klemmen. Dazu benötigst du aber RPi.GPIO um diese GPIOs als Input auf einen Flankenwechsel von High auf Low überwachen. Im Anschluss auf diesen IRQ kannst du das Auslesen des dazugehörigen Port Registers ( A oder B ) starten. Damit muss man nicht ständig den Bus blockieren, weil man in einem permanenten Auffrage-Loop ist.
Allerdings hast du nur ca. 20 ms Zeit, diese Auffrage durchzuführen, falls einer der als Input genutzten GPIOs durch einen externe Vorgang ( Taster ) auf den Pegel Low gezogen wird.
Andernfalls bei höheren Spannungen musst auf eine geeignet Art ( z.B. Pegelwandler ) die Spannungskompatibilität herstellen. Damit diese beiden INT Rückmelder funktionieren, muss mit einem Pull-Up der Eingang auf die Vc des MCP23017 zogen werden, und durch diesen Schaltvorgang der Pegel auf den LOW-Level absinken. -
Guten Tag,
Über diesen Multiplexer wirst du es nie schaffen mit dem Shell-Tool i2cdetect die daran angeschlossenen Sensoren zu finden.
Über die Programmiersprache C/C++ bestehen je nach Art des Multiplexers zwei Lösungen.
Wie das bei deinem MP ist kann ich mangels Wissens darum nicht beantworten. Einmal wird die eigene Adresse des Multiplexers genutzt, um irgendwie mit Verrechnung der Bus-Adressen die Komponenten anzusprechen, dieser erzeugt dann sozusagen virtuelle Adressen. Und dann die direkt-schaltende Methode, wo der Ausgang am Multiplexer ähnlich einem Portexpander aktiv geschaltet wird, und die Komponente am betreffenden Port mit der eigenen Adresse angesprochen werden kann. Für die Arduino IDE , aber damit nur für µController gibt es fertig Bibliotheken dafür. Nur habe ich selber noch keine passende Möglichkeit gefunden, dieses auch mit Python umzusetzen.
Wenn es jetzt keine Displays sind, die man nicht abschalten sollte, sondern reine Werterfassungssensoren, die nicht wirklich permanent unter Strom stehen müssen, dann ist entweder der Weg RasPi GPIO-OUT als Vc des Sensors , oder bei mehreren über einen Portexpnader die einfachere und schnellere Lösung. Zumal du damit auch noch die Testmöglichkeit hast, über die Shell die einzelnen Sensoren via eines Bus-Scans zu erkennen. -
Guten Tag,
Mit Python ist das so eine Sache mit diesen Multiplexern. Bis jetzt habe ich dafür noch keine Lösung gefunden. Dennoch einen Lösungsvorschlag würde ich dir mit auf den Weg geben.
Python
Display Morefrom smbus import SMBus ''' A simple Python 3.x code with SMBUS ( I²C / 2Wire Bus by Philips / NXP ) to read the sensor with the circuit HTU21A. MIT-Lizenz Copyright (c) 2022 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Datasheet at http://web.sensor-ic.com:8000/ZLXIAZAI/MEAS20140716/HTU21A.pdf ''' class HTU21D(object): CMD_TRIG_TEMP_HM = 0xE3 CMD_TRIG_HUMID_HM = 0xE5 CMD_TRIG_TEMP_NHM = 0xF3 CMD_TRIG_HUMID_NHM = 0xF5 CMD_WRITE_USER_REG = 0xE6 CMD_READ_USER_REG = 0xE7 CMD_RESET = 0xFE def __init__(self, busno=1, address=0x40): self.bus = SMBus(busno) self.i2c_address = address self.__check_bus__(self.bus, self.i2c_address) def read_temperature(self): self.__reset__() msb, lsb, crc = self.bus.read_i2c_block_data(\ self.i2c_address, self.CMD_TRIG_TEMP_HM, 3) return ((-46.85 + 175.72 * (msb * 256 + lsb) / 65536)\ if self.__crc_check___(msb, lsb, crc) else -1) def read_humidity(self): self.__reset__() msb, lsb, crc = self.bus.read_i2c_block_data(\ self.i2c_address, self.CMD_TRIG_HUMID_HM, 3) return (((-6 + 125 * (msb * 256 + lsb) / 65536.0) / 100.0)\ if self.__crc_check___(msb, lsb, crc) else -1) def __reset__(self): self.bus.write_byte(self.i2c_address, self.CMD_RESET) def __check_bus__(self, bus, address): try: value = bus.read_i2c_block_data(self.i2c_address, \ self.CMD_READ_USER_REG,3) except : print('Sensor GY21_HTU21 not found at', hex(address)) exit() print(('Sensor GY21_HTU21 found.' if value == [2, 0 , 0] else \ 'is not a sensorGY21_HTU21 at this bus address')) def __crc_check___(self, msb, lsb, crc): remainder = ((msb << 8) | lsb) << 8 remainder |= crc divsor = 0x988000 for i in range(0, 16): if remainder & 1 << (23 - i): remainder ^= divsor divsor >>= 1 return (True if remainder == 0 else False)Zum Ersten - ich würde auf diesen Adafruit Code verzichten. Dafür gibt es auch schnellere Alternativen (siehe Code-Listing).
Dann würde ich einfach, so habe ich mir zumindest in einer ähnlichen Situation beholfen, weil es wirklich keine wirklich vernünftige PYTHON Lösung für diese Bus-Multiplexer gibt, ich habe die Vc Leitungen über einen Portexpander geschaltet. Somit nacheinander die Sensoren angeschaltet, die Sensorwerte ausgelesen, diesen einen Sensor wieder Stromlos gemacht, und dann den nächsten Sensor aktiviert.
Wenn es keine zeitkritischen Vorgänge sind, kann man hier z.B. den 8 BIt Portexpander PCF8574 nutzen. Dazu integriert man diesen PCF8574 in den Bus, und nutzt die Output GPIOs als Spannungsversorgung für den jeweiligen Sensor. Funktioniert absolut Problemlos, denn auch der PCF8574 ist via Python sehr einfach zu steuern. Du musst nur beachten, nach der Power-ON Schaltung über einen der GPIO Output Ports des Portexpanders, noch eine Verweilzeit einzubauen, bis der Sensor abgefragt werden kann. Auch so kann man recht einfach, mehrere I2C Bus Komponenten mit gleicher Adresse abfragen, solange diese nicht immer und wirklich zeitgleich an sein sollen. -
Guten Abend,
ist ja normal weil noch keine Meßwert erfasst wurde.
Python
Display Morefrom bme280 import BME280 from machine import Pin, I2C, Timer from time import sleep, sleep_ms from sh1106 import SH1106 from hx711_gpio import HX711 import urequests import network import secrets import rp2 class messure_sensor(): def __init__(self, bme, hx, http, key): self.bme280 = bme self.hx711 = hx self.temperatur = '' self.luftdruck = '' self.luftfeuchtigkeit = '' self.gewicht = '' self.gewicht_str = '' self.http = http self.api_key = key def read(self): self.temperatur, self.luftdruck, self.luftfeuchtigkeit\ = self.bme280.values gewicht = (self.hx711.get_value()*-1/41100)-1 self.gewicht_str= str(abs(round(gewicht,2))) self.send() def get(self): return (self.temperatur, self.luftdruck, self.luftfeuchtigkeit,\ self.gewicht_str) def send(self): bme_readings = {'field1':self.temperatur, 'field2':self.luftdruck, 'field3':self.luftfeuchtigkeit} request = urequests.post('http://api.thingspeak.com/update?api_key=' +\ self.api_key, json = bme_readings, headers = self.http) request.close() class Display(): def __init__(self, sh1106): self.sh = sf1106 self.active = False def write(self, args): if not self.active: self.active = True temperatur, luft, feucht, massestr = args self.sh.poweron() self.sh.fill(0) self.sh.text('STOCK Nr.1',1,1) self.sh.text('Temp: ',1,10) self.sh.text(temperatur,50,10) self.sh.text('LD.: ',1,20) self.sh.text(luft,50,20) self.sh.text('LF: ',1,30) self.sh.text(feucht,50,30) self.sh.text('Gew.:',1,40) self.sh.text(massestr,50,40) self.sh.text('kg',112,40) self.sh.text('T BR.:',1,50) self.sh.text(temperatur,50,50) self.sh.show() sleep(30) # wait for 30 secounds self.sh.poweroff() self.active = False def dis_write(timer): display.write(readsensor.get()) SSID = secrets.ssid PSWD = secrets.pw rp2.country('DE') wlan = network.WLAN(network.STA_IF) wlan.active(True) wlan.connect(SSID, PSWD) LED_BUILTIN = Pin("LED", Pin.OUT) # warte auf WLAN Verbindung while not (wlan.status() < 0 or wlan.statuis() >= 3): sleep(1) # Verbindung hergestellt LED_BUILTIN.value(1) #Definitons for I2C-Bus SDA_PIN = 0 CLK_PIN = 1 i2c=I2C(0, sda= Pin(SDA_PIN), scl=Pin(CLK_PIN), freq=400000) #Definitions for OLED-Display WIDTH = 128 HEIGHT = 64 oled = sh1106.SH1106_I2C(WIDTH, HEIGHT, i2c, Pin(16), 0x3c) #Wahrscheinlich der externe VCC PIN = 16 ? # Wahrscheinlich dein Wägesensor ? pin_OUT = Pin(3, Pin.IN, pull=Pin.PULL_DOWN) pin_SCK = Pin(2, Pin.OUT) hx = HX711(pin_SCK, pin_OUT) hx.set_gain(128) sleep_ms(50) sensorBME = BME280(i2c=i2c) readsensor = messure_sensor(sensorBME, hx, {'Content-Type': 'application/json'},\ 'T0AP92DECV6YOC1S') display = Display(oled) button = Pin(14, Pin.IN, Pin.PULL_DOWN) button.irq(trigger=Pin.IRQ_RISING, handler = dis_write) timer = Timer(period=(10 * 60 * 1000), mode=Timer.PERIODIC,\ callback=lambda t:readsensor.read()) #------------------------------------------------------------------------------------------------------ # neues File #------------------------------------------------------------------------------------------------------ secrets.py ssid = 'WLAN_SSID' pw = '0123456789'Wenn ich jetzt keinen Denkfehler mehr drin habe
damit müsste mit jeder Werterfassung auch das Wert-Versenden ablaufen
-
auch ohne #
nimm mal die () nach dis_write weg.
-
Guten Tag
Danke Dennis89 stimmt du hast Recht
bei Pull_Down, ist es ja IRQ_RISING !
Stimmt man sollte den Code ausprobieren können, und die Hardware auch da haben. -
Guten Tag,
wenn der Code keinen Fehler bringt nimm mal die Raute aus Zeile 53 raus.
Python
Display Morefrom bme280 import BME280 from machine import Pin, I2C, Timer from time import sleep, sleep_ms from sh1106 import SH1106 from hx711_gpio import HX711 class messure_sensor(): def __init__(self, bme, hx): self.bme280 = bme self.hx711 = hx self.temperatur = None self.luftdruck = None self.luftfeuchtigkeit = None self.gewicht = None self.gewicht_str = None def read(self): self.temperatur, self.luftdruck, self.luftfeuchtigkeit\ = self.bme280.values gewicht = (self.hx711.get_value()*-1/41100)-1 self.gewicht_str= str(abs(round(gewicht,2))) def get(self): return (self.temperatur, self.luftdruck, self.luftfeuchtigkeit,\ self.gewicht_str) class Display(): def __init__(self,sh1106): self.sh = sf1106 def write(self, args): temperatur, luft, feucht, massestr = args self.sh.poweron() self.sh.fill(0) self.sh.text('STOCK Nr.1',1,1) self.sh.text('Temp: ',1,10) self.sh.text(temperatur,50,10) self.sh.text('LD.: ',1,20) self.sh.text(luft,50,20) self.sh.text('LF: ',1,30) self.sh.text(feucht,50,30) self.sh.text('Gew.:',1,40) self.sh.text(massestr,50,40) self.sh.text('kg',112,40) self.sh.text('T BR.:',1,50) self.sh.text(temperatur,50,50) self.sh.show() sleep(30) # wait for 10 secounds self.sh.poweroff() def dis_write(pin): pass # display.write(readsensor.get()) #Definitons for i2c-Com SDA_PIN = 0 CLK_PIN = 1 i2c=I2C(0, sda= Pin(SDA_PIN), scl=Pin(CLK_PIN), freq=400000) #Definitions for OLED-Display WIDTH = 128 HEIGHT = 64 oled = sh1106.SH1106_I2C(WIDTH, HEIGHT, i2c, Pin(16), 0x3c) #Wahrscheinlich der externe VCC PIN = 16 ? # Wahrscheinlich dein Wägesensor ? pin_OUT = Pin(3, Pin.IN, pull=Pin.PULL_DOWN) pin_SCK = Pin(2, Pin.OUT) hx = HX711(pin_SCK, pin_OUT) hx.set_gain(128) sleep_ms(50) sensorBME = BME280(i2c=i2c) readsensor = messure_sensor(sensorBME, hx) display = Display(oled) button = Pin(14, Pin.IN, Pin.PULL_DOWN) button.irq(trigger=Pin.IRQ_RISING, handler = dis_write) timer = Timer(period=(10 * 60 * 1000), mode=Timer.PERIODIC,\ callback=lambda t:readsensor.read())EDIT PIN geändert / Falling - Rising geänndert
-
Guten Tag,
Ich würde vorschlagen, wenn du mit messure_sensor.get() die letzten Werte auslesen und zugeliefert bekommst, kannst du auch eine zweiten Timer starten, wieder mit einer Periode. Und dort rufst du dann diese def send() auf.
Pythondef send(timer, values): # dann wie oben die values in die einzelnen Werte zerlegen und den Sende-Code hie reintragen timer1 = Timer(.... callback=lambda t: send(readsensor.get()) -
Guten Tag,
ich hätte jetzt nur noch diesen Lösungsvorschlag anzubieten
Python
Display Morefrom bme280 import BME280 from machine import Pin, I2C, Timer from time import sleep, sleep_ms from sh1106 import SH1106 from hx711_gpio import HX711 class messure_sensor(): def __init__(self, bme, hx): self.bme280 = bme self.hx711 = hx self.temperatur = None self.luftdruck = None self.luftfeuchtigkeit = None self.gewicht = None self.gewicht_str = None def read(self): self.temperatur, self.luftdruck, self.luftfeuchtigkeit\ = self.bme280.values gewicht = (self.hx711.get_value()*-1/41100)-1 self.gewicht_str= str(abs(round(gewicht,2))) def get(self): return (self.temperatur, self.luftdruck, self.luftfeuchtigkeit,\ self.gewicht_str) class Display(): def __init__(self,sh1106): self.sh = sf1106 def write(self, timer, args): temperatur, luft, feucht, massestr = args self.sh.poweron() self.sh.fill(0) self.sh.text('STOCK Nr.1',1,1) self.sh.text('Temp: ',1,10) self.sh.text(temperatur,50,10) self.sh.text('LD.: ',1,20) self.sh.text(luft,50,20) self.sh.text('LF: ',1,30) self.sh.text(feucht,50,30) self.sh.text('Gew.:',1,40) self.sh.text(massestr,50,40) self.sh.text('kg',112,40) self.sh.text('T BR.:',1,50) self.sh.text(temperatur,50,50) self.sh.show() sleep(30) # wait for 10 secounds self.sh.poweroff() #Definitons for i2c-Com SDA_PIN = 0 CLK_PIN = 1 i2c=I2C(0, sda= Pin(SDA_PIN), scl=Pin(CLK_PIN), freq=400000) #Definitions for OLED-Display WIDTH = 128 HEIGHT = 64 oled = sh1106.SH1106_I2C(WIDTH, HEIGHT, i2c, Pin(16), 0x3c) #Wahrscheinlich der externe VCC PIN = 16 ? # Wahrscheinlich dein Wägesensor ? pin_OUT = Pin(3, Pin.IN, pull=Pin.PULL_DOWN) pin_SCK = Pin(2, Pin.OUT) hx = HX711(pin_SCK, pin_OUT) hx.set_gain(128) sleep_ms(50) sensorBME = BME280(i2c=i2c) readsensor = messure_sensor(sensorBME, hx) display = Display(oled) button = Pin(14, Pin.IN, Pin.PULL_DOWN) button.irq(trigger=Pin.IRQ_FALLING, handler = display.write(readsensor.get())) timer = Timer(period=(10 * 60 * 1000), mode=Timer.PERIODIC,\ callback=lambda t:readsensor.read()) -
Guten Tag,
Dennis89 würde es etwas bringen den Return in get() bei messure_sensor in Klammer zu setzen und diesen in eine Tuple zu wandeln, dann aber nur eine Variable bei write() in Display() nur eine Variable zu übernehmen und diese dann erst in der Funktion aufzulösen ?
Phira78 leider habe ich diese Hardware nicht verfügbar, so das ich keinen LIVE Test machen konnte. -
Guten Tag,
der erste Teil deines Codes ist wirklich nicht besonders schön
Python
Display Morefrom bme280 import BME280 from machine import Pin, I2C, Timer from time import sleep, sleep_ms from sh1106 import SH1106 from hx711_gpio import HX711 class messure_sensor(): def __init__(self, bme, hx): self.bme280 = bme self.hx711 = hx self.temperatur = None self.luftdruck = None self.luftfeuchtigkeit = None self.gewicht_str = None def read(self): self.temperatur, self.luftdruck, self.luftfeuchtigkeit\ = self.bme280.values gewicht = (self.hx711.get_value()*-1/41100)-1 self.gewicht_str= str(abs(round(gewicht,2))) def get(self): return self.temperatur, self.luftdruck, self.luftfeuchtigkeit,\ self.gewicht_str class Display(): def __init__(self,sh1106): self.sh = sf1106 def write(self, temperatur, luft, feucht, massestr): self.sh.poweron() self.sh.fill(0) self.sh.text('STOCK Nr.1',1,1) self.sh.text('Temp: ',1,10) self.sh.text(temperatur,50,10) self.sh.text('LD.: ',1,20) self.sh.text(luft,50,20) self.sh.text('LF: ',1,30) self.sh.text(feucht,50,30) self.sh.text('Gew.:',1,40) self.sh.text(massestr,50,40) self.sh.text('kg',112,40) self.sh.text('T BR.:',1,50) self.sh.text(temperatur,50,50) self.sh.show() sleep(30) # wait for 30 secounds self.sh.poweroff() #Definitons for i2c-Com SDA_PIN = 0 CLK_PIN = 1 i2c=I2C(0, sda= Pin(SDA_PIN), scl=Pin(CLK_PIN), freq=400000) #Definitions for OLED-Display WIDTH = 128 HIGHT = 64 oled = sh1106.SH1106_I2C(128, 64, i2c, Pin(16), 0x3c) #Wahrscheinlich der externe VCC PIN = 16 ? # Wahrscheinlich dein Wägesensor ? pin_OUT = Pin(3, Pin.IN, pull=Pin.PULL_DOWN) pin_SCK = Pin(2, Pin.OUT) hx = HX711(pin_SCK, pin_OUT) hx.set_gain(128) sleep_ms(50) sensorBME = BME280(i2c=i2c) # fehlerhafte Zeile entfernt readsensor = messure_sensor(sensorBME, hx) display = Display(oled) button = Pin(14, Pin.IN, Pin.PULL_DOWN) button.irq(trigger=Pin.IRQ_FALLING, handler = display.write(readsensor.get())) timer = Timer(period=(10 * 60 * 1000), mode=Timer.PERIODIC,\ callback=lambda t:readsensor.read())Theoretisch, wenn ich keinen Tippfehler eingebaut habe, müsste das bis auf die Datenübermittlung soweit funktionieren. Der TIMER steuert die Abfrage der Sensoren, und der Buutton-Interrupt schaltet für 30 Sek. das Display an, welches dann wieder von alleine aus geht.
-
Guten Tag,
und herzlich Willkommen im Forum
Loops ? Was heißt das nun ? Ich frage jetzt mal sehr direkt nach der von dir verwendeten Programmiersprache ?
In µPython kann man die Funktion machine.Pin.irq() verwenden, um in Kombination auf "Falling" des GPIO-Pegels reagiert, und damit das Display aktiviert. Über diesen Interrupt-Handler ruft man das entsprechende Funktionsmodul auf, in diesem wird dann zum Abschluss ein machine.Timer() gestartet der nur einmal durchlaufen wird, um anschließend wieder das Display abzuschalten.
Normal braucht man für diese periodischen Abläufe die du mit loop() einschließt auch keinen solchen Aufbau.
Du kannst zu diesem Zweck auch wieder einen machine.Timer() benutzen, welcher in der Handler-Funktion das einsammeln und übertragen der Daten übernimmt. Damit kann man entweder über eine Taktreduzierung machine.freq() oder andere Mechanismen für einen Stromeinsparung sorgen. Zur bessern und zügigeren Verarbeitung schalten man dann innerhalb, falls du auf die Taktreduzierung setzt, dieser Funktion die Taktrate wieder nach oben.
Vielleicht könntest du deinen bisherigen Code hier mal einstellen. Bitte verwende dazu Code-Funktion über die Menüleiste "</>". -
Guten Tag,
aus jedem Energiesparmodus kommst du mit einem Event heraus. Das bedeutet so meine Feststellung, machine.pin.irq() oder machine.Timer() reicht um das PICO wieder in den Normalmodus zu versetzen. Nur erfolgt dann auch der komplette Re-Start des __main__.
Hier gibt es einige Lösungsvorschläge, wie man das machen und umsetzen kann. -
Guten Tag,
ich würde dir raten auf die Bibliothek GPIOZERO zu setzen, um deine Servo anzusteuern.
Weiterhin denke ich wenn du diese Schrittweiten über die Polpaare in LIST hast, dann musst du dir auch den aktuellen Stand der letzten Motorstellung merken.
Hier wirst du wohl nicht umhinkommen eine "Class" zu schreiben, einfacher auch wieder mit GPIOZERO umzusetzen.
Neben dem INIT der PINs ( ich hoffe du hast einen entsprechenden Motortreiber dazwischen geschaltet ) müsstest du die Endlagen festlegen, dann für die Funktionsausführung mit Richtung einen Step-Counter , der dann intern diese LIST der Spulenpaarungen wiederholt in der richtigen Richtung wiederholt durchläuft. Dabei muss du intern dir die aktuelle Position als Wegeposition, wie auch die zu letzte aufgerufene Spulenpaarung.Ich wüsste jetzt keine alternative Lösung, wie man ohne CLASS eine Endlagenbegrenzung und die aktuelle Motorstellung zwischenspeichern könnte.
