Tag: Status

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.

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.