https://github.com/easeus-data-recovery-crack

main.py

diagram.json

import rp2

@rp2.asm_pio(out_init = (rp2.PIO.OUT_LOW, rp2.PIO.OUT_LOW),
             set_init = (rp2.PIO.OUT_LOW, rp2.PIO.OUT_LOW))
def fallblatt():
    wrap_target()
    pull(block)
    mov(x, osr)
    pull(block)
    
    label("Start")
    set(pins, 0b01)
    jmp(pin, "StepMotor1")

    label("StepMotor0")
    mov(y, osr)
    
    label("LoopMotor0")
    jmp(pin, "Edge01")
    jmp("ContMotor0")

    label("ContMotor0")
    jmp(y_dec, "LoopMotor0")
    mov(pins, invert(pins))
    jmp("StepMotor0")

    label("Edge01")
    jmp(x_dec, "ContMotor1")
    jmp("Stop")

    label("StepMotor1")
    mov(y, osr)
    
    label("LoopMotor1")
    jmp(pin, "ContMotor1")
    jmp("Edge10")
    
    label("ContMotor1")
    jmp(y_dec, "LoopMotor1")
    mov(pins, invert(pins))
    jmp("StepMotor1")

    label("Edge10")
    jmp(x_dec, "ContMotor0")
    
    label("Stop")
    set(pins, 0b00)
    wrap()



# state machines for PIO

MACHINE = (
    rp2.StateMachine(0),
    rp2.StateMachine(1),
    rp2.StateMachine(2),
    rp2.StateMachine(3),
    rp2.StateMachine(4),
    rp2.StateMachine(5)
)

# init and start pio machines

PIOPROG = piodrv.fallblatt
PIOFREQ = 2000
BASEPIN = (MOTOR[0][0], MOTOR[1][0], MOTOR[2][0], MOTOR[3][0], MOTOR[4][0], MOTOR[5][0])

for i, sm in enumerate(MACHINE):
    sm.init(PIOPROG, freq = PIOFREQ,
        in_base = BASEPIN[i],
        out_base = BASEPIN[i],
        set_base = BASEPIN[i],
        jmp_pin = SENSOR[i])
    sm.active(1)
    sm.put(0)   # Steps
    sm.put(400) # Speed


# eof


piodrv.py



COUNTER     0     0     0     0     1     1     1     1
notCOUNTER  1     1     1     1     0     0     0     0
MOTOR       0     1     0     1     0     1     0     1

SENSOR      1     1     1     1     0     1     0     1

-------------------------------------

DSR-Flipflop:

Clock:  L->H active
R, S: active H
R hat Vorrang

R 0 0 1 1
S 0 1 0 1
-
Q X 1 0 0

---------------------------------------

POS     0   1   1   0   1   1   1   0   0
NEG     0   0   1   1   1   0   1   1   0
Q       =0  0   =0  1   =1  0   =0  1   =1

S       0   0   0   1   0   0   0   1   0
R       0   1   0   0   0   1   0   0   0



74HC165

PL: low = load, high = shift
CP: serial clock, L->H active
CE: clock enable, active low, set to GND
DS: serial input
Q7: serial output
D0..D7: inputs



readme.txt

import time
from machine import Pin, Timer

# import rp2
# import array
# import micropython

# CONSTANTS:

SPEED_DOWN = 0
SPEED_UP = 1

CMD_IDLE = 0
CMD_ON = 1
CMD_OFF = 2
CMD_UP = 3
CMD_DOWN = 4
CMD_CALIBRATE = 5

DATA_SIZE = 100     # calibration data array


