For this week we were assigned to mill, solder, and program a mil an in-circuit programmer that includes a microcontroller. After quick training on the mill, I got into milling my board. The process was relatively quick and did not require too much creativity. However, I did fail on my first attempt, after interfering with the calibration process while replacing the tip.
If you'll look closely you will see that the resulting board (on the left) is different than the outlines (right and center). That is because I used a slightly different design that Anthony made.

Soldering the components was exciting since it made the board look like an actual functioning chip. I soldered before, and after getting used to the small size of the components the process went pretty well. I soldered two 0_Ω resistors, a 1_μ capacitor, two cable connectors, and a microcontroller.

Programming the chip

Unlike the previous parts, this one was not fast and easy. Installations on an M1 MacBook are a tough mission, and even after 2 hours of terminal commands we could'nt make it work. Both EDBG and pyOCD refused to let me program my chip.
Eventually I gave up and used a Windows computer to program it.

The scanning process was way quicker then I expected. I wanted to scan a small rubber duck and used the Revpoint scanner to do that.
I took a few tries to get it to work, but I was surprised of the results. The model that attached here is a compressed version of the scanning which consisted of much more data, so in practice the scanner can produce much smoother results.

This week was less creatively challenging than most of the weeks of the class. I started by modifying the simple SAM-D11C board and added an LED and a button.
That was the first time I used fusion to design a PCB or designed a circuit in general. It took me some time to get used to the workflow but at the end of the week, I noticed that I felt much more comfortable with that. I was happy to learn another complementary skill after electronics production week and I am looking forward to embedded programming week, which will add another skill on top of these two.
After a pretty straightforward design process, I had my first version of the PCB and was ready to mill. I milled the board and soldered the components and that whole process went smoothly without any issues.
However, programming the board was harder due to the EDBG-mac compatibility problems, but with Anthony's help, I was able to get it programmed with the 'echo' code.

After reviewing my board, I noticed that a lot of optimization can be done to significantly reduce the area of the board and improve the arrangement of the parts.
I started tweaking my routing step by step while making sure I am not violating the design rules. Ultimately, I got a much smaller and better-looking PCB design.
Although I had a programmed board by that point, I wanted to see if the second version is still programmable. I milled and populated the board and went on to program it.
While trying to program it we noticed that when the board and the programmer are connected to different power supplies, the programmer cannot find the board. Anthony suggested that this can happen due to disconnected grounds, and indeed that was the situation.
To solve that, I added a jumper wire between the two disconnected grounds and successfully programmed the board.

Traditional woodworking was a hobby of mine way before coming to MIT, and so far, I have built a few furniture pieces that I am really proud of. However, during this past week, I have learned that computer-controlled woodworking requires different skills, and poses different issues to consider.
The idea of building a chair is sitting at the back of my mind for a long time, and I knew it will be a perfect fit for this week's assignment. I wanted to create a light design with curved surfaces and a smooth appearance, that can fit different environments easily while also keeping an impressive presence.
After sketching the legs and the 'ribs' of the chair, I added the supports and quickly had the first version of the design.

When I started preparing the CAM, I noticed that only cutting the ribs will require seven 48"×48" sheets of OSB, which was much more than I could afford because of both machine time and the amount of material.
I tried to change the design and reduce the amount of material it requires. Making it fit into two OSB sheets while keeping the design characteristics and general appearance was an enjoyable challenge that felt like a puzzle.
Luckily my design was relatively constrained and parametric, so updating it after most of it was complete wasn't extremely hard.
I reduced the number of ribs from 20 to 12, increased the angle of the ribs so it'll be easier to nest them on the sheet, and generally made all the parts smaller. After assembling the chair, I added a support plate at the bottom to make it more robust. After many iterations, I made it fit into two sheets but was concerned that the result will be less stable and too small.

With Anthony's great help, I was able to get the CAM done pretty quickly and had it ready to cut. We added 'dog bones' to all the ribs joints but left the legs as designed to get a cleaner look at the more exposed joints.
The cutting process was surprisingly fast and took less than 15 minutes. However, removing the pieces from the machine bed was a lot more challenging. Since some of them were pretty thin and fragile on their own, it required us to be extra careful and we still broke one of the ribs.
Anthony was able to extract the second sheet as a whole and saved us the trouble of extracting each piece individually. Later we cut a few more ribs from scrap pieces to replace the broken ones. I think that was the most challenging and stressful part of this job and I felt a huge relief when we were done with it.
I got plenty of help from Anthony throughout the week and especially during this part, and I thank him a lot for that.

