## Bram's Learning Curve 
Here I post my progress on learning and mastering Arduino. I originally did the Game development study but decided to switch to "Technische Informatica". That is why I need to learn everything from scratch, and everything is new to me. 
This is the reason that I made these documents, in order to track my progression in this new study. 

### Buzzer 
For one of my first projects, I wanted to learn how to use a buzzer with different notes. 
To achieve this, I went on a search across sites to see how I can use frequencies to make different sounds. 
Then I came across a teaching site (https://www.codingkids.nl/arduino-buzzer.html) that taught me the language to communicate to the buzzer what frequencies to use. This way I can make any sound come out of this simple buzzer. 

### Arduino Video 
I watched a video about using Arduino and took a lot of op notes along the way.  
The link is: (https://www.youtube.com/watch?v=BLrHTHUjPuw). 
```
// $Arduino information: 

//pinnumber(locatie, in-/output) 

//digitalwrite(locatie, high/low) 

//delay(time in millisec) 

//int... <- variable 

//with a decimal its a double -> 1,2 

//a character is a char -> "a" 

// $serial communications: 

setup: 
Serial.begin(9600) -> the text speed 
Serial.sprintLn(text) 

Loop: 
Serial.print("text") 
Serial.printLn(....) -> variable because no " 

//Ctrl + shift + M = serial monitor. 
The text speed needs to be the same as given. 

// $If Statements: 

if(condition){ 

    action 

}else{ 

    action 

} 

// && = "and" 

// || = "or" 

\/\/For loops: 

For(int*i; i <= 10 ; i++){ 

    serial.print(i) 

} 

// The fading of led's: 

examples, basics, fade 

// servo's  

examples, servo, sweep 
```
### Linux and raspberry PI. 
To gain more knowledge about Linux, I first asked my classmates if they could get me started.  

They showed me how to gain access to a server and told me how to navigate through files. 
By doing this I got taught the following commands: 
```
~ $ 'ls -la' = show file / folders 

~ $ 'top' = see currently running programs 

~ $ 'cd ' = change directory 

~ $ 'mkdir name' = make directory 

~ $ 'touch name' = make file 

~ $ 'ping ip addres' 

~ $ 'ssh username@ip address' = open ssh connection. 
```
### Air, temperature, and all sort of stuff. 

After the Linux coding I decided to take a step back and began gaining experience with sensors. 
I began trying to make our group project's "node" for myself. 
I did this by using one of the main sensors and tried programing it myself. 
I used this website for the information and for the right library:(https://randomnerdtutorials.com/esp32-dht11-dht22-temperature-humidity-sensor-arduino-ide/). 
Aside from the website I used my teammates for help where it was needed. 
I wanted to make my own spin on the original design by including a button to activate the sensor and an LED to show if its on. 
The rest of the tutorial was clear and worked like a charm.  
the code used looks like this:  

Begin by including a specific library for the DHT11.
``` 
#include "DHT.h" 
#define DHTPIN 4 
#define DHTTYPE DHT11  
DHT dht(DHTPIN, DHTTYPE); 
```
using This perticulair serial port, means that you do have to switch to it when you want to see results coming in. 
The dht.begin command starts the process.
```
void setup() { 
//the serial port:
Serial.begin(9600); 

//the initial test if the code works
Serial.println(F("DHTxx test!")); 
//the library start
dht.begin(); 
} 
```
It starts by making float variables, to give over the information.
It also includes a error message in case of no feedback.

```
void loop() { 
  delay(2000); 
  //a float has decimal numbers and the library reads the measurements.
  float h = dht.readHumidity(); 
  float t = dht.readTemperature(); 
  float f = dht.readTemperature(true); 

//isnan = there is no reading , the || is "or"
  if (isnan(h) || isnan(t) || isnan(f)) { 

    Serial.println(F("Failed to read from DHT sensor!")); 

    return; 
  } 
  float hif = dht.computeHeatIndex(f, h); 
  float hic = dht.computeHeatIndex(t, h, false); 

  //all serial.print's send stuff to the serial board to showcase.
  Serial.print(F("Humidity: ")); 
  Serial.print(h); 
  Serial.print(F("%  Temperature: ")); 
  Serial.print(t); 
  Serial.print(F("°C ")); 
  Serial.print(f); 
  Serial.print(F("°F  Heat index: ")); 
  Serial.print(hic); 
  Serial.print(F("°C ")); 
  Serial.print(hif); 
  Serial.println(F("°F")); 
} 
``` 
And the physical board looks like this:  
![Physical DHT11 board off](<assets/DHT11 state 1.jpg>) 
And here it looks in action:  
![physical DHT11 board on](<assets/DHT11 state 2.jpg>) 

Later on, I could expand this code and the physical product to include the rest of the sensors. 

The wiring is shown here:
![my fritzing diagram](assets/DHT11_by_button_fritzing.png)
The red cables are 3v, the black cables are the ground and the green cable is the echo for data.
This version is using a DHT22, this is a updated version of a DHT11 but still provides the same information and still uses the same pins. So i decided to compromise for it, using it in my fritzing diagram.

The wire-frame is shown below:
![wireframe DHT11](assets/DHT11_by_button_wireframe.png)
This helps visualise all connections and shows what parts were used for reproductional .

### Buzzers .pt 2 
I found out how to make multiple buzzers go off with the press of one button and increase as Mutch as there are pins. 
I tried to not look up anything for this one but did ask questions from time to time. 
I designed it to work with scanning if there is any input and then output this signal to activate the buzzers.  
This output signal can activate over multiple pins so this one button can set off all sorts of stuff. 
The code is short and simple:  

``` 
//set up some variables 
int button = 20; 
int buzzerone = 12; 
int buzzertwo = 11; 
```
Now we set the pins up to either input or output a signal.
```
void setup() { 
//put down some pins that will output , and some that input.
pinMode(button, INPUT); 
pinMode(buzzerone, OUTPUT); 
pinMode(buzzertwo, OUTPUT); 
} 
```
Here the button pin will seek a signal, when it is given it will send signals to the other given pins in the if-statement. 
```
void loop() { 
  //read is there is input on the button pin, if so send output to the other pins, otherwise keep them off.
  if(digitalRead(button) == HIGH){ 
    digitalWrite(buzzerone, HIGH); 
    digitalWrite(buzzertwo, HIGH); 
  }else{ 
    digitalWrite(buzzerone, LOW); 
    digitalWrite(buzzertwo, LOW); 
  } 
} 
```  

Here I made the physical design but instead of buzzers I used lights in order to show it working. 
![board turned off.](<assets/Buzzer board off.jpg>) 
And here is the the board working: 
![board working and turned on.](<assets/Buzzer board on.jpg>) 

To Show my wiring more clearly, here is my fritzing board:
![fritzing_buttons pt2](assets/Buzzer_board_fritzing.png)
the red wires are 3v, the black wires are the ground connections.

Here the wireframe is shown for parts specification and possible reproduction:
![wireframe _ buzzers pt2](assets/Buzzer_board_wireframe.png)

### Python For Dummies. 
My job was to make a connection between the WebSocket and the database we had set up, and to do this we wanted to use python. 
To give an easy picture, here is where i would come:
![my datqa-websocket connection](assets/myconnection.png)
It looks easy, but for someone who never worked wit hpython and linux, this will prove to be a challenge.

Because I was totally new to all of python I began asking friends for advice and started asking chatgpt for some examples.
and worked in reverse in order to understand python fully.
I went and looked up fitting tutorials on W3SChools.  
The following were used:  

(https://www.w3schools.com/python/python_mysql_getstarted.asp) 

(https://websockets.readthedocs.io/en/stable/) 

(https://www.w3schools.com/python/python_mysql_insert.asp) 

(https://www.w3schools.com/python/python_json.asp) 

After still not getting it very well i asked Dano (a teammate of mine) if he could teach me some basics, and so we did. 
He taught me how to make a simple calculator and told me why my code worked the way it did. 
(This was the code:

// this prints a cheatsheet to know if the user wants plus or minus.
print("1 = + 2 = -") 
c = int(input()) 

// a input is given for the first number.
print("first number") 
a = input() 

//a input is given for the second number.
print("second number") 
b= input() 

//a if-statement to see if it is plus or minus.
if c == 1: 
    print(int(a) + int(b))  
elif c == 2:  
    print(int(a) - int(b)) 
) 

Even if it looked simple, this was the ignition I needed to understand python better and continue my own research. 

### Python for dummmies pt2
After some intense trail and error, I managed to connect to the websocket.
After wich I also managed to send infromation to the database by including details like pasword and such.
I began investigating deeper and asked for other people's vision on my code.

It wasa hard to notice what problems there were, but eventualy me and a classmate found out that the problem was inside of the database itself instead of the code. So after fixing some issues with the primary keys and some tesing with the code, I managed to fix the issues that popped up. 

Now the code is able to send websocket data to the database under the name of node "1".
This will have to be updated so all names could be sent to the database without causing issues.
But the current code does what we expect from sprint two but I will surely continue working on making it perfect.

### python for dummies pt3
After the sprint review for sprint two, we as a team decided that it was time to make progress with connecting more nodes, and so I did.

I began searching for leads on how to grab information from a database, and used this website to teach me:
https://www.w3schools.com/python/python_mysql_select.asp

Once I figured out how to grab information, I wanted to put it in an array and look if the connected node(wich I put in a varriable) was already known in the array. The webpage for this was: https://stackabuse.com/python-check-if-array-or-list-contains-element-or-value/

This originaly didn't work, and by printing all my variables and the array I initially didn't see anything that would prevent it from working.
But for some reason the given node wouldn't compare itself to the nodes in the array.
That is when I found out the data from the array was in a tuple. So when I changed the variable to turn into a tuple, it worked like a charm.

Then after all of this trouble, I finished by putting the new node MAC (in string format) into the correct collum in the database so this will MAC will be saved in the future. 