Herzlich Willkommen im einzigen (deutschsprachigem) Picaxe-Forum.

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

Foren Suche

  • 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: 480
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