Пример #1
0
class Bot:
    def __init__(self):
        self.wheels = Wheels()
        pass

    def move(self, left, right, time):
        self.wheels.move(left, right, time)
Пример #2
0
    def __init__(self, scanInterval=0.1):
        self.sensors = DistanceSensors()
        self.robot = Wheels()

        self.previousDistance = -1.0
        self.previousDirection = Direction.Stop
        self.stuckCount = 0

        # start distance scanning
        if not (self.sensors.StartScanner(scanInterval, True)):
            raise SensorException("Distance sensors not working")
Пример #3
0
 def start_wheels(self):
     """Start the Wheels Process"""
     self.ns.target_steering = SteeringDirection.NONE
     self.ns.target_throttle = 0
     # Create class and process
     self.wheels = Wheels(self.ns)
     self._start_process("wheels")
Пример #4
0
 def __init__(self, manufacturer):
     # the names list contains model from Specialized bikes as I am a huge fan of its bikes (I own one! :-))
     names = [
         "Pitch", "Epic", "Source", "Enduro", "Fatboy", "Status", "Demo",
         "Tarmac", "Allez", "Venge", "Shiv", "Roubaix", "Secteur",
         "Diverge", "Awol", "Crux", "Langster", "Sirrus", "Daily",
         "Crosstail", "CossRoads", "Expedition"
     ]
     self.frame = Frames(1)
     self.wheels = Wheels(1)
     self.manufacturer = manufacturer
     self.model_name = choice(names)
     self.weight = (self.frame.frame_weight +
                    2 * self.wheels.wheel_weight) / 1000.0
     self.cost = self.frame.frame_cost + 2 * self.wheels.wheel_cost
Пример #5
0
 def __init__(self):
     self.wheels = Wheels()
     pass
Пример #6
0
import sys
import RPi.GPIO as GPIO
from wheels import Wheels

GPIO.setmode(GPIO.BCM)

robot = Wheels()
robot.Stop()

GPIO.cleanup()
Пример #7
0
        return self.age

    def getSpeed(self):
        return self.speed

    #A method to increase/decrease speed. Time is in seconds
    #Amount is the speed increase per second in km/h
    def accelerate(self, time, amount):
        i = 0

        #increase speed as time X amount
        while i < time:
            self.speed += amount
            if (self.speed >= self.maxSpeed):
                self.speed = self.maxSpeed
                break
            i += 1


newTreds = Wheels()
newTreds.changeTire(0, 10)
newTreds.changeTire(1, 10)
newTreds.changeTire(2, 10)
newTreds.changeTire(3, 10)
lancer = Car("lancer", newTreds, "LPG", "2L", "Auto", "Burgandy", 145)
print(lancer)
lancer.accelerate(10, 20)
print(lancer.getSpeed())
print(lancer.wheels)
newTreds.changeTire(0, -1)
print(lancer.wheels)
Пример #8
0
from boat import Boat
from car import Car
from engine import Engine
from gas_tank import GasTank
from solar_car import SolarCar
from wheels import Wheels


def drive(driveable):
    driveable.get_wheels_count()
    driveable.turn('Right')
    driveable.accelerate()
    driveable.turn('Right')
    driveable.brake()


if __name__ == '__main__':
    car = Car(GasTank(60), Engine(80), Wheels(4))
    solarCar = SolarCar(GasTank(50), Engine(120), Wheels(8))
    boat = Boat(GasTank(900), Engine(200), Wheels(0))

    for i in [boat, car, solarCar]:
        drive(i)
