Über serielle schnittstelle signale empfangen

[kasim]

Hallo
ich wollte ein kleines spiel programmieren muss dafür aber signale von einer seriellen schnittstelle emfangen können.
nun habe ich aber keine ahnung wie man in python diese signale einbinden kann
schon mal danke für eure antworten[/code]

[lunar]

pyserial

[keppla]

Hallo
ich wollte ein kleines spiel programmieren muss dafür aber signale von einer seriellen schnittstelle emfangen können.
nun habe ich aber keine ahnung wie man in python diese signale einbinden kann
schon mal danke für eure antworten[/code]

Willst du nicht erstmal eine Frage stellen?

Aber, die Antwort auf die Frage, die du stellst könnte http://wiki.python.org/moin/PySerial sein.

[kasim]

meine frage: wie lasse ich python diese signale erkennen??

danke für eure antwort auf meine nicht vorhandene frage aber ich verstehe nicht was is damit nun anfangen soll

[lunar]

Wie wäre es mit: Die Dokumentation dieses Moduls lesen und anschließend das daraus erworbene Wissen in ein Programm gießen? Ohne konkrete Problembeschreibung kann man dir schlecht helfen.

[kasim]

ich möchte eine fahrradsimulation erstellen
ich sitze also vor dem computer auf dem fahrrad und wen ich in die pedale trete tritt mein double im bildsvhirm auch in die pedale
den reifen des fahrrads werde ich mit einem magnetsen sor versehen und immer wenn das rad eine umdrehung hinter sich hat soll der abstand bis zu nächsten umdrehung gemessen werden wodurch die geschwindigkeit de fahrades errechnet werden kann
ich weiß aber nicht wie diese nullen und einsen die der magnetsensor sendet(eigentlich ja nur dei einsen) in den computer zu bekommen sind und dies soll it python geschehen
in so etwas habe ich kein bisschen erfahrung und würde dies gerne in einem tutorial genau erklärt bekomen(am besten auf deutsch!)
tut mir leid , dass ich so undurchsichtig alles beschrieben habe.

[gerold]

ich weiß aber nicht wie diese nullen und einsen die der magnetsensor sendet(eigentlich ja nur dei einsen) in den computer zu bekommen sind

Hallo kasim!

Schau dir mal diese Anleitung http://halvar.at/elektronik/motorsteuer ... odul-bauen an. Dort wird erklärt, wie du einen RS-232/TTL-Adapter bauen kannst. Alternativ gibt es so etwas natürlich auch zu kaufen: http://www.pollin.de/shop/shop.php?cf=d ... Y5OTgxOTk=

Für einfache Rückmeldungen kannst du den CTS-Pin abfragen. Schließt du den CTS-Eingang mit GND kurz, dann bekommst du mit dem Befehl ``s.getCTS()`` ein ``True`` zurück. Schließt du den CTS-Eingang mit VCC (+5 V) kurz, dann bekommst du mit dem Befehl ``s.GetCTS()`` ein ``False`` zurück.

Man könnte diesen CTS-Pin auch ohne den Aufbau mit dem MAX232-IC abfragen. Allerdings ist das dann nicht mehr allzu störungssicher. Das Verbindungskabel darf dann nur sehr kurz sein. Da das Risiko zu groß ist, dass dabei etwas nicht funktioniert, erkläre ich es gar nicht erst.

Code: Alles auswählen

>>> import serial
>>> s = serial.Serial("COM1")
>>> s.getCTS()
False
>>> 

Wenn du diesen CTS-Eingang in einer timergesteuerten Schleife abfragst, dann hast du deine Information.

mfg
Gerold

[gerold]

Hallo!

Dieses Codebeispiel zeigt in einem Fenster an, wie groß die Zeitspanne seit dem letzten Impuls (LOW-HIGH-Flanke des CTS-Eingangs) war.

"IntervalMeter.run" läuft als eigenständiger Thread. Immer wenn eine LOW-HIGH-Flanke erkannt wurde, wird das Event "CtsEvent" ausgelöst. Dieses Event kann über den Eventbinder "EVT_CTS" gebunden werden. Damit man sich nicht "verrenken" muss, damit man die Methode "Bind" mit der Klasse "IntervalMeter" verwenden kann, habe ich die Klasse auch von "wx.Timer" abgeleitet. Damit bekomme ich die Bind-Methode geerbt. Einen anderen Grund für das Erben von "wx.Timer" gibt es nicht.

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: iso-8859-15 -*-

import wx
import wx.lib.newevent
import threading
import serial
import time

wx.SetDefaultPyEncoding("iso-8859-15")