I started my design from the basic SAM-D11C microcontroller circuit and only added a 10-pin connector, connected to different I/Os, ground, and 5V.
The design was simple but very flexible and can be used for all sorts of tasks depending on the program and the components that are connected to it.
I finished the design, milled, and soldered, and was finally ready to start working on the program! Little did I know that the software library I was planning to use (Adafruit Neopixel) refuses to work with the SAM-D11C and requires stronger microcontrollers. Junhong tried to help me modify the library system files and force it to support the SAM-D11C, and I found this website that described the same problem, but we quickly understood that milling a new board with a different microcontroller will be quicker and easier.

I was less worried about this part of the week and playing with the code and LEDs was fun. I wanted to write a program that takes input from a button and sends 'pulses' through the LEDs strip.
I used an array of 10 integers, each of which can function as an indicator of the starting point of a pulse.
Each button press will take the first array argument that still does not represent a pulse and start incrementing it on each loop iteration. This allows me to have multiple pulses at the same time instead of one.

This was one of the hardest weeks for me in the class so far.
Although I started working on the assignment early in the week, I experienced many troubles with my molds and was able to start casting only the night before class.
After all, I am relatively proud of the result and happy that I could finish on time, considering the circumstances.

My goal was to design a product that will utilize the main advantage of molding and casting - to produce many identical parts quickly.
I remembered seeing a kind of sculpture online that uses many similar 3D printed parts to create an art piece with a "flowing" impression.
I thought I can produce a simple version of a sculpture as such using molding and casting.
I started by designing a sigle part, which was pretty simple using the Form tool on Fusion. Then with the assembly feature, I design a final version of the assembled sculpture.

I used Neil's board as a reference and only changed some of the routings. That time, I didn't plan to use the board to do anything except measure distance, and unfortunately didn't add breakout pins. Because of that, I had to solder many wires to connect the speaker.

Soldering

That was the first time I used the soldering paste, and I am glad it worked on the first try. I found a lot of uncertainty in this process since it is almost impossible to know if the component was correctly placed or well-soldered.
Even after soldering the sensor, there is no way to tell if it's appropriately connected until programming the circuit.

Enclosure

To build the enclosure, I laser-cut the parts from wood and glued them all together. I aimed for a more refined design, yet the result was good and held everything together without too many visible wires. I used a DC motor with a gearbox that was wired to a potentiometer, a switch, and a 9V battery. The motor circuit was completely separate from the sensor board.
When assembling, I tried to use reliable connections, including heat shrinks for the electronics or designated grooves and holes for mechanical connections.

Lastly, to address the noisiness of the sensor output, I added a moving average filter that computes the average value of the last five measurements.
Together with lowering the motor speed, this step dramatically improved the overall outcome.

For this week, I used my board from embedded programming week and wrote a different program to use the addressable LEDs to make a ping pong game!
Due to the flexibility of the board, it didn't require any hardware changes and was fairly easy to implement. I think this is a great example of the flexibility that comes with embedded programming.
I was extremely happy with the result and had a lot of fun making it and playing with it.

This week was a great opportunity to start working on my final project.
I wanted to start building the infrastructure for my chessboard project and aimed to create a board that handles network communication.
My goal was to be able to control the I/O pins of the microcontroller from a distant platform.

I used Neil's example board as a reference and added some breakout pins for some GPIOs. Since this was only a development board, I did not use all the GPIOs of the ESP32.
Milling and soldering were pretty straightforward.

Reset problem

I had a similar problem as I had with my input devices board. The ESP was resetting very frequently and was not stable at all.
With Junhong's help, we found that the problem was that the rise time after a reset was too short, not allowing enough time for the board to stabilize. Junhong suggested an easy fix - adding a capacitor between the reset button and the ground.
I soldered the capacitor as a patch, which immediately solved the problem.

Later I accidentally ripped the reset button and some of the copper around it, so I updated my design and remade the board.
I also used a breadboard to build a simple LED board for testing and laser cut an enclosure.

The FTDI Programmer

Due to the scarcity of FTDI cables in the shop, I used Quentin's design and built an FTDI programmer board.
I've been using it as my only programmer for a few days, and it's working perfectly.

#include 
#if defined(ESP32)
#include 
#elif defined(ESP8266)
#include 
#endif
#include 
#include 

// Provide the token generation process info.
#include "addons/TokenHelper.h"
// Provide the RTDB payload printing info and other helper functions.
#include "addons/RTDBHelper.h"

// Insert Firebase project API Key
#define API_KEY "AIzaSyB-fTzPgR0OgoQQ39NwGTsnaVDQ-6AWDKM"

// Insert RTDB URLefine the RTDB URL */
#define DATABASE_URL "https://m8-chess-default-rtdb.firebaseio.com/"

// Define Firebase Data object
FirebaseData fbdo;