################
class DriveUnit:
################
    def __init__(self, pinPos, pinNeg):
        self._pinPos = pinPos
        self._pinNeg = pinNeg
        self._inv = False           # inverted polarity marker
        self._pwr = False           # power status marker

    def TakeStep(self):             # toggle output
        if self._pwr:               # can't take a step without power
            if self._inv:
                self._pinPos.on()
                self._inv = False
                self._pinNeg.off()
            else:
                self._pinNeg.on()
                self._inv = True
                self._pinPos.off()
    
    @property
    def Power(self):
        return self._pwr

    @Power.setter
    def Power(self, switch):
        if switch:                      # power on in current polarity
            if self._inv:
                self._pinPos.off()      # (should already be off)
                self._pinNeg.on()
            else:
                self._pinNeg.off()      # (should already be off)
                self._pinPos.on()
        else:                           # power off
            self._pinPos.off()
            self._pinNeg.off()
        self._pwr = switch



################
class Fallblatt:
################
    def __init__(self, sName, objCounterPin, objSensorPin, objMotorPins):
        # public attributes
        self.Name = sName               # Module name (can be chosen arbitrarily)
        self.Speed = [100, 200]         # list of [drive down period, drive up period] in ms

        # private attributes
        self._COUNTER = objCounterPin   # pin for switch counter sensor on/off
        self._SENSOR = objSensorPin     # pin for input from engine sensor
        self._MOTOR = objMotorPins      # tuple of motor driving pins
        self._drive = DriveUnit(self._MOTOR[0], self._MOTOR[1])     # can be exchanged/reversed here if necessary
        self._display = 255             # target value of display position
        self._position = 255            # actual value of position
        self._req = False               # request, set when new display value arrived
        self._cmd = CMD_IDLE            # engine drive command: 0 = idle, 1 = on, 2 = off, 3 = up, 4 = down
        self._run = False               # driver running
        self._calibrating = False       # calibration run
        self._data = [0] * DATA_SIZE    # time data for calibration
        self._dataindex = 0             # pointer to _data
        self._nextstep = False          # flag for freerun

        # interrupts
        self._SENSOR.irq(handler = self._SENSOR_isr, trigger = Pin.IRQ_RISING | Pin.IRQ_FALLING)
        self._TIMER = Timer(-1)         # create new timer object
        self._setspeed(SPEED_DOWN)      # 0 = down, 1 = up, initialize and start Timer
 

    def __str__(self):
        return f"{self.Name}"


    #----------------------------------
    # interrupt service
    #----------------------------------

    def _SENSOR_isr(self, pinobj):      # interrupt service routine for _SENSOR
        if self._calibrating and self._run:
            self._timestamp()
            self._nextstep = True
        elif self._COUNTER.value() == 1:  # running up to display
            self._position += 1         # count _SENSOR edges
            if self._position == self._display:  # target arrived
                self._cmd = CMD_OFF     # set motor off
        else:                           # going home to blank
            if self._SENSOR.value() == 0:   # run until _SENSOR goes low
                self._cmd = CMD_OFF     # set motor off
                self._position = 0      # synchronize counter


    def _TIMER_isr(self, timerobj):     # interrupt service routine for _TIMER
        # check the starting conditions...
        if not self._run:               # ... only if not running or calibrating yet
            if self._req or self._position != self._display:    # new request, so start the engine
                if self._display == 0 or self._position != 0:
                    self._cmd = CMD_DOWN
                else:                   # current position is 0
                    self._cmd = CMD_UP

        # drive the engine
        if self._cmd == CMD_IDLE:
            self._drive.TakeStep()      # if the engine is powered on then take a step

        elif self._cmd == CMD_ON:
            self._drive.Power = True    # switch engine on
            self._cmd = CMD_IDLE

        elif self._cmd == CMD_OFF:
            self._drive.Power = False   # switch engine off
            self._run = False
            self._cmd = CMD_IDLE

        elif self._cmd == CMD_UP:
            self._COUNTER.on()          # set driving direction and speed
            self._setspeed(SPEED_UP)
            self._run = True
            self._req = False
            if self._drive.Power:
                self._cmd = CMD_IDLE    # when the engine is already running, keep going
            else:
                self._cmd = CMD_ON      # if the engine is not yet running, start it first

        elif self._cmd == CMD_DOWN:
            self._COUNTER.off()         # set driving direction and speed
            self._setspeed(SPEED_DOWN)
            self._run = True
            self._req = False
            if self._drive.Power:
                self._cmd = CMD_IDLE    # when the engine is already running, keep going
            else:
                self._cmd = CMD_ON      # if the engine is not yet running, start it first

        else:                   # nop (illegal _cmd value ...)
            self._cmd = CMD_IDLE


    def _TIMER_calibrate_isr(self, timerobj):     # interrupt service routine for _TIMER for calibrate
        if self._calibrating and self._run:
            if self._nextstep:
                self._nextstep = False
                self._drive.TakeStep()
                # self._timestamp()     # not necessary here
            else:
                pass
                # timeoutbehandlung fehlt hier noch (falls kein nextstep kommt, Blatt hängen bleibt...)


    #----------------------------------
    # private methods
    #----------------------------------

    def _setspeed(self, index):
        self._TIMER.init(mode = Timer.PERIODIC, period = self.Speed[index], callback = self._TIMER_isr)

    def _request(self, target):
        self._display = target
        self._req = True

    def _timestamp(self):
        if self._dataindex >= DATA_SIZE:
            self._run = False
            self._drive.Power = False
            for i, value in enumerate(self._data):      # 0 .. DATA_SIZE - 1
                if i == DATA_SIZE - 1 :
                    self._data[i] = 0
                else:
                    self._data[i] = time.ticks_diff(self._data[i + 1], self._data[i])
        else:
            self._data[self._dataindex] = time.ticks_ms()
            self._dataindex += 1


    #----------------------------------
    # public methods
    #----------------------------------


    def display(self, target):      #
        self._request(target)

    def stop(self):
        self._drive.Power = False   # switch engine off
        self._run = False
        self._req = False
        self._display = self._position
        self._cmd = CMD_IDLE

    def calibrate(self):
        self.stop()
        self._TIMER.init(mode = Timer.PERIODIC, period = 1, callback = self._TIMER_calibrate_isr)
        self._dataindex = 0
        self._nextstep = False
        self._drive.Power = True
        self._run = True
        self._calibrating = True
        self._nextstep = True

    def reset(self):
        self.stop()
        self._calibrating = False
        self._position = 255
        self._request(0)
        self._setspeed(SPEED_DOWN)      # install appropriate timer interrupt


    #----------------------------------
    # public properties
    #----------------------------------

    @property
    def position(self):             # read only
        return self._position
    
    @property
    def busy(self):                 # read only
        return self._run or self._req or self.position != self._display




