haftalik degisim

Author: F4tihh

Button.py

@@ -0,0 +1,20 @@
+import RPi.GPIO as GPIO
+from time import sleep
+GPIO.setmode(GPIO.BCM)
+
+BUTTON = 12
+LED = 20
+GPIO.setup(BUTTON, GPIO.IN)
+GPIO.setup(LED, GPIO.OUT)
+GPIO.output(LED, GPIO.LOW)
+
+try:
+  while True:
+    GPIO.wait_for_edge(BUTTON, GPIO.RISING)
+    GPIO.output(LED, GPIO.HIGH)
+    sleep(2)
+    GPIO.output(LED, GPIO.LOW)
+except KeyboardInterrupt:
+  GPIO.output(LED, GPIO.LOW)
+  GPIO.cleanup()
+  raise

__pycache__/cardreader.cpython-310.pyc

@@ -0,0 +1,90 @@
+from time import sleep, time
+import sys
+from mfrc522 import SimpleMFRC522
+import RPi.GPIO as GPIO
+
+readers = []
+poll_list = list()
+curr_poll_list = list()
+RESET_PIN = 21  # In BCM pin number. See: https://pinout.xyz
+
+
+def read_init():
+    rfid_count = 18
+    for i in range(0, rfid_count):
+        poll_list.append(i)
+    curr_poll_list = poll_list.copy()
+
+    GPIO.setmode(GPIO.BCM)
+
+    for i in range(0, rfid_count):
+        # Parameters are bus and device number respectively. Device number is allias to
+        # Chip Select (Slave Select) in SPI Protocol.
+        # /dev/spidev<bus>.<device>
+        # Pin association to the device numbers configured by device tree object.
+        # See: /home/alarm/spi-cs-extend.dts
+        # See: https://gist.github.com/mcbridejc/d060602e892f6879e7bc8b93aa3f85be
+        readers.append(SimpleMFRC522(0, i, 800000))
+
+    # Its recommended to reset MFRC522 after each polling. Pulling Reset_Pin to low
+    # (by setting the ping to low mode in out settings) turns off the sensors until
+    # the pin is high again.
+    GPIO.setup(RESET_PIN, GPIO.OUT)
+
+    GPIO.output(RESET_PIN, GPIO.LOW)
+    sleep(0.01)
+
+    GPIO.output(RESET_PIN, GPIO.HIGH)
+    sleep(0.01)
+
+
+def read_process():
+    reads = dict()
+    poll_duration_in_s = 2.5
+    try:
+        # One-shot reads might miss. So its better to poll multiple times.
+        old_time = 0
+        total_read = 0
+        while True:
+            if time() - old_time < poll_duration_in_s:
+                for i, v in enumerate(curr_poll_list):
+                    readers[v].READER.MFRC522_Init();
+                    # print(v)
+                    id, text = readers[v].read_no_block()
+                    if id:
+                        reads[v + 1] = id
+                        txt = "0x001"
+                        #readers[v].write(txt) # RFID TAg eklemek istersek bu komutu çalýþtýracaðýz.
+                        curr_poll_list.remove(v)
+                    print("%d ID: %s %s" % (i, id, text)) 
+		    
+                    #print(list(str(text).encode('ascii')))
+                total_read += 1
+                # print(curr_poll_list)
+
+            else:
+                if total_read != 0:
+                    return reads
+                for number, id in sorted(reads.items()):
+                    print("RFID NUMBER: %d KEY ID: %d" % (number, id))
+
+                reads.clear()
+                print("Total Read = %d.\tReading the devices..." % (total_read))
+                total_read = 0
+                old_time = time()
+                curr_poll_list = poll_list.copy()
+                GPIO.output(RESET_PIN, GPIO.LOW)
+                sleep(0.05)
+
+                GPIO.output(RESET_PIN, GPIO.HIGH)
+                sleep(0.05)
+
+
+    except KeyboardInterrupt:
+        GPIO.cleanup()
+        raise
+
+
+def to_ascii(text):
+    ascii_values = [ord(character) for character in text]
+    return ascii_values

__pycache__/cardreader2.cpython-311.pyc

@@ -0,0 +1,20 @@
+from time import sleep, time
+
+def read_process():
+    # Resim kimlik kartları listesi
+    resim_id_listesi = [1, 2, 3, 4, 5]
+
+    try:
+        reads = dict()
+        for i in range(5):
+            resim_id = resim_id_listesi[i]
+            reads[i] = resim_id
+        return reads
+
+    except KeyboardInterrupt:
+        raise
+
+if __name__ == "__main__":
+    reads = read_process()
+    print("reads:", reads)
+    

__pycache__/config.cpython-310.pyc

@@ -0,0 +1,13 @@
+[Unit]
+Description=Service for the game
+
+[Install]
+WantedBy=multi-user.target
+
+[Service]
+User=root
+Type=simple
+ExecStart=/usr/bin/python3 /home/alarm/project/src/main.py
+WorkingDirectory=/home/alarm/project/src
+Restart=always
+RestartSec=5