Пример #9
0
class AutoRobot:
    def __init__(self, scanInterval=0.1):
        self.sensors = DistanceSensors()
        self.robot = Wheels()

        self.previousDistance = -1.0
        self.previousDirection = Direction.Stop
        self.stuckCount = 0

        # start distance scanning
        if not (self.sensors.StartScanner(scanInterval, True)):
            raise SensorException("Distance sensors not working")

    def GetDistanceToNextObstacle(self):
        '''
        Returns the remaining direction, distance in CMs in the current direction of travel
        Returns space in forward direction if stopped or rotating 
        '''
        distance = -1.0
        if self.robot.direction == Direction.Forward or self.robot.direction == Direction.Stop or \
            self.robot.direction == Direction.SpinLeft or self.robot.direction == Direction.SpinRight:
            distance = self.sensors.frontDistance[ServoDirection.Ahead]
        elif self.robot.direction == Direction.Reverse:
            distance = self.sensors.backDistance[ServoDirection.Ahead]
        elif self.robot.direction == Direction.ForwardRight:
            distance = self.sensors.frontDistance[ServoDirection.OffRight]
        elif self.robot.direction == Direction.ForwardLeft:
            distance = self.sensors.frontDistance[ServoDirection.OffLeft]
        elif self.robot.direction == Direction.ReverseLeft:
            distance = self.sensors.backDistance[ServoDirection.OffLeft]
        elif self.robot.direction == Direction.ReverseRight:
            distance = self.sensors.backDistance[ServoDirection.OffRight]
        elif self.robot.direction == Direction.MoveRight:
            distance = self.sensors.frontDistance[ServoDirection.Right]
        elif self.robot.direction == Direction.MoveLeft:
            distance = self.sensors.frontDistance[ServoDirection.Left]
        return self.robot.direction, distance

    def GetFurthestEnd(self):
        '''
        Returns direction, distance
        Work out if there is more space infront or behind and ignore sides
        '''
        if self.sensors.backDistance[
                ServoDirection.Ahead] > self.sensors.frontDistance[
                    ServoDirection.Ahead]:
            print("Furthest = Reverse",
                  self.sensors.backDistance[ServoDirection.Ahead])
            return Direction.Reverse, self.sensors.backDistance[
                ServoDirection.Ahead]
        else:
            print("Furthest = Forward",
                  self.sensors.frontDistance[ServoDirection.Ahead])
            return Direction.Forward, self.sensors.frontDistance[
                ServoDirection.Ahead]

    def GetMaxDistanceDirection(self):
        '''
        Returns servo end, servo direction, distance
        Returns the sensor direction with the most space and what that distance is
        '''
        maxRearDistance = max(self.sensors.backDistance.values())
        maxFrontDistance = max(self.sensors.frontDistance.values())

        if maxRearDistance > maxFrontDistance:
            res = [
                key for key in self.sensors.backDistance
                if self.sensors.backDistance[key] >= maxRearDistance
            ]
            if abs(self.sensors.backDistance[ServoDirection.Ahead] -
                   maxRearDistance) < 10:
                return ServoEnd.Back, ServoDirection.Ahead, self.sensors.backDistance[
                    ServoDirection.Ahead]
            else:
                return ServoEnd.Back, res[0], maxRearDistance
        else:
            res = [
                key for key in self.sensors.frontDistance
                if self.sensors.frontDistance[key] >= maxFrontDistance
            ]
            if abs(self.sensors.frontDistance[ServoDirection.Ahead] -
                   maxFrontDistance) < 10:
                return ServoEnd.Front, ServoDirection.Ahead, self.sensors.frontDistance[
                    ServoDirection.Ahead]
            else:
                return ServoEnd.Front, res[0], maxFrontDistance

    def GetMinDistanceDirection(self):
        '''   
        Returns servo end, servo direction, distance
        Returns the sensor direction with the most space and what that distance is
        '''
        minRearDistance = min(self.sensors.backDistance.values())
        minFrontDistance = min(self.sensors.frontDistance.values())

        if minRearDistance < minFrontDistance:
            res = [
                key for key in self.sensors.backDistance
                if self.sensors.backDistance[key] <= minRearDistance
            ]
            return ServoEnd.Back, res[0], minRearDistance
        else:
            res = [
                key for key in self.sensors.frontDistance
                if self.sensors.frontDistance[key] <= minFrontDistance
            ]
            return ServoEnd.Front, res[0], minFrontDistance

    def SetSpeedBasedOnDistance(self, distance):
        '''
        Set speed based on space infront of us
        Return the current speed
        '''
        if distance < 20.0:
            self.robot.Stop()
        elif distance < 40.0:
            self.robot.Speed(40)
        elif distance < 60.0:
            self.robot.Speed(50)
        elif distance < 100.0:
            self.robot.Speed(80)
        else:
            self.robot.Speed(100)
        return self.robot.robotspeed

    def RotateToBiggestSpace(self):
        ''' 
        Returns direction, distance in new direction of travel
        Rotates so either front or rear is pointing to biggests space.
        '''
        attempts = 5
        preferredDirection = self.GetMaxDistanceDirection()

        while attempts > 0:  # repeat until the front or back is pointing to the biggest space
            print("rotating, biggest space is ", preferredDirection)

            self.robot.Speed(70)

            # work out whether to spin right or left
            if (preferredDirection[0] == ServoEnd.Front and
                (preferredDirection[1] == ServoDirection.OffRight or preferredDirection[1] == ServoDirection.Right)) or \
                (preferredDirection[0] == ServoEnd.Back and
                (preferredDirection[1] == ServoDirection.OffLeft or preferredDirection[1] == ServoDirection.Left)):
                print("spin right")
                self.robot.SpinRight()
            else:
                print("spin left")
                self.robot.SpinLeft()

            if ServoDirection.OffLeft or ServoDirection.OffRight:
                time.sleep(0.5)  # rotate a bit
            else:
                time.sleep(1.0)  # rotate a lot
            self.robot.Stop()

            # reassess where the biggest space is
            preferredDirection = self.GetMaxDistanceDirection()

            # if the best direction is forward or reverse don't spin and return
            if preferredDirection[1] == ServoDirection.Ahead or \
                preferredDirection[1] == ServoDirection.OffLeft or \
                preferredDirection[1] == ServoDirection.OffRight:
                print("direction chosen", preferredDirection)
                if preferredDirection[0] == ServoEnd.Front:
                    return Direction.Forward, preferredDirection[2]
                else:
                    return Direction.Reverse, preferredDirection[2]

            # wait to get new set of distance readings
            time.sleep(1)
            attempts -= 1
        raise StuckException("cannot rotate out of trouble giving up")

    def AreWeStuck(self, direction, distance):
        '''
        Returns True if we haven't moved in the last four checks for being stuck
        '''
        if abs(
                distance - self.previousDistance
        ) < 1.0 and direction == self.previousDirection and direction != Direction.Stop:
            self.stuckCount += 1
            if self.stuckCount == 4:
                print("Stuck!")
                return True
        else:
            self.stuckCount = 0
        return False

    def UpdatePosition(self, direction, distance):
        '''
        Record our current location we we can determine later if we are stuck
        '''
        self.previousDirection = direction
        self.previousDistance = distance

    def GetNearestObstacleInDirectionOfTravel(self, currentDirection):
        '''
        Find out how far away we are from any obstacle directly infront of our direction of travel
        '''
        nearestObstacle = self.GetMinDistanceDirection()
        if nearestObstacle[0] == ServoEnd.Front:
            obstacleGeneralDirection = Direction.Forward
        else:
            obstacleGeneralDirection = Direction.Reverse
        if obstacleGeneralDirection != currentDirection:
            return 1000.0
        return nearestObstacle[2]