# end class Fallblatt:



    '''
    @property
    def speed(self):
        return self._speed
    @speed.setter
    def speed(self, tupleSpeed):
        self._speed = tupleSpeed
    '''


# eof


fallblatt.py

import time
from machine import Pin, Timer

# import rp2
# import array
# import micropython

# CONSTANTS:

# NEU:
SPEED_SLOW = 0
SPEED_FAST = 1
DEFAULT_PERIODS = [200, 100]


# ALT:
SPEED_DOWN = 0
SPEED_UP = 1

CMD_IDLE = 0
CMD_ON = 1
CMD_OFF = 2
CMD_UP = 3
CMD_DOWN = 4
CMD_CALIBRATE = 5

DATA_SIZE = 100     # calibration data array


################
class DriveUnit:
################
    def __init__(self, pinPos, pinNeg):
        # private attributes
        self._pinPos = pinPos
        self._pinNeg = pinNeg
        self._bInv = False                  # inverted polarity marker
        self._bPwr = False                  # power status marker
        self._bRun = False                  # run status marker

    
    #----------------------------------
    # public properties
    #----------------------------------

    @property
    def running(self):
        return self._bRun or self._bPwr

    @running.setter
    def running(self, bValue):
        self._bRun = bValue


    #----------------------------------
    # public methods / commands
    #----------------------------------

    def drive(self):                        # called periodically
        if self._bRun:
            if self._bPwr:                  # take a step if power is on
                if self._bInv:
                    self._pinPos.on()
                    self._bInv = False
                    self._pinNeg.off()
                else:
                    self._pinNeg.on()
                    self._bInv = True
                    self._pinPos.off()
            else:                           # switch power on in current polarity
                if self._bInv:
                    self._pinPos.off()      # (should already be off)
                    self._pinNeg.on()
                else:
                    self._pinNeg.off()      # (should already be off)
                    self._pinPos.on()
                self._bPwr = True
        else:                               # switch power off
            self._pinPos.off()
            self._pinNeg.off()
            self._bPwr = False

    def run(self):
        self._bRun = True

    def stop(self):
        self._bRun = False




