MakerLabLPI · andreeastroia · Dec 8, 2022 · Dec 29, 2022 · Dec 29, 2022 · Dec 29, 2022
diff --git a/README.md b/README.md
@@ -30,6 +30,15 @@ This is the repository of the [LPI](https://www.learningplanetinstitute.org/en),
 * Team formation + Ideation report
 * Project week - Project mainly focusing on solving the challenge while addressing odometry or kinematics problems. Implementation of your own algorithm to optimise the results.
 
+## General Algorithm
+
+![WhatsApp Image 2023-01-05 at 02 10 01](https://user-images.githubusercontent.com/113441374/211695876-3de23d4a-08ad-44cb-9595-b7b99a7c9578.jpg)
+
+## A* Algorithm
+
+![image](https://user-images.githubusercontent.com/113441374/211696021-2a777b58-28ab-4869-af80-ab5d695bcebe.png)
+
+
 # Mini project guide
 Fork this repository and add your team members as collaborators to your fork. Make sure it is a public repository.
 

diff --git a/lib/Flowchart_Astar algorithm.pdf b/lib/Flowchart_Astar algorithm.pdf
diff --git a/lib/algorithm.md b/lib/algorithm.md
@@ -0,0 +1,73 @@
+# Algorithm
+## Path finding and A*
+
+#### A* is a graph traversal and path search algorithm. Starting from a specific starting node of a graph, it aims to find apath to the given goal node having the smallest cost
+
+We are going to take this grid as an example:
+
+![image](https://user-images.githubusercontent.com/113441374/210691268-29917a55-1359-42c9-96c4-0a360b14ac95.png)
+
+
+The grid has a start point, an end point and obstacles
+
+- First, it checks for neighbours. Because our robot can move up,
+down, right or left, it checks for the neighbour that has
+smallest cost.
+
+- The smallest cost, f is the sum of g and h, where:
+    - g = the movement cost to move from the starting point to a given
+square on the grid, following the path generated to get there
+    - h = the estimated movement cost to move from that given square on the grid to
+the final destination
+
+- At each iteration, the f value is calculated
+
+- It keeps track of the paths originating from the start node
+
+- The algorithm is extending the paths one grid cell at a time until its termination criterion is satisfied, which is meeting the end node
+
+## The steps involved in implementation of A*
+
+- Specifying the start and end node
+
+- Creating an open list to store all the nodes that can be taken into account when calculating the path
+
+- Creating a closed list that stores all the nodes that have been visited
+
+- We start with the start node and check its children (up, down, left and right)
+
+- We check if the children are in the maze boundaries, if the identify as an obstacle, or if they were already visited. If they meet any of these requirements, then we skip to the next child and do not calculate the f value, nor assign it to the open list. Otherwise, we calculate the g and h cost that form the final f.
+
+- We then check for the child with the lowest f and make this child the current node. We also append it to the closed list to form the path later
+
+- The iteration continues until the current node will have the same x and y positions as the end node.
+
+- The path will be returned taken into account the parents of the nodes. The path is calculated backwards, starting with the end point and tracing back the parents accordingly.
+
+## Flowchart of A* algorithm
+
+ ![image](https://user-images.githubusercontent.com/113441374/210694023-ff1081c1-a971-48b0-8659-01b11a468859.png)
+
+
+## Movment
+
+## Test the front 
+
+![WhatsApp Image 2023-01-05 at 09 25 47](https://user-images.githubusercontent.com/113441374/210738497-08524a0e-cebb-4d09-93bc-6667d08010e6.jpg)
+
+## frontOpen
+
+![WhatsApp Image 2023-01-05 at 09 25 48](https://user-images.githubusercontent.com/113441374/210738582-f55d6433-0d8e-457a-8c01-411f206d52bc.jpg)
+
+## Go Forward
+
+![WhatsApp Image 2023-01-05 at 09 25 48](https://user-images.githubusercontent.com/113441374/210738674-e10dde17-e0c5-458c-9e5b-c02088b8faa9.jpg)
+
+## Turn left
+
+![WhatsApp Image 2023-01-05 at 09 25 47](https://user-images.githubusercontent.com/113441374/210738742-470fb530-3c18-4797-bcde-74f7c72a3066.jpg)
+
+
+### General Algorithm of movment
+
+![WhatsApp Image 2023-01-05 at 02 10 02](https://user-images.githubusercontent.com/113441374/210738268-da515aec-b926-45a1-8071-9e2a88f34c6f.jpg)
diff --git a/lib/ideation.md b/lib/ideation.md
@@ -0,0 +1,35 @@
+Ideation Report Template
+
+Project Name: Robot MHA
+
+Team: CRI project Link https://github.com/bmarid/robotics_course_2022
+
+Mariia Bai, Andreea Stroia, Hala Albahloul
+
+1. Introduction : what do you want to do  
+    Path planning robot. (8*8, 1 cell - 51 sm)
+
+2. Algorithm / Bibliography 
+A* algorithm
+
+3. How you will solve this problem   
+Code the map, Recognise obstacles, recalculate path, using A* algorithm. 
+
+4. Expected List of Features
+Code a Map
+Recognise obstacles 
+Change/recalculate best path
+
+5. List of equipment needed (if we need to buy)
+Arduino uno
+H-bridge 
+Ultrasonic sensor
+DC-motors
+Jumpers 
+Battery
+Robot pieces
+Wheels
+
+6. References
+https://www.youtube.com/watch?v=6TsL96NAZCo
+
diff --git a/lib/images/forward.jpeg b/lib/images/forward.jpeg
diff --git a/lib/images/front_open.jpeg b/lib/images/front_open.jpeg
diff --git a/lib/images/general_movment_algorithm.jpeg b/lib/images/general_movment_algorithm.jpeg
diff --git a/lib/images/left.jpeg b/lib/images/left.jpeg
diff --git a/lib/images/test_front.jpeg b/lib/images/test_front.jpeg
diff --git a/lib/resources.md b/lib/resources.md
@@ -0,0 +1,15 @@
+# Resources
+
+### Using L298N Dual H-Bridge to control of DC motors:
+https://dronebotworkshop.com/dc-motors-l298n-h-bridge/
+
+### Using Ultrasonic sensor:
+https://www.maxbotix.com/articles/how-ultrasonic-sensors-work.htm
+
+### A* Algorithm
+https://www.youtube.com/watch?v=-L-WgKMFuhE&t=331s
+
+https://www.youtube.com/watch?v=6TsL96NAZCo
+
+https://www.geeksforgeeks.org/a-search-algorithm/
+
diff --git a/lib/schematics/components.md b/lib/schematics/components.md
@@ -0,0 +1,55 @@
+# Circuit and Schematics
+## 1. Circuit 
+![Copy of H-bridge motor driver](https://user-images.githubusercontent.com/113441374/210682973-18f31141-829d-4f7e-8ea8-1e3abdd9150d.png)
+
+
+## 2. Components
+- Arduino Uno.
+
+![image](https://user-images.githubusercontent.com/113441374/210687728-327f0895-2ed0-4d82-b56c-b8b7f33a53a9.png)
+
+
+- L298N Dual H-bridge.
+
+- HC-SR04 Ultrasonic sensor.
+
+- 2 DC motors.
+
+![image](https://user-images.githubusercontent.com/113441374/210687852-0bfac715-8339-416a-8b22-6e41a906753c.png)
+
+- Battery 6v.
+
+![image](https://user-images.githubusercontent.com/113441374/210688150-caf0acda-b1c5-4c2b-9200-30cf57a4ed8c.png)
+
+
+- BreadBoard.
+
+![image](https://user-images.githubusercontent.com/113441374/210687993-6f0da085-5ee1-4233-a764-671feb3f4a3c.png)
+
+- Wires.
+
+  - ### L298N Dual H-bridge
+
+  ![WhatsApp Image 2023-01-05 at 01 37 36](https://user-images.githubusercontent.com/113441374/210739374-1c4d257d-d582-4194-8653-66b8e8871443.jpg)
+
+  An H-bridge is a simple circuit that lets you control a DC motor to go backward or forward.
+
+Changing the polarity of the power supply to DC motor is used to change the direction of rotation.
+Apart from changing the rotation direction, the H-bridge can provide additional operation modes, "brake" and "free run until frictional stop". The H-bridge arrangement is generally used to reverse the polarity/direction of the motor, but can also be used to 'brake' the motor, where the motor comes to a sudden stop, as the motor's terminals are shorted
+
+  - ### HC-SR04 Ultrasonic sensor
+
+![image](https://user-images.githubusercontent.com/113441374/210739285-c5b838a6-2a18-4c3e-858f-190f58706721.png)
+
+   Ultrasonic sensors work by emitting sound waves at a frequency too high for humans to hear. then wait for the sound to be reflected back, calculating distance based on the     time required. 
+    calculated based on this formula: Distance = ½ T x C
+
+   T = Time and C = the speed of sound
+
+  ![WhatsApp Image 2023-01-05 at 01 28 59](https://user-images.githubusercontent.com/113441374/210690752-99c998a2-366d-4235-aff9-a494c9369873.jpg)
+
+  ![WhatsApp Image 2023-01-05 at 01 29 23](https://user-images.githubusercontent.com/113441374/210690803-d6ab0ac6-a0ac-416a-95bb-29af6868a3ea.jpg)
+
+
+
+
diff --git a/src/A* algorithm C b/src/A* algorithm C
@@ -0,0 +1,183 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+//Defining the start and end nodes
+int start_x =1;
+int start_y=0;
+int end_y=5;
+int end_x=9;
+
+//Creating a struct to store all the nodes that the robot can take
+
+typedef struct {
+    int x; //position of x
+    int y; //position of y
+    double f;
+    double g;
+    double h;
+}Node;
+
+typedef struct{
+    Node info;
+    struct List_node* next;
+}List_node;
+
+
+// Creating a simple list to store the nodes
+
+List_node* creation(List_node* new_node, List_node* startnode, Node node, List_node* endnode) {
+
+	new_node->info.x = node.x;
+	new_node->info.y = node.y;
+	new_node->info.g = abs((new_node->info.x - startnode->info.x) + (new_node->info.y - startnode->info.y));
+	new_node->info.h = abs((new_node->info.x - endnode->info.x) + (new_node->info.y - endnode->info.y));
+    new_node->info.f = new_node->info.g + new_node->info.h;
+
+    return new_node;
+}
+
+//Creating a function to insert new nodes
+
+List_node* inseration(List_node* startnode, Node node, List_node* endnode)
+{
+    List_node* new_node = (List_node*)malloc(sizeof(List_node));
+    new_node = creation(new_node, startnode, node, endnode);
+
+	if (startnode)
+	{
+		List_node* aux = startnode;
+		while (aux->next)
+			aux = aux->next;
+		aux->next = new_node;
+	}
+	else
+		startnode = new_node;
+
+    int min = 10000;
+    int count = 0;
+
+    //Allocating memory for the new nodes the robot can take
+    //It can go left, right, down and up
+    List_node* left_node = (List_node*)malloc(sizeof(List_node));
+    List_node* up_node = (List_node*)malloc(sizeof(List_node));
+    List_node* right_node = (List_node*)malloc(sizeof(List_node));
+    List_node* down_node = (List_node*)malloc(sizeof(List_node));
+
+    //The robot goes left
+    if(node.x > 0) { //
+        Node nodeLeft;
+        nodeLeft = node;
+        nodeLeft.x = node.x - 1;
+        left_node = creation(left_node, startnode, nodeLeft, endnode);
+        if(left_node->info.f < min)
+        {
+            min = left_node->info.f;
+            count = 4;
+        }
+    }
+
+    //The robot goes uo
+    if(node.y > 0) {
+        Node nodeUp;
+        nodeUp = node;
+        nodeUp.y = node.y + 1;
+        up_node = creation(up_node, startnode, nodeUp, endnode);
+        if(up_node->info.f < min)
+        {
+            min = up_node->info.f;
+            count = 1;
+        }
+    }
+
+    //The robot goes right
+    if(node.x < 7) {
+        Node nodeRight;
+        nodeRight = node;
+        nodeRight.x = node.x + 1;
+        right_node = creation(right_node, startnode, nodeRight, endnode);
+        if(right_node->info.f < min)
+        {
+            min = right_node->info.f;
+            count = 2;
+        }
+    }
+
+    //The robot goes down
+    if(node.y < 7) {
+        Node nodeDown;
+        nodeDown = node;
+        nodeDown.y = node.y - 1;
+        down_node = creation(down_node, startnode, nodeDown, endnode);
+        if(down_node->info.f < min)
+        {
+            min = down_node->info.f;
+            count = 3;
+        }
+    }
+
+    //The robot goes up
+    if(count == 1) {
+        new_node->next = up_node;
+    } else if (count == 2) {
+        new_node->next = right_node;
+    } else if (count == 3) {
+        new_node->next = down_node;
+    } else {
+        new_node->next = left_node;
+    }
+
+    if(new_node->info.x != end_x && new_node->info.y != end_y)
+        return startnode;
+    else
+        inseration(startnode, node, endnode);
+}
+
+void path(List_node* head)
+{
+	List_node* aux = head;
+	while (aux)
+	{
+		printf("\n(%d, %d) ",
+			aux->info.x, aux->info.y);
+		aux = aux->next;
+	}
+}
+
+void main()
+{
+    //Initializing the end node
+
+    List_node *Endnode;
+    Endnode->info.x = end_x;
+    Endnode->info.y = end_y;
+    Endnode->info.g = 0;
+    Endnode->info.h = 0;
+    Endnode->info.f = 0;
+    Endnode->next = NULL;
+
+    int maze[8][8] =
+            {{0, 0, 1, 0, 0, 0, 0, 0},
+            { 0, 0, 1, 0, 0, 0, 0, 0},
+            { 0, 0, 1, 0, 0, 0, 0, 0},
+            { 0, 0, 1, 0, 0, 0, 0, 0},
+            { 0, 0, 1, 0, 0, 0, 0, 0},
+            { 0, 0, 0, 0, 0, 0, 0, 0},
+            { 0, 0, 1, 0, 0, 0, 0, 0},
+            {0, 0, 1, 0, 0, 0, 0, 0}};
+
+    for(int i = 0; i < 8; i++)
+        for(int j = 0; j < 8; j++) {
+
+            List_node *Startnode;
+            Node node;
+            node.x = start_x;
+            node.y = start_y;
+            node.g = 0;
+            node.h = 0;
+            node.f = 0;
+            Startnode->info = node;
+            Startnode->next = NULL;
+
+            Startnode = inseration(Startnode, node, Endnode);
+        }
+}