FirebaseAuth auth;
FirebaseConfig config;

#define LED_PIN_0 25
#define LED_PIN_1 26
#define LED_PIN_2 27
#define LED_PIN_3 14
#define LED_PIN_4 12
#define LED_PIN_5 32
#define LED_PIN_6 33

unsigned long sendDataPrevMillis = 0;
int LED0;
int LED1;
int LED2;
int LED3;
int LED4;
int LED5;
int LED6;

float floatValue;
bool signupOK = false;

void setup()
{
    Serial.begin(115200);

    WiFiManager wm;

    wm.resetSettings();

    bool res;
    res = wm.autoConnect("M8_Chessboard", "");

    if (!res)
    {
    Serial.println("Failed to connect");
    }

    Serial.print("Connecting to Wi-Fi");
    while (WiFi.status() != WL_CONNECTED)
    {
    Serial.print(".");
    delay(300);
    }
    Serial.println();
    Serial.print("Connected with IP: ");
    Serial.println(WiFi.localIP());
    Serial.println();

    /* Assign the api key (required) */
    config.api_key = API_KEY;

    /* Assign the RTDB URL (required) */
    config.database_url = DATABASE_URL;

    /* Sign up */
    if (Firebase.signUp(&config, &auth, "", ""))
    {
    Serial.println("ok");
    signupOK = true;
    }
    else
    {
    Serial.printf("%s\n", config.signer.signupError.message.c_str());
    }

    /* Assign the callback function for the long running token generation task */
    config.token_status_callback = tokenStatusCallback; // see addons/TokenHelper.h

    Firebase.begin(&config, &auth);
    Firebase.reconnectWiFi(true);

    pinMode(LED_PIN_0, OUTPUT);
    pinMode(LED_PIN_1, OUTPUT);
    pinMode(LED_PIN_2, OUTPUT);
    pinMode(LED_PIN_3, OUTPUT);
    pinMode(LED_PIN_4, OUTPUT);
    pinMode(LED_PIN_5, OUTPUT);
    pinMode(LED_PIN_6, OUTPUT);
}

void loop()
{
    if (Firebase.ready() && signupOK && (millis() - sendDataPrevMillis > 500 || sendDataPrevMillis == 0))
    {
    sendDataPrevMillis = millis();
    if (Firebase.RTDB.getInt(&fbdo, "/LED/0"))
    {
        if (fbdo.dataType() == "int")
        {
        LED0 = fbdo.intData();
        // Serial.print("LED 0 - ");
        // Serial.print(LED0);
        // Serial.println("");
        if (LED0 == 1)
        {
            digitalWrite(LED_PIN_0, HIGH);
        }
        else
        {
            digitalWrite(LED_PIN_0, LOW);
        }
        }
    }
    else
    {
        Serial.println("0" + fbdo.errorReason());
    }

    if (Firebase.RTDB.getInt(&fbdo, "/LED/1"))
    {
        if (fbdo.dataType() == "int")
        {
        LED1 = fbdo.intData();
        // Serial.print("LED 1 - ");
        // Serial.print(LED1);
        // Serial.println("");
        if (LED1 == 1)
        {
            digitalWrite(LED_PIN_1, HIGH);
        }
        else
        {
            digitalWrite(LED_PIN_1, LOW);
        }
        }
    }
    else
    {
        Serial.println("1" + fbdo.errorReason());
    }

    if (Firebase.RTDB.getInt(&fbdo, "/LED/2"))
    {
        if (fbdo.dataType() == "int")
        {
        LED2 = fbdo.intData();
        // Serial.print("LED 2 - ");
        // Serial.print(LED2);
        // Serial.println("");
        if (LED2 == 1)
        {
            digitalWrite(LED_PIN_2, HIGH);
        }
        else
        {
            digitalWrite(LED_PIN_2, LOW);
        }
        }
    }
    else
    {
        Serial.println("2" + fbdo.errorReason());
    }

    if (Firebase.RTDB.getInt(&fbdo, "/LED/3"))
    {
        if (fbdo.dataType() == "int")
        {
        LED3 = fbdo.intData();
        // Serial.print("LED 3 - ");
        // Serial.print(LED3);
        // Serial.println("");
        if (LED3 == 1)
        {
            digitalWrite(LED_PIN_3, HIGH);
        }
        else
        {
            digitalWrite(LED_PIN_3, LOW);
        }
        }
    }
    else
    {
        Serial.println("3" + fbdo.errorReason());
    }

    if (Firebase.RTDB.getInt(&fbdo, "/LED/4"))
    {
        if (fbdo.dataType() == "int")
        {
        LED4 = fbdo.intData();
        // Serial.print("LED 4 - ");
        // Serial.print(LED4);
        // Serial.println("");
        if (LED4 == 1)
        {
            digitalWrite(LED_PIN_4, HIGH);
        }
        else
        {
            digitalWrite(LED_PIN_4, LOW);
        }
        }
    }
    else
    {
        Serial.println("4" + fbdo.errorReason());
    }

    if (Firebase.RTDB.getInt(&fbdo, "/LED/5"))
    {
        if (fbdo.dataType() == "int")
        {
        LED5 = fbdo.intData();
        // Serial.print("LED 5 - ");
        // Serial.print(LED5);
        // Serial.println("");
        if (LED5 == 1)
        {
            digitalWrite(LED_PIN_5, HIGH);
        }
        else
        {
            digitalWrite(LED_PIN_5, LOW);
        }
        }
    }
    else
    {
        Serial.println("5" + fbdo.errorReason());
    }

    if (Firebase.RTDB.getInt(&fbdo, "/LED/6"))
    {
        if (fbdo.dataType() == "int")
        {
        LED6 = fbdo.intData();
        // Serial.print("LED 6 - ");
        // Serial.print(LED6);
        // Serial.println("");
        if (LED6 == 1)
        {
            digitalWrite(LED_PIN_6, HIGH);
        }
        else
        {
            digitalWrite(LED_PIN_6, LOW);
        }
        }
    }
    else
    {
        Serial.println("6" + fbdo.errorReason());
    }
    }
}

