def __init__(self):
# Storing the engines of this car
self.__leftengine = Engine('A')
self.__rightengine = Engine('B')
self.__leftled = Light.Light('D')
self.__rightled = Light.Light('C')
self.__distance_sensor = DistanceSensor(17, 4)
# Storing the distance between the centers of the cars
# TODO measure width and gearratio
self.__widthcar = 20.
self.__gearratio = 1. / 3.
# Storing the perimeter of the wheels (2*pi*r)
self.__perimeter = 2 * math.pi * 2.579
print 'initing Controller'
ControllerCommands.init(self.__leftengine, self.__rightengine,
self.__distance_sensor, self.__perimeter,
self.__gearratio, self.__widthcar,
self.__leftled, self.__rightled)
print 'Controller inited'
# Storing a reference to a brickpi thread
self.__io = IO_Thread([self.__leftengine, self.__rightengine],
[self.__distance_sensor],
[self.__leftled, self.__rightled])
self.__command_going = False
self.__command_thread = None
self.__parcours = None
def __init__(self, FPGAReader):
DemoEngine.SceneBase.__init__(self, 800, 480)
#Lock colors:
lockScreen = pygame.Surface(self.LockSize)
self.lock = Lock.Lock(lockScreen, self)
#Random bits:
rand = pygame.Surface(self.RandomBitsSize)
self.randScreen = RandScreen.RandScreen(rand, FPGAReader, self)
randT = pygame.Surface(self.RandomTitleSize)
self.randTitle = RandScreenButtons.RandScreenButtons(
randT, self.randScreen, self, self.RandomTitlePos)
#Live data:
liveScreen = pygame.Surface(self.LiveSize)
self.liveData = LiveData.LiveData(liveScreen, FPGAReader, self)
#Graph:
graphScreen = pygame.Surface(self.GraphSize)
self.graph = Graph.Graph(graphScreen, FPGAReader, self, self.GraphPos)
#Bounds button:
boundScreen = pygame.Surface(self.BoundButSize)
self.boundButton = BoundButton.BoundButton(boundScreen, FPGAReader,
self)
#ROSel:
RSScreen = pygame.Surface(self.RSSize)
self.RS = RS.RS(RSScreen, FPGAReader, self)
#Lock light:
lockLightScreen = pygame.Surface(self.LockLightSize)
self.lockLight = Light.Light(lockLightScreen, 'Lock',
FPGAReader.getLock, self)
#Not found light:
nfLightScreen = pygame.Surface(self.NFLightSize)
f = lambda: not (FPGAReader.getFound())
self.nfLight = Light.Light(nfLightScreen, 'Found', f, self)
#FPGA reader:
self.FPGAReader = FPGAReader
def __init__(self, arrivalRates, travelMatrix, capacity, flow,
signalTimings, timeLimit, synchronous, seed):
random.seed(seed)
rng = RandomNumberGenerator.RandomNumberGenerator(seed)
self.output = []
self.carsInSystem = 0
self.id = 0
self.finished = False
self.timeLimit = timeLimit
self.arrivalRates = arrivalRates
self.signalTimings = signalTimings
self.flow = flow
self.capacity = capacity
self.time = 0
self.eventList = PQ.PriorQ()
self.travelMatrix = travelMatrix
self.lights = [Light.Light(self.signalTimings[i]) for i in range(19)]
self.randomNumbers = []
self.arrivalIndex = {
0: 0,
1: 1,
2: 2,
5: 3,
6: 4,
9: 5,
10: 6,
13: 7,
16: 8,
17: 9,
18: 10
}
self.rngCounter = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
for i in range(20000):
self.randomNumbers.append(rng.GetRandList())
if synchronous:
for i in [0, 3, 4, 7, 8, 11, 12, 13, 14, 18]:
self.lights[i].setState(1)
else:
for i in [1, 2, 4, 7, 9, 10, 12, 13, 14, 18]:
self.lights[i].setState(1)
self.lanes = [
Lane.Lane(self.capacity[i], self.lights[i]) for i in range(19)
]
for lane in self.arrivalRates:
self.scheduler(
self.time - math.log(self.randomNumbers[self.rngCounter[
self.arrivalIndex[lane]]][self.arrivalIndex[lane]]) /
self.arrivalRates[lane], "System Arrival", lane)
self.rngCounter[self.arrivalIndex[lane]] += 1
for i in range(19):
self.scheduler(self.lights[i].getNextChange(), "Light Change", i)
self.intersections = {
0: (0, 1, 2, 3),
1: (4, 5, 6, 7),
2: (8, 9, 10, 11),
3: (12, 99, 13, 14),
4: (15, 16, 17, 18)
}
def getLight(self, n):
returnValue = libpanda._inPkJyoxj1p(self.this, n)
import Light
returnObject = Light.Light(None)
returnObject.this = returnValue
if returnObject.this == 0:
return None
returnObject.userManagesMemory = 1
return returnObject
def __init__(self):
self.PWM = Motor()
self.servo = Servo()
self.led = Led()
self.ultrasonic = Ultrasonic()
self.buzzer = Buzzer()
self.adc = Adc()
self.light = Light()
self.infrared = Line_Tracking()
self.tcp_Flag = True
self.sonic = False
self.Light = False
self.Mode = 'one'
self.endChar = '\n'
self.intervalChar = '#'
def getSample():
""" No args. Get a sample of Temp+Humidity & Light. Discard it. Wait half a second
"""
Temp.Temp()
Light.Light()
time.sleep(0.5)
# Get 5 samples delayed 0,1 sec each to get the average
t, h, l = 0, 0, 0
for i in range(5):
x, y = Temp.Temp()
z = Light.Light()
t = t + x
h = h + y
l = l + z
time.sleep(0.1)
t = t / 5
h = h / 5
l = l / 5
l = abs(l - 1023)
# print "Temperature: ", t, " Humidity:", h,"%", "Light:", l
return [t, h, l]
def __init__(self, *args):
self.objects = {None: []}
self.textures = {}
self.gl_textures = {}
self.materials = {}
self.lights = []
self.options = SceneOptions() # apply default options
self.materials[None] = Material() # setup default material
self.Add(args)
if len(self.lights) == 0: # add default light
self.Add(
Light(type=POINT).Move(*(self.options.size, ) *
3).Name('DefaultLight'))
if not self.ambient_light:
self.Add(
Light(type=AMBIENT,
intensity=self.options.ambient_intensity).Name(
'DefaultAmbientLight'))
def checkLight(test=False):
"""Check if lights should be on or off
Args:
test: flag for testing system
Returns:
None
Raises:
None
"""
# Get times from env and split into components
s = env['lights']['On']
e = env['lights']['Off']
state = determineState(s, e)
l = Light()
if state:
l.set_on(test)
pass
else:
l.set_off(test)
pass
def checkLight(test=False):
# Get times from env and split into components
s=env['Lights']['On']
s=s.split(':')
e=env['Lights']['Off']
e=e.split(':')
# Munge date into times
t=datetime.now()
st=t.replace(hour=int(s[0]), minute=int(s[1]), second=int(s[2]))
et=t.replace(hour=int(e[0]), minute=int(e[1]), second=int(e[2]))
if test:
print "Start Time: ", st
print "End Time: ", et
l=Light()
msg="Lights should be On"
if (st < datetime.now()) and (et > datetime.now()):
l.setLightOn()
else:
msg="Lights should be Off"
l.setLightOff(test)
if test:
print msg
def checkLight(self):
"""Check if lights should be on or off
Args:
test: flag for testing system
Returns:
None
Raises:
None
"""
# Move import here so can trap if fails
# couchdb library does not seem to load when initially starting
self._logger.debug("In checkLight")
import Light
# Get times from env and split into components
s = env['lights']['On']
e = env['lights']['Off']
state = self.determineState(s, e)
l = Light.Light(self._logger)
if state:
l.set_on(test)
return "On"
else:
l.set_off(test)
return "Off"
tLights = []
edges = []
allTLIds = []
isAmbulancePresent = False
delayTime = 0
while step < 455:
if isAmbulancePresent:
if last != traci.vehicle.getRoadID(ambulanceID):
last = traci.vehicle.getRoadID(ambulanceID)
if last[0] != ":":
edges.append(last)
elif last[1:len(last) - 2] in allTLIds:
tLights.append(
Light.Light(edges[len(edges) - 1], last[1:len(last) - 2]))
elif last[1:len(last) - 3] in allTLIds:
tLights.append(
Light.Light(edges[len(edges) - 1], last[1:len(last) - 3]))
if traci.vehicle.getRoadID(ambulanceID) == endEdge:
initialTime = step
print(f'Initial Completion Time = {step}')
delayTime = 0
isAmbulancePresent = False
if step == 100:
isAmbulancePresent = True
tm.addAmbulance(ambulanceID, routeID, viewID, startEdge, endEdge)
allTLIds = traci.trafficlight.getIDList()
edges.append(startEdge)
def _addLight(self):
l = Light(self._canvas, self._lx.get(), self._ly.get())
self._world.addLight(l)
pixels = numpy.roll(px, (1, 2), (0, 1))
return pixels
#CREACIÓN DEL CONTENEDOR DE LA IMAGEN
i = Image.new("RGB", (500, 500), (0, 0, 0))
px = numpy.array(i)
#CARGA DE IMAGEN
#im_file = Image.open("BackWhite.png") VERSIÓN FONDO BLANCO
im_file = Image.open("Back.png")
ref = numpy.array(im_file)
#FUENTES DE LUZ
fuentesDeLuz = [
Light(128, 133, (153, 0, 102), 0.3),
Light(220, 448, (0, 0, 150), 0.3),
Light(373, 224, (155, 155, 155), 0.3)
]
#PAREDES, su orden afecta funcionamiento
walls = [
Bound(14, 23, 173, 23, True, (96, 57, 34)), #H2
Bound(14, 23, 14, 256, True, (96, 57, 34)), #V2
Bound(14, 256, 77, 256, True, (96, 57, 34)), #H1
Bound(77, 256, 77, 483, True, (96, 57, 34)), #V2
Bound(77, 483, 362, 483, True, (96, 57, 34)), #H1
Bound(362, 333, 362, 483, True, (96, 57, 34)), #V1
Bound(362, 333, 488, 333, True, (96, 57, 34)), #H1
Bound(488, 23, 488, 333, True, (96, 57, 34)), #V1
Bound(267, 23, 488, 23, True, (96, 57, 34)), #H2
def add_light(self):
light = Light(self.display, color=(0, 0, 0))
obj = Object_Instance(light=light, id=self.id_counter)
self.scene.add_instance(obj)
self.id_counter += 1
def initPanels(self):
for i in range(NUM_PANEL_LIGHTS):
self.cave_panel_lights[i] = Light(i + 1)
def generate(self):
self.shader = ShaderProgram("./shaders/vs.glsl", "./shaders/fs.glsl")
self.shader.addUniform("screen_dim")
self.shader.addUniform("mat_transform")
self.shader.addUniform("mat_projection")
self.shader.addUniform("mat_view")
self.cubeShader = ShaderProgram("./shaders/cube_vs.glsl",
"./shaders/cube_fs.glsl")
self.cubeShader.addUniform("mat_transform")
self.cubeShader.addUniform("mat_projection")
self.cubeShader.addUniform("mat_view")
self.lightShader = ShaderProgram("./shaders/light_vs.glsl",
"./shaders/light_fs.glsl")
self.lightShader.addUniform("mat_transform")
self.lightShader.addUniform("mat_projection")
self.lightShader.addUniform("mat_view")
# ** every shader must be added list of shader called shaders
self.shaders = [self.shader, self.cubeShader, self.lightShader]
self.meshes = []
self.renderer = Renderer(self.shaders)
self.pos = glm.vec2(0, 0)
self.angle = 0
self.transform = glm.identity(glm.mat3x3)
self.model = Mesh((-1.0, -0.0), (.3, .3), "./res/image.png")
self.cube_model = Cube()
self.light_model = Light()
# self.light_model = Light(0.5)
self.e = Entity(self.model, Vector3(0, 0, 0), Vector3(0.0, 0.0, 0.0),
Vector3(1, 1, 1))
self.cube_entity = Entity(self.cube_model, Vector3(-1, -1, -1),
Vector3(0.0, 0.0, 0.0), Vector3(1, 1, 1))
self.light_entity = Entity(self.light_model, Vector3(-0.5, -0.5, -0.5),
Vector3(0.0, 0.0, 0.0),
Vector3(0.2, 0.2, 0.2))
self.shadersDict = {
self.e: [self.shader, False],
self.cube_entity: [self.cubeShader, True],
self.light_entity: [self.lightShader, True]
}
precision = 3
self.cube_entities = []
r = 3
for i in range(10):
x = round(uniform(-r, r), precision)
y = round(uniform(-r, r), precision)
z = round(uniform(-r, r), precision)
self.cube_entities.append(
Entity(self.cube_model, Vector3(x, y, z),
Vector3(0.0, 0.0, 0.0), Vector3(0.5, 0.5, 0.5)))
self.shadersDict[self.cube_entities[i]] = [self.cubeShader, True]
# self.cube_entities = Entity(self.cube_model, Vector3(0,0,0), Vector3(0.0,0.0,0.0), Vector3(1,1,1))
self.camera = Camera()
import time
from LED import *
from Light import *
from Ir import *
from Rest import *
from TextLocal import *
import datetime
rest = Rest()
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(31, GPIO.IN)
GPIO.setup(33, GPIO.IN)
GPIO.setup(35, GPIO.IN)
GPIO.setup(37, GPIO.IN)
lcd = LED()
light = Light()
ir = Ir()
mode = 'auto'
count = 0
textLocal = TextLocal()
while True:
mymode = rest.get('SmartStreet/Mode')
mode = mymode[1]['mode']
print(mode)
time.sleep(1)
try:
if mode == 'auto':
if light.getLightStatus() == 'Night':
d = 0
if ir.getIrStatus() == 'Yes':
