def __init__(self, name, x, y, radar_length, angle=-90, length=16):
#set x,y and orientation posistion
self.x = x
self.y = y
self.orientation = math.radians(-90)
#set steering and acceleration/speed values
self.steering_angle = 0.0
self.previous_steering_angle = 0.0
self.max_steering_angle = math.radians(30)
self.acceleration = 0.0
self.max_acceleration = 5.0
self.speed = 0.0
self.max_speed = 10
#build car body based on the lenght
self.car_length = 50
self.car_width = 30
self.wheel_length = 10
self.wheel_width = 5
#set params used for score calculation
self.time = 200
self.time_alive = 200
self.checkpoint_passed = 2
self.is_alive = True
self.radar = Radar(self.x, self.y, 130,
(180, -90, -40, -15, 0, 15, 40, 90),
math.degrees(self.steering_angle))
def __init__(self, token):
self.TOKEN = token
locale.setlocale(locale.LC_ALL, '')
self.days = [
'todos os dias',
'Segunda-Feira',
'Terça-Feira',
'Quarta-Feira',
'Quinta-Feira',
'Sexta-Feira',
'Sábado',
'Domingo',
]
self.reg = [
r'^\d*$', # user_id
r'^(\d\d[/]){2}\d{4}$', # date
r'^[1-9]+\d*$', # blocks
r'^\d+([,]\d+)?$', # perc, capital
r'^([a-zA-Z]{4}\d{1,2}|B3SA3)(, ?([a-zA-Z]{4}\d{1,2}|B3SA3))*?$', # tickers
r'^([0-1]\d|2[0-3]):[0-5]\d$', # hour
]
self.modes = ['SD', 'SW', 'MD', 'MW']
self.sm_dw = {
self.modes[0]: 'Small Caps/Diário',
self.modes[1]: 'Small Caps/Semanal',
self.modes[2]: 'Mid Large Caps/Diário',
self.modes[3]: 'Mid Large Caps/Semanal',
}
self.rd = Radar()
def main():
config = Configuration("config.ini")
logging.basicConfig(level=config.logging_level)
logger = logging.getLogger('SpeedTrap')
logger.info("SpeedTrap Starting")
logger.info("Loading configuration file")
if config.clear_local_on_start:
LocalTools.clean_local(config)
log_speed = LogSpeed(config)
radar = Radar(config)
execute_loop = True
while execute_loop:
try:
current_report = radar.read_serial_buffer()
if (len(current_report) > 0):
try:
current_report_json = json.loads(current_report)
current_speed = abs(float(current_report_json['speed']))
logger.debug("Current speed is %s", current_speed)
log_speed.log_speed(current_speed)
except:
pass
else:
log_speed.log_speed(0)
except KeyboardInterrupt:
execute_loop = False
logger.info("SpeedTrap Terminating")
while threading.active_count() > 1:
logger.info('Waiting for %s threads to terminate.',
threading.active_count() - 1)
time.sleep(1)
def main():
print("#auto drive start#")
start_game()
radar = Radar(HIT_X, HIT_Y)
player = PlayerCharacter(radar)
reactor.callWhenRunning(player.start)
reactor.callWhenRunning(radar.start)
reactor.run()
def main():
start_game()
radar = Radar((HIT_X, HIT_Y))
player = PlayerCharacter(radar)
reactor.callWhenRunning(player.start)
reactor.callWhenRunning(radar.start)
reactor.run()
def start(self): # start sec_div10 count self.sec_div10 = [-1] self.add_second() # create temporary list self.temporary_list = [] # create enemy list self.enemy_list = [] # create sub x_center = self.width//2 y_center = self.height//2 # Sub(x,y, color, size, lifes, atack_time, sec_div10, temporary_list, enemy_list) self.sub = Sub( x_center, y_center, self.color, self.size, self.lifes, self.atack_time, self.sec_div10, self.temporary_list, self.enemy_list) # create radar dots qtd = self.n_dots width = self.width / qtd height = self.height / qtd self.dot_list = [] for i in range(qtd): for j in range(qtd): # Dot(x, y, color, size, time_fade, start_fadein) self.dot_list.append(Dot( width*j+width//2, height*i+height//2, self.color, 0, self.time_fadeout, False)) # create radar # Radar(sub, range, add_angle, dot_list, enemy_list) self.radar = Radar( self.sub, self.range_radar, 360/self.time_radar, self.dot_list, self.enemy_list) # start enemies spawn countdown pygame.time.set_timer(pygame.USEREVENT+1, 5000) # normal enemies pygame.time.set_timer(pygame.USEREVENT+2, 30000) # boss
def main():
# Intervalo de tiempo en el que vamos a medir
tiempo_inicial = datetime.datetime(2016, 3, 5, 1)
tiempo_final = datetime.datetime(2016, 3, 5, 10)
import math
# parametros del generador de senales
amplitud = 0.2
fase = 1
frecuencia = 20 * math.pi
#Construir un nuevo genrador de senales
Gen = Generador(amplitud, fase, frecuencia)
#Construir un detector
detector = Detector()
#construir un nuevo radar
radar = Radar(Gen, detector)
# parametros para un blanco
amplitud_de_frecuencia_del_blanco = amplitud + 100
tiempo_inicial_b = datetime.datetime(2016, 3, 5, 2)
tiempo_final_b = datetime.datetime(2016, 3, 5, 6)
# Construir un nuevo blanco
blanco = Blanco(amplitud_de_frecuencia_del_blanco, tiempo_inicial_b,
tiempo_final_b)
lista_blancos = [blanco]
#Construir un medio
medio = Medio(lista_blancos)
#Hago funcionar el radar
radar.detectar(medio, tiempo_inicial, tiempo_final)
radar.graficar(medio, tiempo_inicial, tiempo_final)
def data(coords):
niantic = Niantic()
try:
niantic.connect()
except Exception as e:
logger.error('%s: failed to connect: %s' % (coords, e))
return ('Failed to connect', 500)
radar = Radar(niantic)
location = __parse_location(coords)
if not location:
return ('Invalid coordinates: %s' % coords, 400)
try:
data = radar.locate(location)
except Exception as e:
logger.error('%s: failed to locate: %s' % (coords, e))
return ('Failed to locate', 500)
return jsonify(pokemons=data.pokemons,
gyms=data.gyms,
pokestops=data.pokestops)
def __init__(self, surface):
self.surface = surface
self.x_pos = BORDER_SIZE
self.y_pos = round(const.WIN_HEIGHT*2/3)
self.width = const.WIN_LENGTH - 2*BORDER_SIZE
self.height = round(const.WIN_HEIGHT/3 - BORDER_SIZE)
radar_radius = round(self.height/2) - 20
self.radar = Radar(self.x_pos + 5 + self.width - radar_radius - 10, \
self.y_pos + round(self.height/2) + 2, radar_radius)
self.sensors = Sensors(self.x_pos + 5, self.y_pos + 2)
self.laser_button_n = DashButton((self.x_pos + 510, self.y_pos + 30, 70, 70))
self.laser_button_s = DashButton((self.x_pos + 510, self.y_pos + 110, 70, 70))
self.repair_switch = DashButton((self.x_pos + 350, self.y_pos + 70, 150, 100))
self.laser_n_disabled = False
self.laser_s_disabled = False
self.repair_disabled = False
self.cactus_button = DashButton((BORDER_SIZE, const.WIN_HEIGHT - BORDER_SIZE - 80, 55, 80))
def __init__(self, location):
self.name = "MazeRobotPieSlice"
self.default_speed = 25.0
self.default_turn_speed = 9.0
self.actualRange = 40.0
self.default_robot_size = 5.5 # radius of robot
self.default_sensor_density = 5
self.velocity = 0.0
self.heading = math.pi/2
self.location = location
self.old_location = location
self.time_step = 0.099
self.heading_noise = 0.0
self.rangefinders = []
self.radars = []
for i in range(0,5):
between_angle = math.pi/4.0
final_angle = math.pi/2-(between_angle*i)
self.rangefinders.append(RangeFinder(final_angle, self.actualRange))
for i in range(0,4):
between_angle = math.pi/2.0
start_angle = math.pi/4-(between_angle*i)
self.radars.append(Radar(start_angle, start_angle + between_angle))
def main(self):
self.radar = Radar()
self.radar.draw_radar()
self.radar.display.getMouse()
self.radar.display.close()
import rospy
from agrosbuspkg.msg import CANFrameData #info about packet from arduino
from humsensor import Humidity
from radar import Radar
from tempsensor import Temperature
#settings for topic to subscribe and Publish
rospy.init_node('ROSNODE', anonymous=True) #node initialising
#setting publisher
PUB = rospy.Publisher('fromros', CANFrameData,
queue_size=10) #for outgoing packets
#log level
LOG_LEVEL = 3 #affect logging level visble on the cmd-line
#RADAR HCSR04
RADARHCSR04 = Radar("hcsr04_topic", 2, 10, PUB)
#Temp/HUM DHT11
DHT11 = Temperature("dht11_topic", 1, 10)
#HUM DHT11
DHT11_HUM = Temperature("dht11_hum_topic", 1, 10)
def logfunction(msg_id, int_timestamp, msg_len, msg_payload, direction):
"""this function logs event with different levels"""
s_timestamp = int_timestamp / 1000
s_timestamp = datetime.datetime.fromtimestamp(s_timestamp)
#direction = 1 -> outgoing packet direction=0 -> ingoing packet
if direction == 0:
direction = "Incoming packet "
def __init__(self):
self._camera = Camera()
self._radars = [Radar('test', 18, 24)]
self._agent = Agent()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-c",
"--config",
dest="filename",
help="load configuration file",
required=True)
config_filename = parser.parse_args().filename
config = Configuration(config_filename)
logging.basicConfig(filename=config.logging_path,
level=config.logging_level)
logger = logging.getLogger('SpeedTrap')
logger.info("SpeedTrap Starting")
logger.info("Configuration file successfully loaded")
logger.debug("%s", config)
if config.clear_local_on_start:
LocalTools.clean_local(config)
# log_speed = LogSpeed(config)
execute_loop = True
radar = Radar(config)
# Create pipes for inter-process communication
video_queue = Queue() # Video Ring Buffer
logger.debug("Starting video capture Process")
capture_video = CaptureVideo(config)
capture_parent, capture_child = Pipe()
capture_speed_parent, capture_speed_child = Pipe()
capture_process = Process(target=capture_video.capture,
args=(capture_child, capture_speed_child,
video_queue))
capture_process.start()
logger.info("Video capture Process started")
logger.debug("Starting video record Process")
record_video = RecordVideo(config)
record_parent, record_child = Pipe()
record_process = Process(target=record_video.record,
args=(record_child, video_queue))
record_process.start()
logger.info("Video record Process started")
logger.debug("Starting scribe Process")
data_recorder = Scribe(config)
data_parent, data_child = Pipe()
data_process = Process(target=data_recorder.capture, args=(data_child, ))
data_process.start()
logger.info("Scribe Process started")
# Tracking if we are currently recording so we don't accidentally create a race condition
recording = False
speed = 0
logger.debug("Starting radar polling loop")
while execute_loop:
try:
if record_parent.poll():
record_result = record_parent.recv()
logger.debug("Message received on record_parent Pipe()")
if type(record_result) is SpeedRecord:
logger.debug("Received message is a SpeedRecord")
logger.debug("Sending message on data_parent Pipe()")
data_parent.send(record_result) # Log Data
# Change the behavior of the capture process back to its default.
recording = False
capture_parent.send(0)
current_report = radar.read_serial_buffer()
if len(current_report) > 0:
try:
current_report_json = json.loads(current_report)
speed = abs(float(current_report_json['speed']))
except:
pass
else:
speed = 0
logger.debug("Current speed is %s", speed)
logger.debug(
"Sending message of %s to capture_speed_parent Pipe()", speed)
capture_speed_parent.send(speed)
if speed > config.record_threshold and recording is False:
recording = True
# Change the behavior of the video capture and recording process to record mode
logger.debug("Sending message of 1 to capture_parent Pipe()")
capture_parent.send(1)
logger.debug("Sending message of 1 to record_parent Pipe()")
record_parent.send(1)
except KeyboardInterrupt:
execute_loop = False
logger.info("SpeedTrap Terminating")
from car import Car
from radar import Radar
target = Car(v=20 * 1000 / 3600,
a_x=10000.0,
a_y=1000.0,
a_z=1000.0)
radars = [
Radar(x=0.0, y=100000.0, z=10000.0, sigma_range=10.0, sigma_azimuth=0.1),
Radar(x=100000.0, y=0.0, z=10000.0, sigma_range=10.0, sigma_azimuth=0.1),
# Radar(x=100000.0, y=100000.0, z=10000.0, sigma_range=10.0, sigma_azimuth=0.1),
# Radar(x=0.0, y=-100000.0, z=10000.0, sigma_range=10.0, sigma_azimuth=0.1),
]
#title
title = myfont.render("PiAware Radar", 1, GREEN)
screen.blit(title, TITLEPOS)
sac = myfont.render("stuffaboutcode.com", 1, GREEN)
screen.blit(sac, (TITLEPOS[0], TITLEPOS[1] + LINESPACE))
#flight data timer
flight_data_timer = None
#get the home position
home_x, home_y = lat_lon_to_x_y(args.lat, args.lon)
#startup the radar
radar = Radar(screen,
RADARRECT,
radar_pos=(home_x, home_y),
scale=scale,
back_col=BLACK,
radar_col=GREEN)
radar.start()
#get the flight data
myflights = FlightData(data_url=piaware_url)
done = False
next_refresh = pygame.time.get_ticks()
while not done:
#should the flights be refreshed
if pygame.time.get_ticks() > next_refresh:
#keep a track of the last aircraft we saw
if (start):
dir = "down" if track.dir else "up"
print track.id, "new track", dir
else:
print track.id, "end", len(track.speeds), track.maxSpeed, "mph"
def status(msg):
sys.stderr.write(msg)
sys.stderr.write("\n")
r = Radar(
sampleRate=44100,
alsaPeriod=1024,
sampleBuffer=2048,
#realtimeCallback=radarRealtimeStatus,
#trackDebugCallback=radarTrackDebug,
trackCallback=radarTrack)
try:
status("Listening...")
while (True):
r.sample()
except alsaaudio.ALSAAudioError:
status("No soundcard!")
except KeyboardInterrupt:
status("Interrupted!")
except:
status("Unexpected error!")
def main():
"""
- Parse user-specified data from YaML
- Check to see that the needed graphics are available. If not, get them.
- Get the radar imagery, complete with warnings graphics
- Get today's hazardous weather outlook statement and parse it
- Check for FTM outage notifications
- Get, parse, and write out current weather conditions to specified locations.
- TODO: should run the getweather.sh shell script, that overlays/composites
the weather graphics. At present, that shell script calls this script
and runs the overlays with -bash-.
- Check for and acquire current multi-band GOES-x imagery of a given resolution.
"""
if os.path.exists('weatherwidget.log'):
os.remove('weatherwidget.log')
logging.basicConfig(
filename='weatherwidget.log',
level=logging.DEBUG,
format='%(asctime)s %(levelname)s %(threadName)-10s %(message)s',
)
data = wf.load_settings_and_defaults(SETTINGS_DIR, 'settings.yml',
'defaults.yml')
if not data:
logging.error('Unable to load settings files. These are required.')
sys.exit(
'settings files are required and could not be loaded successfully.'
)
logging.info('Checking for radar outage.')
wf.outage_check(data)
logging.info('Retrieving current weather observations.')
right_now = Observation(data)
right_now.get_current_conditions()
right_now.get_backup_obs(use_json=False)
right_now.merge_good_observations()
logging.debug('Merged current conditions: %s', right_now.con1.obs)
sum_con = right_now.conditions_summary()
if right_now.con1.obs and sum_con:
text_conditions, nice_con = right_now.format_current_conditions()
logging.debug('Current conditions from primary source: %s', nice_con)
wf.write_json(some_dict=nice_con,
outputdir=data['output_dir'],
filename='current_conditions.json')
else:
logging.error(
'Something went wrong getting the current conditions. Halting.')
return 1
wf.write_text(os.path.join(data['output_dir'], 'current_conditions.txt'),
text_conditions)
# Get radar image:
current_radar = Radar(data)
current_radar.check_assets()
current_radar.get_radar()
current_radar.get_warnings_box()
if current_radar.problem:
logging.error('Unable to retrieve weather radar image. Halting now.')
# Hazardous Weather Outlook and alerts:
today_alerts = Alerts(data)
today_alerts.get_alerts()
# Get hydrograph image.
if wf.get_hydrograph(abbr=data['river_gauge_abbr'],
hydro_url=data['defaults']['water_url'],
outputdir=data['output_dir']).ok:
logging.info('Requesting hydrograph for station %s, gauge "%s".',
data['radar_station'], data['river_gauge_abbr'])
else:
logging.error('Failed to get hydrograph information.')
return 1
forecast_obj = Forecast(data=data)
logging.debug('Getting the forecasts.')
forecast_obj.get_forecast()
forecastdict = forecast_obj.parse_forecast()
if forecastdict is None:
logging.error('Unable to parse forecast!')
return 1
forecast_obj.write_forecast(outputdir=data['output_dir'])
logging.debug('Getting area forecast discussion.')
forecast_obj.get_afd()
logging.debug('Getting zone forecast.')
zoneforecast = ZoneForecast(data)
zoneforecast.get()
wf.write_json(some_dict=forecastdict,
outputdir=data['output_dir'],
filename='forecast.json')
wsvg.make_forecast_icons(forecastdict, outputdir=data['output_dir'])
# Satellite imagery:
current_image = Imagery(band='GEOCOLOR', data=data)
current_image.get_all()
logging.info('Finished program run.')
return 0
exit(0)
signal.signal(signal.SIGINT, signal_handler)
if __name__ == "__main__":
if len(sys.argv) < 2:
print("Usage: python {command} <port>".format(command=sys.argv[0]))
exit(0)
PORT = int(sys.argv[1])
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind((HOST, PORT))
sock.listen(1)
print("Listening on port {port} ...".format(port=PORT))
client_socket, client_addr = sock.accept()
print("Connected by: ", client_addr)
radar = Radar(min_range=0, range_resolution=0.1)
try:
# Send config data first
radar.send_config_packet(client_socket)
# Commence data stream
radar.start_data_stream(client_socket)
except Exception as e:
print(e)
sock.close()
self.textSurf = self.font.render("UAL121", 1, (86, 176, 91))
self.surf.blit(self.textSurf, (9, 0))
self.rect = self.surf.get_rect()
self.x = 600 / radar.scale
self.y = 300 / radar.scale
self.heading = 60
self.speed = 250
def update(self, elapsed):
self.h = ((self.speed * px_per_nm) / 3600 * (elapsed / 1000)) * 60
self.x += (sin(radians(self.heading)) * self.h) / radar.scale
self.y -= (cos(radians(self.heading)) * self.h) / radar.scale
asdex = Asdex(airport_data, screen_height, screen_width)
radar = Radar(airport_data, screen_height, screen_width)
aircraft = Aircraft()
elapsed = 1
sweep = 0
running = True
scene = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
scene = not scene
if not scene:
screen.blit(radar.surface, (0, 0))