Web app

Since manually changing values through the firebase admin console is cumbersome and slow, I build a JavaScript test app that connects to the same database, reads and changes values, and controls the LEDs.
This tutorial describes most of the process.
I used Firebase hosting for this app, which allowed me to have an easy deployment process and a public domain.

for (let i = 0; i < 7; i++) {
    ref = database.ref("LED/" + i);
    ref.on('value', (snapshot) => {
        val = snapshot.val();
        console.log(val);
        element = document.getElementById("LED" + i)
        if (val == 1) {
            element.innerHTML = "ON";
            element.style.backgroundColor = "green";
        } else {
            element.innerHTML = "OFF";
            element.style.backgroundColor = "red";
        }

    }, (errorObject) => {
        console.log('The read failed: ' + errorObject.name);
    });
}

function tglLED(LEDid) {
    ref = database.ref("LED/" + LEDid);
    ref.get().then((snapshot) => {
        if (snapshot.exists()) {
            ref.set(snapshot.val() * -1);
        } else {
            console.log("No data available");
        }
    }).catch((error) => {
        console.error(error);
    });
}

WiFi Manager

I was proud of the result I had so far but having to hard-code the WiFi credentials every time I moved to a different network made it hard to use the board.
Originally, I thought I'll have to build a mobile app to send WiFi credentials via Bluetooth to the ESP. I was trying to find a minimalist solution for this problem, and everything seemed way too complicated.
After some research, I found this incredible library that handles this burden with a few lines of code.
I had to dive into their weirdly written code to customize the interface to a more user-friendly design, but it was worth it.
The result is a smooth, straightforward process that does not require downloading an app or any special effort from the user.
This tutorial helped me with the installation and configuration of the library.
The code for the WiFi manager is included in the ESP32-Firebase code above.

For interface week, I plan to build a chess app that controls the M8 chessboard using the same infrastructure I developed this week.

Machine week was a lot of fun! Together with my lab mates, we built a cool drawing bot that process images and draw a filtered version of them.

I was curious to learn more about the mechanical aspects of building a machine and specifically designing a gantry system.
We divided the work into different tasks and assigned a few people to each of them.
I was helping with designing and cutting the parts and with assembling the gantry system.
It was a great way to see firsthand the challenges of designing a mechanical machine and the constraints that should be taken into consideration.

A major challenge we had while building the gantry was to make the wheels' mounts fit well to the aluminum extrusion. We solved it by adding fractures to the parts, to create more pressure between the wheels and the rail.
The integration between all the different groups was great, and I was proud of the overall result.

Although I was eager to learn how to weld, I wanted to use wildcard week for my final project. I wanted to use the CNC lathe we have at the EECS shop to make the chess pieces for my final project.

This is a great opportunity to thank Anthony for removing the dust from the old machine and setting it up for this job. Although he likes to complain about this machine, I had a great time using it and felt very comfortable working with it at the end.

I designed a chess set with a modern look to match the 'innovative' feel of the project.
The most challenging piece was the knight since it is not symmetric like the other pieces.
I designed the knight with a revolution of its head and then cut and filed it manually. I also used a Dremel to decorate the rook.

I used black wood stain to color the black pieces of the set and sanded all the pieces for a smooth finish.

This was one of the most fun weeks of the class for me!