Пример #10
0
from boat import Boat
from car import Car
from engine import Engine
from gas_tank import GasTank
from solar_car import SolarCar
from wheels import Wheels


def test_drive(driveable):
    driveable.get_wheels_count()
    driveable.turn('Ліво')
    driveable.accelerate()
    driveable.turn('Ліво')
    driveable.brake()


if __name__ == '__main__':
    car = Car(GasTank(29), Engine(35), Wheels(4))
    solarCar = SolarCar(GasTank(10), Engine(25), Wheels(4))
    boat = Boat(GasTank(58), Engine(36), Wheels(0))

    vehicles = [boat, car, solarCar]

    for i in vehicles:
        test_drive(i)
Пример #11
0
class Car:
    engine = Engine()  # подключаем двигатель
    transmission = Transmission()  # подключаем КП
    wheels = Wheels()  # подключаем колёса

    def __init__(self):
        self.path = 0
        self.power = False
        self.gasoline = 0.0
        self.oil = 0.0
        self.speed = 0.0
        self.__time_start = 0

    def __repr__(self):
        self.transforms()
        return "Данные автомобиля и поездки:\n" \
               "\tзапущен = %s\n" \
               "\tуровень топлива = %s л.\n" \
               "\tуровень масла = %s %%\n" \
               "\tскорость = %s км/ч\n" \
               "\tпройденый путь = %s км" % (self.power, self.gasoline, self.oil, self.speed, self.path)

    def transforms(self):  # соединение классов, получение данных для вывода
        self.engine.time = self.power * (time.time() - self.__time_start)
        self.transmission.turns_engine = self.engine.turns_engine()
        self.wheels.turns_wheels = self.transmission.clutch_pedal()
        self.power = self.engine.power
        self.gasoline = self.engine.gasoline
        self.oil = self.transmission.oil * 100
        self.get_speed()
        self.path = self.wheels.transform_path()

    def turn_on(self):  # включить двигатель, начинаем отсчёт времени
        try:
            self.engine.start_engine()
        except Exception as e:
            print("Авто не поедет, пока есть проблемы:\n %s" % e)
        else:
            self.__time_start = time.time()
            print("Вжжжжжжжж-чух-чух-чух-чух")

    def turn_off(self):  # выключить двигатель
        self.engine.stop_engine()
        print("Двигатель выключен")

    def add_gasoline(self, litres):  # добавить топлива
        self.engine.add_gasoline(litres)
        print("Машина заправлена. Всего в баке %s литров бензина" %
              self.engine.gasoline)

    def add_oil(self):  # восстановить масло
        self.transmission.add_oil()
        print("Ты зашёл на ближайшую СТО и поменял масло. Какой молодец ^_^ ")

    def change_speed(self,
                     gas=engine.gas,
                     gear=transmission.gear):  # изменить скорость
        self.transmission.gear = gear
        self.engine.gas = gas
        print(
            "Теперь ты едешь на %s передаче и нажал газ на %s градусов. Какой молодец ^_^ "
            % (self.transmission.gear, self.engine.gas))

    def get_speed(self):  # расчитать скорость
        try:
            self.speed = self.engine.rpm * self.transmission.gear * self.wheels.wheel * 60
        except Exception:
            self.speed = 0
        return self.speed