class IntervalMeter(threading.Thread, wx.Timer):
    
    # Event-Klassen und Eventbinder-Funktionen erstellen
    (CtsEvent, EVT_CTS) = wx.lib.newevent.NewEvent() 
    
    
    def __init__(self):
        threading.Thread.__init__(self)
        wx.Timer.__init__(self)
        self.cancel = threading.Event()
    
    
    def run(self):
        old_cts_status = False
        last_tick = None
        s = serial.Serial("COM1")
        while not self.cancel.isSet():
            cts = s.getCTS()
            if cts and not old_cts_status:
                # LOW-HIGH-Flanke
                new_tick = time.clock()
                if last_tick:
                    interval = new_tick - last_tick
                    # Event auslösen
                    event = self.CtsEvent()
                    event.interval = interval
                    self.ProcessEvent(event)                     
                last_tick = new_tick
            old_cts_status = cts
            time.sleep(0.01)
        s.close()
    
    
    def stop(self):
        self.cancel.set()


class MyFrame(wx.Frame):
    
    def __init__(
        self, parent = None, title = u"Intervallanzeige", size = wx.Size(350, 100)
    ):
        wx.Frame.__init__(self, parent, -1, title, size = size)
        
        panel = wx.Panel(self)
        
        vbox = wx.BoxSizer(wx.VERTICAL)
        panel.SetSizer(vbox)
        
        lab_interval = wx.StaticText(panel, label = u"0")
        vbox.Add(lab_interval, 1, wx.EXPAND | wx.ALL, 5)
        self.lab_interval = lab_interval
        
        font = lab_interval.GetFont()
        font.SetPointSize(18)
        font.SetWeight(wx.FONTWEIGHT_BOLD)
        lab_interval.SetFont(font)
        
        self.interval_meter = IntervalMeter()
        self.interval_meter.start()
        self.interval_meter.Bind(IntervalMeter.EVT_CTS, self.show_interval)
        
        self.Bind(wx.EVT_CLOSE, self.on_close)
    
    
    def show_interval(self, event):
        interval = event.interval
        self.lab_interval.SetLabel(str(interval))
        wx.Bell()
    
    
    def on_close(self, event):
        self.interval_meter.stop()
        self.interval_meter.join()
        event.Skip()


def main():
    app = wx.PySimpleApp()
    f = MyFrame()
    f.Center()
    f.Show()
    app.MainLoop()


if __name__ == "__main__":
    main()

mfg
Gerold

[kasim]

vielen dank gerold
mit deiner zweiten antwort kann nich nicht so viel anfangen, denn die
verstehe ich nicht aber deine erste antwort hilft mir wirklich weiter!! kennst du diese begehle auch noch für den parallelen anschluss?? damit wird nämlich alles einfacher

[Hyperion]

Es gibt ein Modul namens pyparallel (o.ä.). Dazu gibt es hier im Board auch schon Threads, am besten suchst Du mal danach. Iirc ging es da auch mal um das Einlesen. Ich persönlich habe es nur für das Ausgeben von Signalen verwendet.

[kasim]

ich hab da nichts zu gefunden
könntet ihr mir nicht einfach so einen quelltext geben wie gerold einen geschrieben hat(den kurzen den langen brauch ich nicht)??
wäre sehr nett

[gerold]

kennst du diese begehle auch noch für den parallelen anschluss?? damit wird nämlich alles einfacher

Hallo kasim!

Im Gegenteil. Es wird schwieriger anzusteuern. Der Parallelport versteht keinen Spaß. Ein kleiner Fehler beim Hardwareaufbau und der ist hinüber. Der Parallelport steht nur mehr bei wenigen, neuen Computern zur Verfügung. Beim Parallelport kann Windows dir einen Strich durch die Rechnung machen und den Zugriff blockieren. Das ist dann nur umständlich umgehbar.

Wenn du die Serielle nimmst, dann kannst du auch einen USB/RS-232-Adapter verwenden. Die einzige Einschränkung ist, dass du mit der Seriellen, nicht mehrere Signale auswerten kannst, ohne hardwaretechnisch aufzurüsten.

Aber wenn du es versuchen möchtest, hier ist ein Code, der aufzeigt, wie man mit pyParallel auch das Datenregister (unter Windows) einlesen kann.

Code: Alles auswählen

>>> import parallel
>>> from parallel.parallelwin32 import _pyparallel
>>> p = parallel.Parallel(port = 0)
>>> p.setData(123)
>>> _pyparallel.inp(p.dataRegAdr)
123
>>>

Ob das auch in der Praxis funktioniert, weiß ich nicht, da ich es nicht ausprobiert habe.


EDIT:

Ich habe mich ein wenig eingelesen. Bevor man die Daten vom Parallelport abfragen kann, muss man ein Bit des Control-Registers ändern. Das Bit mit dem Wert 16 muss geändert werden. Damit werden die Data-Pins des Parallelports hochohmig. Dann kann man die Data-Pins direkt mit GND oder VCC verbinden um ein Signal an den Computer zu übermitteln. Das wird in pyParallel nicht gemacht. Es wäre gar nicht schwer, das zu ergänzen.


Die Statusleitungen kannst du mit diesen Befehlen auslesen:

Code: Alles auswählen

>>> p.getInAcknowledge()
1
>>> p.getInBusy()
1
>>> p.getInError()
1
>>> p.getInPaperOut()
1
>>> p.getInSelected()
1
>>>

mfg
Gerold

[kasim]

vielen dank
vielleicht nehme ich doch den seriellen!