多处理两个都使用time.sleep（）的函数

Question

I'm working on a project with the raspberry pi where I need to have two functions running in parallel both of which need to access the same GPIO pins (they need to turn on/off the same pumps).

The issue is that function1 needs to access these pumps every 40 minutes and use them for 5 mins at a time and function2 needs to access them every 3 hours for 5 mins at time. The way I am keeping the pumps active is by turning on the GPIO pin, using time.sleep(), then turn it off. After the functions use the pumps they will need to dispense chemicals in water and wait for these chemicals to dissolve (function1 waits 30 minutes, function2 waits 3 hours).

I am looking for the best way to run these functions in parallel while taking into account the possible scheduling/timing conflicts between them. I want function1 to be able to utilize the pumps even while function2 is waiting for its chemicals to dissolve. I am thinking to use a global variable to check whether the pump is in use to let the functions know that they need to wait to access those pumps but after some testing I am not sure this works with multiprocessing.

I've set up some test code to simulate the timing of the functions. According to my output, it seems both function1 and function2 are proceeding to dispense their chemicals at the same time. Any ideas or advice is greatly appreciated.

import time
from multiprocessing import Process

pumpInUse = False #used to store the state of the pumps

def function1():
    global pumpInUse
    if pumpInUse is False:
        print "starting function1 test @ " + str((time.strftime("%H:%M:%S")))
        pumpInUse = True #turn pump on
        time.sleep(5)  #simulating 5 minutes of pump use
        print "function1 test complete @ " + str((time.strftime("%H:%M:%S")))
        pumpInUse = False #turn pump off
        function1status = 'bad' #simulating bad chemical level

        if function1status == 'bad':
            print "dispense chemicals @ " + str((time.strftime("%H:%M:%S")))
            time.sleep(10) #simulate wait 30 minutes after chemcials dispensed
            print "checking water @ " + str((time.strftime("%H:%M:%S")))
            pumpInUse = True
            time.sleep(5) #simulating 5 minutes of pump use
            print "function1 complete @ " + str((time.strftime("%H:%M:%S")))
            pumpInUse = False

def function2():
    global pumpInUse
    if pumpInUse is False:
        print "starting function2 test @ " + str((time.strftime("%H:%M:%S")))
        pumpInUse = True
        time.sleep(5) #simulating 5 minutes of pump use
        print "function2 test complete @ " + str((time.strftime("%H:%M:%S")))
        pumpInUse = False
        function2status = 'bad' #simulating bad chemical level

        if function2status == 'bad':
            print "dispense chemicals @ " + str((time.strftime("%H:%M:%S")))
            time.sleep(30) #simulate wait 3 hours after chemicasl dispensed
            print "checking water @ " + str((time.strftime("%H:%M:%S")))
            pumpInUse = True
            time.sleep(5) #simulating 5 minutes of pump use
            print "function2  complete @ " + str((time.strftime("%H:%M:%S")))
            pumpInUse = False

if __name__ == '__main__':
    #while True:
        p1 = Process(target=function1)
        p2 = Process(target=function2)
        p1.start()
        p2.start()
        p1.join()
        p2.join()

Answer 1

You're looking thread (or process) synchronization primitives , in this case, probably a Lock . function1 would acquire a blocking lock and release it when it was done. When function2 attempted to acquire the lock, it would automatically wait until the lock was released.