Пример #12
0
pig = pigpio.pi()

def input_char(message):
    try:
        win = curses.initscr()
        win.addstr(0, 0, message)
        while True:
            ch = win.getch()
            if ch in range(32, 127): break
            time.sleep(0.05)
    except: raise
    finally:
        curses.endwin()
    return chr(ch)

wheels = Wheels(pig, left_servo_pin, right_servo_pin)

s = 22

def forward():
    set_speeds(s,s)

def backward():
    set_speeds(-s, -s)

def left():
    set_speeds(0, s)

def right():
    set_speeds(s, 0)
Пример #13
0
from sensors import Sensor
from sensors import Sensors
from wheels import Wheel
from wheels import MockWheel
from wheels import Wheels
import RPi.GPIO as GPIO
from runtime import Runtime
from processor import Processor

GPIO.setmode(GPIO.BOARD)

sensor1 = Sensor(11, 13)
sensor3 = Sensor(15, 16)
sensor5 = Sensor(18, 19)
sensor6 = Sensor(21, 22)
sensor8 = Sensor(23, 24)
sensor10 = Sensor(26, 29)

leftMotor = Wheel(5, 3, 7, 7)
rightMotor = Wheel(8, 10, 12, 1)
# rightMotor = MockWheel("rightWheel")

zrobot_runtime = Runtime(
    Sensors([sensor1, sensor3, sensor5, sensor6, sensor8, sensor10]),
    Processor(), Wheels(leftMotor, rightMotor))
zrobot_runtime.start()
Пример #14
0
import sys
import RPi.GPIO as GPIO
from wheels import Wheels
from ultrasonic import DistanceSensors

GPIO.setmode(GPIO.BCM)
sensors = DistanceSensors()
sensors.StartScanner(0.2)

robot = Wheels()
x = 's'

try:
    while x != 'e':
        x=input()

        if x =='f':
            robot.Forward()
        elif x == 'b':
            robot.Backward()
        elif x == 's' or x == '0':
            robot.Stop()
        elif x == 'l':
            robot.SpinLeft()
        elif x == 'r':
            robot.SpinRight()
        elif x == 'mr':
            robot.MoveRight()
        elif x == 'ml':
            robot.MoveLeft()
        elif x == 'fr':