def manual_cal():
c = Camera()
sweep = list(range(EXP_MIN, EXP_MAX, EXP_STEP))
imgs = c.exposure_sweep(sweep)
for e, i in zip(sweep, imgs):
debug_save_img(i, str(e) + '.jpg')
def cap_deck():
c = Camera()
sd = SerialDevice()
dispenser = Dispenser(serial_device=sd)
count = 0
for i in range(10):
_ = input('press enter to start...')
for j in range(10):
img = c._capture_image(enable_and_disable=True)
debug_save_img(img, '/home/pi/pics/{}.jpg'.format(count))
count += 1
dispenser.dispense_card()
def auto_cal():
print("Ensure blank white playing card is being used")
c = Camera()
img_raw = c._capture_image(enable_and_disable=True)
img_greyscale = cv2.cvtColor(img_raw, cv2.COLOR_BGR2GRAY)
img_gs_blur = cv2.GaussianBlur(img_greyscale, (5, 5), 0)
img_gs_blur_crop = img_gs_blur[cfg.H_MIN:cfg.H_MAX, cfg.W_MIN:cfg.W_MAX]
debug_save_img(img_gs_blur_crop,
'Shuffle-o-matic/helpers/Card_Imgs/cal.jpg')
print("Calibration image updated!")
def main():
sd = SerialDevice()
d_motor = DispenseStep(serial_device=sd)
p_motor = PushStep(serial_device=sd)
b_motor = BinStep(serial_device=sd)
dispenser = Dispenser(serial_device=sd)
camera = Camera()
b_motor.zero()
p_motor.zero()
d_motor.zero()
t_start = time.time()
d_motor.enable()
d_motor.raise_stage()
print('READY')
try:
while True:
try:
cmd, data = check_for_cmd()
if cmd is not None:
pre_shuffle(d_motor, p_motor, b_motor, dispenser)
if 'RAND' in cmd:
random_shuffle(d_motor, p_motor, b_motor, dispenser,
data)
elif 'BJACK' in cmd or 'HOLD' in cmd:
planned_shuffle(d_motor, p_motor, b_motor, dispenser,
camera, data)
post_shuffle(d_motor, p_motor, b_motor, dispenser)
print('Shuffle Completed!')
except Exception as e:
print('Shuffle Errored!', e)
pass
time.sleep(0.1)
except KeyboardInterrupt:
post_shuffle(d_motor, p_motor, b_motor, dispenser)
d_motor.disable()
def cam_test():
c = Camera()
while True:
_ = input('Press enter to read card')
card = c.read_card(enable_and_disable=True)
print(card.rank, card.suit)
def planned_shuffle(d_motor:DispenseStep, p_motor:PushStep, b_motor:BinStep, dispenser:Dispenser, camera:Camera, deck):
# Initialize vars
dispenser.enable_motor()
dispenser.baseline_motor_cur()
t_last_dispense = time.time()
n_bins = len(cfg.bin_heights_load_mm)
cards_in_trash = 0
camera.start_camera()
# Generate bin reqs for deck
deck.break_into_bins(n_bins=n_bins)
def empty_trash():
p_motor.enable()
b_motor.unload_bin_pos(n_bins-1)
time.sleep(0.1)
p_motor.run()
p_motor.disable()
junk_cards_dispensed = 0
last_card = camera.read_card()
while junk_cards_dispensed < cfg.planned_shuffle_timeout:
card = camera.read_card()
# Determine where to put card. If it is the same as last, it probs failed to dispense
if card.rank is None and card.suit is None:
bin_index = None
elif last_card.rank is card.rank and last_card.suit is card.suit:
print('Previous card failed to dispense. Re-dispensing')
pass
else:
bin_index = deck.get_bin(card)
last_card = card
print(card.rank, card.suit, ":", bin_index)
# Handle vars if trash card
if bin_index is None:
bin_index = n_bins - 1
cards_in_trash += 1
junk_cards_dispensed += 1
# Move to bin location
b_motor.load_bin_pos(bin_index)
# Dispense card
while time.time() < t_last_dispense + cfg.min_time_between_dispenses_s:
pass
if not dispenser.dispense_card():
raise Exception("Card Jam")
t_last_dispense = time.time()
# Check for full trash
if cards_in_trash >= cfg.max_cards_per_bin:
empty_trash()
cards_in_trash = 0
# Check for shuffle completion
if deck.is_shuffle_complete:
return_all_cards(p_motor, b_motor)
break
else:
print("Planned Shuffle Timeout")
camera.stop_camera()
def main():
c = Camera()
c.start_camera()
card = c.read_card()
print(card.rank, card.suit)
c.stop_camera()