Status Report – Page 5 – Project Belka

Team Update for 2/15/2020

What are the most significant risks that could jeopardize the success of the project?

Our biggest risk currently is getting our specific requirements down for what goal we want to accomplish.

We want to be able to create an interesting problem while still meeting the project specs of CubeRover, so we’ve decided to add more rigorous measures that will expand on the current protocols. For instance, in order for Turbo Coding to be truly effective, we must send large data such that our added computation is worth the clock cycles to run.

Another risk that could jeopardize the success of the project is the learning curve for understanding and implementing complex error detection and handling algorithms that all of us are somewhat experienced and familiar. All of us have some experience implementing error detecting and correcting algorithms for data transmission, but to achieve our goal of finding and writing the best algorithms for what we want to achieve, we may be spending an unexpected and greater amount of time implementing such algorithms.

How are these risks being managed? What contingency plans are ready?

The risks are being managed by circumventing most of our outside influence. We are planning to take the essential functions asked to be delivered by CubeRover without only working within the scope of their project. Our contingency plan is that if we do not get all necessary documentation to implement along with their specifications, then we will make the decisions ourselves on what to implement, keeping their core instructions intact. For instance, if we are unsure of whether we need to implement a small number of data packets being sent or a large number, they have different trade-offs depending on implementation, so our goal is to implement a valid solution and verification for both so that we don’t have to spend any time waiting for communication between teams.

The risks will be managed by recognizing when the implementation of certain algorithms may be too difficult and unfit to implement for our project and begin slowing down the progress of the project. If we find ourselves in this situation, the contingency plan will be implementing another algorithm that will successfully error detect the effects but won’t be ultimately optimized to meet the constraints of the project; actually writing the algorithms and verifying that error detecting and handling is successful is upmost priority, and then, we can begin figuring out how to optimize the program given a working program.

Were any changes made to the existing design of the system (requirements, block diagram, system spec, etc)?

There were changing made to the existing design because we added a different way to interface with our Microcontroller from our Computers which will be UART or USART.

Why was this change necessary, what costs does the change incur, and how will these costs be mitigated going forward?

This change was necessary because the current USB slot is being used for loading the program onto the microcontroller, it also adds ease of use to interface through UART.

Provide an updated schedule if changes have occurred.

Our updated Gantt Chart parallelizes the work that we are doing so that we have more time to work on individual responsibilities while still being on schedule.

This is also the place to put some photos of your progress or to brag about a

component you got working.

Mia Han’s Status Update for 2/15/20

What did you personally accomplish this week?

After deciding what each team member is responsible for researching, I was tasked to determine what libraries should be used to implement the API design. We needed decide and figure out how the GUI will transmit control signals to the MCU and how the MCU will send status signals to the GUI; this week, we needed to figure out if we were transmitting data over USB or over UART. Finding different libraries that we could use wasn’t difficult, but finding the best libraries specifically for the STM32 that also met our needs was more challenging. Additionally, we needed to take into account what libraries will be use with each port and the pro’s and con’s of using various different libraries. I went over our decision for using UART and microPython + C here.

The highest priority will be writing the code for the transactions between the GUI and the MCU; once we can successfully test and run the code, we will begin designing and creating the GUI which will be implemented in Python.

Is your progress on schedule or behind?

I believe that my progress is slightly behind; with deciding these libraries, I feel that designing the remaining parts of the project will be easier now that we know what languages and libraries we would like to use. Plus, I can begin finding code samples and begin writing the code for the transactions between the GUI and the MCU. However, some potential issues that may arise are issues integrating the transactions between the MCU and other components like I2C, UART etc with the transactions between the MCU and UART (GUI), an aspect of the design that I haven’t looked too much into yet. These issues may be more apparent once sketching the functionality of the programs and writing a few programs are completed, so hopefully, this should be resolved by next week.

What deliverables do you hope to accomplish in the next week?

This week, I hope to work closely with my team to determine the requirements of priority for each component of our project; once the upmost important requirements are determined, I hope that we can begin designing how each of our responsible portions of the project will be integrated based on each other’s portions need. I hope to begin writing crucial functions for the implementation to verify that it is feasible to integrate transmit and receive signals from the MCU. Additionally, I hope to further research the usage of using UART as a port on the MCU to determine if other issues may arise to ensure that using MicroPython and UART are the best choices for our project.

John Paul Harriman’s Status Report for 2/15/2020

What did you personally accomplish this week on the project? Give files or photos that demonstrate your progress. Prove to the reader that you put sufficient effort into the project over the course of the week (12+ hours).

A lot of the work I did this week was formally putting our meeting work together into a digestible format. I also did more thorough research on what specific error correction code we were going to use since there are multiple benefits and drawbacks to each. LPDC was our frontrunner in the beginning, but we are now shifting towards Turbo Codes since it has become the space pseudo-standard.

You can check out my formal proposal for such a use here.

I also went ahead and re-verified the parts we were using before our plan of purchasing in which I added a new, necessary peripheral in order to act with our microcontroller, which is a USB to TTL connection to help interface with the SMT Microcontroller via UART.

Our group collaborated on what our overall structure is going to be, but I formalized it here.

Our group collaborated on what our overall API is going to be, but I formalized it and reformatted to a more UART-centric format here.

The Turbo code formatting is not well-documented on it’s implementation so that is where the majority of my week went into. Figuring out how exactly to implement this ourselves and deciding whether this will be a viable solution in the long run.

Is your progress on schedule or behind? If you are behind, what actions will be taken to catch up to the project schedule?

According to our initial Gantt chart, we are behind on our progress. We are planning to do order our parts as soon as possible which will allow us to begin our deployment onto each component. The other is while we are waiting for our parts to ship, we hope to do a pre-simulation without outside peripherals which will only be functions running within the command line. We have allowed ourselves a little slack since we initially planned for a sequential implementation instead of parallel, but I would personally like to be much further along in the project.

What deliverables do you hope to complete in the next week?

My deliverable for the next week is to submit the order forms for all the necessary parts. Then start with a base implementation of I2C that will allow passing of data frames between two instances running. Then be able to add error insertion into the protocol through a middleman instance, which will finally be able to detect error. I’m limiting just to error detection for now so that we can establish our upper-bound of our error correction, which is just asking to send the packet again.