################
class Fallblatt:
################
    def __init__(self, sName, pinCounter, pinSensor, apinMotor):
        # public attributes
        self.Name = sName              # Module name (can be chosen arbitrarily)

        # private attributes
        self._pinCounter = pinCounter   # pin for switch counter sensor on/off
        self._pinCounter.on()           # always on except during home run
        self._pinSensor = pinSensor     # pin for input from engine sensor
        self._apinMotor = apinMotor     # tuple of motor driving pins
        self._oDrive = DriveUnit(self._apinMotor[0], self._apinMotor[1])     # can be exchanged/reversed here if necessary
        self._anPeriods = DEFAULT_PERIODS   # list of [low speed period, high speed period] in ms
        self._opcode = "idle"           # operation code for interrupt service routines
        self._flapsamount = -1          # total number of flaps, -1 = unknown
        self._flapno = -1               # current flap number, actual position, -1 = unknown
        self._stepcnt = 0               # counter for step mode
        self._flaptarget = -1           # target value for _flapno

        # interrupts
        self._oTimer = Timer(-1)            # create new timer object
        self._SetSpeed(SPEED_FAST)          # initialize and start Timer
        self._pinSensor.irq(handler = self._sensor_isr, trigger = Pin.IRQ_RISING | Pin.IRQ_FALLING)


    def __str__(self):
        return f"{self.Name}"


    #----------------------------------
    # interrupt service
    #----------------------------------

    def _timer_isr(self, timerObject):
        if self._opcode == "stop":
            self._oDrive.stop()
            self._opcode = "idle"

        elif self._opcode == "home":
            self._pinCounter.off()
            self._flapno = -1               # unknown flap

        else:                               # else condition (idle, run, step, goto)
            pass

        if self._opcode in ["run", "step", "goto", "home"]:
            self._oDrive.run()

        self._oDrive.drive()


    def _sensor_isr(self, pinObject):       # interrupt service routine for _pinSensor
        if self._pinCounter.value() == 0:   # driving home mode
            if self._pinSensor.value() == 0:   # running until _pinSensor goes low
                self._pinCounter.on()
                self._flapno = 0            # synchronize counter
                self._oDrive.stop()
                self._opcode = "idle"

        else:                               # counting mode
            if self._flapsamount > 0 and self._flapno >= 0:     # count flaps position if valid
                self._flapno += 1
                if self._flapno >= self._flapsamount:           # check overflow
                    self._flapno = 0

                if self._opcode == "goto" and self._flapno == self._flaptarget:
                    self._oDrive.stop()
                    self._opcode = "idle"

            if self._opcode == "step":      # drive until _stepcnt = 0
                self._stepcnt -= 1
                if self._stepcnt == 0:
                    self._oDrive.stop()
                    self._opcode = "idle"

            else:                           # else condition (idle, run, stop)
                pass



        '''


        if self._calibrating and self._run:
            self._timestamp()
            self._nextstep = True
        elif self._COUNTER.value() == 1:  # running up to display
            self._position += 1         # count _SENSOR edges
            if self._position == self._display:  # target arrived
                self._cmd = CMD_OFF     # set motor off
        '''


    #----------------------------------
    # private methods
    #----------------------------------

    def _SetSpeed(self, index):
        self._oTimer.init(mode = Timer.PERIODIC, period = self._anPeriods[index], callback = self._timer_isr)


    #----------------------------------
    # public properties
    #----------------------------------

    @property
    def running(self):
        return self._oDrive.running

    @property
    def busy(self):
        return self._opcode <> "idle" or self._oDrive.running


    @property
    def PeriodSlow(self):
        return self._anPeriods[SPEED_SLOW]

    @PeriodSlow.setter
    def PeriodSlow(self, nValue):
        if nValue > 10:
            self._anPeriods[SPEED_SLOW] = nValue
        else:
            self._anPeriods[SPEED_SLOW] = DEFAULT_PERIODS[SPEED_SLOW]

    @property
    def PeriodFast(self):
        return self._anPeriods[SPEED_FAST]

    @PeriodFast.setter
    def PeriodFast(self, nValue):
        if nValue > 10:
            self._anPeriods[SPEED_FAST] = nValue
        else:
            self._anPeriods[SPEED_FAST] = DEFAULT_PERIODS[SPEED_FAST]



    #----------------------------------
    # public methods
    #----------------------------------

    def slow(self):                     # select slow speed
        self._SetSpeed(SPEED_SLOW)

    def fast(self):                     # select fast speed
        self._SetSpeed(SPEED_FAST)

    def run(self):                      # run continuously until stop()
        self._opcode = "run"

    def stop(self):                     # stop immediate
        self._opcode = "stop"

    def home(self):                     # drive to reference position (flap 0)
        self._opcode = "home"

    def step(self, nSteps):
        if nSteps > 0:
            self._stepcnt = nSteps
            self._opcode = "step"

    def goto(self, nTarget):
        if self._flapsamount > 0 and nTarget > 0 and nTarget < self._flapsamount:
            self._flaptarget = nTarget
            self._opcode = "goto"