__pycache__/controller.cpython-310.pyc

@@ -0,0 +1,38 @@
+cfg = {
+        ###########  ROTATION ###########
+        # Initialization configuration.
+        # pitch_degree is the degree from which the pitch will be rotated down to.
+        "pitch_degree": 13,
+        ###########  ROTATION ###########
+        # Rotations to right or left, clockwise or counter-clockwise in respectively.
+        # rotate_degree controls the degree of the turn.
+        # rotate_speed controls the speed in degrees of the turn.
+        "rotate_degree": 90,
+        "rotate_speed": 90,
+        "yaw_speed": 120,
+
+        ###########  MOVING ###########
+        # Movement to forward, backward, left, right or fastforward.
+        # "move_distance" in meters to control the distance.
+        # "move_gain" will be added to move_distance to calculate final distance to be inputted to robot.
+        # Change it to particularize for different surfaces.
+        # "move_speed" controls the speed for forward, backward, left and right movements.
+        # "move_fastspeed" controls the speed for fastforward.
+        "move_distance": 0.75,
+        "move_gain": 0.05,
+        "move_speed": 1,
+        "move_fastspeed": 1,
+
+        ###########  DANCE ###########
+        # Dance movement. Dance movement rotates chassis to right and left repeatedly in place.
+        # The dance will start with an half of the specified degree to a side then will be followed by
+        # full degree rotations back and forth. To finish at the center, a final half degree movement will
+        # be made.
+        # "dance_angle" specifies the full degree of the dance movement. The half degree wil be calculated not specified.
+        # "dance_speed" is the speed in degrees in which all the rotation will be made.
+        # "dance_iter" is the number of full degree iterations.
+        "dance_angle": 90,
+        "dance_speed": 120,
+        "dance_iter": 4,
+        }
+

__pycache__/controller.cpython-311.pyc

