Hi Dronesonen! 😊
Last week we conducted the following efforts:
Discipline – Software:
Erik-Andre Hegna:
I do not have much to add this week. Most of this week was spent on discussing and planning the logic of the mouse. Lots of theoretical progress, but little to show for yet. Ask will comment on the details.
Lars Leganger:
This week I worked on the driver code of the mouse. I started by extending the code so it now can read all three sensors. Now that we have the front, left and right sensors to get values from I started to work on how it should act based on the value readings. The actual sensor readings and measurements are going to be put in the code on Monday, but the skeleton is ready. The driver functions that are implemented are actions based on how its placed. If its at a dead end it should do a 180-degree rotation If f it can drive left or right, then a 90-degree rotation. The plan is to hard code it, so the rotation is based on time. so, the delay will change based on how much time the mouse needs to do the rotations. I also added a reverse function for the mouse.
void Reverse() {
analogWrite(MP1_1,0);
analogWrite(MP1_2,225);
analogWrite(MP2_1,0);
analogWrite(MP2_2,255);
}
void setup() {
pinMode(trigger_pin1, OUTPUT);
pinMode(trigger_pin2, OUTPUT);
pinMode(trigger_pin3, OUTPUT);
pinMode(echo_pin1, INPUT);
pinMode(echo_pin2, INPUT);
pinMode(echo_pin3, INPUT);
pinMode(MP1_1,OUTPUT);
pinMode(MP1_2,OUTPUT);
pinMode(MP2_1,OUTPUT);
pinMode(MP2_2,OUTPUT);
Serial.begin(115200);
}
void loop() {
double SensorReadFront = readSensorFront();
delay(50);
double SensorReadLeft = readSensorLeft();
delay(50);
double SensorReadRight = readSensorRight();
delay(50);
if(SensorReadFront > 40 || SensorReadLeft < 10 || SensorReadRight <10 ){
driveForward();
}
if(SensorReadFront < 10 && SensorReadLeft > 20 && SensorReadRight < 10){
leftRotate();
delay(20);
}
if(SensorReadFront < 10 && SensorReadLeft < 10 && SensorReadRight > 20){
rightRotate();
delay(20);
}
if(SensorReadFront < 10 && SensorReadLeft < 10 && SensorReadRight < 10){
rightRotate();
delay(40);
}
}
Ask Lindbråten:
On Monday, I spent the time I had available, discussing with Erik and Lars on how we could continue building the skeletal framework for our mapping algorithm from week 4. We quickly realized that in order to transfer the “way of coding” from standard C++ to platform IO/Arduino we had to either change out the smart pointers and vectors for raw pointers and dynamic arrays or hopefully find two libraries that facilitates the usage of both in arduino. Fortunately, Erik-Andre and I found two libraries that facilitated both, allowing us to avoid time-consuming backtracking. Here’s the links if anybody is interested:
Smart pointers:
https://www.arduino.cc/reference/en/libraries/arxsmartptr/
Vectors:
https://www.arduino.cc/reference/en/libraries/vector/
On Wednesday my goal was to hopefully start running the distance tests for our ultrasonic sensors, (to find a best fit function that returns the real-world distance based on a measurement), with a micromouse prototype that was equipped with the PCB. But as it wasn’t fully configured yet, Erik-Andre and I went back to the drawing board to sketch a decision tree for the functions and actions that would need to be executed, from the moment the micromouse enters a cell and leaves it, in order to map paths or a path from the starting point to the goal in the maze. Here’s the sketch:
While this might seem really confusing, I’ll attempt to provide a rough but concise explanation of the decision tree (ignoring the blue scribbles):
While (IsGoal() = false){
- Get sensor values, adjust and store them in the correct variables.
- Run division (sensor value / cell-length -> 16 ) on all three sensor values.
- Compare the difference between the decimal parts of the division for both sides.
- Check the decimal part for the front sensor’s division.
- If the difference is between a set margin and front sensor’s decimal part = 0.5 ± a set tolerance, the micromouse is approximately centered and we go to step 3. If its not centered, adjust the micromouse’s position and try step 2 again (hardcoded motor-control functions is what we are planning to use here).
- Divide all three sensor values by 16, and use the integer value of the result to determine how many nodes/cells must be created in the direction the respective sensor is pointing.
- If the coordinates in the grid, where you want to create a new cell/node, has a nullptr, new nodes will be created here and connected to the active cell/node the micromouse is currently inside. If the coordinates respond to a place in the grid where a node has already been created, new nodes will not be created there, but connected for the second time to the new neighboring cell/node the micromouse is currently inside.
- Here’s where the micromouse must decide which node to visit next.
- The isVisited variable of the active cell will be set to true.
- One of the three hardcoded – motor-control functions: DriveForw, DriveRight, DriveLeft, will be activated.
- The active-cell variable will be set to the next node/cell in the direction the micromouse is driving, and the while loop continues from the top.
}
When the micromouse is creating and connecting nodes we are using cardinal directions, the xy-axis and the micromouse’s position in degrees to determine the forward-, left- and right direction. The picture below should illustrate our thought process behind it:
Short explanations:
- A right turn adds the value -> 90 to the micromouse’s positioning, while a left turn subtracts 90 from the position value.
- Ex. At positioning = 90 or -270: The forward direction is set towards the east-direction (creating nodes in this direction requires an increase of the x-idx each time and to connect them the next node’s westptr will point to the previous node while the previous node’s eastptr will point to the next node). The left direction is set towards the north-direction (creating nodes in this direction requires an increase of the y-idx each time and to connect them the next node’s southptr will point to the previous node while the previous node’s northptr will point to the next node). The right-direction is set towards the south-direction (creating nodes in this direction requires a decrease of the y-idx each time and to connect them the next node’s northptr will point to the previous node while the previous node’s southptr will point to the next node).
Implementation-wise, Erik-Andre and I decided to have a go at the whole thing separately, since we both wanted to work with every functionality, and it didn’t look like too much work. I suspect that we also have different thoughts behind how things can be implemented as well. Therefore, I imagine it would be easier and faster to work this way and see which solution works the best, rather than trying to work on specific functionalities and having to communicate back and forth to continuously adapt them to what the other person is doing. I spent most of the day on Friday to finalize a potential solution for the software framework and functionalities – 2 and 3 – in the decision tree description. Here’s the framework of the classes I’ve implemented:
#include <Arduino.h>
#include <ArxSmartPtr.h>
#include <Vector.h>
class Node;
class Maze;
class Micromouse;
class Node
{
private:
std::shared_ptr<Node> m_north_ptr = nullptr;
std::shared_ptr<Node> m_east_ptr = nullptr;
std::shared_ptr<Node> m_south_ptr = nullptr;
std::shared_ptr<Node> m_west_ptr = nullptr;
bool m_isVisited = false;
double m_xidx = 0;
double m_yidx = 0;
public:
Node() {};
Node(double x_idx, double y_idx, bool isVisited) :
m_xidx(x_idx), m_yidx(y_idx), m_isVisited(isVisited){}
std::shared_ptr<Node> getNorthptr() {
return m_north_ptr;
}
std::shared_ptr<Node> getSouthptr() {
return m_south_ptr;
}
std::shared_ptr<Node> getEastptr() {
return m_east_ptr;
}
std::shared_ptr<Node> getWestptr() {
return m_west_ptr;
}
void setNorthptr(std::shared_ptr<Node> n) {
m_north_ptr = n;
}
void setSouthptr(std::shared_ptr<Node> n) {
m_south_ptr = n;
}
void setEastptr(std::shared_ptr<Node> n) {
m_east_ptr = n;
}
void setWestptr(std::shared_ptr<Node> n) {
m_west_ptr = n;
}
bool getIsVisited() {
return m_isVisited;
}
double getXidx() {
return m_xidx;
}
double getYidx() {
return m_yidx;
}
};
class Micromouse
{
private:
double m_left_sensor_val = 0;
double m_right_sensor_val = 0;
double m_front_sensor_val = 0;
int m_position = 0;
std::shared_ptr<Node> m_active_cell;
std::shared_ptr<Maze> m_maze_obj;
public:
Micromouse();
Micromouse(double l_s_val, double r_s_val, double f_s_val, int position, std::shared_ptr<Node> a,
std::shared_ptr<Maze> b):
m_left_sensor_val(l_s_val), m_right_sensor_val(r_s_val), m_front_sensor_val(f_s_val), m_position(position),
m_active_cell(a), m_maze_obj(b){}
double getLeftSensorVal(){
return m_left_sensor_val;
}
double getRightSensorVal(){
return m_right_sensor_val;
}
double getFrontSensorVal(){
return m_front_sensor_val;
}
int getPosition(){
return m_position;
}
std::shared_ptr<Node> getActiveCell(){
return m_active_cell;
}
std::shared_ptr<Maze> getMazeObj(){
return m_maze_obj;
}
void setLeftSensorVal(double value){
m_left_sensor_val = value;
}
void setRightSensorVal(double value){
m_right_sensor_val = value;
}
void setFrontSensorVal(double value){
m_front_sensor_val = value;
}
void setPosititon(int value){…
}
void setActiveCell(std::shared_ptr<Node> n){
m_active_cell = n;
}
void setMazeObj(std::shared_ptr<Maze> n){
m_maze_obj = n;
}
bool isGoal(){…
}
Vector<double> intAndDecPart(double a, double b){…
}
bool isCentered(){…
}
void connectNodesLeft(std::shared_ptr<Node> current, std::shared_ptr<Node> next, int pos){…
}
void connectNodesRight(std::shared_ptr<Node> current, std::shared_ptr<Node> next, int pos){…
}
void connectNodesForw(std::shared_ptr<Node> current, std::shared_ptr<Node> next, int pos){…
}
void createNodes(){…
}
};
class Maze
{
private:
Vector<Vector<std::shared_ptr<Node>>> m_grid;
int m_grid_size; // number of cells = m_grid_size x m_grid_size (16 x 16). So this equals to 16.
public:
Maze(int grid_size){
m_grid_size = grid_size;
for (int i{0}; i < m_grid_size; i++){
Vector<std::shared_ptr<Node>> row;
for (int j{ 0 }; j < m_grid_size; j++) {
row.push_back(nullptr);
}
m_grid.push_back(row);
}
setGoalCells(); //Create goal and start cell immediatly when creating the maze
setStartCell();
}
int getGridSize(){
return m_grid_size;
}
Vector<Vector<std::shared_ptr<Node>>> getGrid(){
return m_grid;
}
void setStartCell(){
int x_start, y_start = 0;
m_grid[x_start][y_start] = std::make_shared<Node>(x_start,y_start, false);
}
void setGoalCells(){
int x_low_idx, y_low_idx = m_grid_size/2;
int x_high_idx, y_high_idx = x_low_idx + 1;
for (int i{x_low_idx}; i <= x_high_idx; i++){
for (int j{y_low_idx}; j <= y_high_idx; j++){
m_grid[i][j] = std::make_shared<Node>(i, j, false);
}
}
}
void setNewMaze(Vector<Vector<std::shared_ptr<Node>>> a){
m_grid = a;
}
};
Important functions:
- Checking if the micromouse has reach one of the goal cells:
bool isGoal(){
if (
m_active_cell->getXidx() == 8 && m_active_cell->getYidx() == 8 ||
m_active_cell->getXidx() == 8 && m_active_cell->getYidx() == 9 ||
m_active_cell->getXidx() == 9 && m_active_cell->getYidx() == 8 ||
m_active_cell->getXidx() == 9 && m_active_cell->getYidx() == 9){
return true;
}
return false;
}
- Adjusting the position of the micromouse:
void setPosititon(int value){
if (m_position + value == 360 || m_position + value == -360){
m_position = 0;
}
m_position += value;
}
- Storing the integer and decimal part of a division between a sensor value and 16, separately:
Vector<double> intAndDecPart(double a, double b){
Vector<double> results;
double division_result = a / b;
int integer_part = static_cast<int>(division_result);
double decimal_part = division_result - integer_part;
results.push_back(integer_part);
results.push_back(decimal_part);
return results;
}
- Checking if the micromouse is centered:
bool isCentered(){
int cell_size = m_maze_obj->getGridSize();
double tolerance = 0.05;
Vector<double> right_sensor = intAndDecPart(m_right_sensor_val, cell_size);
Vector<double> left_sensor = intAndDecPart(m_left_sensor_val, cell_size);
Vector<double> front_sensor = intAndDecPart(m_front_sensor_val, cell_size);
if (right_sensor.back() - left_sensor.back() >= -tolerance &&
right_sensor.back() - left_sensor.back() <= tolerance &&
front_sensor.back() >= 0.5 - tolerance && front_sensor.back() <= 0.5 + tolerance ){
return true;
}
return false;
}
- Connecting nodes/cells:
void connectNodesLeft(std::shared_ptr<Node> current, std::shared_ptr<Node> next, int pos){
if (pos == 0){
current->setWestptr(next);
next->setEastptr(current);
}
if (pos == 90 || pos == -270){
current->setNorthptr(next);
next->setSouthptr(current);
}
if (pos == 180 || pos == -180){
current->setEastptr(next);
next->setWestptr(current);
}
if (pos == -90 || pos == 270){
current->setSouthptr(next);
next->setNorthptr(current);
}
}
void connectNodesRight(std::shared_ptr<Node> current, std::shared_ptr<Node> next, int pos){
if (pos == 0){
current->setEastptr(next);
next->setWestptr(current);
}
if (pos == 90 || pos == -270){
current->setSouthptr(next);
next->setNorthptr(current);
}
if (pos == 180 || pos == -180){
current->setWestptr(next);
next->setEastptr(current);
}
if (pos == -90 || pos == 270){
current->setNorthptr(next);
next->setSouthptr(current);
}
}
void connectNodesForw(std::shared_ptr<Node> current, std::shared_ptr<Node> next, int pos){
if (pos == 0){
current->setNorthptr(next);
next->setSouthptr(current);
}
if (pos == 90 || pos == -270){
current->setEastptr(next);
next->setWestptr(current);
}
if (pos == 180 || pos == -180){
current->setSouthptr(next);
next->setNorthptr(current);
}
if (pos == -90 || pos == 270){
current->setWestptr(next);
next->setEastptr(current);
}
}
- Creating nodes:
void createNodes(){
int cell_size = m_maze_obj->getGridSize();
Vector<double> right_sensor = intAndDecPart(m_right_sensor_val, cell_size);
Vector<double> left_sensor = intAndDecPart(m_left_sensor_val, cell_size);
Vector<double> front_sensor = intAndDecPart(m_front_sensor_val, cell_size);
int num_nodes_forw = front_sensor.front();
int num_nodes_l = left_sensor.front();
int num_nodes_r = right_sensor.front();
int act_x_idx = m_active_cell->getXidx();
int act_y_idx = m_active_cell->getYidx();
Vector<Vector<std::shared_ptr<Node>>> grid_vector = m_maze_obj->getGrid();
if (num_nodes_forw >= 1){
if (m_position == 0){
for (int i{0}; i < num_nodes_forw; i++){
act_y_idx++;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx,false);
connectNodesForw(grid_vector[act_x_idx][act_y_idx--], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesForw(grid_vector[act_x_idx][act_y_idx--], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
if (m_position == 90 || m_position == -270){
for (int i{0}; i < num_nodes_forw; i++){
act_x_idx++;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx,false);
connectNodesForw(grid_vector[act_x_idx--][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesForw(grid_vector[act_x_idx--][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
if (m_position == 180 || m_position == -180){
for (int i{0}; i < num_nodes_forw; i++){
act_y_idx--;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx,false);
connectNodesForw(grid_vector[act_x_idx][act_y_idx++], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesForw(grid_vector[act_x_idx][act_y_idx++], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
if (m_position == -90 || m_position == 270){
for (int i{0}; i < num_nodes_forw; i++){
act_x_idx--;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx,false);
connectNodesForw(grid_vector[act_x_idx++][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesForw(grid_vector[act_x_idx++][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
}
if (num_nodes_l >= 1){
if (m_position == 0){
for (int i{0}; i < num_nodes_l; i++){
act_x_idx--;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx, false);
connectNodesLeft(grid_vector[act_x_idx++][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesLeft(grid_vector[act_x_idx++][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
if (m_position == 90 || m_position == -270){
for (int i{0}; i < num_nodes_l; i++){
act_y_idx++;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx, false);
connectNodesLeft(grid_vector[act_x_idx][act_y_idx--], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesLeft(grid_vector[act_x_idx][act_y_idx--], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
if (m_position == 180 || m_position == -180){
for (int i{0}; i < num_nodes_l; i++){
act_x_idx++;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx, false);
connectNodesLeft(grid_vector[act_x_idx--][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesLeft(grid_vector[act_x_idx--][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
if (m_position == -90 || m_position == 270){
for (int i{0}; i < num_nodes_l; i++){
act_y_idx--;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx, false);
connectNodesLeft(grid_vector[act_x_idx][act_y_idx++], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesLeft(grid_vector[act_x_idx][act_y_idx++], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
}
if (num_nodes_r >= 1){
if (m_position == 0){
for (int i{0}; i < num_nodes_r; i++){
act_x_idx++;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx,false);
connectNodesRight(grid_vector[act_x_idx--][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesRight(grid_vector[act_x_idx--][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
if (m_position == 90 || m_position == -270){
for (int i{0}; i < num_nodes_r; i++){
act_y_idx--;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx,false);
connectNodesRight(grid_vector[act_x_idx][act_y_idx++], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesRight(grid_vector[act_x_idx][act_y_idx++], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
if (m_position == 180 || m_position == -180){
for (int i{0}; i < num_nodes_r; i++){
act_x_idx--;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx,false);
connectNodesRight(grid_vector[act_x_idx++][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesRight(grid_vector[act_x_idx++][act_y_idx], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
if (m_position == -90 || m_position == 270){
for (int i{0}; i < num_nodes_r; i++){
act_y_idx++;
if (grid_vector[act_x_idx][act_y_idx] == nullptr){
grid_vector[act_x_idx][act_y_idx] = std::make_shared<Node>(act_x_idx, act_y_idx,false);
connectNodesRight(grid_vector[act_x_idx][act_y_idx--], grid_vector[act_x_idx][act_y_idx], m_position);
} else {
connectNodesRight(grid_vector[act_x_idx][act_y_idx--], grid_vector[act_x_idx][act_y_idx], m_position);
}
}
}
}
m_maze_obj->setNewMaze(grid_vector); //setting the new updated maze to be the grid vector I made changes to.
}
};
I’m fully aware that the createNodes() – function have a lot of redundant computing, and that it (together with the other functions) might contain some logical errors that I have yet to discover since I haven’t tested it yet. But any potential troubleshooting/changes would have to wait until were able to test the final prototype-mouse within the maze, or atleast after the measurement-adjustment functionality is setup. Hopefully I’m able to complete that within next week👍
Discipline – Electrical/Mechanical:
Hugo Valery Mathis Masson-Benoit:
The objective for this week was to solder the PCB. I received the PCB on Monday and soldered right away the component all together.
While double checking everything, I realized that there was a problem with the PCB design. The footprint I used for the magnetic sensor reversed some pins, and so I needed to adapt their placement.
I bended a little bit the pins to make them correspond on the right tracks. This way the sensors should be working.
I’m going to deliver a document to the other members of the group to indicate them which pin corresponds to which component, and how to implement the magnets on the wheels.
Conclusion:
The PCB has been soldered and given to the other members of the group to run the tests and connect the mechanical structure. If there is no problem with the electrical design, my part of the project is done. The end of the hardware is the responsibility of the mechanical engineer.
Objective for next week:
Doing my part for the final presentation of the project and respond to the questions.
Jemima Niquen Tapia:
This week as we already have the PCB, we have been available to prepare the place of the mechanical parts and also of the support points for the second floor. As we have this I have prepared some wires that are specifically made to suit the micro mouse, the size and also the necessary cable terminations to fit with the PCB. We can check it in the first picture, the wires have been cut and solded according to the termination needed and also try to match with the wire color.
Unexpectedly, in the moment of connecting some wires and making some checks we found some problems with the PCB, As we can see in the picture there was some points that we had to effort the soldier. This made it difficult as we thought the problema was something else. When we fixed it, it all work well.
In the end, we have been able to connect the important parts and to check the wires, but we are missing the magnetic sensor connections and we are not sure if we are going to use them yet. We have to talk with the software engineers, anyway as we have the magnetics already in the PCB we are going to implement them.
Cesia Niquen Tapia:
This week , we got the new wheels which are made for improve the attachment and are made mostly mith plastic but the central part that is made with wood which is better attached to the engine.
On the other hand we needed to do the holes of the PCV for all the components, which was kind of difficult due to the early soldering. This caused little modifications in the position of some components. We used two different drills, 3mm and 2.5mm, for the things that had to be well attached, and for the ones where we didn’t have that much space.
Due to the arrival of the PCV we could also do the measurements to design a properly second floor that fits our space and needs and that can withstand the microbit and the battery. And we finally put it all together.
For next week the mechanical and the electronic part have in mind to:
- End the connections and the micromouse structure.
- Do the wheels with the magnets and implement them in wheels correctly.
- Design a battery holder, to have an easy acces to change this.