def __init__(self, name):
# self._IdAndLoopInfo = {}
# self.__continuousLoopInfo = {}
self._loopId = 0
Car.__init__(self, name)
# self.gps.deviceInit()
print '---------------loop initial complete-----------------------------'
def __init__(self, name):
self.__i = 0
self.__j = 0
self._count = 0
self.__frontGPS = []
self.__secondGPS = []
self.__frontGPSLength = 0
self.__lastSingularLength = 0
# self._IdAndSingular = {}
# self._continuousSingular = {}
Car.__init__(self, name)
def ReInitVariant(self,_id):
Car.deviceInit(self)
xmlDeal = XMLDeal()
mapList,cog_dir,accel,V_max,time,radio,lineList= xmlDeal.importTrainRoute( r'./scenario/train_route.xml' )
print 'ReInitVariant---------------------------------------------------'
print cog_dir,accel,V_max,time,radio,lineList
print 'linemap',lineList
lineInfo = LineInfoBase('lineInfo')
lineInfo.deviceInit( varFile = r'./scenario/Line_Info.xml')
print '----------lineList-------',lineInfo.getDataValue(lineList[_id])
GpsAndOdometer._lineList = lineList
self._blockList = [int( _s ) for _s in lineInfo.getDataValue(GpsAndOdometer._lineList[_id])[2].strip().split( ',' )]
print '-------block list-----',self._blockList
self._ssaList = [int( _s ) for _s in lineInfo.getDataValue(GpsAndOdometer._lineList[_id])[1].strip().split( ',' )]
self._direction = lineInfo.getDataValue(GpsAndOdometer._lineList[_id])[0]
self._mapList = mapList
print '------direction------',self._direction
self.__cog = cog_dir
self._accel_positive = accel[0]
self._accel_negative = accel[1]
self._V_max = V_max
self._Timer = time[0]
self._smallTimer = time[1]
self._out_radio = radio[0]
self._in_radio = radio[1]
print self._blockList,self.__cog,self._accel_positive,self._accel_negative
print self._V_max,self._Timer,self._smallTimer,self._out_radio,self._in_radio
# self._block_map = self.getBlockMap()
# self._blockList = self.getBlockList()
# self._mapList = self.getMapList()
self.__ssaList = self.getSSAList()
print '------block list--------',self._blockList
self._IdAndSingular = self.getFormatSingularBlock()
# print '--------id and singular------',self._IdAndSingular
GpsAndOdometer._IdAndSSA = self.getFormatSSA()
GpsAndOdometer._continuousSSA = self.getContinuousSSA()
# print '------------id and sssa------------',self._IdAndSSA
self._continuousSingular = self.getContinuousSingular()
self.__lastSingularLength = self.getLastSingularLength()
self.__frontGPS = self.getFirstGPS()
self.__secondGPS = self.getSecondGPS()
self.__frontGPSLength = self.getFirstGPSLength()
# print '--------------blockMap------------',self._block_map
# print len(self._block_map)
# print '----id and singular-----',self._IdAndSingular
pass
def ReInitVariant(self,_id):
Car.deviceInit(self)
xmlDeal = XMLDeal()
mapList,cog_dir,accel,V_max,time,radio,lineList= xmlDeal.importTrainRoute( r'./scenario/train_route.xml' )
lineInfo = LineInfoBase('lineInfo')
lineInfo.deviceInit( varFile = r'./scenario/Line_Info.xml')
# print '----------lineList-------',lineInfo.getDataValue(lineList[_id])
self.__blockList = [int( _s ) for _s in lineInfo.getDataValue(lineList[_id])[2].strip().split( ',' )]
self._direction = lineInfo.getDataValue(lineList[_id])[0]
# print '------direction------',self._direction
# print 'loop blocklist',self.__blockList
self._IdAndLoopInfo = self.getFormatLoopInfo()
self._continuousLoopInfo = self.getContinusLoopInfo()
print '------------------------------- loop device ReInitVariant--------------------------------'
def __init__(self, prob_matrix, num_cars):
self.grid = prob_matrix
self.dim_x, self.dim_y = prob_matrix.shape
self.idle_car_list = []
self.use_car_list = []
for i in range(num_cars):
self.idle_car_list.append(Car(self.choose_rand_point()))
self.passengers = []
class TestCar(unittest.TestCase):
def __init__(self, *args, **kwargs):
self.car = Car()
unittest.TestCase.__init__(self, *args, **kwargs)
def test_turn_on(self):
self.assertTrue(self.car.turn_on())
def test_turn_of(self):
self.assertFalse(self.car.turn_off())
def test_move_without_turn_on(self):
self.assertTrue(self.car.move(1000))
def test_move(self):
self.assertTrue(self.car.turn_on())
self.assertTrue(self.car.move(1000))
def read_file(input_file):
rides = []
with open(input_file) as f:
lines = f.readlines()
_, _, cars_nb, _, bonus, time = list(map(int, lines.pop(0).split()))
for i, line in enumerate(lines):
args = list(map(int, line.split()))
rides.append(Ride(i, *args))
rides = sorted(rides, key=lambda x: x.score, reverse=True)
cars = [Car(time, bonus) for _ in range(cars_nb)]
return time, bonus, cars, rides, cars_nb
def get_vehicle(self, type):
if type == VehicleType.BUS:
return Bus()
elif type == VehicleType.CAR:
return Car()
elif type == VehicleType.MOTORCYCLE:
return Motorcycle()
elif type == VehicleType.VAN:
return Van()
else:
return None
def read_plates_from_database(self):
con = 'tablice'
conn = sqlite3.connect(con)
conn.text_factory = sqlite3.OptimizedUnicode
cur=conn.cursor()
for row in cur.execute('SELECT * FROM Tablice '):
x = row[2]
y = row[1]+" "+row[0]
u=Car(x,y)
self.cars.append(u)
def retreive_guest(self, ID): # If a guest parked before and came back to release their car, we need to retrieve their information from the guest file
f = open('437Guest.txt', 'r')
line = f.readline()
while line != '':
test = line.split()
if ID == test[4]:
car1 = Car(test[2], test[3], test[0], test[1])
p1 = Guest(test[0], test[1], car1, self, self.CarRotationManager,ID,test[5]) # ---initialize guest---
return p1
line = f.readline()
return None
class Context:
def __init__(self, physicsWorld):
pygame.init()
# constants
self.PPM = 20.0 # pixels per meter
self.TARGET_FPS = 60
self.TIME_STEP = 1.0 / self.TARGET_FPS
self.SCREEN_WIDTH = 1200
self.SCREEN_HEIGHT = 800
self.screenSize = (self.SCREEN_WIDTH, self.SCREEN_HEIGHT)
self.zoom = 1.0
self.offset = (0.0, 0.0)
self.viewCenter = (self.SCREEN_WIDTH/2, self.SCREEN_HEIGHT/2)
self.clock = pygame.time.Clock()
# core objects
self.screen = pygame.display.set_mode((self.SCREEN_WIDTH, self.SCREEN_HEIGHT))
self.world = physicsWorld
# world objects
self.terrain = Terrain(self, 0, self.SCREEN_HEIGHT/self.PPM/2, 2, 25, TerrainGenerator.Composer(1, math.pi))
self.car = Car(self, 0, 0)
self.keys = pygame.key.get_pressed()
def update(self):
self.keys = pygame.key.get_pressed()
self.terrain.update()
self.car.update()
self.world.Step(self.TIME_STEP, 10, 10)
def draw(self):
self.screen.fill((0, 0, 0, 0))
self.terrain.draw()
self.car.draw()
pygame.display.flip()
self.clock.tick(self.TARGET_FPS)
def initCars(self):
result = {}
cars_per_route = self.cars_num // self.routes_num
for i in range(self.routes_num):
# selected = [False, False, False, False]
for j in range(cars_per_route):
carID = i * cars_per_route + j
phase = j % 4
r = self.routes[i]
x, y = r.random_select(phase)
result[carID] = Car(carID, x, y, i, phase)
return result
def findCar(self, make, color, year):
'''Creates a temporary car with inputs
make, color, year. Returns True if found.
'''
cur = self.head
wantedCar = Car(make, color, year)
while cur:
if cur.car == wantedCar:
return True
else:
cur = cur.next
return False
def bookCar(self,Car,Customer):
#cost = Car.rental_fee
cost = Car.rental_fee() * Customer._rental_period
if ((Car.get_type == "Large" or Car.get_type == "Premium") and Customer.get_rental_period>7):
cost = cost * 0.95
Customer.set_total_cost(cost)
print(Customer)
print("Car Details")
print(Car)
print("Total Fee: $", cost)
print("\n")
self.add_cars_rented()
def testCalculateIntersection():
xA = 5
yA = 0
xB = 10
yB = 0
angle = 0
calculate_x_ = lambda a_: ((((yA - yB) / (xA - xB)) * xA) - yA) / ((yA - yB) / (xA - xB) - a_)
print(calculate_x_(np.tan(np.deg2rad(angle))))
print(((xA - xB) != 0) and (yA - yB) / (xA - xB) - np.tan(np.deg2rad(angle)) != 0)
print("Car output: ", Car.calculate_x_intersection([xA, yA], [xB, yB], np.tan(np.deg2rad(angle)), angle ))
def add_to_inventory(self, type, name, rank, kms_travelled, lat, lng):
#v = Vehicle(type, name, rank, kms_travelled, lat, lng)
if type == "Car":
v = Car(name, rank, kms_travelled, lat, lng)
elif type == "Bike":
v = Bike(name, rank, kms_travelled, lat, lng)
elif type == "Bus":
v = Bus(name, rank, kms_travelled, lat, lng)
else:
raise Exception("Invalid vehicle type")
self.inventory[v.name] = v
def __init__(self, canvas, lightsposition, carPosition, direction):
self.canvas = canvas
self.trafficLightImage = []
self.loadTrafficLightImages()
self.lightsposition = lightsposition
self.trafficLightImgID = self.canvas.create_image(
self.lightsposition[0],
self.lightsposition[1],
anchor=NE,
image=self.trafficLightImage[0])
self.currentLight = "R"
self.timer = 0
self.timerLabel = self.createTimerLabel()
self.startTimer()
self.car = Car(self.canvas, carPosition, direction)
self.updated = False
def mutation(old_cars):
update_lambda(iter)
new_cars = []
for old_car in old_cars:
new_cars.append(Car(copy(old_car.gen)))
for car in new_cars:
a = array(random.uniform(-lmbd, lmbd, len(car.gen)))
car.gen += multiply(car.gen, a)
check_for_repeats(new_cars + old_cars)
return new_cars
def addCar(self, make, color, year):
# temp holds our link
temp = Link(Car(make, color, year))
self.counter += 1
# testing head
if self.head == None:
# changes head to the link holder
self.head = temp
return
# handle if list is not empty
temp.setNext(self.head)
self.head = temp
def continue_as_guest(self): #Function that takes info to create a guest; then adds the info into the guest file.It returns a new Guest object.
Name = input("Please enter your name:\n")
FamilyName = input("Please enter your family name:\n")
model = input("Please enter your car model:\n")
model = self.remove_spaces(model)
platenumber = input("Please enter your car's plate number:\n")
car1 = Car(model, platenumber, Name, FamilyName)
p1 = Guest(Name, FamilyName, car1, self, self.CarRotationManager) # ---initialize guest---
print("Welcome" + " " + Name + "!")
print("Your ID number is: " + str(p1.uniqueID))
print("Remember your ID number, you must enter it back to pick up your car.")
return p1
def reset(self):
# resets the game to it's original state
self.__lives = 3
self.__score = 0
self.__car = Car(
(
GameConstants.LANE2_X,
# GameConstants.SCREEN_SIZE[1] - GameConstants.CAR_SIZE[1]),
GameConstants.SCREEN_SIZE[1] / 2),
pygame.image.load(
GameConstants.VEHICLES["SPRITE_CAR_BLUE1"])).convert_alpha()
self.__npcCars = [] # clear all cars from screen
def initializeCars(self):
self.generation = 1
self.generationRecord = []
self.maxFitRecord = []
self.minFitRecord = []
self.avgFitRecord = []
self.bestColor = []
self.cars = []
for ps in range(PopulationSize):
firstPoint = self.checkpoints[-1]
p0 = float(firstPoint.pos[0]), float(firstPoint.pos[1])
self.cars.append(Car(p0))
def main():
global car_actions
init_logger()
# Initialize the car and stop it from moving
car = Car(CAR_CONF)
car.stop()
# Define the actions that the Car supports
car_actions = {
"FORWARD": car.forward,
"REVERSE": car.reverse,
"TURN_LEFT": car.turn_left,
"TURN_RIGHT": car.turn_right,
"ACCELERATE": car.accelerate,
"DECELERATE": car.decelerate,
"STOP": car.stop
}
coro = asyncio.start_server(handle_car_data, host=HOST, port=PORT)
log.info('[HANDLE_DATA] Starting uasyncio event loop')
loop.create_task(coro)
loop.run_forever()
log.info('[HANDLE_DATA] Finishing uasyncio event loop')
loop.close()
# Stop the car to avoid crashes ;)
car.stop()
def main():
#define record and car variables
car = Car()
car.connect(port="/dev/ttyACM0")
print("Waiting to hear from vehicle...")
while (not car.connected):
time.sleep(0.05)
print('connected')
record = Record()
#have a while loop so multiple runs can be executed
while (True):
print(
"Enter a negative double to go left\nor a positive double to go right\nelse type exit to quit\n"
)
divert = (input('<< '))
try:
divert = float(divert)
except ValueError:
break
print(divert)
executeManeuver(divert, car, record)
record.close()
car.close()
def load(self, description, state=None):
"Loads object from JSON data."
self.params = description['modelParameters']
self._road.load(description['road'])
for lightId, lightData in description['trafficLights'].iteritems():
light = SimpleSemaphore(id=lightId)
lState = {}
if state is not None:
lState = state['trafficLights'][lightId]
light.load(lightData, lState)
self._lights.append(light)
if state is not None:
for carData in state['cars'].itervalues():
c = Car(model=self, road=self._road)
c.load(carData, carData)
self._cars.append(c)
for carData in state['enterQueue']:
c = Car(model=self, road=self._road)
c.load(carData, carData)
self._enterQueue.append(c)
# Fields
self.time = kts46.utils.str2timedelta(state['time'])
self._lastCarGenerationTime = kts46.utils.str2timedelta(state['lastCarGenerationTime'])
self._lastCarId = state['lastCarId']
class Anita:
Name = "Anita"
Country = ""
Hobby = ""
Height = 0
Weight = 0
MyCar = Car()
MyFlower = Flower()
MyBag = Bag()
def intro(self):
print("hello I'm" + self.Name + "my hobby is" + self.Hobby +
", my weight is " + str(self.Weight))
def __init__(self, screen):
self.name = "Let's Start"
self.car = Car(screen)
self.target = TargetOne(screen)
self.targets = []
self.backGroundImage = pygame.transform.scale(
pygame.image.load("images/png/background-1.png"),
(screen.get_width(), screen.get_height()))
self.backGroundImageY = 0
self.backGroundImageX = 0
self.screen = screen
self.speed = 1
self.endFlag = False
#2 saniyede bir hedef üretilmeli
self.pgenerateTargetTimer = pTimer(2.5, self.generateTarget, screen)
self.finishEvent = pygame.event.Event(pygame.USEREVENT,
attr1='finishEvent')
self.complatedEvent = pygame.event.Event(pygame.USEREVENT,
attr1='GameComplated')
self.gasUseTimer = pTimer(1, self.car.useGas, screen)
def on_init(self):
pygame.init()
# font 시스템 초기화
pygame.font.init()
# font 설정
self.font = pygame.font.SysFont('Raleway', 30)
# 글씨 쓰기
# 텍스트, 안티얼라이싱 여부, 색
self.text = self.font.render('Racing Car~!', False, (0, 0, 0))
# 디스플레이 모드 설정, 디스플레이 데이터를 screen이라는 변수에 담는다
self.screen = pygame.display.set_mode(self.size, 0, 16)
# 창 색깔 설정, 바꿔보세요!
self.screen.fill((255, 255, 255))
# 창 이름 설정, 바꿔보세요!
pygame.display.set_caption("Hello Pygame!")
# running flag 초기화
# flag란? 단순 참/거짓 값을 통해 프로그램을 제어하기 위한 변수
# 이 프로그램에선 running = True 일 때만 게임이 실행되도록 한다
self.running = True
# 게임의 모든 sprite를 포함하는 변수
self.sprites = pygame.sprite.Group()
# playerCar에 Car라는 sprite를 만들어 담는다.
# Car 색깔 바꿔보세요!
# EX) (255, 0, 0) -> (0, 255, 0)
self.playerCar = Car((0, 255, 0), 100, 30)
self.playerCar.rect.x = 0
self.playerCar.rect.y = 0
# playerCar를 게임 sprite 관리 그룹에 추가한다.
self.sprites.add(self.playerCar)
def create_car(gene, layers_shape):
layers = []
beg = 0
end = 0
for layer_shape in layers_shape:
beg = end
end += layer_shape[0] * layer_shape[1]
layers.append(gene[beg:end].reshape(layer_shape))
initial_position = Point(const.car_initial_x, const.car_initial_y)
initial_angle = const.car_initial_angle
initial_speed = const.car_initial_speed
brain = Brain(Network(layers))
return Car(initial_position, initial_angle, initial_speed, brain)
def __init__(self):
""" Constructs the World """
self.sky = SkyDome("Resources/Models/skydome.egg")
self.sky.sky.setScale(Vec3(10, 10, 10))
self.setupPhysX()
self.setup3DAudio()
self.car = Car(self.physxScene, self.audio3d, "defender.xml")
self.car.setActiveAudioProfile('outside')
self.setupLight()
self.initTrack()
taskMgr.add(self.simulate, 'PhysX Simulation')
# To to use Steering Wheel change inputHandler to SteeringControl
self.inputHandler = KeyControl(self.car)
#self.inputHandler = SteeringControl( self.car )
self.cameraControl = CameraControl(self.car)
self.cameraControl.enableTowerCamera()
self.speedometer = Speedometer()
render.setShaderAuto()
self.accept('escape', sys.exit)
def updateStep(self, stepNum):
for i in range(self.numRoads + 2):
if (self.EWRoad[i][1].speed >= stepNum and self.EWRoad[i][0] == 1):
cars = self.EWRoad[i - 1][0] + 1
if (cars == 2):
return 0
speed = self.EWRoad[i][1].speed
wait_time = self.EWRoad[i][1].wait_time
self.EWRoad[i - 1] = (cars, Car(wait_time, speed))
self.EWRoad[i] = (0, Car(0, 0))
for i in range(self.numRoads + 2):
if (self.NSRoad[i][1].speed >= stepNum and self.NSRoad[i][0] == 1):
cars = self.NSRoad[i - 1][0] + 1
if (cars == 2):
return 0
speed = self.NSRoad[i][1].speed
wait_time = self.NSRoad[i][1].wait_time
self.NSRoad[i - 1] = (cars, Car(wait_time, speed))
self.NSRoad[i] = (0, Car(0, 0))
if (self.EWRoad[1][0] == 1) and (self.NSRoad[1][0] == 1):
return 0
#self.updatePos()
return 1
def getElements(self):
trees = self.getTree()
cars = []
for tree in trees:
price = tree.xpath('//section[@class="used-list-vehicle"]//div[@class="used-list-price"]//p[1]//span[@class="large"]/text()')
year = tree.xpath('//section[@class="used-list-vehicle"]//table[@class="used-list-spec"]//tr[3]//td[1]/text()')
name = tree.xpath('//section[@class="used-list-vehicle"]//div[@class="used-list-right"]//h2[@class="used-left-title"]/text()')
url = tree.xpath('//section[@class="used-list-vehicle"]//div[@class="used-list-left"]//a[1]/@href')
for i in range(len(price)):
price[i] = price[i].replace(',', '')
price[i] = price[i].replace('£', '')
car = Car("Hilton", int(price[i]), int(year[i]), name[i], self.url + url[i]);
cars.append(car);
self.cars = cars
def run():
createEmptyField()
# insert Exit
placeExit("Right", EXIT_HEIGHT)
# insert cars
RedCar = Car([0, 3], "Horizontal", 2, RED_CAR_INT)
Car1 = Car([0, 5], "Horizontal", 3, 1)
Car2 = Car([4, 2], "Vertical", 3, 2)
Car3 = Car([2, 3], "Vertical", 2, 3)
Car4 = Car([1, 2], "Horizontal", 2, 4)
Car5 = Car([3, 0], "Horizontal", 2, 5)
CARSLIST.append(RedCar)
CARSLIST.append(Car1)
CARSLIST.append(Car2)
CARSLIST.append(Car3)
CARSLIST.append(Car4)
CARSLIST.append(Car5)
for car in CARSLIST:
placeCar(car)
printFieldFlipped()
# Dit is een zootje bullshit
BlokkadeList = getBlokkadeList(RED_CAR_INT, 0)
print "BlokkadeList RED_CAR: "
print BlokkadeList
# Loop the cars in the positive list
for CarNumber in BlokkadeList[0][0:-1]:
# The y of the Redcar is the height of conflict
BlokkadeList1 = getBlokkadeList(
CarNumber, CARSLIST[RED_CAR_INT].MainCoordinate[1])
print "Per auto ", CarNumber, ": BlokkadeList: "
print BlokkadeList1
# If the positive blocking list is empty move 1 in pos direction
if BlokkadeList[0][-1] != 0 and len(BlokkadeList[0]) == 1:
if canMoveCar(CarNumber, BlokkadeList1[0][-1]):
print "move pos"
moveCar(CarNumber, BlokkadeList1[0][-1])
# or if the negative blocking list is empty, move 1 in neg direction
elif (BlokkadeList[0][-1]) != 0 and len(BlokkadeList[0]) == 1:
if canMoveCar(CarNumber, BlokkadeList1[1][-1]):
print "move neg"
moveCar(CarNumber, BlokkadeList1[1][-1])
# Test voor horizontale auto die een list wil krijgen
# Car 1 moet aan de kant voor Car3, die heeft conflict x = 2
BlokkadeList = getBlokkadeList(Car1.Number, 2)
print "De BlokkadeList van 1 wanneer hij aan de kant moet voor 3 is: "
print BlokkadeList
# If the positive blocking list is empty move 1 in pos direction
if (BlokkadeList[0][-1]) != 0 and len(BlokkadeList[0]) == 1:
print "in if"
if canMoveCar(Car1.Number, BlokkadeList[0][-1]):
print "move pos"
moveCar(Car1.Number, BlokkadeList[0][-1])
def create_population(self, input_size):
self.pop = []
self.nodes = input_size
for _ in range(self.pop_size):
car = Car()
car.get_genes(self.nodes,
genes=[[[
1.3001829422392683, 0.8000856027691232,
-1.5785073281530515, -2.8647414187322386,
-0.7141955007518759, -0.3670487821346391,
-3.7998092630225644, -4.405835967094093,
2.0557444816390857, -0.09336194023387456,
-0.7266628432639095, 0.5002341909216479,
0.32317776785895425, -1.9559411100920112,
0.14616350746591955
],
[
-0.6300914796369126, -2.25749173353568,
1.4792635329477752, -0.3327470291154955,
4.9655237160018455, -1.3673537444481587,
-1.603815188875779, -3.187818364141801,
3.12763867621749
],
[
-1.125398828359506, -3.460349939960378,
3.0711242443193996
]],
[[
4.226548855181022, 4.291171140731139,
-2.424117565430474
],
[
-4.9718817032241525, -0.6808755943276221,
-4.768670702354022
], [0.9272046954287498]]])
# print("Car Genes_____", car.genes)
self.pop.append(car)
def park(self, regNo, colour):
# For this we need to get the nearest free slot
car = Car(regNo, colour)
if not self._primaryCheck():
return
nearestSlot = self.getNearestFreeSlot()
# print(nearestSlot)
if nearestSlot != None:
# Assign
self._slots[nearestSlot].car(car)
print("Allotted Slot no : {}".format(nearestSlot))
else:
# Slots are full
print("Slots are full")
return
def init(data):
data.car = Car()
data.mode = "main menu"
makeButtons(data)
# backprop variables
data.controls = np.matrix([0, 0])
data.controlTimer = data.timerDelay * 2
# genetic algorithm vairbales
data.generation = 0
data.highestFitness = 0
#data.learning = False
data.numCars = 50
data.showNeuralNetwork = False
def SendDeviceUpdateMessage(self):
"Send Device Updata Message"
while True:
# if lock.acquire():
# pass
time.sleep(Car._sTimer)
self.__count = self.__count + 1
# if self.car.getAllowStopFlag() == True:
# print '-------allow stop-------',Car._allowstop
if Car._manualStop == True:
# print '-------------manual stop----------'
_cmd = self.packAppMsgHasHead( self.loophour, self.getDataValue( 'cmdMsgId' ), self.getDataValue( 'manualStop' ))
elif Car._allowstop == True:
# print '-------------auto run-------------'
_cmd = self.packAppMsgHasHead( self.loophour, self.getDataValue( 'cmdMsgId' ), self.getDataValue( 'autoRun' ))
else:
# print '-------------cog run -------------'
_cmd = self.packAppMsgHasHead( self.loophour, self.getDataValue( 'cmdMsgId' ), self.getDataValue( 'cmdCog' ) )
self.loadDeviceDic['rs'].inQ.put( _cmd )
if self.__count == 50 :
_time = datetime.datetime.now()
print '---simmain SendDeviceUpdataMsg---',_time
self.logMes( 4, '--loophour--%d --time-- %f' % ( self.loophour, time.clock() ) )
self.__count = 0
self.loophour += 1
#给车辆发送启动命令
_cmd = self.packAppMsgHasHead( self.loophour, self.getDataValue( 'cmdMsgId' ), self.getDataValue( 'cmdStart' ) )
self.loadDeviceDic['rs'].inQ.put( _cmd )
if 0<= (self._totalMile - Car.getAmountMile()) <= 12:
print '1 stop---------------'
self.car.ReSetAmountMile()
_idList = GpsAndOdometer._lineList
if len(_idList) != 0:
self.loophour = 0
self.__count = 0
time.sleep(5)
_cmd = self.packAppMsgHasHead( self.loophour, self.getDataValue( 'cmdMsgId' ), self.getDataValue( 'cmdRepeate' ) )
self.loadDeviceDic['rs'].inQ.put( _cmd )
time.sleep(5)
self.ReInitDevice()
print '-------repeat--------'
continue
else:
_cmd = self.packAppMsgHasHead( self.loophour, self.getDataValue( 'cmdMsgId' ), self.getDataValue( 'cmdEnd' ) )
self.loadDeviceDic['rs'].inQ.put( _cmd )
def __init__(self):
""" Constructs the World """
self.sky = SkyDome( "Resources/Models/skydome.egg" )
self.sky.sky.setScale( Vec3( 10,10,10))
self.setupPhysX()
self.setup3DAudio()
self.car = Car( self.physxScene, self.audio3d, "defender.xml" )
self.car.setActiveAudioProfile( 'outside' )
self.setupLight()
self.initTrack()
taskMgr.add(self.simulate, 'PhysX Simulation')
# To to use Steering Wheel change inputHandler to SteeringControl
self.inputHandler = KeyControl( self.car )
#self.inputHandler = SteeringControl( self.car )
self.cameraControl = CameraControl( self.car )
self.cameraControl.enableTowerCamera()
self.speedometer = Speedometer();
render.setShaderAuto()
self.accept( 'escape', sys.exit )
from Car import Car
from Passenger import Passenger
from Person import Person
# Create an instance of Car with the default empty occupant list
mycar = Car( make='Kia', model='Sportage')
# Create the driver and passenger, both instances of Passenger
driver = Passenger()
driver.setName('Paul')
driver.setAge(43)
driver.setIsDriver(True)
driver.setSeatPosition(0)
passenger = Passenger()
passenger.setName('Bob')
passenger.setAge(23)
passenger.setIsDriver(False)
passenger.setSeatPosition(1)
# Create a Person object
person = Person()
person.setName('Charlie')
person.setAge(35)
# Add both our passengers
mycar.addOccupant(driver)
mycar.addOccupant(passenger)
# And then our person. The addOccupant method does not specify an object type.
# We could add some handling inside the Car class to raise an error if
#!/usr/bin/python
import time
from Car import Car
import os
car = Car(0)
directions={
"FORWARD":car.forward,
"REVERSE":car.reverse,
"STOP":car.stop,
"RIGHT":car.right,
"LEFT":car.left
}
dt=os.stat("/home/pi/sacredsf-projects/car/direction.txt").st_mtime
while(True):
poll=os.stat("/home/pi/sacredsf-projects/car/direction.txt").st_mtime
fd = open("/home/pi/sacredsf-projects/car/direction.txt",'rw')
direction=fd.read()
if(poll == dt and (direction=="LEFT" or direction=="RIGHT")):
#no change, so just go forward
direction = "FORWARD"
if(poll!=dt):
dt=poll
direction=direction.strip()
sh=open("/home/pi/sacredsf-projects/car/speed.txt")
speed = int(sh.read())
car.setSpeed(speed)
def __init__(self, *args, **kwargs):
self.car = Car()
unittest.TestCase.__init__(self, *args, **kwargs)
class World( DirectObject ):
""" Dynamic world """
def __init__(self):
""" Constructs the World """
self.sky = SkyDome( "Resources/Models/skydome.egg" )
self.sky.sky.setScale( Vec3( 10,10,10))
self.setupPhysX()
self.setup3DAudio()
self.car = Car( self.physxScene, self.audio3d, "defender.xml" )
self.car.setActiveAudioProfile( 'outside' )
self.setupLight()
self.initTrack()
taskMgr.add(self.simulate, 'PhysX Simulation')
# To to use Steering Wheel change inputHandler to SteeringControl
self.inputHandler = KeyControl( self.car )
#self.inputHandler = SteeringControl( self.car )
self.cameraControl = CameraControl( self.car )
self.cameraControl.enableTowerCamera()
self.speedometer = Speedometer();
render.setShaderAuto()
self.accept( 'escape', sys.exit )
# To turn on physx visual debugging, uncomment below
#self.enablePhysxDebug()
def initTrack(self):
""" Loads the track model and the collision model for it. """
kitchen = PhysxKitchen()
trackCollision = loader.loadModel( "Resources/Models/TrackCollision.egg" )
fenceCollision = loader.loadModel( "Resources/Models/FenceCollision.egg")
self.track = loader.loadModel( "Resources/Models/Track.egg" )
triMeshDesc = PhysxTriangleMeshDesc()
triMeshDesc.setFromNodePath( trackCollision )
triMesh = kitchen.cookTriangleMesh( triMeshDesc )
triMeshShapeDesc = PhysxTriangleMeshShapeDesc()
triMeshShapeDesc.setMesh( triMesh )
triMeshDesc2 = PhysxTriangleMeshDesc()
triMeshDesc2.setFromNodePath( fenceCollision )
triMesh2 = kitchen.cookTriangleMesh( triMeshDesc2 )
triMeshShapeDesc2 = PhysxTriangleMeshShapeDesc()
triMeshShapeDesc2.setMesh( triMesh2 )
actor = PhysxActorDesc()
actor.setName( 'trackcollision' )
actor.addShape( triMeshShapeDesc )
actor.addShape( triMeshShapeDesc2 )
self.physxtrack = self.physxScene.createActor( actor )
self.track.reparentTo( render )
loader.loadModel( "Resources/Models/Fence.egg" ).reparentTo( self.track )
loader.loadModel( "Resources/Models/Rocks.egg" ).reparentTo( self.track )
linfog = Fog( "Fog" )
linfog.setColor( Vec4( 0.8, 0.85, 0.8, 1 ) )
linfog.setExpDensity( 0.003 )
self.track.attachNewNode(linfog)
render.setFog(linfog)
def enablePhysxDebug(self):
""" Turns on physx visual debuggging """
self.debugNP = render.attachNewNode(self.physxScene.getDebugGeomNode())
self.debugNP.node().on()
self.debugNP.node().visualizeWorldAxes(True)
def setupPhysX(self):
""" Sets up the physx world """
self.physx = PhysxManager.getGlobalPtr()
sceneDesc = PhysxSceneDesc()
sceneDesc.setGravity(Vec3(0, 0, -9.81))
self.physxScene = self.physx.createScene(sceneDesc)
mGround = self.physxScene.getMaterial( 0 )
mGround.setRestitution(0.0)
mGround.setStaticFriction(0.8)
mGround.setDynamicFriction(0.2)
def setup3DAudio(self):
""" Initializes the 3D audio manager """
self.audio3d = Audio3DManager( base.sfxManagerList[0], base.cam )
def setupLight(self):
""" Sets up the scene lighting """
ambient_source = AmbientLight('ambient')
ambient_source.setColor(Vec4( 0.6, 0.65, 0.7, 1 ))
ambient = render.attachNewNode(ambient_source.upcastToPandaNode())
render.setLight( ambient )
sun = render.attachNewNode( DirectionalLight( 'sun' ) )
sun.node().setScene( render )
render.setLight( sun )
sun.reparentTo( self.car.chassisModel )
sun.setH( -60 )
sun.setP( -60 )
sun.setPos( 0, 0, 10 )
sun.node().getLens().setFov( 70 )
sun.node().getLens().setNearFar( 1, 20 )
sun.node().getLens().setFilmSize( 16, 16 )
sun.node().setColor( Vec4( 1, 0.96, 1, 1 ))
sun.node().setShadowCaster( True )
self.sun = sun
def simulate(self, task):
""" Simulation loop, called every frame """
dt = globalClock.getDt()
self.physxScene.simulate(dt)
self.physxScene.fetchResults()
self.car.simulate(dt)
self.cameraControl.simulate(dt)
self.sun.setH( render, -60 )
self.sun.setP( render, -60 )
self.speedometer.updateSpeedometer( self.car.speed )
self.inputHandler.simulate( dt )
return task.cont
file_size = os.path.getsize('/home/pi/motion/lastsnap.jpg')
print(file_size)
self.request.sendall(bytes(str(file_size), 'utf8'))
with open('/home/pi/motion/lastsnap.jpg', 'rb')as fin:
r = fin.read(block_size)
while r:
self.request.send(r)
r = fin.read(block_size)
elif oper:
my_car.exec_operation(int(oper))
else:
pass
except TimeoutError:
print("a client quited")
break
if __name__ == '__main__':
server = None
my_car = None
try:
cf = read_config()
my_car = Car(cf)
cam = CamMotion(cf['cam_server_ip']['control_port'])
cam.check()
server = TCPServer(('', 8001), ResponseHandler)
server.serve_forever()
except KeyboardInterrupt:
my_car.disconnect()
server.server_close()
import numpy as np
import time
from Car import Car, angle_diff
car = Car()
distance = 200
# finds the zero value by doing a first order fit
def find_zero(x,y):
m,b=np.polyfit(x,y,1)
return -b/m
def test_steering_angle(steering):
start_heading = car.dynamics.heading
car.forward(distance, fixed_steering_us = steering)
after_forward_heading = car.dynamics.heading
car.forward(-distance, fixed_steering_us = steering)
after_reverse_heading = car.dynamics.heading
forward_diff = angle_diff(start_heading, after_forward_heading)
reverse_diff = angle_diff(after_forward_heading, after_reverse_heading)
print 'steering: {} fwd_diff: {} rev dif: {} '.format(steering, forward_diff, reverse_diff)
return forward_diff, reverse_diff
steering_input = range(1440, 1480, 10)
forward_results = []
reverse_results = []
for steering in steering_input:
(forward_result, reverse_result) = test_steering_angle(steering)
forward_results.append(forward_result)
reverse_results.append(reverse_result)
fuel_price_x = input("Price in euro for 1 liter of fuel(e.g: 1.175): ")
fuel_price = float(fuel_price_x)
fuel_efficiency_x = input("How much km with 1 liter of fuel ? ")
fuel_efficiency = int(fuel_efficiency_x)
kw_x = input("KW: ")
kw = int(kw_x)
euro_type_x = input("Euro(0-6) insert a number between 0 and 6: ")
euro_type = int(euro_type_x)
km_year_x = input("How much km for year do you thik to drive ? ")
km_year = int(km_year_x)
car2 = Car(name, fuel, fuel_price, fuel_efficiency, kw, euro_type)
fuel_cost_year = '%.2f' % car2.fuelYearCost(km_year)
#bollo = '%.2f' % float(car2.bollo())
b = car2.bollo()
#print("b ---> ",b)
#print(type(b))
#print("The price of drive car tax: ", bollo)
total_cost = '%.2f' % (float(fuel_cost_year) + float(b))
#print("Total cost maintenance/year (fuel + drive car tax) is: ", total_cost)
bo = str(b)
tot = str(total_cost)
fu = str(fuel_cost_year)
print "socket successfully created"
# reserve port and host
host = '' # host is self; "server"
port = 12345
# bind port
s.bind((host, port))
print "socket binded to %s" %(port)
# put socket into listening mode
s.listen(5)
print "socket is listening"
# Create Instance of Car
car = Car()
# endless loop
while True:
# establish connection with client
c, addr = s.accept()
print 'Got connection from', addr
data = c.recv(1024)
if not data or str(data) == "exit":
break
else:
print str(data)
# send a thank you message to the client
c.send('thank you for connecting ')
temp = ""
