class Car: def __init__(self): self.drive_msg = DriveMessage() self.check_msg = CheckMessage() self._bus = can.interface.Bus(bustype='socketcan', channel='can0') self.transmitter = Transmitter(self._bus) self.receiver = Receiver(self._bus, self.update) self.data = CarData() self.last_update = time.time() self.notifier = can.Notifier(self._bus, [self.receiver]) self.controller = PIController(proportional=0.05, integral=0.1) gpsd.connect() self.send_messages() def update(self, data: CarData): self.last_update = time.time() self.data = data if self.tx_check(data.rx_check): self.periodic_update() else: self.send_messages() def can_error(self): self.check_msg.invalid_message_received() self.send_messages() @property def is_outdated(self): return time.time() - self.last_update > 1.0 @property def is_ok(self): return self.data.has_control and not self.is_outdated def periodic_update(self): self.increment_msg_counts() self.update_from_controller() self.send_messages() self.clear_errors() def increment_msg_counts(self) -> None: self.drive_msg.increment_msg_count() self.check_msg.increment_msg_count() def update_from_controller(self) -> None: self.drive_msg.velocity = Driving.to_can( self.controller.update(self.velocity)) def clear_errors(self) -> None: self.check_msg.clear_errors() def send_messages(self): if self.drive_msg is not None: self.transmitter.transmit(self.drive_msg) if self.check_msg is not None: self.transmitter.transmit(self.check_msg) def drive(self, v: float, s: float) -> None: print(f'Setting velocity {Driving.to_can(int(v))}') self.drive_msg.velocity = Driving.to_can(int(v)) print(f'Setting steering {Steering.to_can(int(s))}') self.drive_msg.steering = Steering.to_can(int(s)) def release_control(self) -> None: self.drive_msg.ctrl = 0 def shutdown(self) -> None: self.release_control() self.periodic_update() time.sleep(0.2) self.transmitter.shutdown() time.sleep(0.2) self._bus.shutdown() def tx_check(self, rx_check: int) -> bool: if rx_check > self.check_msg.tx_check or self.check_msg.tx_check == 255: self.check_msg.set_tx_check(rx_check) return True return False @property def velocity(self) -> float: return self.data.velocity @velocity.setter def velocity(self, velocity: Union[int, float]) -> None: self.controller.target = velocity # self.drive_msg.velocity = Driving.to_can(int(velocity)) @property def steering_angle(self) -> float: return self.data.steering_angle @steering_angle.setter def steering_angle(self, steering: Union[int, float]) -> None: self.drive_msg.steering = Steering.to_can(int(steering)) @property def ebrake(self) -> bool: return self.check_msg.stop @ebrake.setter def ebrake(self, enabled: bool) -> None: self.check_msg.stop = enabled @property def gps_position(self): return gpsd.get_current().position()
# print(airborne) # print("Concentration Units (standard)") # print("---------------------------------------") # print("PM 1.0: %d\tPM2.5: %d\tPM10: %d" % # (pm10_standard, pm25_standard, pm100_standard)) # print("Concentration Units (environmental)") # print("---------------------------------------") # print("PM 1.0: %d\tPM2.5: %d\tPM10: %d" % (pm10_env, pm25_env, pm100_env)) # print("---------------------------------------") # print("Particles > 0.3um / 0.1L air:", particles_03um) # print("Particles > 0.5um / 0.1L air:", particles_05um) # print("Particles > 1.0um / 0.1L air:", particles_10um) # print("Particles > 2.5um / 0.1L air:", particles_25um) # print("Particles > 5.0um / 0.1L air:", particles_50um) # print("Particles > 10 um / 0.1L air:", particles_100um) # print("---------------------------------------") buffer = buffer[32:] # print("Buffer ", buffer) if (airborne.particles_03um < 200): led.green() elif (airborne.particles_03um < 350): led.yellow() else: led.red() if airborne_data_list.__len__() > 0 and i % 30 == 0: transmitter.transmit(airborne_data_list)
def start(): get_arguments() # Transmitter.transmit returns the new size of a block new_block_size = Transmitter.transmit(parameter_dict[K], parameter_dict[F]) # for T trials, repeat the simulation for i in range(parameter_dict[T]): # clear this trial's variables trials_time = 0 trials_received_frames = 0 trials_failed_frames = 0 # Set the first seed for the simulation Simulator.set_seed(parameter_dict[TSeeds][i]) while (trials_time <= parameter_dict[R]): trials_received_blocks = 0 # new frame trials_failed_blocks = 0 # new frame # set the number of blocks to be transmitted in this frame transmissions = parameter_dict[K] if (parameter_dict[K] == 0): transmissions = 1 # For K blocks (or 1 if K == 0), simulate the transmission for j in range(transmissions): # range starts at 0 # frame_failure = 0 if block was transmitted successfully block_failure = handle_block(new_block_size, parameter_dict[E], parameter_dict[K]) # record block success or failure if (block_failure > 0): trials_failed_blocks += 1 else: trials_received_blocks += 1 # set trials_time to number of bits and response overhead trials_time += (parameter_dict[F] + (parameter_dict[K] * Transmitter.r) + parameter_dict[A]) # update number of transmitted frames Statistics.update(Statistics.total_frames) # frame failed, resend the frame if(trials_failed_blocks >= 1): trials_failed_frames += 1 # the last frame being sent (no longer needed) see forums #elif(trials_time > parameter_dict[R]): # pass # successful transmition else: Statistics.update(Statistics.correctly_received_frames) trials_received_frames += 1 #a print("Trial number:", i) #a print("Received Frames", trials_received_frames) #a print("Failed Frames", trials_failed_frames) # Assume: Take all K*(F+r) trials_time units into account # even if in last frame Statistics.append(Statistics.throughput_averages, ((parameter_dict[F] * trials_received_frames) / trials_time)) if(trials_received_frames != 0): # Assume: Take all frames into account, even last frame Statistics.append(Statistics.frame_averages, (trials_received_frames + trials_failed_frames) / trials_received_frames) else: Statistics.append(Statistics.frame_averages, 0) # Add to total time Statistics.statistics_dict[Statistics.total_time] += trials_time # Call Print Statements #a print() #a print("----------------------------------------------") print_input(sys.argv) Statistics.set_final_values(parameter_dict[F], parameter_dict[R]) Statistics.print_frame_ci() Statistics.print_throughput_ci()
def start(): get_arguments() # Transmitter.transmit returns the new size of a block new_block_size = Transmitter.transmit(parameter_dict[K], parameter_dict[F]) # for T trials, repeat the simulation for i in range(parameter_dict[T]): # clear this trial's variables trials_time = 0 trials_received_frames = 0 trials_failed_frames = 0 # Set the first seed for the simulation Simulator.set_seed(parameter_dict[TSeeds][i]) while (trials_time <= parameter_dict[R]): trials_received_blocks = 0 # new frame trials_failed_blocks = 0 # new frame # set the number of blocks to be transmitted in this frame transmissions = parameter_dict[K] if (parameter_dict[K] == 0): transmissions = 1 # For K blocks (or 1 if K == 0), simulate the transmission for j in range(transmissions): # range starts at 0 # frame_failure = 0 if block was transmitted successfully block_failure = handle_block(new_block_size, parameter_dict[E], parameter_dict[K]) # record block success or failure if (block_failure > 0): trials_failed_blocks += 1 else: trials_received_blocks += 1 # set trials_time to number of bits and response overhead trials_time += (parameter_dict[F] + (parameter_dict[K] * Transmitter.r) + parameter_dict[A]) # update number of transmitted frames Statistics.update(Statistics.total_frames) # frame failed, resend the frame if (trials_failed_blocks >= 1): trials_failed_frames += 1 # the last frame being sent (no longer needed) see forums #elif(trials_time > parameter_dict[R]): # pass # successful transmition else: Statistics.update(Statistics.correctly_received_frames) trials_received_frames += 1 #a print("Trial number:", i) #a print("Received Frames", trials_received_frames) #a print("Failed Frames", trials_failed_frames) # Assume: Take all K*(F+r) trials_time units into account # even if in last frame Statistics.append( Statistics.throughput_averages, ((parameter_dict[F] * trials_received_frames) / trials_time)) if (trials_received_frames != 0): # Assume: Take all frames into account, even last frame Statistics.append(Statistics.frame_averages, (trials_received_frames + trials_failed_frames) / trials_received_frames) else: Statistics.append(Statistics.frame_averages, 0) # Add to total time Statistics.statistics_dict[Statistics.total_time] += trials_time # Call Print Statements #a print() #a print("----------------------------------------------") print_input(sys.argv) Statistics.set_final_values(parameter_dict[F], parameter_dict[R]) Statistics.print_frame_ci() Statistics.print_throughput_ci()