Author: pjoyce

This week I was able to sort out how to run the program on the RPi on start-up, allowing it to be used in headless mode.

We tried integrating Ryan’s part and my part today and ran into issues calling his python scripts from my program. The system() command frequently causes the entire Pi to crash. Ryan is attempting to work around this with another scripting tool, while I am trying to troubleshoot the system() command. We also found a small bug in the legality check that I will correct tonight. Otherwise, everything between the hardware and the firmware is working great.

Hoping we can fix everything up for the demo on Monday.

Over Thanksgiving break, I was able to rewrite the firmware with a new library. I ended up using the bcm2835 library after finding out that it still worked on the RPi 4, as it includes both GPIO and SPI functionality.

Vikram and I tested the board with the firmware. After working through some bugs, we are very confident in both the piece detection and legality checking aspects of the project. We also observed that the legality latency is very fast.

I also implemented a function to convert the last played legal move into standard algebraic notation (the most common format of notation). Ryan and I finalized the methods for sending this notation to the website.

After this week, I am back on schedule. I am confident that we will be able to finish integration next week.

This week I wanted to test my firmware on the RPi. Unfortunately, we discovered that the library I had used to write the RPi SPI and GPIO transactions, WiringPi, is no longer supported and we could not download it onto the RPi. I had to find other libraries – spidev for the SPI transactions and pigpio for the GPIO control.

Therefore, I rewrote the firmware to utilize these libraries. The new libraries are not as straightforward to use as WiringPi was, but I am confident that I understand them now and will be able to get the firmware working all the same. I also ordered some cables for the Pi that I didn’t have, so I can test the firmware with my Pi next week while we’re on break.

The lack of progress this week sets me a bit further behind schedule. That said, I will be staying in Pittsburgh over Thanksgiving break and will have some time to dedicate to getting this back on track. This combined with the slack time we have makes me still confident that we will finish on schedule.

We had the interim demos this week, which went well. We were able to get the firmware and board working perfectly, so our sensor demo functioned exactly as planned.

Once the firmware was working on the Arduino, I translated into the c++ that will eventually run on the RPi. This was not too difficult, due to the RPi SPI interface using the WiringPi library being quite similar to Arduino. However, there were some differences that I had to be sure I understood. I also took the opportunity to slightly rearrange the sensor read order – the Arduino firmware writes the sensor data into an array column by column, while the sensors are read row by row, which was confusing and a bit inefficient. The new c++ firmware is easier to read as a result. I was also able to finish implementing the output state logic for the legality check using the GPIO functions of the WiringPi library. The large remaining concern here is that my programs still have to be tested on the RPi itself.

I plan on testing my code on the RPi next week. Again, working on firmware integration took longer than expected, so I am about a week behind schedule. I will aim to get the code functioning so that user testing and remaining hardware testing can begin the week of 11/21.

This week, we decided on our goals for the upcoming design demo on Monday. Our goal for the hardware/firmware side is to be able to read the sensors on the chess board, accurately identify the state of each square (White/Black/No piece), and represent the board graphically (with ascii).

To that end, I spent all of my time this week working with Vikram to get the firmware working and debug the board and code. There were numerous problems that we had to fix, including incorrect SPI usage, a mismatch of the rows and columns in my code, poor connections on the board and more. All in all, we have the board almost entirely working, with just one remaining issue with a piece on square being read as being on two squares. We will tackle this issue tomorrow and hope to have the sensor reading perfect by Monday.

This integration and debugging work took longer than expected, and as a result I was unable to sort out the software interface with Ryan. This goal will be pushed back to next week. I am not concerned by this delay, because it is a lower priority aspect of the project (not needed for the demo) and we have plenty of slack time scheduled.

I spent this week working on the firmware, which will control the ADC and multiplexers on the board. I learned the basics of SPI, which is used to send/receive data with the ADC. I finished writing the control logic in the legality check program, and used a useful C++ library, wiringPi, to add in the controls for the SPI and GPIO pins on the Pi.

After writing most of that firmware, I realized that I don’t have a micro SD to load the program onto the RPi. I ordered one, but it won’t be here by monday to test with the actual board, so I am translating the program into an Arduino sketch. We can use this simple sketch program to ensure that the ADC, multiplexers, and sensors on the board are functioning as expected. Translating my C++ firmware into Arduino is fairly straightforward, as the wiringPi library was made to be similar to Arduino functions.

Overall I am on schedule, and next week I should be able to start working with Ryan on how to send moves from my program to his webapp/server.

During the week of 10/9 to 10/15, almost all of my work on the project was directed to the Design Review Report. It took several hours of writing and editing, and in the end I think we created a very thorough description of our design.

I have mostly used the week of fall break to relax, but I was able to spend some time researching and thinking about what I will do to implement the board’s firmware. The firmware will run on the RPi and communicate with the ADC over SPI and control the multiplexers with gpio logic signals. I have never used SPI before, so I read up on it a bit and found a C++ library that should make using it easier. I’m writing the firmware in C++ because I am already using it for the Legality Check software. I’ll hopefully be able to write the firmware next week and test it with the assembled board over next weekend.

All in all, I am on schedule and have no concerns at the moment.