@@ -0,0 +1,177 @@
+import time
+import curses
+from robomaster import robot,config,chassis,gimbal,blaster,led
+from game import *
+from config import cfg
+import pygame
+
+ep_robot = robot.Robot()
+ep_chassis : chassis.Chassis
+ep_gimbal  : gimbal.Gimbal
+ep_blaster  : blaster.Blaster
+ep_led      : led.Led
+
+
+
+pitch_degree = cfg["pitch_degree"]
+def controller_con_test():
+    if ep_robot.get_version() is None:
+        exit(1)
+
+def controller_init():
+    global ep_chassis
+    global ep_gimbal
+    global ep_blaster
+    global ep_led
+    if not ep_robot.initialize(conn_type="sta", proto_type='udp'):
+        print("Robot initialization failed")
+        exit(1)
+    #ep_robot.initialize(conn_type="sta", proto_type='udp')
+    ep_chassis = ep_robot.chassis
+    ep_gimbal = ep_robot.gimbal
+    ep_blaster = ep_robot.blaster
+    ep_led = ep_robot.led
+    ep_led.set_led(r=0,g=0,b=255)
+    # move pitch to the max
+    # ep_gimbal.move(pitch=120, pitch_speed=90).wait_for_completed()
+    # get it down to a certain degree
+    ep_gimbal.moveto(yaw=0, pitch=pitch_degree, pitch_speed=90, yaw_speed=90).wait_for_completed()
+    controller_sound(2)
+    ep_led.set_led(r=255,g=255,b=0)
+
+    #Upload sound files
+    # upload_file = "/python/sdk_audio_9.wav"
+    # ep_robot._ftp.upload("gameover.wav", upload_file)
+    # ep_robot.play_sound(0xE0 + 9, times=1).wait_for_completed()
+
+    # ep_robot._audio_id = (ep_robot._audio_id + 1) % 10
+    # upload_file = "/python/sdk_audio_{0}.wav".format(ep_robot._audio_id)
+    # ep_robot._ftp.upload(filename, upload_file)
+    # logger.info("upload file {0} to target {1}".format(filename, upload_file))
+    # sound_id = 0xE0 + (ep_robot._audio_id % 10)
+
+
+### Actions ###
+
+def controller_test():
+    for i in range(25):
+        print(i)
+        time.sleep(1)
+        controller_sound(i)
+  # controller_fire()
+    pass
+  # controller_dance()
+  # controller_crotate()
+  # controller_sound()
+  # controller_crotate()
+  # controller_sound()
+  # controller_powerforward()
+  # controller_fire()
+  # pass
+
+def controller_close():
+  ep_robot.close()
+
+def _controller_brake():
+  ep_chassis.drive_wheels(w1=0, w2=0, w3=0, w4=0)
+
+rotate_degree = cfg["rotate_degree"]
+rotate_speed = cfg["rotate_speed"]
+yaw_speed = cfg["yaw_speed"]
+
+# clockwise rotate
+def controller_rotate():
+  ep_chassis.move(z=-rotate_degree,z_speed=rotate_speed).wait_for_completed()
+  ep_gimbal.move(yaw=rotate_degree,yaw_speed=yaw_speed).wait_for_completed()
+
+# counter-clockwise rotate
+def controller_crotate():
+  ep_chassis.move(z=rotate_degree,z_speed=rotate_speed).wait_for_completed()
+  ep_gimbal.move(yaw=-rotate_degree,yaw_speed=yaw_speed).wait_for_completed()
+
+move_distance = cfg["move_distance"] + cfg["move_gain"]
+move_speed = cfg["move_speed"]
+move_fastspeed = cfg["move_fastspeed"]
+
+def controller_forward():
+  ep_chassis.move(x=move_distance,xy_speed=move_speed).wait_for_completed()
+  _controller_brake()
+
+def controller_backward():
+  ep_chassis.move(x=-move_distance,xy_speed=move_speed).wait_for_completed()
+  _controller_brake()
+
+def controller_left():
+  ep_chassis.move(y=-move_distance,xy_speed=move_speed).wait_for_completed()
+  _controller_brake()
+
+def controller_right():
+  ep_chassis.move(y=move_distance,xy_speed=move_speed).wait_for_completed()
+  _controller_brake()
+
+def controller_fastforward():
+  ep_chassis.move(x=move_distance,xy_speed=move_fastspeed).wait_for_completed()
+  _controller_brake()
+
+dance_angle = cfg["dance_angle"]
+dance_half_angle = dance_angle / 2
+dance_speed = cfg["dance_speed"]
+dance_iter = cfg["dance_iter"]
+
+def controller_dance():
+    # ep_chassis.move(z=-90,z_speed=120)
+    # ep_gimbal.move(yaw=-90,yaw_speed=120)
+    ep_robot.play_audio("destiny.wav")
+    #
+    pygame.mixer.init()
+    pygame.mixer.music.load("destiny.wav")
+    pygame.mixer.music.play()
+    while pygame.mixer.music.get_busy():
+        continue
+    #
+    ep_led.set_led(r=255,g=0,b=255,effect="flash")
+    ep_chassis.move(z=dance_half_angle,z_speed=dance_speed).wait_for_completed()
+    for _ in range(dance_iter):
+        ep_chassis.move(z=-dance_angle,z_speed=dance_speed).wait_for_completed()
+        ep_chassis.move(z=dance_angle,z_speed=dance_speed).wait_for_completed()
+    ep_chassis.move(z=-dance_half_angle,z_speed=dance_speed).wait_for_completed()
+    time.sleep(2)
+    ep_led.set_led(r=255,g=255,b=0)
+
+    # ep_gimbal.move(yaw=45,yaw_speed=120).wait_for_completed()
+    # for _ in range(3):
+    #     ep_gimbal.move(yaw=-90,yaw_speed=120).wait_for_completed()
+    #     ep_gimbal.move(yaw=90,yaw_speed=120).wait_for_completed()
+    # ep_gimbal.move(yaw=-45,yaw_speed=120).wait_for_completed()
+
+    # ep_gimbal.move(yaw=, yaw_speed=120)
+    # robot_ctrl.set_mode(rm_define.robot_mode_free)
+    # chassis_ctrl.set_rotate_speed(120)
+    # gimbal_ctrl.set_rotate_speed(120)
+    # gun_ctrl.fire_continuous()
+    # # while True:
+
+    # gimbal_ctrl.rotate(rm_define.gimbal_right)
+    # chassis_ctrl.rotate_with_time(rm_define.anticlockwise, 0.2)
+    # gimbal_ctrl.rotate(rm_define.gimbal_left)
+    # chassis_ctrl.rotate_with_time(rm_define.clockwise, 0.4)
+    # gimbal_ctrl.rotate(rm_define.gimbal_right)
+    # chassis_ctrl.rotate_with_time(rm_define.anticlockwise, 0.2)
+    pass
+
+def controller_music():
+    ep_robot.play_audio("shark.wav").wait_for_completed()
+    pass
+
+def controller_sound(sound_id):
+    ep_robot.play_sound(sound_id, times=1).wait_for_completed()
+
+def controller_fire():
+    ep_led.set_led(r=255,g=0,b=0)
+    for i in [8, 15, 25]:
+        for j in [-20, 0, 20]:
+            ep_gimbal.moveto(yaw=j, pitch=i, pitch_speed=90, yaw_speed=90).wait_for_completed()
+            ep_blaster.fire()
+    ep_gimbal.moveto(yaw=0, pitch=pitch_degree, pitch_speed=90, yaw_speed=90).wait_for_completed()
+    ep_led.set_led(r=255,g=255,b=0)
+