def __init__(self, pin, timer, channel): ''' Initializes the infared receiver @param pin: pin is a pyb.Pin.board object for the interrupt pin that will detect interrupts from the IR reciever @param timer: timer is the timer the interrupt pin will use @param channel: channel is the channel the timer will use ''' #----------------------------------------------------------------------# # Allocate memory so that exceptions raised in interrupt service # routines can generate useful diagnostic printouts # comment this line out after testing alloc_emergency_exception_buf(100) #----------------------------------------------------------------------# # assign the pin as an input pin intPin = pyb.Pin(pin, pyb.Pin.IN) # channel is the channel the timer will use, specified by the function # parameter. Has to be brought to the Class scope because it is used in # the irISR callback function self.channel = channel # Assign the timer a 16-bit period and a prescaler of 79 to collect # accurate timestamps. Prescaler of 79 to account for 80Mhz clock speed # to output counts as microseconds tim = pyb.Timer(timer, prescaler=79, period=0xFFFF) # set up the timer object to detect rising and fallingedges tim.channel(channel, pyb.Timer.IC, polarity=pyb.Timer.BOTH, pin=intPin, callback=self.irISR) # A queue to be used as a buffer for interrupt timestamp data. Buffer # size is greater than full pulse count to account for repeat codes # that disrupt a full pulse set. self.ir_data = task_share.Queue('I', 200, thread_protect=False, overwrite=False, name="ir_data") # Data is a class scoped list that is filled with timestamps # from the ir_data queue self.data = [] self.address = task_share.Share('I', thread_protect=False, name="address") self.command = task_share.Share('I', thread_protect=False, name="address") self.command.put(0) self.address.put(0) self.task = cotask.Task(self.readInfaredSensorTask, name='Infared Reading Task', priority=5, profile=True, trace=False)
def main(): # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed motor_task = cotask.Task(task_motor, name='motor_task', priority=1, period=1, profile=True, trace=False) # front_sensor_task = cotask.Task (task_front_sensor, name = 'front_sensor_task', priority = 2, # period = 25, profile = True, trace = False) #back_sensor_task = cotask.Task (task_back_sensor, name = 'back_sensor_task', priority = 3, # period = 25, profile = True, trace = False) #right_sensor_task = cotask.Task (task_right_sensor, name = 'right_sensor_task', priority = 4, # period = 25, profile = True, trace = False) #left_sensor_task = cotask.Task (task_left_sensor, name = 'left_sensor_task', priority = 5, # period = 25, profile = True, trace = False) #bluetooth_task = cotask.Task (task_bluetooth, name = 'bluetooth_task', priority = 6, # period = 25, profile = True, trace = False) cotask.task_list.append(motor_task) # cotask.task_list.append (front_sensor_task) #cotask.task_list.append (back_sensor_task) #cotask.task_list.append (right_sensor_task) #cotask.task_list.append (left_sensor_task) #cotask.task_list.append (bluetooth_task) # A task which prints characters from a queue has automatically been # created in print_task.py; it is accessed by print_task.put_bytes() # Run the memory garbage collector to ensure memory is as defragmented as # possible before the real-time scheduler is started gc.collect() # Run the scheduler with the chosen scheduling algorithm. Quit if any # character is sent through the serial por vcp = pyb.USB_VCP() while not vcp.any(): cotask.task_list.pri_sched() # Empty the comm port buffer of the character(s) just pressed vcp.read() # Print a table of task data and a table of shared information data print('\n' + str(cotask.task_list) + '\n') print(task_share.show_all()) # print (control_task.get_trace ()) print('\r\n') ''' aye = pyb.I2C(1, pyb.I2C.MASTER)
client.loop_stop() yield () if __name__ == "__main__": print("Skylux Project Main()") global motorHandler motorHandler = motor_handler() mqttClient = skylux_mqtt.initMQTT() ##implement way to listen to MQTT mqttTask = cotask.Task(mqttControl, name='MQTT_Listener', priority=2, period=1000, profile=True, trace=False) fauxmoTask = cotask.Task(fauxmoControl, name="Fauxmo", priority=1, period=100, profile=True, trace=False) cotask.task_list.append(mqttTask) cotask.task_list.append(fauxmoTask) while True: cotask.task_list.pri_sched()
if __name__ == "__main__": print ('\033[2JTesting scheduler in cotask.py\n') # Create a share and some queues to test diagnostic printouts share0 = task_share.Share ('i', thread_protect = False, name = "Share_0") q0 = task_share.Queue ('B', 6, thread_protect = False, overwrite = False, name = "Queue_0") q1 = task_share.Queue ('B', 8, thread_protect = False, overwrite = False, name = "Queue_1") # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed motor_task = cotask.Task (task_motor, name = 'motor_task', priority = 1, period = 25, profile = True, trace = False) front_sensor_task = cotask.Task (task_front_sensor, name = 'front_sensor_task', priority = 2, period = 25, profile = True, trace = False) back_sensor_task = cotask.Task (task_back_sensor, name = 'back_sensor_task', priority = 3, period = 25, profile = True, trace = False) right_sensor_task = cotask.Task (task_right_sensor, name = 'right_sensor_task', priority = 4, period = 25, profile = True, trace = False) left_sensor_task = cotask.Task (task_left_sensor, name = 'left_sensor_task', priority = 5, period = 25, profile = True, trace = False) cotask.task_list.append (motor_task) cotask.task_list.append (front_sensor_task)
## Hold pitch encoder values q8 = task_share.Share('f', thread_protect=False, name="Queue_8") ## Hold roll encoder values q9 = task_share.Share('f', thread_protect=False, name="Queue_9") # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed ## Motor task should be run at least every 22ms for "real time" results task1 = cotask.Task(task1_pitch_motor, name='Task_1', priority=2, period=22, profile=True, trace=False) ## Motor task should be run at least every 22ms for "real time" results task2 = cotask.Task(task2_roll_motor, name='Task_2', priority=2, period=22, profile=True, trace=False) ## The IMU read task should as often as the motors to keep consistency between movement # and current angles task3 = cotask.Task(task3_imu_read, name='Task_3', priority=3, period=22,
thread_protect=False, overwrite=False, name="Calibration_Queue") # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed #task1 = cotask.Task (task1_fun, name = 'Task_1', priority = 1, #period = 1000, profile = True, trace = False) #task2 = cotask.Task (task2_fun, name = 'Task_2', priority = 2, #period = 100, profile = True, trace = False) span_motor_task = cotask.Task(task_span_motor_fun, name='Span_Motor_Task', priority=6, period=10, profile=True, trace=False) tilt_motor_task = cotask.Task(task_tilt_motor_fun, name='Tilt_Motor_Task', priority=6, period=10, profile=True, trace=False) interface_task = cotask.Task(task_interface_fun, name='Interface_Task', priority=1, period=100, profile=True, trace=False) dart_motor_task = cotask.Task(task_dart_motor_fun,
""" while True: # If there's a character in the queue, print it if print_queue.any(): # print (chr (print_queue.get ()), end = '') print(print_queue.get(), end='') # If there's another character, tell this task to run again ASAP if print_queue.any(): print_task.go() yield (0) ## This queue holds characters to be printed when the print task gets around # to it. global print_queue print_queue = task_share.Queue('B', BUF_SIZE, name="Print_Queue", thread_protect=THREAD_PROTECT, overwrite=False) ## This is the task which schedules printing. global print_task print_task = cotask.Task(run, name='Printing', priority=0, profile=PROFILE) # This line tells the task scheduler to add this task to the system task list cotask.task_list.append(print_task)
thread_protect=False, name='Position Control 1') setpoint1 = task_share.Share('I', thread_protect=False, name='Setpoint 1') step_rsp1 = task_share.Share('H', thread_protect=False, name='Step Response 1') get_data1 = task_share.Share('H', thread_protect=False, name='Get Data 1') pos_ctrl2 = task_share.Share('H', thread_protect=False, name='Position Control 2') setpoint2 = task_share.Share('I', thread_protect=False, name='Setpoint 2') step_rsp2 = task_share.Share('H', thread_protect=False, name='Step Response 2') get_data2 = task_share.Share('H', thread_protect=False, name='Get Data 2') # Create tasks motor1_task = cotask.Task(motor1_fun, name='Motor 1', priority=2, period=10, profile=True, trace=False) cotask.task_list.append(motor1_task) motor2_task = cotask.Task(motor2_fun, name='Motor 2', priority=2, period=10, profile=True, trace=False) cotask.task_list.append(motor2_task) # user_input = cotask.Task(user_input, name='Motor 1', priority=1, # period=750, profile=True, trace=False) # cotask.task_list.append(user_input) manual_control = cotask.Task(manual_control, name='Manual Control',
#################################################################### pwm1 = motor_task_func.Motor_Task(20, 1, 5, 3, pyb.Pin.board.PA2, 2) pwm2 = motor_task_func.Motor_Task(20, 1, 5, 4, pyb.Pin.board.PA3, 2) pwm3 = motor_task_func.Motor_Task(1, 20, 8, 2, pyb.Pin.board.PC8, 2) pwm4 = motor_task_func.Motor_Task(1, 20, 8, 1, pyb.Pin.board.PC6, 2) # pwm2 = motor_task_func.Motor_Task(500, 5, 1, 3, pyb.Pin.board.PB15, 1) #################################################################### ############################## TASKS ############################### #################################################################### #Turret Hub Timing => Timing: 100 ms, Priority 1 (Lowest) task0 = cotask.Task(pwm1.mot_fun, name='Task_0', priority=1, period=100, profile=True, trace=False) task1 = cotask.Task(pwm2.mot_fun, name='Task_1', priority=1, period=100, profile=True, trace=False) task2 = cotask.Task(pwm3.mot_fun, name='Task_2', priority=1, period=100, profile=True, trace=False) task3 = cotask.Task(pwm4.mot_fun,
# Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed # #Turret Hub Timing => Timing: 100 ms, Priority 1 (Lowest) # task0 = cotask.Task (turret_hub.turret_hub_fun, name = 'Task_0', priority = 1, # period = 100, profile = True, trace = False) #Pan Encoder => Timing 2 ms, Priority 5(Highest) # task1 = cotask.Task (pan_encoder.enc_fun, name = 'Task_1', priority = 5, # period = 2, profile = True, trace = False) #Tilt IMU => Timing 5 ms (minimum 10 ms, applied 2x SF), Priority 5(Highest) task2 = cotask.Task(tilt_IMU.IMU_fun, name='Task_2', priority=5, period=5, profile=True, trace=False) # #Pan Motor => Timing 20 ms, Priority 3 (Medium) # task3 = cotask.Task (pan_motor.mot_fun, name = 'Task_3', priority = 3, # period = 20, profile = True, trace = False) #Tilt Motor => Timing 20 ms, Priority 3 (Medium) task4 = cotask.Task(tilt_motor.mot_fun, name='Task_4', priority=3, period=20, profile=True, trace=False) # #Nerf Gun => Timing 200 ms, Priority 1 (Lowest) # task5 = cotask.Task (nerf_gun.gun_fun, name = 'Task_5', priority = 1, # period = 200, profile = True, trace = False)
IRShare = task_share.Share('i') shareIMU = task_share.Share('f') shareLine = task_share.Share('i') encoderR = EncoderDriver('PB6', 'PB7', 4, direction='clockwise') encoderL = EncoderDriver('PC6', 'PC7', 8, direction='counterclockwise') controllerR = ClosedLoopDriver(0, 0, .2, 100) motorR = MotorDriver() controllerL = ClosedLoopDriver(0, 0, .2, 20) motorL = MotorDriver('PC1', 'PA0', 'PA1', 5, 100) if __name__ == "__main__": print('\033[2JTesting scheduler in cotask.py\n') task1 = cotask.Task(MotorControlTask, name='Task1 MC', priority=6, period=50, profile=True, trace=False) task2 = cotask.Task(LineSensorTask, name='Task2 LS', priority=5, period=100, profile=True, trace=False) task3 = cotask.Task(IMU_Task, name='Task3 IMU', priority=1, period=50, profile=True, trace=False) task4 = cotask.Task(TOF_Task,
enc_1_position = task_share.Share('i', thread_protect=False, name="Share_0_enc_1_position") enc_2_position = task_share.Share('i', thread_protect=False, name="Share_0_enc_2_position") Run = task_share.Share('i', thread_protect=False, name="Run_Intertask_Comm_Variable") # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed task1 = cotask.Task(Encoder1_fun, name='Task_1', priority=5, period=2, profile=True, trace=False) task2 = cotask.Task(MotorCtrl1_fun, name='Task_2', priority=3, period=20, profile=True, trace=False) task3 = cotask.Task(Encoder2_fun, name='Task_3', priority=5, period=2, profile=True, trace=False) task4 = cotask.Task(MotorCtrl2_fun,
yield (0) if __name__ == "__main__": print('\033[2JTesting scheduler in cotask.py\n') share0 = task_share.Share('i', thread_protect=True, name="Share_0") qt1 = task_share.Queue('f', 500, thread_protect=True, overwrite=False) qp1 = task_share.Queue('f', 500, thread_protect=True, overwrite=False) qt2 = task_share.Queue('f', 500, thread_protect=True, overwrite=False) qp2 = task_share.Queue('f', 500, thread_protect=True, overwrite=False) #used to test different periods and plot the results #per = eval(input()) task1 = cotask.Task(motor1_fun, name='Motor_1', priority=1, period=25, profile=True, trace=False) task2 = cotask.Task(motor2_fun, name='Motor_2', priority=2, period=25, profile=True, trace=False) cotask.task_list.append(task1) cotask.task_list.append(task2) gc.collect() time = [] pos = []
# Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed # #Turret Hub Timing => Timing: 100 ms, Priority 1 (Lowest) # task0 = cotask.Task (turret_hub.turret_hub_fun, name = 'Task_0', priority = 1, # period = 100, profile = True, trace = False) # #Pan Encoder => Timing 2 ms, Priority 5(Highest) # task1 = cotask.Task (pan_encoder.enc_fun, name = 'Task_1', priority = 5, # period = 2, profile = True, trace = False) #Tilt IMU => Timing 5 ms (minimum 10 ms, applied 2x SF), Priority 5(Highest) task2 = cotask.Task(tilt_IMU.IMU_fun, name='Task_2', priority=5, period=5, profile=True, trace=False) # #Pan Motor => Timing 20 ms, Priority 3 (Medium) # task3 = cotask.Task (pan_motor.mot_fun, name = 'Task_3', priority = 3, # period = 20, profile = True, trace = False) # #Tilt Motor => Timing 20 ms, Priority 3 (Medium) # task4 = cotask.Task (tilt_motor.mot_fun, name = 'Task_4', priority = 3, # period = 20, profile = True, trace = False) # #Nerf Gun => Timing 200 ms, Priority 1 (Lowest) # task5 = cotask.Task (nerf_gun.gun_fun, name = 'Task_5', priority = 1, # period = 200, profile = True, trace = False) #cotask.task_list.append (task0) #cotask.task_list.append (task1) cotask.task_list.append(task2)
thread_protect=False, overwrite=False, name="Queue_0") q1 = task_share.Queue('B', 8, thread_protect=False, overwrite=False, name="Queue_1") # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed motor1_task = cotask.Task(task_motor1, name='motor1_task', priority=1, period=25, profile=True, trace=False) motor2_task = cotask.Task(task_motor2, name='motor2_task', priority=2, period=25, profile=True, trace=False) cotask.task_list.append(motor1_task) cotask.task_list.append(motor2_task) # A task which prints characters from a queue has automatically been # created in print_task.py; it is accessed by print_task.put_bytes() # Run the memory garbage collector to ensure memory is as defragmented as
time_elapsed.put(0) #setup perception shares Line_L = task_share.Share ('i', thread_protect = False, name = "L") Line_L.put(1) Line_C = task_share.Share ('i', thread_protect = False, name = "C") Line_C.put(1) Line_R = task_share.Share ('i', thread_protect = False, name = "R") Line_R.put(1) #setup task share and tasks q0 = task_share.Queue ('B', 6, thread_protect = False, overwrite = False, name = "Queue_0") task1 = cotask.Task (motor_task_1, name = 'right_motor', priority = 1, period = 20, profile = True, trace = False) task2 = cotask.Task (motion_control, name = 'motion', priority = 2, period = 21, profile = True, trace = False) task3 = cotask.Task (ir_sensor_task, name = 'ir_sensor', priority = 2, period = 25, profile = True, trace = False) task4 = cotask.Task (perception, name = 'perception', priority = 1, period = 20, profile = True, trace = False) cotask.task_list.append (task1) cotask.task_list.append (task2) cotask.task_list.append (task3) cotask.task_list.append (task4)
heading_OK = task_share.Share('f', thread_protect=True, name="heading_OK") pitch_OK = task_share.Share('f', thread_protect=True, name="pitch_OK") trigger_ready_share = task_share.Share('f', thread_protect=True, name="trigger_ready_share") set_coord_share = task_share.Share('f', thread_protect=True, name="set_coord") calibrated_share = task_share.Share('f', thread_protect=True, name="calibrated") # Assigns a each of the above functions to the a task variable task1 = cotask.Task(heading_motor_fun, name='Heading Motor', priority=1, period=10, profile=True, trace=False) task2 = cotask.Task(pitch_motor_fun, name='Pitch_Motor', priority=2, period=10, profile=True, trace=False) task3 = cotask.Task(IMU_fun, name='IMU', priority=1, period=10, profile=True, trace=False) task4 = cotask.Task(servo_fun,
pyb.Pin.board.PC1, timer, channel) p_motor = motor_task_func.Motor_Task(p_params, p_enable, pyb.Pin.board.PB2, pyb.Pin.board.PB13, pyb.Pin.board.PA5, pyb.Pin.board.PH1, pyb.Pin.board.PC0, timer, channel) #################################################################### ############################## TASKS ############################### #################################################################### # Hub Task task1 = cotask.Task (hub.hub_fun, name = 'Task_1', priority = 1, period = 100, profile = True, trace = False) # Feedback Tasks task2 = cotask.Task (x_feedback.fb_fun, name = 'Task_2', priority = 5, period = 5, profile = True, trace = False) task3 = cotask.Task (z_feedback.fb_fun, name = 'Task_3', priority = 5, period = 5, profile = True, trace = False) task4 = cotask.Task (y_feedback.fb_fun, name = 'Task_4', priority = 5, period = 5, profile = True, trace = False) task5 = cotask.Task (p_feedback.fb_fun, name = 'Task_5', priority = 5, period = 5, profile = True, trace = False) # Motor Tasks task6 = cotask.Task (x_motor.mot_fun, name = 'Task_6', priority = 3, period = 20, profile = True, trace = False) task7 = cotask.Task (z_motor.mot_fun, name = 'Task_7', priority = 3,
if state == OFF1: if IR.getCommand() == C.START: state = ANALYZE_US yield (state) if __name__ == "__main__": try: print('\033[2JTesting scheduler in cotask.py\n') # intitialize motor task 1 using Task() t1 = cotask.Task(driveTask, name='Drive Task', priority=1, period=10, profile=True, trace=False) t2 = cotask.Task(lineFollowerTask, name='Line Follower Task', priority=1, period=50, profile=True, trace=False) t3 = cotask.Task(ultraSonicDistanceTask, name='UltraSonic Distance Task', priority=2, period=50, profile=True, trace=False)
# Create a share and some queues to test diagnostic printouts sm1 = task_share.Share('f', thread_protect=False, name="Share_1") sm2 = task_share.Share('f', thread_protect=False, name="Share_2") sm3 = task_share.Share('f', thread_protect=False, name="Share_3") # md1 = task_share.Share ('B', thread_protect = False, name = "mdone1") # md2 = task_share.Share ('B', thread_protect = False, name = "mdone2") # md_3 = task_share.Share ('B', thread_protect = False, name = "mdone3") # nv = task_share.Share ('B', thread_protect = False, name = "new value") # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed task1 = cotask.Task(Control1, name='Control1', priority=4, period=10, profile=True, trace=False) task2 = cotask.Task(Control2, name='Control2', priority=4, period=10, profile=True, trace=False) task3 = cotask.Task(Control3, name='Control3', priority=5, period=10, profile=True, trace=False) task4 = cotask.Task(Overlord,
file_search = True while file_search == True: file_name = io_funcs.get_input(str, 'File name? [file.txt] ') try: file = open(file_name, 'r') file_search = False except: print('Not a valid file name or type. Please try again') # Initializing motors and encoders with a task motor_1_task = motor_task.Motor_control_task(0) mname1 = 'Motor_' + str(motor_1_task.motor_number) cotask.task_list.append( cotask.Task(motor_1_task.run_motor, name=mname1, priority=3, period=8, profile=True)) motor_2_task = motor_task.Motor_control_task(1) mname2 = 'Motor_' + str(motor_2_task.motor_number) cotask.task_list.append( cotask.Task(motor_2_task.run_motor, name=mname2, priority=3, period=8, profile=True)) # Zero calibration print('Bring the motors to calibration point, aka x = 0 and y = L1 + L2') cal = True
thread_protect=False, overwrite=False, name="Queue_0") q1 = task_share.Queue('B', 8, thread_protect=False, overwrite=False, name="Queue_1") # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed task1 = cotask.Task(task1_fun, name='Task_1', priority=1, period=1000, profile=True, trace=False) task2 = cotask.Task(task2_fun, name='Task_2', priority=2, period=100, profile=True, trace=False) cotask.task_list.append(task1) cotask.task_list.append(task2) # A task which prints characters from a queue has automatically been # created in print_task.py; it is accessed by print_task.put_bytes() # Create a bunch of silly time-wasting busy tasks to test how well the
if x == True: print_task.put (data) x = not x # yield to another task and resume at this line yield (0) # # ============================================================================= # # if __name__ == "__main__": try: print ('\033[2JTesting scheduler in cotask.py\n') ## intitialize motor task 1 using Task() m1 = cotask.Task (motor_1, name = 'Motor 1', priority = 1, period = 40, profile = True, trace = False) ## intitialize motor task 2 using Task() m2 = cotask.Task (motor_2, name = 'Motor 2', priority = 1, period = 40, profile = True, trace = False) # add each task to the task list cotask.task_list.append (m1) cotask.task_list.append (m2) # execute the task list using the priority attribute of each task while True: cotask.task_list.pri_sched () # Run the memory garbage collector to ensure memory is as defragmented as possible before the real-time scheduler is started gc.collect () # If a keyboard interrupt is thrown, set the motor duty cycles to 0
# pan_completion, tilt_completion) # nerf_gun = nerf_task_func.Nerf_Task(WINDUP_GUN, FEED_BULLETS, pyb.Pin.board.PC6, pyb.Pin.board.PC7) # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed # #Turret Hub Timing => Timing: 100 ms, Priority 1 (Lowest) # task0 = cotask.Task (turret_hub.turret_hub_fun, name = 'Task_0', priority = 1, # period = 100, profile = True, trace = False) #Pan Encoder => Timing 2 ms, Priority 5(Highest) task1 = cotask.Task(pan_encoder.enc_fun, name='Task_1', priority=5, period=2, profile=True, trace=False) #Tilt IMU => Timing 5 ms (minimum 10 ms, applied 2x SF), Priority 5(Highest) # task2 = cotask.Task (tilt_IMU.IMU_fun, name = 'Task_2', priority = 5, # period = 5, profile = True, trace = False) #Pan Motor => Timing 20 ms, Priority 3 (Medium) task3 = cotask.Task(pan_motor.mot_fun, name='Task_3', priority=3, period=20, profile=True, trace=False) #Tilt Motor => Timing 20 ms, Priority 3 (Medium) # task4 = cotask.Task (tilt_motor.mot_fun, name = 'Task_4', priority = 3, # period = 20, profile = True, trace = False)
import drive import motor_driver import strategy from micropython import alloc_emergency_exception_buf alloc_emergency_exception_buf(100) if __name__ == '__main__': ir.init() strategy.Strategy = strategy.BasicStrategy() drive_task = cotask.Task(drive.handler, name='Drive Task', priority=1, period=20, profile=True, trace=False) strategy_task = cotask.Task(strategy.handler, name='Strategy Task', priority=1, period=10, profile=True, trace=False) ir_task = cotask.Task(ir.handler, name='IR Task', priority=2, period=50, profile=True, trace=False)
thread_protect=False, overwrite=False, name="Queue_0") q1 = task_share.Queue('B', 8, thread_protect=False, overwrite=False, name="Queue_1") # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed task1 = cotask.Task(task1_fun, name='Task_1', priority=1, period=100, profile=True, trace=False) task2 = cotask.Task(task2_fun, name='Task_2', priority=2, period=100, profile=True, trace=False) task3 = cotask.Task(task3_closed_loop, name='Task_3', priority=3, period=10, profile=True, trace=False) cotask.task_list.append(task1)
pyb.Pin.board.PA0, pyb.Pin.board.PA1, 2.2, 0.145, 200) turret_hub = turret_hub_task_func.Turret_Hub_Task(pan_position, tilt_angle, pan_coords, tilt_coords, FEED_BULLETS, WINDUP_GUN) nerf_gun = nerf_task_func.Nerf_Task(WINDUP_GUN, FEED_BULLETS, pyb.Pin.board.PC7, pyb.Pin.board.PC6) # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed #Turret Hub Timing => Timing: 100 ms, Priority 1 (Lowest) task0 = cotask.Task (turret_hub.turret_hub_fun, name = 'Task_0', priority = 1, period = 100, profile = True, trace = False) #Pan Encoder => Timing 2 ms, Priority 5(Highest) task1 = cotask.Task (pan_encoder.enc_fun, name = 'Task_1', priority = 5, period = 2, profile = True, trace = False) #Tilt IMU => Timing 5 ms (minimum 10 ms, applied 2x SF), Priority 5(Highest) task2 = cotask.Task (tilt_IMU.IMU_fun, name = 'Task_2', priority = 5, period = 5, profile = True, trace = False) #Pan Motor => Timing 20 ms, Priority 3 (Medium) task3 = cotask.Task (pan_motor.mot_fun, name = 'Task_3', priority = 3, period = 20, profile = True, trace = False) #Tilt Motor => Timing 20 ms, Priority 3 (Medium) task4 = cotask.Task (tilt_motor.mot_fun, name = 'Task_4', priority = 3, period = 20, profile = True, trace = False) #Nerf Gun => Timing 200 ms, Priority 1 (Lowest) task5 = cotask.Task (nerf_gun.gun_fun, name = 'Task_5', priority = 1, period = 200, profile = True, trace = False)
name="Share_0_enc_1_position") enc_2_position = task_share.Share('i', thread_protect=False, name="Share_0_enc_2_position") Run = task_share.Share('i', thread_protect=False, name="Run_Intertask_Comm_Variable") # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed task1 = cotask.Task(Encoder1_fun, name='Task_1', priority=5, period=1, profile=True, trace=False) task2 = cotask.Task(MotorCtrl1_fun, name='Task_2', priority=3, period=10, profile=True, trace=False) # task3 = cotask.Task (Encoder2_fun, name = 'Task_3', priority = 5, # period = 1, profile = True, trace = False) # task4 = cotask.Task (MotorCtrl2_fun, name = 'Task_4', priority = 3, # period = 10, profile = True, trace = False) task5 = cotask.Task(UI_fun, name='Task_5', priority=3,
# pan_completion, tilt_completion) # nerf_gun = nerf_task_func.Nerf_Task(WINDUP_GUN, FEED_BULLETS, pyb.Pin.board.PC6, pyb.Pin.board.PC7) # Create the tasks. If trace is enabled for any task, memory will be # allocated for state transition tracing, and the application will run out # of memory after a while and quit. Therefore, use tracing only for # debugging and set trace to False when it's not needed # #Turret Hub Timing => Timing: 100 ms, Priority 1 (Lowest) # task0 = cotask.Task (turret_hub.turret_hub_fun, name = 'Task_0', priority = 1, # period = 100, profile = True, trace = False) #Pan Encoder => Timing 2 ms, Priority 5(Highest) task1 = cotask.Task(pan_encoder.enc_fun, name='Task_1', priority=5, period=2, profile=True, trace=False) #Tilt IMU => Timing 5 ms (minimum 10 ms, applied 2x SF), Priority 5(Highest) # task2 = cotask.Task (tilt_IMU.IMU_fun, name = 'Task_2', priority = 5, # period = 5, profile = True, trace = False) # #Pan Motor => Timing 20 ms, Priority 3 (Medium) # task3 = cotask.Task (pan_motor.mot_fun, name = 'Task_3', priority = 3, # period = 20, profile = True, trace = False) # #Tilt Motor => Timing 20 ms, Priority 3 (Medium) # task4 = cotask.Task (tilt_motor.mot_fun, name = 'Task_4', priority = 3, # period = 20, profile = True, trace = False) # #Nerf Gun => Timing 200 ms, Priority 1 (Lowest) # task5 = cotask.Task (nerf_gun.gun_fun, name = 'Task_5', priority = 1, # period = 200, profile = True, trace = False)
# pyb.Pin.board.PC3, 8, 1, 5, 1, 'Z ') # y_motor = motor_task_func.Motor_Task(y_params, y_steps, y_enable, y_status, y_limit, # pyb.Pin.board.PC7, pyb.Pin.board.PC5, pyb.Pin.board.PD2, # pyb.Pin.board.PC1, 8, 2, 5, 2, 'Y ') # p_motor = motor_task_func.Motor_Task(p_params, p_steps, p_enable, p_status, p_limit, # pyb.Pin.board.PC9, pyb.Pin.board.PA5, pyb.Pin.board.PB9, # pyb.Pin.board.PC0, 8, 4, 5, 4, 'P ') #################################################################### ############################## TASKS ############################### #################################################################### # Hub Task task1 = cotask.Task(hub.hub_fun, name='Task_1', priority=1, period=100, profile=True, trace=False) # Feedback Tasks task2 = cotask.Task(x_feedback.fb_fun, name='Task_2', priority=5, period=20, profile=True, trace=False) # task3 = cotask.Task (z_feedback.fb_fun, name = 'Task_3', priority = 5, # period = 20, profile = True, trace = False) # task4 = cotask.Task (y_feedback.fb_fun, name = 'Task_4', priority = 5, # period = 20, profile = True, trace = False) # task5 = cotask.Task (p_feedback.fb_fun, name = 'Task_5', priority = 5,