Herzlich Willkommen im einzigen (deutschsprachigem) Picaxe-Forum.

Der Ursprung dieses Forum reicht bis in das Jahr 2008 zurück

Foren Suche

  • Variablen der PicaxeDatum26.01.2019 19:59
    Thema von BoomBoomMagic im Forum Basic's

    Hier erkläre ich einmal den Zusammenhang von Bits , Bytes und Words bei einer Picaxe.

    Ein Byte besteht , wie man wissen sollte , aus 8 Bits.
    Gezählt wird ab 0 und von rechts nach links , also : bit7 , bit6 , bit5 , bit4 , bit3 , bit2 , bit1 , bit0

    2 Bytes ergeben ein Word = 16 Bit ( bit15 , bit14 , bit13 , bit12 , bit11 , bit10 , bit9 , bit8, bit7 , bit6 , bit5 , bit4 , bit3 , bit2 , bit1 , bit0 )


    Das Picaxe-System benutzt anders als bei anderen Basicdialekten feste Namen als Variablen.
    Somit sind die Bits vorgegeben mit bit0 bis bit15 , die Bytes mit b0 bis b27 und die Words mit w0 bis w13

    Hier mal eine Art Tabelle als Übersicht :


    |addpics|nqa-j-a56d.jpg|/addpics|

  • Eine LED blinken lassenDatum26.01.2019 19:58
    Thema von BoomBoomMagic im Forum Basic's

    zunächst der Schaltplan , der sehr einfach aufgebaut ist :



    Es gibt jetzt mehrere Möglichkeiten wie man diese LED jetzt blinken lassen kann.


    1. per Binärverknüpfung

    1
    2
    3
    4
    5
    6
    7
    8
     

    let dirsc=%00000011
    do
    b0=b0 xor 2
    let pinsc=b0
    pause 1000
    loop
     
     




    2. per Port-Wackeln

    1
    2
    3
    4
    5
    6
    7
     

    let dirsc=%00000011
    do
    toggle c.1
    pause 1000
    loop
     
     




    3. per AN/AUS

    1
    2
    3
    4
    5
    6
    7
    8
    9
     

    let dirsc=%00000011
    do
    pinc.1=1
    pause 1000
    pinc.1=0
    pause 1000
    loop
     
     

    |addpics|nqa-i-308d.jpg|/addpics|

  • LCD 20x4 an der PicaxeDatum26.01.2019 19:55
    Thema von BoomBoomMagic im Forum Basic's

    Wie man ein LCD-Display ( 16 x 2 ) an einer Picaxe betreibt , habe ich ja schon einmal ausführlich beschrieben. ^^

    Viele möchten aber gerne auch einmal ein 20x4 Display nutzen.
    OK.
    Wenn man nicht gerade einen "Exoten" kauft , hat man in der Regel die gleichen Anschlüsse wie bei einem 16x2 Display.
    14 Pins ohne Backlightpins und 16 Pins mit Backlightpins - Belegungen sind von Pin1 - Pin14 identisch.

    Der Code ist im grunde auch gleich, zumindest die Initialisierung.
    Lediglich beim Anzeigen der Zeilen haben wir jetzt 2 zeilen mehr und müssen dementsprechend vor der Anzeige von Texten in die entsprechende Reihe schalten.

    Hierzu mal ein Beispielcode ( für eine 14M2 ):

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
     

    #picaxe 14M2
     
    symbol Wert = b0
    symbol HighWert = b1
    symbol LowWert = b2
     

    let dirsb=%11111111
    let dirsc=0
     

    ' INITIALISIERUNG
    FOR b10=1 to 3
    LET PINSb=%00100011:low 5
    LET PINSb=%00100011:low 5
    pause 50
    NEXT b10
     
    ' 4 Bit Modus
    LET PINSb=%00100000:low 5
    LET PINSb=%00100010:low 5
    pause 10
     
    ' 5x8 Matrix / 2 Reihen
    LET PINSb=%00100010:low 5
    LET PINSb=%00101000:low 5
    pause 10
     
    'Display Clear
    LET PINSb=%00100000:low 5
    LET PINSb=%00100001:low 5
    pause 10
     
    'Return Home
    LET PINSb=%00100000:low 5
    LET PINSb=%00100110:low 5
    pause 10
     
    ' Display ON,Cursor OFF, No blinken
    LET PINSb=%00100000:low 5
    LET PINSb=%00101100:low 5
    pause 10
    let pinsb=0
    '#######################################
    '#######################################
     

    ' ~~~~~~~~ Reihe 1 ~~~~~~~~~~~~~~~~~~~
    LET PINSb=%00100000:low 5
    LET PINSb=%00100010:low 5
    for b10=0 to 15
    lookup b10,("Dies ist Zeile 1"),Wert
    gosub Sendtext
    next b10
    ' ~~~~~~~~ Reihe 2 ~~~~~~~~~~~~~~~~~~~
    LET PINSb=%00101100:low 5
    LET PINSb=%00100000:low 5
    for b10=0 to 15
    lookup b10,("Dies ist Zeile 2"),Wert
    gosub Sendtext
    next b10
    ' ~~~~~~~~ Reihe 3 ~~~~~~~~~~~~~~~~~~~
    LET PINSb=%00101001:low 5
    LET PINSb=%00100100:low 5
    for b10=0 to 15
    lookup b10,("Dies ist Zeile 3"),Wert
    gosub Sendtext
    next b10
    ' ~~~~~~~~ Reihe 4 ~~~~~~~~~~~~~~~~~~~
    LET PINSb=%00101101:low 5
    LET PINSb=%00100100:low 5
    for b10=0 to 15
    lookup b10,("Dies ist Zeile 4"),Wert
    gosub Sendtext
    next b10
     
    end
     
    SendText:
    HighWert=Wert/16
    LowWert=HighWert*16:LowWert=Wert-LowWert
     
    HighWert=HighWert+48
    let pinsb=HighWert:low 5
     
    LowWert=LowWert+48
    let pinsb=LowWert:low 5
    return
     

     

  • Das alphanumerische LCD-DisplayDatum26.01.2019 19:37
    Thema von BoomBoomMagic im Forum Basic's

    Viele fertige Routinen sind ja in der Picaxe schon enthalten , nur für ein Display leider bis heute noch nichts.
    Etwas verwunderlich , da echte Mikrocontroller solch Routinen schon von je her enthalten haben.

    Von daher gibt es 2 Möglichkeiten :

    1. man kauft sich ein teures serielles Display
    2. man erstellt sich selbst eine Routine

    Ein normales LCD-Display 16x2 gibt es ja schon bei Ebay für 3.- bis 5.- Euro.
    Zu 99,9% sind alle Displays völlig identisch vom Anschluss als auch von der Programmierung her.

    Solch Display läßt sich im sogenannten 8Bit-Modus als auch im 4Bit-Modus programieren.
    Beim 8Bit-Modus benötigt man 8 Datenleitungen + RS + Enable = 10 Leitungen.
    Beim 4Bit-Modus benötigt man nur 4 Datenleitungen + RS + Enable = 6 Leitungen.

    Der 4Bit-Modus hat sich mittlerweile durchgesetzt und wird am häufigsten benutzt.
    Einzige Besonderheit dabei ist, das man eben für jeden Befehl zur Ausführung 2x ein 4Bit-Byte senden muss.

    Der Trick beim 4Bit-Modus ist , das man die unteren 4 Bits eines Bytes auf Masse setzt und somit diese auf logisch 0 setzt.
    Dadurch brauch man nur noch 4 Leitungen für die oberen 4Bits um ein volles Byte zu erhalten.


    Um sich die Sache einfach zu halten , insbesondere beim Programmieren einer Routine ,
    empfiehlt es sich , zusammenliegende Pins von xx.0 bis xx.5 für das Display zu nehmen.



    So ein Display hat im Grunde 2 Modi :

    a ) ist der RS-Pin auf Low = Command-Mode
    b) ist der RS-Pin auf High = ASCII-Mode

    Im Command-Mode werden folgende Aktionen ausgeführt :
    - Initialisierung
    - Setzen der Cursorposition
    - Cursor an/aus
    - Cursor blinken oder nicht
    - Shiften rechts/links
    - Display Clear

    Im ASCII-Mode werden ausschließlich nur ASCII-Zeichen gesendet für die Anzeige auf dem Display.

    Ein Display kann man also nicht einfach so anschliessen und danach einfach mal ein paar Texte rübersenden.
    Solch ein Display hat selbst einige Mikrocontroller auf seiner Platine denen man ja erst einmal mitteilen muß
    was man gern möchte.
    Dazu macht man am Anfang immer erst eine Initialisierung

    Ich denke jetzt die Initialisierung im Detail zu erklären gehört mehr in ein Fortgeschrittenen Tutorial , insofern
    hier die Initialisierung ohne groß Kommentar :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
     

    FOR b0=1 to 3
    LET PINSb=%00100011:low 5
    LET PINSb=%00100011:low 5
    pause 50
    NEXT b0

    ' 4 Bit Modus
    LET PINSb=%00100000:low 5
    LET PINSb=%00100010:low 5
    pause 10
     
    ' 5x8 Matrix / 2 Reihen
    LET PINSb=%00100010:low 5
    LET PINSb=%00101000:low 5
    pause 10
     
    'Display Clear
    LET PINSb=%00100000:low 5
    LET PINSb=%00100001:low 5
    pause 10
     
    'Return Home
    LET PINSb=%00100000:low 5
    LET PINSb=%00100110:low 5
    pause 10
     
    ' Display ON,Cursor OFF, No blinken
    LET PINSb=%00100000:low 5
    LET PINSb=%00101100:low 5
    pause 10
    let pinsb=0
     
    Return
     
     




    Diesen Code , zusammen mit dem Schaltplan für die Anschlussbelegung kann man immer und immer wieder nutzen.


    Vielleicht wird dem ein oder anderen aufgefallen sein , das ich ja sagte , das wir "nur" 4 Bits senden ,
    jedoch immer das 5. Bit auf 1 gesetzt ist.

    Tjaaa , wenn man alles richtig angeschlossen hat, ist ja Bit5 ( Pin xx.5 ) => Enable
    Ein Display benötigt immer eine Art Clock-Signal um etwas auszuführen.
    Das heißt , wenn ich etwas senden will , muß ich einmal das Bit5 auf High und wieder auf Low setzen.

    In der Initialisierung mache ich das Setzen des Bit5 durch Angabe von Let Pins in einem Atemzug.

    Anschliessend durch den Befehl : low 5 setze ich das Bit5 wieder auf 0

    Damit habe ich also eine Clock ausgelöst und das Display führt den Befehl aus.

    Jetzt haben wir also das Display initialisiert, aber das reicht ja noch nicht. :)

    Jetzt benötigen wir ja noch eine Routine , die uns ASCII-Zeichen auf´s Display sendet.
    Dazu benutzen wir folgende :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     

    SendText:
     
    HighWert=Wert/16
    LowWert=HighWert*16:LowWert=Wert-LowWert
     
    HighWert=HighWert+48
    let pinsb=HighWert:low 5
     
    LowWert=LowWert+48
    let pinsb=LowWert:low 5
     
    return
     
     



    Was wird hier gemacht ?
    Nun, .... nehmen wir an , wir wollen ein 'A' ans Display senden.
    Ein 'A' ist ja das ASCII-Zeichen '65'
    Da wir ja keine vollen Bytes senden können, müssen wir dieses in 2x 4Bits unterteilen.
    Da 4Bits max. eine Zahl von 16 sein kann , ist also der Teilungsfaktor => 16
    Also rechnen wir:

    65 : 16 = 4 ( HighWert=Wert/16 )

    16 x 4 = 64
    65 - 64 = 1 (LowWert=HighWert*16 : LowWert=Wert-LowWert )


    Da wir ja gesagt haben , das wenn wir ASCII-Zeichen senden wollen ,
    wir den Pin RS auf high haben müssen , zudem der Pin Enable auch high sein soll ,
    wären das also Bit4 + Bit5 ( 16+32 = 48 ) , und zähle somit auf den ersten Wert,
    dem Highwert noch 48 drauf.
    ( HighWert=HighWert+48 )

    Da eine Ausführung ja ein Clock-Signal benötigt ,
    wir durch die Addition von 48 den Enable schon auf high gesetzt haben ,
    müssen wir den Enable nur noch auf low setzen um den Clock zu vollenden.
    ( let pinsb=HighWert:low 5 )

    Das ganze "Spiel" erfolgt jetzt auch nochmal mit dem LowWert .....
    ( LowWert=LowWert+48 : let pinsb=LowWert:low 5 )



    Das war schon die ganze Routine für das Senden von ASCII-Zeichen. :thumbsup:
    Wenn man das einmal verstanden hat , einfacher als Fahrrad fahren.


    Was jetzt noch fehlt , das wären ja die Command-Befehle.

    Zunächst beschränke ich mich hier auf die Positionierung des Cursors.
    Wir können , wenn genug Interesse besteht , später noch auf andere Commands eingehen. ^^

    Eigentlich ist bei allen Displays der Befehl für : Cursor 1. Zeile - links und Cursor 2. Zeile - links immer gleich.

    Cursor 1. Zeile - links = 128
    Cursor 2. Zeile - links= 192

    Da dies Commands sind , bleibt der Pin RS auf low.
    Es müssen jetzt nur noch die Werte in 2x 4Bits gewandelt werden.

    1
    2
    3
    4
    5
    6
    7
    8
    9
     

    'Cursor 1. Zeile :
    LET PINSb=%00100000:low 5
    LET PINSb=%00100010:low 5
     
    'Cursor 2. Zeile :
    LET PINSb=%00101100:low 5
    LET PINSb=%00100000:low 5
     
     

    |addpics|nqa-h-cf6c.jpg|/addpics|

  • Drehencoder mit der PicaxeDatum26.01.2019 19:32
    Thema von BoomBoomMagic im Forum Basic's

    Einen sogenannten Drehencoder oder Drehimpulsgeber mit einer Picaxe auszuwerten ist leider garnicht so einfach. :(

    "Normale" Mikrocontroller haben meistens bereits schon fertige Routinen enthalten , während bei einer Picaxe man das leider selber machen muss.



    Drehencoder gibt es in viele Variationen :



    Sie arbeiten in der Regel alle nach dem selben Prinzip:

    2 Pins ( meist A + B ) werden mit einem Pullup-Widerstand auf High gesetzt.
    Während des Drehens verbindet der Drehencoder nun abwechselnd Pin A oder Pin B mit Pin C = Masse.
    Ab und an wird sogar noch ein Kondensator von 100nF parallel zum Pullup gesetzt.


    Da ja nun beim Drehen unheimlich schnelle Impulse entstehen , ist die Picaxe leider nicht in der Lage ohne Verluste den Encoder auswerten zu können und auch noch eine Anzeige darzustellen.

    Es ist aber möglich nach dem Auswerten 2 Ausgänge passend zur Drehrichtung mit LED´s zu versehen , die einem die Richtung und Anzahl der Impulse darstellen.

    Dazu hier der Schaltplan :


    Der zugehörige Code ist am Anfang vielleicht nicht so ganz leicht zu verstehen , aber evtl. kommt der Ein oder Andere hinter das Prinzip :


    Quellcode

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
     

    setfreq m8
     
    let dirs=%00000111
     
    symbol Impulsgeber_rauf = pinc.3
    symbol Impulsgeber_runter = pinc.4
    symbol Impulse = b0
    symbol Impulse_merken = b1
     

    bit0 = Impulsgeber_rauf
    bit1 = Impulsgeber_runter
    impulse_merken = impulse
     
    do
     
    bit0 = Impulsgeber_rauf
    bit1 = Impulsgeber_runter
     
    ' rauf zählen - rechts rum
    if impulse = 2 and impulse_merken = 0 then
    pulsout c.1,200
    impulse_merken = 3
    do
    bit0 = Impulsgeber_rauf
    bit1 = Impulsgeber_runter
    loop until impulse = 3
    endif
     
    if impulse = 1 and impulse_merken = 3 then
    pulsout c.1,200
    impulse_merken = 0
    do
    bit0 = Impulsgeber_rauf
    bit1 = Impulsgeber_runter
    loop until impulse = 0
    endif
    '-----------------------------------
     
    ' runter zählen - links rum
    if impulse = 1 and impulse_merken = 0 then
    pulsout c.2,200
    impulse_merken = 3
    do
    bit0 = Impulsgeber_rauf
    bit1 = Impulsgeber_runter
    loop until impulse = 3
    endif
     
    if impulse = 2 and impulse_merken = 3 then
    pulsout c.2,200
    impulse_merken = 0
    do
    bit0 = Impulsgeber_rauf
    bit1 = Impulsgeber_runter
    loop until impulse = 0
    endif
     
    loop
     
     

    |addpics|nqa-d-8f3e.jpg,nqa-e-9c0f.jpg,nqa-f-d095.jpg,nqa-g-ffe8.jpg|/addpics|

  • Thema von BoomBoomMagic im Forum Basic's

    Die Picaxe eignet sich sehr gut um Spannungen zu messen.

    Wichtig zu beachten ist allerdings :
    Die zu messende Spannung darf niemals höher als die Versorgungsspannung der Picaxe sein - sprich 5V !

    Um eine vernünftige Messung zu erzielen , benötigt man eine sehr stabile Versorgungsspannung ,
    da die Picaxe die Versorgungsspannung als Referenzspannung beim Messen nutzt.
    ( Bei manchen Picaxe kann man die Referenzspannung einstellen , ob intern oder extern - hier nutzen wir ausschließlich die interne )

    ADC bedeutet : Analog - Digital - Conversion
    Das heißt , aus einer Gleichspannung eine Dezimalzahl ermitteln.

    Es gibt 2 Befehle dazu :

    1. readadc -> hierbei wird mit 8Bit aufgelöst , was allerdings recht wenig ist
    2. readadc10 -> hierbei wird mit 10Bit aufgelöst , dieser Befehl ist zu empfehlen

    10Bit bedeutet , das aus der analogen Spannung ein Wert von 0 bis 1023 ermittelt werden kann.

    Wenn wir also eine stabile Versorgungsspannung von 5V haben , dann wäre : 0 = 0 Volt / 1023 = 5V

    Jetzt benötigen wir lediglich den Teilungsfaktor : 5V : 1023 = 0,0048

    Fangen wir hier erst einmal mit dem Schaltplan an.
    Als Test nutzen wir ein simples Poti mit 10K um Werte zu erhalten.



    Den ermittelten Wert lassen wir uns über ein Terminalprogramm anzeigen.
    ( Wir nutzen 4Mhz , das heißt : 4800 Baud einstellen )

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
     

    symbol Zehntausend = b4
    symbol tausend = b5
    symbol Hundert = b6
    symbol Zehner = b7
    symbol Einer = b8
     
    let dirsc=%00000001
     
    do
    readadc10 1,w0
    if w0<>w1 then
    w1=w0
    w0=w0*10
    w0=w0/100*48
    bintoascii w0,Zehntausend,Tausend,Hundert,Zehner,Einer
    sertxd (Tausend,".",Hundert,Zehner,Einer," Volt",13,10)
    endif
    loop
     
     



    Damit wir auch Kommastellen anzeigen lassen können ,setzen wir den ermittelten Wert
    nach dem Einlesen um eine Potenz höher, also in diesem Fall x10

    Weil jetzt können wir mit /100 x 48 den Wert durch 0.048 , unserem Teilungsfaktor teilen lassen.

    Nun erhalten wir zahlen im Tausenderbereich , wobei wir uns gedanklich nach der 1. Stelle einen Punkt vorstellen müssen.

    Das Ganze wandeln wir jetzt noch mit dem Befehl : BINTOASCII in einzelne Zahlen um und senden diese an den Terminal am PC.




    |addpics|nqa-b-3f31.jpg,nqa-c-fd9a.jpg|/addpics|

  • LDR ( Lichtsensor ) an der PicaxeDatum26.01.2019 19:26
    Thema von BoomBoomMagic im Forum Basic's

    Einen LDR ( Light Diode Resistor ) ist ein lichtempfindlicher Widerstand ,
    der je nach Helligkeit eine angelegte Spannung mehr oder weniger durch läßt.

    Dadurch läßt sich ein LDR wunderbar mit einer ADC-Messung auswerten.

    Hier will ich einmal eine Schaltung vorstellen , die einen LDR ausliest und
    entsprechend eine LED an- oder ausschaltet.

    Wobei , die LED geht erst an , wenn ein voreingestellter Wert an Helligkeit erreicht ist
    und aus erst , wenn ein voreingestellter Wert unterschriten wird.

    Dazu erst einmal der Schaltplan :


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
     

    symbol Messung = w0
    symbol Max_Prozent_Hell = b2
    symbol Min_Prozent_Dunkel = b3
    symbol LED_An = b4
    symbol LED = pinc.4
     

    let dirsc=%00010001' Pin4+0 als Ausgang + Pin1,2,3 als Eingang definieren
     
    ' Hier kann man bestimmen ab welche Werte reagiert werden soll
    Max_Prozent_Hell = 80
    Min_Prozent_Dunkel = 20
     
    do
    readadc10 1,Messung
    Messung = Messung / 10 ' Prozentumrechnung
     
    If Messung >= Max_Prozent_Hell and LED_An =0 then
    LED_An = 1
    LED = 1
    endif
     
    If Messung <= Min_Prozent_Dunkel and LED_An = 1 then
    LED_An = 0
    LED = 0
    endif
    loop
     
     

    |addpics|nqa-a-0a9c.jpg|/addpics|

  • BINTOASCII - was 'n das' n ?Datum26.01.2019 19:24
    Thema von BoomBoomMagic im Forum Basic's

    Der Befehl BINTOASCII ( binär Zahl zum ASCII-Zeichen ) wird hauptsätzlich benutzt ,
    wenn Werte die größer als ein Byte sind , seriell übertragen werden sollen oder bei der Kommunikation mit LCD-Displays.

    Bei der seriellen Übertragung kann man ja nur Bytes verwenden.
    Was aber tun , wenn man Zahlen hat die weit größer sind ?
    Z.B. ein Word ?
    Oder eine Kommazahl ?

    Hier kommt dann der Befehl : BINTOASCII ins Spiel.
    Mit diesem Befehl "zerlegt" man quasi die große Zahl in deren einzelne Ziffern.

    Es gibt 2 Möglichkeiten BINTOASCII zu nutzen:

    1. zum Übermitteln eines Bytes
    2. zum Übermitteln eines Word

    Bei einem "Zerlegen" eines Bytes benötigt der Befehl 3 Variablen : Hunderter - Zehner - Einer

    Beispiel :
    die Zahl 123 würde "zerlegt" werden in -> Hunderter = 1 , Zehner = 2 , Einer = 3

    Beim einem "Zerlegen" eines Word benötigt der Befehl 5 Variablen : Zehntausender - Tausender - Hunderter - Zehner - Einer
    Beispiel :

    die Zahl 12345 würde "zerlegt" werden in :
    Zehntausender = 1
    Tausender = 2
    Hunderter = 3
    Zehner = 4
    Einer = 5

    Danach kann man dann mit dem Befehl sertxd z.B. die Werte einzeln übermitteln :

    sertxd (Zehntausender , Tausender , Hunderter,Zehner , Einer , 13,10)

  • Dimmen mit einem TasterDatum26.01.2019 19:23
    Thema von BoomBoomMagic im Forum Basic's

    Ein einfacher Dimmer , der mittels nur einem Taster eine LED hell und dunkel schalten kann ,
    ist recht einfach zu realisieren.

    Wir nutzen dazu den Befehl : PWMOUT zum Aktivieren und PWMDUTY zum Einstellen .
    Da wir PWMOUT nutzen ist bei der jeweilgen Picaxe im Manual nachzusehen , welcher Pin dafür geeigent ist.


    Zunächst der Schaltplan :


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
     

    let dirsc=%0000101
     
    pwmout c.2,150,w0
    b2=1
     
    main:
    if pinc.1=1 then
    b2=b2 xor 1
    on b2 goto AN,AUS
    endif
    goto main
    end
     

    AN:
    do while w0<1023
    inc w0
    pwmduty c.2,w0
    loop until pinc.1=0
    goto main
     

    AUS:
    do while w0>0
    dec w0
    pwmduty c.2,w0
    loop until pinc.1=0
    goto main
     
     

    |addpics|nqa-9-b5dc.jpg|/addpics|

  • Leuchtturm - EffektDatum26.01.2019 19:21
    Thema von BoomBoomMagic im Forum Basic's

    Hier mal ein kleiner Spaß , wie man eine LED mit einem Leuchtturm-Effekt aufleuchten lassen kann.



    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
     

    let dirsc=%0000101
     
    pwmout c.2,150,w0
     
    main:
     
    for w0=1 to 40
    pwmduty c.2,w0
    pause 12
    next w0
     
    pause 150
    pwmduty c.2,1000
    pause 100
     
    for w0=50 to 0 step -1
    pwmduty c.2,w0
    pause 15
    next w0
    pause 1200
     
    goto main
    end
     
     

    |addpics|nqa-8-81e9.jpg|/addpics|

  • GrundschaltungDatum26.01.2019 19:19
    Thema von BoomBoomMagic im Forum Basic's

    Die Grundschaltung aller Picaxe für die serielle Komunikation ist im Grunde immer die Gleiche.
    Sie besteht lediglich aus 3 Widerständen.

    siehe hierzu auch unten : Picaxe - Beispiele


    |addpics|nqa-7-d8ec.jpg|/addpics|

  • Shift Register an der PicaxeDatum26.01.2019 19:16
    Thema von BoomBoomMagic im Forum Basic's

    Ein Shift Register an einer Picaxe kann viele Vorteile bringen.
    Mit nur 3 Pins ist es möglich 8 Ausgänge schalten zu können.

    Das macht es besonders bei kleineren Picaxe interessant , die von Haus aus wenig Pins zu bieten haben.

    Es gibt viele Typen an Shift Registern , jedoch empfehle ich das CD4094.
    1. es hat eine breite Spanne an möglicher Versorgungsspannung
    2. es bietet ein STROBE
    3. es hat eine Latch-Funktion


    Strobe :

    Der
    Vorteil bei einer STROBE-Funktion ist es, das man "in Ruhe" die
    einzelnen Bits an Shift Register senden kann , ohne das diese gleich
    ausgeführt werden .
    Erst nachdem die STROBE-Leitung einen Impuls
    erhalten hat, werden die aktuellen Bitzustände übernommen und sind an
    den Ausgängen sichtbar - quasi eine Quittierung.

    Latch:

    Die
    Latch-Funktion hat den Vorteil , das der letzte Zustand gehalten wird,
    egal was derzeitig an die aktuellen Bits gesendet wurde.
    Erst nach dem Strobe wird der neue Zustand angezeigt und weiter gehalten.
    Damit ist es also nicht nötig ständig den Zustand senden zu müssen , sondern nur bei einer Änderung.


    Zunächst hier einmal der Schaltplan :


    Auf Lochraster könnte es z.B. so aussehen :



    Jetzt kann man das Shift Register ja zu vielen Zwecken benutzen.
    Also Beispiel habe ich hier einmal ein paar Arten von Lauflichtern programiert.

    Beispiel 1 :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
     

    ' ############################################
    ' # Lauflicht => 1 LED von Links nach Rechts #
    ' ############################################
     

    symbol Clock = c.0
    symbol Data_ = pinc.1
    symbol Strobe = c.2
     

    let dirsc=%00000111
    b0=1
     

    do
     
    gosub Senden
    pause 100
     
    if b0<128 then
    b0=b0*2
    else
    b0=1
    endif
     
    loop
    end
     

    Senden:
     
    Data_=bit0:pulsout Clock,1
    Data_=bit1:pulsout Clock,1
    Data_=bit2:pulsout Clock,1
    Data_=bit3:pulsout Clock,1
    Data_=bit4:pulsout Clock,1
    Data_=bit5:pulsout Clock,1
    Data_=bit6:pulsout Clock,1
    Data_=bit7:pulsout Clock,1
    pulsout Strobe,1
     
    return
     
     




    Beispiel 2 :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
     

    ' ##################################
    ' # Lauflicht => 1 LED hin und her #
    ' ##################################
     

    symbol Clock = c.0
    symbol Data_ = pinc.1
    symbol Strobe = c.2
    symbol Richtung = b1
     
    let dirsc=%00000111
    b0=1
     

    do
     
    gosub Senden
    pause 100
     
    if b0<128 and Richtung =0 then
    b0=b0*2
    else
    Richtung=1
    endif
     
    if b0>1 and Richtung=1 then
    b0=b0/2
    else
    Richtung=0
    endif
     
    loop
    end
     

    Senden:
     
    Data_=bit0:pulsout Clock,1
    Data_=bit1:pulsout Clock,1
    Data_=bit2:pulsout Clock,1
    Data_=bit3:pulsout Clock,1
    Data_=bit4:pulsout Clock,1
    Data_=bit5:pulsout Clock,1
    Data_=bit6:pulsout Clock,1
    Data_=bit7:pulsout Clock,1
    pulsout Strobe,1
     
    return
     
     




    Beispiel 3

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
     

    ' ##################################
    ' # Lauflicht => 2 LED hin und her #
    ' ##################################
     

    symbol Clock = c.0
    symbol Data_ = pinc.1
    symbol Strobe = c.2
    symbol Richtung = b1
     
    let dirsc=%00000111
    b0=3
     

    do
     
    gosub Senden
    pause 100
     
    if b0<128 and Richtung =0 then
    b0=b0*2
    else
    Richtung=1
    endif
     
    if b0>0 and Richtung=1 then
    b0=b0/2
    endif
     
    if b0=0 and Richtung=1 then
    Richtung=0
    b0=3
    endif
     
    loop
    end
     

    Senden:
     
    Data_=bit0:pulsout Clock,1
    Data_=bit1:pulsout Clock,1
    Data_=bit2:pulsout Clock,1
    Data_=bit3:pulsout Clock,1
    Data_=bit4:pulsout Clock,1
    Data_=bit5:pulsout Clock,1
    Data_=bit6:pulsout Clock,1
    Data_=bit7:pulsout Clock,1
    pulsout Strobe,1
     
    return
     
     




    Das wichtigste ist eigentlich , das man sich eine Routine fertig macht ,
    die das Senden übernimmt , in der die einzelnen Bits des Bytes rückwärts
    an das Shift Register gesendet werden.
    Alles andere ist dann nur noch "Spielerei" und simple Programierung.

    Bei etwas komplexeren Mustern , empfiehlt es sich den Befehl : Lookup zu nutzen

    Beispiel:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
     

    ' ###################################
    ' # Lauflicht => 2 LED kreuzen sich #
    ' ###################################
     

    symbol Clock = c.0
    symbol Data_ = pinc.1
    symbol Strobe = c.2
     
    let dirsc=%00000111
     
    do
     
    for b1=0 to 43
    lookup b1,(0,0,128,128,1,1,64,64,2,2,32,32,4,4,16,16,8,8,16,16,4,4,32,32,2,2,64,64,1,1,128,128,0,0),b0
    gosub Senden
    pause 4
    next b1
     
    loop
    end
     

    Senden:
     
    Data_=bit0:pulsout Clock,1
    Data_=bit1:pulsout Clock,1
    Data_=bit2:pulsout Clock,1
    Data_=bit3:pulsout Clock,1
    Data_=bit4:pulsout Clock,1
    Data_=bit5:pulsout Clock,1
    Data_=bit6:pulsout Clock,1
    Data_=bit7:pulsout Clock,1
    pulsout Strobe,1
     
    return
     

     




    Wichtig wäre noch zu erwähnen :

    Der Befehl : GOSUB ist zwar ein netter Befehl , macht das System allerdings sehr sehr langsam !!
    Wenn man also Muster hat , die so schnell als möglich ablaufen sollen , empfiehlt es sich immer GOTO einzusetzen !

    Im Vergleich zum vorherigen Code hier das Beispiel mit GOTO :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
     

    ' ###################################
    ' # Lauflicht => 2 LED kreuzen sich #
    ' ###################################
     

    symbol Clock = c.0
    symbol Data_ = pinc.1
    symbol Strobe = c.2
     
    let dirsc=%00000111
     
    do
     
    for b1=0 to 43
    lookup b1,(0,0,128,128,1,1,64,64,2,2,32,32,4,4,16,16,8,8,16,16,4,4,32,32,2,2,64,64,1,1,128,128,0,0),b0
    goto Senden
    weiter:
    pause 4
    next b1
     
    loop
    end
     

    Senden:
     
    Data_=bit0:pulsout Clock,1
    Data_=bit1:pulsout Clock,1
    Data_=bit2:pulsout Clock,1
    Data_=bit3:pulsout Clock,1
    Data_=bit4:pulsout Clock,1
    Data_=bit5:pulsout Clock,1
    Data_=bit6:pulsout Clock,1
    Data_=bit7:pulsout Clock,1
    pulsout Strobe,1
     
    goto weiter
     
     



    In diesem kleinen Beispiel ist die Steigerung mit GOTO relativ gering , jedoch schon erkennbar.
    Bei längeren Mustern oder komplexeren Aufgaben würde sich das wesentlich deutlicher zeigen.

    Gosub ist programmiertechnisch eleganter , jedoch kann Eleganz niemals = Schnelligkeit heißen - ein Widerspruch ins sich selbst !
    Also aufpassen was so in anderen Foren evtl. für Blödsinn verzapft wird.
    Anstelle von lookup könnte man auch Read und Write nehmen , aber auch diese Eleganz geht auf Kosten des Tempos.
    Die Funktion(en) table / tablecopy sind das tötlichste an Tempo schlechthin.
    Erst in die Variablen kopieren , dann erst zum Senden schicken ist mind. 1 Schritt unnötig zu viel und kostet Zeit.

    Meist gilt hier eh , doing by learning ..... selber testen und entscheiden |addpics|nqa-5-b541.jpg,nqa-6-76f4.jpg|/addpics|

  • Servo per ADC steuernDatum26.01.2019 19:09
    Thema von BoomBoomMagic im Forum Basic's

    Der ein oder andere möchte vielleicht gern einmal einen Servo mittels Poti und einer ADC-Messung steuern.

    Grundsätzlich ist das kein Problem.
    Allerdings , sind die Wertebereiche beider etwas unterschiedlich !

    Ein Servo kann i.d.R von 75 bis 225 und eine ADC-Messung von 0 bis 1023.

    Würde man jetzt 1:1 die ADC-Werte übernehmen , müßte jetzt auch jeder Laie erkennen ,
    das das so nicht gehen kann und unter Umständen sogar den Servo bzw. dessen Elektronik zerstören kann :!: :o


    Also benötigt man eine Umrechung von 1023 möglichen ADC-Werten auf 150 mögliche Servopositionen.
    Dazu reicht es wenn man sich einen Faktor errechnet mit :

    1023 (mögliche ADC-Werte) : 150 (mögliche Servopositionen [75-225] ) = 6,8


    Dazu hier ein kleiner Beispielcode mit einer 08M2 :


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
     

    #rem
     
    Pinbelegung
    ----
    V+ -| |- GND
    Serin -| |- c.0/Serout
    Servo/c.4 -| |- c.1/ADC
    c.3 -| |- c.2
    ----
     
    #endrem
     
    #picaxe 08m2
     
    let dirsc=%00010001
     
    symbol ADC_Wert = w0
    symbol ADC_Messung = w1
    symbol Servo_Position = b4
    symbol Servo_min = 75
     

    Servo_Position=150 ' Mittelstellung
    servo c.4,Servo_Position
     

    Do
     
    readadc10 c.1,ADC_Messung ' Spannung am Poti messen
    if ADC_Messung<>ADC_Wert then ' hat sich Spannung geändert ...?
    ADC_Wert=ADC_Messung ' neue Spannung merken

    ADC_Messung=ADC_Messung *10 ' umrechnen auf
    ADC_Messung=ADC_Messung /68 ' möglichen Servostellbereich

    Servo_Position=Servo_min+ADC_Messung ' neue Position erechnen
    servopos c.1,Servo_Position ' Servo neu Positionieren
    endif
     
    loop
    end
     

     




    Das gleiche kann man auch per LDR-Messung machen :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
     

    #rem
     

    5V+ -----------------------------
    |
    | |
    ---- | | LDR
    V+ -| |- GND | |
    Serin -| |- c.0/Serout |
    Servo/c.4 -| |- c.1/ ---------
    c.3 -| |- c.2 |
    ---- -
    | |
    20K | |
    | |
    -
    |
    |
    GND -----------------------------
     
    #endrem
     
    #picaxe 08m2
     
    let dirsc=%00010001
     
    symbol LDR_Wert = w0
    symbol LDR_Messung = w1
    symbol Servo_Position = b4
    symbol Servo_min = 75
     

    Servo_Position=150 ' Mittelstellung
    servo c.4,Servo_Position
     
    Do
     
    readadc10 c.1,LDR_Messung ' Spannung am LDR messen
    if LDR_Messung<>LDR_Wert then ' hat sich Spannung geändert ...?
    LDR_Wert=LDR_Messung ' neue Spannung merken

    LDR_Messung=LDR_Messung *10 ' umrechnen auf
    LDR_Messung=LDR_Messung /68 ' möglichen Servostellbereich

    Servo_Position=Servo_min+LDR_Messung ' neue Position erechnen
    servopos c.1,Servo_Position ' Servo neu Positionieren
    endif
     
    loop
    end
     

     

  • Schwellwert /Hysterese programmierenDatum26.01.2019 19:07
    Thema von BoomBoomMagic im Forum Basic's

    Viele haben schon mal vor dem Problem gestanden , eine Hysterese bzw. einen Schwellwert auslesen zu müssen.

    Das ist im Grunde nicht schwer und viele programmieren dies auf einfachste Weise wie z.B. :

    Schleife :
    If Wert_xyz >= Schwellwert then .....

    If Wert_xyz < Schwellwert then .....
    goto Schleife

    grundsätzlich und für den Menschen logisch.

    In den meisten Fällen funktioniert das auch , insbesondere wenn "nur" LED's zu schalten sind.
    In Wahrheit kann dies aber zu ungewollten Effekten führen und für das ein oder andere Baueil sogar schädlich enden.


    Wenn jetzt z.B. die Schleife durchlaufen wird, der Wert_xyz IST größer als der Schwellwert , .....
    wird eine Ausführung je nach Code gemacht, da hier jetzt das then erfolgt.
    Aber ...... wenn jetzt beim nächsten (Schleifen)-Durchgang der Wert_xyz sich nicht geändert hat und somit immer
    noch >= dem Schwellwert ist , wird wieder das then zutreffen und es wird wieder die gleiche Ausführung wie zuvor erfolgen.


    Wenn diese Ausführung z.B. das Wechseln von 2 LED Zuständen ist ( High/Low) , tut denen das nicht so "weh"
    und wenn die Picaxe schnell genug ist , bekommt das menschliche Auge das auch nicht wirklich mit.
    Ist es aber ein anderes Bauteil, was evtl. etwas empfindlich darauf reagiert , das ständig AN geschaltet wird , obwohl
    es ja schon AN ist , ..... kann das unter Umständen solch Bauteil in Mitleidenschaft ziehen.

    Darum sollte man die Hysterese etwas konkreter gestalten in dem man zwar wie gehabt fragt :

    If Wert_xyz >= Schwellwert then .....

    aber dann noch mal explizit nachfragt , ob eine zugehörige Ausführung schon erfolgt ist .
    Denn dann muß diese nicht wiederholt erfolgen.


    Beispiel :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
     

    #rem
     
    Pinbelegung
    ----
    V+ -| |- GND
    | |
    Serin -| |- c.0/Serout
    | |
    ADC/c.4 -| |- c.1 LED rot
    | |
    c.3 -| |- c.2 LED grün
    ----
     

     

    #endrem
     

    #picaxe 08m2
     
    let dirsc=%00000111
     
    symbol Schwellwert = w0
    symbol ADC_Messung = w1
    symbol rot = b4
    symbol gruen = b5
    symbol aus = 0
    symbol an = 1
     

    Schwellwert=100
     
    Do
     
    readadc10 c.4,ADC_Messung ' Spannung am Poti messen
     

    if ADC_Messung>=Schwellwert then ' wenn Spannung >= Schwellwertvorgabe ...
    if rot=aus then ' wenn rote LED noch NICHT an ...
    gosub schalte_rot ' Sprung zur Routine : schalte_rot
    endif
    endif
     
    if ADC_Messung<Schwellwert then ' wenn Spannung < Schwellwertvorgabe ...
    if gruen =aus then ' wenn grüne LED noch NICHT an ....
    gosub schalte_gruen ' Sprung zur Routine : schalte_gruen
    endif
    endif

    loop
    end
     

    schalte_rot:
    rot=an ' merken das rote LED jetzt an ist
    gruen=aus ' merken das grüne LED jetzt aus ist
    high c.1 ' rote LED anschalten
    low c.2 ' grüne LED ausschalten
    return
     

    schalte_gruen:
    gruen=an ' merken das rote LED jetzt aus ist
    rot=aus ' merken das grüne LED jetzt an ist
    low c.1 ' rote LED ausschalten
    high c.2 ' grüne LED anschalten
    return
     
     



    In diesem Codebeispiel wird erst dann ausgeführt wenn :
    a) entsprechender Schwellwert erreicht
    b) noch keine entsprechende Ausführung erfolgte

    Das verschnellert zum Einen den Code und zum Anderen schützt es das(die) Bauteil(e)
    die angeschlossen sind und geschaltet werden sollen.

  • Zufallszahl richtig berechnenDatum26.01.2019 19:04
    Thema von BoomBoomMagic im Forum Basic's

    Der ein oder andere möchte sicherlich auch mal eine Zufallszahl mit einer Picaxe berechnen.

    Jeder kennt dazu den englischen Begriff : Random

    Auch bei der Picaxe heißt dieser Befehl : Random w0

    Für diese Funktion wird bei der Picaxe eine WORD-Variable benötigt.

    Warum ?

    Das ist der Knackpunkt , ..... "Pferdefuss" ..... bei der Picaxe :(

    Die Picaxe generiert eine Zufallszahl im Bereich von 0 - 65535 !

    Möchte man jetzt jedoch nur eine Zahl in einem bestimmten Bereich , fangen jetzt viele an
    das mit IF Anweisungen zu lösen .

    IF w0 > xxxx then ...
    IF w0 > yyyyy then ...
    IF w0 > zzzzz then ...
    IF w0 > nnnn then ...

    kann man natürlich machen ... :? .... jedoch nicht der effektivste Weg und kostet einiges
    an Speicherkapzität.



    Es gibt natürlich einen "Trick" , wie man dies etwas eleganter lösen kann ;)

    Dazu bedient man sich der Funktion : MOD ( Modulo )
    MOD ist die Berechnung eines Restwertes.

    Hier mal eine Seite , auf der man online die Funktion MOD probieren kann mit Erklärung :
    http://www.mathe24.net/modulo.html?action=do


    Und hier jetzt mal ein Beispielcode für die Picaxe , wo eine Zufallszahl von 1-18 generiert werden soll :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
     

    #picaxe 08M2

     
    symbol Zufallszahl = w0 ' = b0 + b1
    symbol neue_Wunschzahl = b2 ' = w1
    symbol vorherige_Wunschzahl = b3 ' = w1
     

    do
     

    random Zufallszahl ' Zufallszahl errechnen lassen ( 0 -65535)

    neue_Wunschzahl=Zufallszahl // 18+1 ' Umrechnen / Begrenzen auf Wunschbereich ( 1-18 )


    if neue_Wunschzahl<>vorherige_Wunschzahl then ' Abfragen ob neue Zufallszahl <> alte Zufallszahl ( keine Wiederholung )

    vorherige_Wunschzahl=neue_Wunschzahl ' neue Zufallszahl merken

    sertxd (#neue_Wunschzahl,13,10) ' Zufallszahl über Tx ausgeben ( 4800 , n , 8 , 1 )

    endif ' Abfrage schliessen


    loop

     

     



    Einzig "Besonderheit" hierbei ist , das ich bei jeder neuen generierten Zufallszahl vor der Übernahme erst
    abfrage , ob diese <> als die vorherige Zufallszahl war um nicht 2 auf einander folgende gleiche Zahlen zu bekommen. :ugeek:



    Um eine Zufallszahl innerhalb eines Bereichs zu generieren muß man auch hier ein wenig tricksen ....
    .... da die Picaxe nur von 0 bis 65535 kann.

    Möchte man jetzt z.B. eine Zufallszahl von 5 bis 10 , müßte man eine Zahl mittels MOD von 1-6 generieren lassen.
    Diesen Wert dann mit 4 addieren , so das man einen Wertebereich von 5-10 erhält.

    Beispiel :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
     

    #picaxe 08M2

     
    symbol Zufallszahl = w0 ' = b0 + b1
    symbol neue_Wunschzahl = b2 ' = w1
    symbol vorherige_Wunschzahl = b3 ' = w1
     

    do
     

    random Zufallszahl ' Zufallszahl errechnen lassen ( 0 -65535)

    neue_Wunschzahl=Zufallszahl // 6+1 ' Umrechnen / Begrenzen auf Wunschbereich ( 1-6 )


    if neue_Wunschzahl<>vorherige_Wunschzahl then ' Abfragen ob neue Zufallszahl <> alte Zufallszahl ( keine Wiederholung )

    vorherige_Wunschzahl=neue_Wunschzahl ' neue Zufallszahl merken

    neue_Wunschzahl=neue_Wunschzahl+4 ' Zufallszahl mit Startwert addieren ( 4 + xxx => Bereich: 5 - 10 )

    sertxd (#neue_Wunschzahl,13,10) ' Zufallszahl über Tx ausgeben ( 4800 , n , 8 , 1 )

    endif ' Abfrage schliessen


    loop
     
     

  • elektronischer WürfelDatum26.01.2019 18:57
    Thema von BoomBoomMagic im Forum Basic's

    Ein Klassiker aus meinen Anfängen mit der Picaxe - passend zum Thema : Zufallszahl





    Das Prinzip ist sehr einfach , es werden 4 Ausgänge genutzt.
    Drei dieser Ausgänge sind jeweils mit 2 LED bestückt für die Zahlen : 2 - 4 - 6
    Um die zahlen 1 - 3 - 5 darstellen zu können , wird an einem weiteren Ausgang nur eine LED gesetzt.
    Damit sind alle Zahlen von 1 - 6 darstellbar.




    Als Quellcode habe ich einmal 3 verschiedene Variationen entwickelt :

    1. die simpelste Methode per Zufall eine Zahl zwischen 1 und 6 zu ermitteln
    und dann entsprechende Ausgänge schalten:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
     

    #picaxe 08M2
     
    let dirsc=%00010111
     

    main:
     
    if pinc.3=1 then
    pause 200
    do
    loop until pinc.3=0
    gosub Auswertung
    endif
     
    goto main
     

    Auswertung:
    let pinsc=0

    RANDOM w0
    w1 = w0 // 6 + 1

    if w1=1 then
    high 0
    endif

    if w1=2 then
    high 4
    endif

    if w1=3 then
    high 0,4
    endif

    if w1=4 then
    high 1,2
    endif

    if w1=5 then
    high 0,1,2
    endif

    if w1=6 then
    high 1,2,4
    endif

    return
     

     



    2. den Würfel würfeln lassen , sprich: zwischen 1x und 10x per Zufall erst würfel und dann anzeigen :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
     

    #picaxe 08m2
     
    let dirsc=%00010111
     
    main:
     
    if pinc.3=1 then
    ' kurz warten ob Tastendruck auch gültig war . . . .
    pause 200
     
    if pinc.3=1 then' Tastendruck war gültig !
    ' Zufallszahl zwischen 1 und 10 berechnen
    random w2
    w3=w2 // 10+1
     
    ' an Hand der Zufallszahl eine Schleife
    for b8=1 to w3
    'Zufallszahl zwischen 1 und 6 berechnen
    gosub Berechnen

    'Zufallszahl anzeigen
    gosub Auswertung
    pause 250

    next b8
    endif
    do
    loop until pinc.3=0
     
    endif
     
    goto main
     

    Berechnen:
    RANDOM w0
    w1 = w0 // 6 + 1
    return
     

    Auswertung:
    let pinsc=0
    select case w1
    case=1
    high 0
     
    case=2
    high 4

    case=3
    high 0,4

    case=4
    high 1,2

    case=5
    high 0,1,2

    case=6
    high 1,2,4
    end select
     
    return
     
     





    3. den würfeln Effekt verstärken und den Würfel ausrollen lassen ,
    mit blinkendem Endergebnis :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
     

    #picaxe 08m2
     
    let dirsc=%00010111
     
    main:
     
    if pinc.3=1 then
    ' kurz warten ob Tastendruck auch gültig war . . . .
    pause 200
     
    if pinc.3=1 then' Tastendruck war gültig !

    ' Zufallszahl zwischen 1 und 10 berechnen
    random w2
    w3=w2 // 10+1
    w3=w3*6
    w6=300/w3
     
    ' an Hand der Zufallszahl eine Schleife
    for b8=1 to w3
    'Zufallszahl zwischen 1 und 6 berechnen
    gosub Berechnen

    'Zufallszahl anzeigen
    gosub Auswertung
    w5=w6*b8
    pause w5

    next b8
    endif
    do
    loop until pinc.3=0
    endif
     
    goto main
     

    Berechnen:
    RANDOM w0
    w1 = w0 // 6 + 1
    return
     

    Auswertung:
    let pinsc=0
    select case w1
    case=1
    for b9=1 to 3
    high 0
    pause 100
    let pinsc=0
    pause 200
    next b9
    high 0
     
    case=2
    for b9=1 to 3
    high 4
    pause 100
    let pinsc=0
    pause 200
    next b9
    high 4

    case=3
    for b9=1 to 3
    high 0,4
    pause 100
    let pinsc=0
    pause 200
    next b9
    high 0,4

    case=4
    for b9=1 to 3
    high 1,2
    pause 100
    let pinsc=0
    pause 200
    next b9
    high 1,2

    case=5
    for b9=1 to 3
    high 0,1,2
    pause 100
    let pinsc=0
    pause 200
    next b9
    high 0,1,2

    case=6
    for b9=1 to 3
    high 1,2,4
    pause 100
    let pinsc=0
    pause 200
    next b9
    high 1,2,4

    end select
     
    return
     

     

    |addpics|nqa-3-6758.gif,nqa-4-5bbd.jpg|/addpics|

  • Thema von BoomBoomMagic im Forum Basic's

    Hier ein mal eine etwas extremere Anwendung mit der Funktion: Zufallsberechnung

    Ein Adventskranz mit 4 LED's die per Zufall unterschiedlich flackern.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
     

    #rem
     
    ---
    V+ -| |- GND
    C.5 -| |- B.0
    C.4 -| |- B.1
    C.3 -| |- B.2 / LED1
    LED4 / C.2 -| |- B.3
    C.1 -| |- B.4 / LED2
    LED3 / C.0 -| |- B.5
    ---
     

     
    #endrem
     
    #picaxe 14m2
     

     
    let dirsb=%11111111
    let dirsc=%00000111
     

    symbol PWM1_Duty = w0 ' b0+b1
    symbol PWM2_Duty = w1 ' b2+b3
    symbol PWM3_Duty = w2 ' b4+b5
    symbol PWM4_Duty = w3 ' b6+b7
     
    symbol PWM1_Duty_merken = w4 ' b8+b9
    symbol PWM2_Duty_merken = w5 ' b10+b11
    symbol PWM3_Duty_merken = w6 ' b12+b13
    symbol PWM4_Duty_merken = w7 ' b14+b15
     
    symbol Zaehler1 = b16
    symbol Zaehler2 = b17
    symbol Zaehler3 = b18
    symbol Zaehler4 = b19
     

    symbol Grundwert1 = 10
    symbol Grundwert2 = 30
    symbol Grundwert3 = 65
    symbol Grundwert4 = 80
     

     

     
    start:
     
    random PWM1_Duty
    if PWM1_Duty<>PWM1_Duty_merken then
    PWM1_Duty_merken=PWM1_Duty
    PWM1_Duty = PWM1_Duty // 240+1
    PWM1_Duty = PWM1_Duty + Grundwert1
    pwmout b.2,100,PWM1_Duty


    for Zaehler1= PWM1_Duty to Grundwert1 step -1
    pwmduty b.2,PWM1_Duty
    next Zaehler1

    for Zaehler1= Grundwert1 to PWM1_Duty
    pwmduty b.2,PWM1_Duty
    next Zaehler1
    else
    goto start
    endif

    goto start


    '------------------------------------------
     
    start1:
     
    random PWM2_Duty
    if PWM2_Duty<>PWM2_Duty_merken then
    if PWM2_Duty<> PWM1_Duty_merken then
    if PWM2_Duty<> PWM3_Duty_merken then
    if PWM2_Duty<> PWM4_Duty_merken then

    PWM2_Duty_merken=PWM2_Duty
    PWM2_Duty = PWM2_Duty // 200+1
    PWM2_Duty = PWM2_Duty + Grundwert2
    pwmout b.4,100,PWM2_Duty


    for Zaehler2= PWM2_Duty to Grundwert2 step -1
    pwmduty b.4,PWM2_Duty
    next Zaehler2

    for Zaehler2= Grundwert2 to PWM2_Duty
    pwmduty b.4,PWM2_Duty
    next Zaehler2
    else
    goto start1
    endif
    endif
    endif
    endif

    goto start1


    '------------------------------------------
     
    start2:
     
    random PWM3_Duty
    if PWM3_Duty<>PWM3_Duty_merken then
    if PWM3_Duty<> PWM1_Duty_merken then
    if PWM3_Duty<> PWM2_Duty_merken then
    if PWM3_Duty<> PWM4_Duty_merken then

    PWM3_Duty_merken=PWM3_Duty
    PWM3_Duty = PWM3_Duty // 170+1
    PWM3_Duty = PWM3_Duty + Grundwert3
    pwmout c.0,100,PWM3_Duty


    for Zaehler3= PWM3_Duty to Grundwert3 step -1
    pwmduty c.0,PWM3_Duty
    next Zaehler3

    for Zaehler3= Grundwert3 to PWM3_Duty
    pwmduty c.0,PWM3_Duty
    next Zaehler3
    else
    goto start2
    endif
     
    endif
    endif
    endif

    goto start2


    '------------------------------------------
     
    start3:
     
    random PWM4_Duty
    if PWM4_Duty<>PWM4_Duty_merken then
    if PWM4_Duty<> PWM1_Duty_merken then
    if PWM4_Duty<> PWM2_Duty_merken then
    if PWM4_Duty<> PWM3_Duty_merken then

    PWM4_Duty_merken=PWM4_Duty
    PWM4_Duty = PWM4_Duty // 150+1
    PWM4_Duty = PWM4_Duty + Grundwert4
    pwmout c.2,100,PWM4_Duty


    for Zaehler4= PWM4_Duty to Grundwert4 step -1
    pwmduty c.2,PWM4_Duty
    next Zaehler4

    for Zaehler4= Grundwert4 to PWM4_Duty
    pwmduty c.2,PWM4_Duty
    next Zaehler4
    else
    goto start3
    endif

    endif
    endif
    endif

    goto start3
     
     



    Es werden 4 unabhängige Zufallszahlen generiert .
    Die jeweilige Zufallszahl ein jeder LED wird zum einen jeweils mit deren eigenen, vorherigen Wert verglichen,
    als auch mit den anderen 3 aktuellen LED-Werten , um zu vermeiden das 2 LED' s gleich flackern.

    Das ganze läuft im Multitasking-Modus und mit der PWM-Funktion.

  • 8-Kanal KnightRider-EffektDatum26.01.2019 18:44
    Thema von BoomBoomMagic im Forum Basic's

    Angeregt durch das User Projekt von Naubadi

    http://www.zierath-software.de/phpBB3/vi...?f=8&p=956#p956

    möchte ich hier einmal ein paar alternative Vorschläge aufzeigen.

    Es gibt sicherlich dutzende an Beispielen wie man solch Effekt programmieren kann.

    Hier nur mal 4 einfache Beispiele als Vorschlag :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
     

    #picaxe20m2
     
    let dirsb=255
    let dirsc=0
     
    symbol LED = b0
    LED=0
     
    Lauflicht:
     
    do while led !=8
    switch on LED
    pause 100
    switch off LED
    inc LED
    loop
     
    LED=6
    do while LED >0
    switch on LED
    pause 100
    switch off LED
    dec LED
    loop
     

    goto Lauflicht
     
     




    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
     

     
    #picaxe20M2
     
    let dirsb=%11111111
    let dirsc=%00000000
     

    b0=1
    let pinsb=b0
    pause 100
     
    do
     
    if b0<128 and b1=0 then
    b0=b0*2
    let pinsb=b0
    pause 100
    else
    b1=128
    endif

    if b0>1 and b1=128 then
    b0=b0/2
    let pinsb=b0
    pause 100
    else
    b1=0
    endif
     

    loop
    end
     
     




    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
     

    #picaxe20M2
     
    let dirsb=%11111111
    let dirsc=%00000000
     

    b0=1
    let pinsb=b0
    pause 100
     
    do
     
    do
    b0=b0*2
    let pinsb=b0
    pause 100
    loop until b0=128

    do
    b0=b0/2
    let pinsb=b0
    pause 100
    loop until b0=1
     
    loop
    end
     
     




    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
     

    #picaxe 20M2
     
    let dirsb=%11111111
    let dirsc=%00000000
     
    write 0,1,2,4,8,16,32,64,128,64,32,16,8,4,2
     
    do
    for b0=0 to 13
    read b0,b1
    let pinsb=b1
    pause 100
    next b0
    loop
    end
     
     

  • Werners Kettenmobil mit einem 14MDatum25.01.2019 19:25
    Thema von BoomBoomMagic im Forum Projekte von User für...

    von Naubaddi » Fr 21. Apr 2017, 23:00
    Hi,

    es ist so weit, das Kettenmobil von Werner Brösel funktioniert :mrgreen: ! Wie so oft bei meinen Basteleien wurde verbaut was so im Keller Rum liegt ;) , ein Bagger mit Kabellenkung, ein V8 von einer 65 Corvette Sting Ray, ein L298N, ein PICAXE 14M, ein Kabelrohr...

    Die meisten Herausforderungen (früher waren es Probleme, schöne moderne Welt :roll: ) war der 14M, nicht sehr komfortabel zu programmieren (meine Meinung) weil es hat Stunden gedauert bis mir klar war wie die Eingänge abgefragt werden :( . Danach ging es recht zügig voran, ist ja nix Weltbewegendes 2 Motoren mit einem PICAXE und einem L298N anzusteuern :D .

    Das Ergebnis ist schon recht brauchbar und kann noch verbessert/angepasst werden, auf dem Video sieht man die erste Fahrt von Werners Kettenmobil. Ein wenig zackig weil es für meine Frau das erste mal war mit einem RC-Fahrzeug, nun möchte Sie eine Drohne/Quadrocopter haben :o .

    Es macht mir halt viel Spaß aus Resten noch etwas zu erstellen, kaufen kann Jeder :mrgreen: .

    Das Programm:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
     

    ; picaxe14m ; automatische Compilerauswahl für gedit
    ; Dateiname: Kettenantrieb 2xGas P14M.axe
    ; Funktion: Das Signal von einem RC-Empfänger auswerten und 2 Motoren für einen Kettenantrieb steuern
    ; Datum: Start 14.04.2017, Stand 21.04.2017
    ; Von: Hermann Friedhoff foto-schubser@arcor.de
    ;
    ; PICAXE 14M Alle Pin Funktionen (w0=b0+b1, w1=b2+b3, ...)
    ;
    ; +---v---+
    ; +V |1 14| 0V
    ; Serial In |2 13| B.0 OUT/Serial Out/INFRAOUT
    ; ADC 4 In 4 |3 12| B.1 Out
    ; INFRAIN In 3 |4 11| B.2 Out
    ; In 2 |5 10| B.3 Out
    ; In 1 |6 9| B.4 Out
    ; In 0 |7 8| B.5 Out
    ; +-------+
    ;
    ; die ca. Werte vom Empfänger-Signal sind: 75, Mitte = 150, 225
    ;
    symbol Motor_rechts_v = B.1 ; Ausgang für den Motor rechts vorwärts
    symbol Motor_rechts_r = B.2 ; Ausgang für den Motor rechts rückwärts
    symbol Motor_links_v = B.3 ; Ausgang für den Motor links vorwärts
    symbol Motor_links_r = B.4 ; Ausgang für den Motor links rückwärts
    ;
    symbol rechts_0 = b0 ; RC-Signal Steuerhebel rechts Mittelstelung
    symbol rechts = b1 ; RC-Signal Steuerhebel rechts Ist-Position
    symbol links_0 = b2 ; RC-Signal Steuerhebel links Mittelstelung
    symbol links = b3 ; RC-Signal Steuerhebel links Ist-Position
    symbol Toleranz = b4 ; eine kleine Toleranz für die Mittelstellung (Leerlauf)
    symbol dumm_v = b11 ; vorwärts mit Toleranz
    symbol dumm_r = b12 ; rückwärts mit Toleranz
    ;
    symbol dumm = b13 ; eine Variable für alles Mögliche
    ;
    Toleranz = 10 ; die Toleranz für die Mittelstellung (Leerlauf)
    pulsin 0, 1, rechts_0 ; die Mittelstellung vom rechten Steuerhebel übernehmen
    pulsin 1, 1, links_0 ; die Mittelstellung vom linken Steuerhebel übernehmen
    let pins = %00000000 ; alle Ausgänge auf 0 (low) setzen
    ;
    Kettenantrieb_steuern: ; Hauptschleife Kettenantrieb steuern
    pulsin 0, 1, rechts ; RC-Signal vom Steuerhebel rechts abfragen und auswerten
    dumm_v = rechts + Toleranz ; Leerlaufbereich für vorwärts
    dumm_r = rechts - Toleranz ; Leerlaufbereich für rückwärts
    if dumm_v < rechts_0 then ; wenn der Leerlaufbereich nach oben verlassen wurde
    high Motor_rechts_v ; Motor rechts, vorwärts ein
    low Motor_rechts_r ; Motor rechts, vorwärts aus
    endif
    if dumm_r > rechts_0 then ; wenn der Leerlaufbereich nach unten verlassen wurde
    high Motor_rechts_r ; Motor rechts, rückwärts ein
    low Motor_rechts_v ; Motor rechts, rückwärts aus
    endif
    if dumm_v > rechts_0 and dumm_r < rechts_0 then ; wenn der Leerlaufbereich nicht verlassen wurde
    low Motor_rechts_r ; Motor rechts, vorwärts aus
    low Motor_rechts_v ; Motor rechts, rückwärts aus
    endif
     

    pulsin 1, 1, links ; RC-Signal vom Steuerhebel rechts abfragen und auswerten
    dumm_v = links + Toleranz ; Leerlaufbereich für vorwärts
    dumm_r = links - Toleranz ; Leerlaufbereich für rückwärts
    if dumm_v < links_0 then ; wenn der Leerlaufbereich nach oben verlassen wurde
    high Motor_links_v ; Motor rechts, vorwärts ein
    low Motor_links_r ; Motor rechts, vorwärts aus
    endif
    if dumm_r > links_0 then ; wenn der Leerlaufbereich nach unten verlassen wurde
    high Motor_links_r ; Motor rechts, rückwärts ein
    low Motor_links_v ; Motor rechts, rückwärts aus
    endif
    if dumm_v > links_0 and dumm_r < links_0 then ; wenn der Leerlaufbereich nicht verlassen wurde
    low Motor_links_r ; Motor rechts, vorwärts aus
    low Motor_links_v ; Motor rechts, rückwärts aus
    endif
    goto Kettenantrieb_steuern ; Ende von: Kettenantrieb_steuern
    ;
     
     




    und ein kleines Video:
    http://www.buggy-club.de/fotos/dateien/Werners-Kettenmobil.avi
    |addpics|nqa-1-96ce.jpg|/addpics|

  • LED an der PicaxeDatum24.01.2019 09:12
    Thema von BoomBoomMagic im Forum Basic's

    Es gibt 2 Möglichkeiten eine LED an einer Picaxe zu betreiben .




    Beispiel 1 :
    In diesem Fall wird der Ausgang auf High gesetzt und die LED leuchtet.
    Ist der Ausgang wieder Low , schaltet die LED ab.


    Beispiel 2 :
    In diesem Fall leuchtet die LED nicht wenn der Ausgang auf High ist !
    Erst wenn der Ausgang auf Low steht, schaltet die LED an.

Inhalte des Mitglieds BoomBoomMagic
Beiträge: 528
Ort: Bielefeld
Geschlecht: männlich
Picaxe Editor 5.5.5 Download
Update auf Picaxe Editor 5.5.6 Download
Picaxe Editor 6.x.x.x Download
Manual1.pdf        -      Grundwissen Download
Manual2.pdf        -      Befehle Download
Manual3.pdf        -      Beispiele Download


Press [Backspace] for back to Menu


Counter
Xobor Forum Software ©Xobor.de | Forum erstellen
Datenschutz