'''
################
class Fallblatt:
################
    def __init__(self, sName, objCounterPin, objSensorPin, objMotorPins):
        # public attributes
        self.Name = sName               # Module name (can be chosen arbitrarily)
        # self.Speed = [100, 200]         # list of [drive down period, drive up period] in ms

        # private attributes
        self._COUNTER = objCounterPin   # pin for switch counter sensor on/off
        self._SENSOR = objSensorPin     # pin for input from engine sensor
        self._MOTOR = objMotorPins      # tuple of motor driving pins
        self._drive = DriveUnit(self._MOTOR[0], self._MOTOR[1])     # can be exchanged/reversed here if necessary

        self._display = 255             # target value of display position
        self._position = 255            # actual value of position
        self._req = False               # request, set when new display value arrived
        self._cmd = CMD_IDLE            # engine drive command: 0 = idle, 1 = on, 2 = off, 3 = up, 4 = down
        self._run = False               # driver running
        self._calibrating = False       # calibration run
        self._data = [0] * DATA_SIZE    # time data for calibration
        self._dataindex = 0             # pointer to _data
        self._nextstep = False          # flag for freerun

        # interrupts
        self._SENSOR.irq(handler = self._SENSOR_isr, trigger = Pin.IRQ_RISING | Pin.IRQ_FALLING)
        # self._TIMER = Timer(-1)         # create new timer object
        # self._setspeed(SPEED_DOWN)      # 0 = down, 1 = up, initialize and start Timer
 

    def __str__(self):
        return f"{self.Name}"


    #----------------------------------
    # interrupt service
    #----------------------------------

    def _SENSOR_isr(self, pinobj):      # interrupt service routine for _SENSOR
        if self._calibrating and self._run:
            self._timestamp()
            self._nextstep = True
        elif self._COUNTER.value() == 1:  # running up to display
            self._position += 1         # count _SENSOR edges
            if self._position == self._display:  # target arrived
                self._cmd = CMD_OFF     # set motor off
        else:                           # going home to blank
            if self._SENSOR.value() == 0:   # run until _SENSOR goes low
                self._cmd = CMD_OFF     # set motor off
                self._position = 0      # synchronize counter



    def _TIMER_isr(self, timerobj):     # interrupt service routine for _TIMER
        # check the starting conditions...
        if not self._run:               # ... only if not running or calibrating yet
            if self._req or self._position != self._display:    # new request, so start the engine
                if self._display == 0 or self._position != 0:
                    self._cmd = CMD_DOWN
                else:                   # current position is 0
                    self._cmd = CMD_UP

        # drive the engine
        if self._cmd == CMD_IDLE:
            self._drive.TakeStep()      # if the engine is powered on then take a step

        elif self._cmd == CMD_ON:
            self._drive.Power = True    # switch engine on
            self._cmd = CMD_IDLE

        elif self._cmd == CMD_OFF:
            self._drive.Power = False   # switch engine off
            self._run = False
            self._cmd = CMD_IDLE

        elif self._cmd == CMD_UP:
            self._COUNTER.on()          # set driving direction and speed
            self._setspeed(SPEED_UP)
            self._run = True
            self._req = False
            if self._drive.Power:
                self._cmd = CMD_IDLE    # when the engine is already running, keep going
            else:
                self._cmd = CMD_ON      # if the engine is not yet running, start it first

        elif self._cmd == CMD_DOWN:
            self._COUNTER.off()         # set driving direction and speed
            self._setspeed(SPEED_DOWN)
            self._run = True
            self._req = False
            if self._drive.Power:
                self._cmd = CMD_IDLE    # when the engine is already running, keep going
            else:
                self._cmd = CMD_ON      # if the engine is not yet running, start it first

        else:                   # nop (illegal _cmd value ...)
            self._cmd = CMD_IDLE



    def _TIMER_calibrate_isr(self, timerobj):     # interrupt service routine for _TIMER for calibrate
        if self._calibrating and self._run:
            if self._nextstep:
                self._nextstep = False
                self._drive.TakeStep()
                # self._timestamp()     # not necessary here
            else:
                pass
                # timeoutbehandlung fehlt hier noch (falls kein nextstep kommt, Blatt hängen bleibt...)


    #----------------------------------
    # private methods
    #----------------------------------

    def _setspeed(self, index):
        self._TIMER.init(mode = Timer.PERIODIC, period = self.Speed[index], callback = self._TIMER_isr)

    def _request(self, target):
        self._display = target
        self._req = True

    def _timestamp(self):
        if self._dataindex >= DATA_SIZE:
            self._run = False
            self._drive.Power = False
            for i, value in enumerate(self._data):      # 0 .. DATA_SIZE - 1
                if i == DATA_SIZE - 1 :
                    self._data[i] = 0
                else:
                    self._data[i] = time.ticks_diff(self._data[i + 1], self._data[i])
        else:
            self._data[self._dataindex] = time.ticks_ms()
            self._dataindex += 1


    #----------------------------------
    # public methods
    #----------------------------------


    def display(self, target):      #
        self._request(target)

    def stop(self):
        self._drive.Power = False   # switch engine off
        self._run = False
        self._req = False
        self._display = self._position
        self._cmd = CMD_IDLE

    def calibrate(self):
        self.stop()
        self._TIMER.init(mode = Timer.PERIODIC, period = 1, callback = self._TIMER_calibrate_isr)
        self._dataindex = 0
        self._nextstep = False
        self._drive.Power = True
        self._run = True
        self._calibrating = True
        self._nextstep = True

    def reset(self):
        self.stop()
        self._calibrating = False
        self._position = 255
        self._request(0)
        self._setspeed(SPEED_DOWN)      # install appropriate timer interrupt


    #----------------------------------
    # public properties
    #----------------------------------

    @property
    def position(self):             # read only
        return self._position
    
    @property
    def busy(self):                 # read only
        return self._run or self._req or self.position != self._display



'''
# end class Fallblatt



'''
    @property
    def speed(self):
        return self._speed
    @speed.setter
    def speed(self, tupleSpeed):
        self._speed = tupleSpeed
'''


# eof
