def main(): threshold = 60 second_threshold = 10 stream = SensorStream() CONTINUOUS_INCREMENT = False TCP_IP = '192.168.43.222' TCP_PORT = 80 BUFFER_SIZE = 1024 sleep_time = 0.05 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((TCP_IP, TCP_PORT)) parser = DataParser(acc_unit=100, gy_unit=128) mov = 0 rotating = False while True: raw_bytestream = s.recv(BUFFER_SIZE) parser.parse_data(raw_bytestream, stream) x,y,z,gX,gY,gZ = stream.getValues() print x,y,z,gX,gY,gZ time.sleep(sleep_time)
def standard_interaction(self): TCP_IP = '192.168.43.222' #192.168.1.X for home networks; .43.X for Samsung Galaxy S5 NEO TCP_PORT = 80 BUFFER_SIZE = 1024 sleep_time = 0.05 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((TCP_IP, TCP_PORT)) parser = DataParser(acc_unit=100, gy_unit=128) #counter = self.stream.memory_size mov = 0 counter_pos = 0 counter_neg = 0 timer = 0 prev_time = time.time() angle = 0 mute = False last_vol = '' rotating = False timer_threshold = 0.4 self.ids.volume.text = str(check_output(["./vol.sh"], shell=True)) while True: raw_bytestream = s.recv(BUFFER_SIZE) parser.parse_data(raw_bytestream, self.stream) #if (counter >0): # self.stream.setMemoryCell(self.stream.memory_size-counter) #elif(counter == 0): # plt.plot(range(self.stream.memory_size),self.stream.memory) # plt.show() # plt.plot(range(self.stream.memory_size),self.stream.memory) # plt.savefig('dataPlot.png') #counter -= 1 x, y, z, gX, gY, gZ = self.stream.getValues() dt = time.time() - prev_time prev_time = time.time() dtheta = dt * gZ angle += dtheta delta_time = time.time() - timer #Linear increment after the time threshold if (delta_time > timer_threshold and rotating and not mute): if (mov == 1): call(["amixer", "-D", "pulse", "sset", "Master", "1%+"]) if (mov == -1): call(["amixer", "-D", "pulse", "sset", "Master", "1%-"]) self.ids.gZ.text = str(gZ) #Reset volume with a rapid anticlockwise movment #if(gZ > 254 and not mute): # mute = True # last_vol = str(check_output(["./vol.sh"], shell=True)) # call(["amixer", "-D", "pulse", "sset", "Master", "0%"]) if (mov <= 0 and self.stream.gZ < -self.threshold): counter_pos += 1 if (not mute): call(["amixer", "-D", "pulse", "sset", "Master", "5%+"]) mov = 1 timer = time.time() angle = 0 rotating = True elif (mov >= 0 and self.stream.gZ > self.threshold): counter_neg += 1 if (not mute): call(["amixer", "-D", "pulse", "sset", "Master", "5%-"]) mov = -1 timer = time.time() angle = 0 rotating = True elif ((mov > 0 and self.stream.gZ > -self.second_threshold) or (mov < 0 and self.stream.gZ < self.second_threshold)): mov = 0 rotating = False #Restore volume to the previous value with a rapid clockwise movment #if(gZ<-254 and mute): # mute = False # last_vol = last_vol.rstrip() # call(["amixer", "-D", "pulse", "sset", "Master", last_vol]) #Useful variables not used #counter_neg, counter_pos, angle, delta_time self.ids.volume.text = str(check_output(["./vol.sh"], shell=True)) time.sleep(sleep_time) s.close()
def main(): threshold = 60 second_threshold = 10 stream = SensorStream() CONTINUOUS_INCREMENT = False TCP_IP = '192.168.43.222' #192.168.1.X for home networks; .43.X for Samsung Galaxy S5 NEO TCP_PORT = 80 BUFFER_SIZE = 1024 sleep_time = 0.05 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((TCP_IP, TCP_PORT)) parser = DataParser(acc_unit=100, gy_unit=128) #counter = self.stream.memory_size mov = 0 rotating = False while True: raw_bytestream = s.recv(BUFFER_SIZE) parser.parse_data(raw_bytestream, stream) #UNCOMMENT TO GET DATA STREAM PLOT FOR DEBUGGING #if (counter >0): # self.stream.setMemoryCell(self.stream.memory_size-counter) #elif(counter == 0): # plt.plot(range(self.stream.memory_size),self.stream.memory) # plt.show() # plt.plot(range(self.stream.memory_size),self.stream.memory) # plt.savefig('dataPlot.png') #counter -= 1 x, y, z, gX, gY, gZ = stream.getValues() if (rotating and CONTINUOUS_INCREMENT): if (mov == 1): print("Rotating clockwise") if (mov == -1): print("Rotating anticlockwise") if (mov <= 0 and stream.gZ < -threshold): if (not CONTINUOUS_INCREMENT): print("Clockwise rotation") mov = 1 rotating = True elif (mov >= 0 and stream.gZ > threshold): if (not CONTINUOUS_INCREMENT): print("Antilockwise rotation") mov = -1 rotating = True elif ((mov > 0 and stream.gZ > -second_threshold) or (mov < 0 and stream.gZ < second_threshold)): mov = 0 rotating = False time.sleep(sleep_time) s.close()
class BehaviorCloner: """Create Keras model to train learn from driving images in simulator and learn to control the car on it's own""" def __init__(self): self._data_parser = DataParser() def _flip_image(self, img_): return cv2.flip(img_, 1) def _combine_LCR(self, labels_, epoch_): left_imgs = self._data_parser.left_imgs center_imgs = self._data_parser.center_imgs right_imgs = self._data_parser.right_imgs angle_adjust = 0.1 left_labels = np.copy(labels_) + angle_adjust center_labels = np.copy(labels_) right_labels = np.copy(labels_) - angle_adjust batch_size = left_imgs.shape[0] row_size = left_imgs.shape[1] col_size = left_imgs.shape[2] total_imgs = np.zeros((batch_size, row_size, col_size, 3)) total_labels = np.zeros(batch_size) for pic_num in range(total_imgs.shape[0]): while 1: # get index index = randint(0, total_imgs.shape[0] - 1) # pick different images lrc_rand = randint(0, 100) if lrc_rand > 66: img = right_imgs[index] label = right_labels[index] elif lrc_rand > 33: img = center_imgs[index] label = center_labels[index] else: img = left_imgs[index] label = left_labels[index] # probability says we shouldn't keep it if (abs(label) * 100 + epoch_ * 10) < randint(0, 100): continue # flip images flip_rand = randint(0, 100) if flip_rand > 50: img = self._flip_image(img) label *= -1 # add and go to next in for loop total_imgs[pic_num] = img total_labels[pic_num] = label break return total_imgs, total_labels def _generator_training(self, labels_, batch_size_, xDiv_, yDiv_): def _f(): epoch = 0 max_epoch = 5 start = 0 end = start + batch_size_ num_imgs = labels_.shape[0] while True: self._data_parser.combine_batch(start, end, xDiv_, yDiv_) #setup data X_batch, y_batch = self._combine_LCR(labels_[start:end], epoch) #get data start += batch_size_ end += batch_size_ if start >= num_imgs: start = 0 end = batch_size_ epoch += 1 if epoch >= max_epoch: epoch = 0 if end >= num_imgs: end = num_imgs yield (X_batch, y_batch) return _f def _generator_validation(self, labels_, batch_size_, xDiv_, yDiv_): def _f(): start = 0 end = start + batch_size_ num_imgs = labels_.shape[0] while True: self._data_parser.combine_batch(start, end, xDiv_, yDiv_) #setup data X_batch = self._data_parser.center_imgs y_batch = labels_[start:end] start += batch_size_ end += batch_size_ if start >= num_imgs: start = 0 end = batch_size_ if end >= num_imgs: end = num_imgs yield (X_batch, y_batch) return _f ''' External API ''' def setup_data(self): self._data_parser.parse_data() # Build model based on # Nvidia "End to End Learning for Self-Driving Cars" def build_model(self, xDiv_, yDiv_): input_height = int(self._data_parser.img_height / yDiv_) input_width = int(self._data_parser.img_width / xDiv_) input_channels = self._data_parser.img_channels self._model = Sequential() # normalize -1<>+1 self._model.add( Lambda(lambda x: x / 127.5 - 1., input_shape=(input_height, input_width, input_channels), output_shape=(input_height, input_width, input_channels))) # Conv Layer #0 (depth=3, kernel=1x1) - change color space self._model.add(Convolution2D(3, 1, 1, border_mode='same')) # Conv Layer #1 (depth=24, kernel=5x5) self._model.add(Convolution2D(24, 5, 5, border_mode='valid')) self._model.add(ELU()) self._model.add(MaxPooling2D(pool_size=(2, 2))) self._model.add(Dropout(0.5)) # Conv Layer #2 (depth=36, kernel=5x5) self._model.add(Convolution2D(36, 5, 5, border_mode='valid')) self._model.add(ELU()) self._model.add(MaxPooling2D(pool_size=(2, 2))) self._model.add(Dropout(0.5)) # Conv Layer #3 (depth=48, kernel=3x3) self._model.add(Convolution2D(48, 3, 3, border_mode='valid')) self._model.add(ELU()) self._model.add(MaxPooling2D(pool_size=(2, 2))) self._model.add(Dropout(0.5)) # Conv Layer #4 (depth=64, kernel=3x3) self._model.add(Convolution2D(64, 3, 3, border_mode='valid')) self._model.add(ELU()) self._model.add(MaxPooling2D(pool_size=(2, 2))) self._model.add(Dropout(0.5)) self._model.add(Flatten()) # Hidden Layer #1 self._model.add(Dense(100)) self._model.add(ELU()) # Hidden Layer #2 self._model.add(Dense(50)) self._model.add(ELU()) # Hidden Layer #3 self._model.add(Dense(10)) self._model.add(ELU()) # Answer self._model.add(Dense(1)) self._model.summary() def train_model(self, num_epochs_, batch_size_, xDiv_, yDiv_): print('BehaviorCloner: train_model()...') # setup for training self._model.compile(optimizer="adam", loss="mse") # train the model train_gen = self._generator_training(self._data_parser.steering_angles, batch_size_, xDiv_, yDiv_) num_imgs_train = self._data_parser.steering_angles.shape[ 0] * 3 #3x for left, center, right history = self._model.fit_generator(train_gen(), num_imgs_train, num_epochs_) # validation validation_gen = self._generator_validation( self._data_parser.steering_angles, batch_size_, xDiv_, yDiv_) num_imgs_validate = self._data_parser.steering_angles.shape[ 0] #1x center accuracy = self._model.evaluate_generator(validation_gen(), num_imgs_validate) print("Accuracy = ", accuracy) print('... train_model() done') def save_model(self): model_json = self._model.to_json() with open('model.json', 'w') as outfile: json.dump(model_json, outfile) self._model.save_weights('model.h5')