Udit’s Status Report for 2/22/20

This week I confirmed that the design I will first be testing is just using the C calls for oscillators on the Decawave/RaspPi chips.

I found enough other people who were able to use this to enough accuracy for TWR/TDoA communication so it is important for us to give it a try.

I wrote a script in both C and python that calculated nanosecond clock ticks using the monotonic performance counter clock. Now we just need to focus on getting the UWB signals sent and received.

Our split up work is being severely hamstrung by that one component so it makes sense for all of us to work on that one part for now.

Also spent significant time this week reading through decawave documentation to start programming a tag software on the decawave chip. I am approaching the problem with Python while Shiva approaches it with C. We will take whichever one works first and run with it. And worked on the design presentation.

Roadblocks maintain programming the decawave chip (as, begrudgingly, Tamal was 100% right about).

Team Status Update for 02/22

This week has been one of setbacks and stalls. Rhea’s progress stalled due to illness and my own progress stalled due to technical difficulties. However, Rhea’s progress is more critical. She has fallen very far behind in terms of tag-anchor communication deliverables. This poses the most severe risk to the project.

To manage this risk, Udit and I will both be setting aside our previous deliverables to work with Rhea on tag-anchor communication. The current anchor-server network difficulties are primarily due to inbuilt issues with Linux, while the tag-anchor communication poses more complex challenges of understanding and implementing custom software. Therefore, we have deemed the anchor-server problems as lower priority to be solved later.

As a result of this, we have also scaled down our mean viable product. Our goal is to get one tag communicating with one anchor, presuming that we will be able to scale the tag-anchor and anchor-server networks up as needed. This change was required to keep the project manageable in the face of unforeseen difficulties while still delivering a viable product. Going forward, we will be aiming for more granular, design-focused deliverables to ensure incremental, consistent, and meaningful progress.

Rhea’s Status Update for 2/22/20

I’ve been incredibly sick this whole week so all my energy has gone towards recovery, and I have been unable to work on the project much.  Due to this, I am behind on my progress.

During lab on Monday, I verified that we can flash an already compiled hex file onto the chips.  I also started working on the code to transfer data from the chips to the Raspberry Pis.

We’ve decided to redistribute my portion since it’s behind and are focusing on getting tag-anchor communication working.  So next week I will be focusing on configuring the chip as an anchor, have it receive a UWB message from a tag, and send a time stamped UWB message back to the tag.

Shiva’s Status Update for 02/22/20

This week, per the desired deliverables laid out in our team’s Gantt Chart, I successfully tested and demonstrated multi-anchor-server communication on February 17th. Unfortunately, I do not have video footage. Shortly after completing that deliverable, my second Raspberry Pi malfunctioned and became unable to connect to my local WiFi networks.  From February 18 through 19, I tried and failed to trouble-shoot this problem. It is still out of commission and so I cannot demonstrate multi-anchor-server communication because I do not have multiple functioning anchors.

As a result, I am currently behind on my next main deliverable:  a 1Mbps load test. I switched gears on February 20 and started writing code for the load test on a single Pi, but it needs to be debugged.

The Gantt chart will need to be redesigned this week. Rhea’s illness has caused her to fall behind.  Because my own work on anchor-server communication has only been slowed down by faulty equipment, I will be moving to assist Rhea with her work on tag-anchor communication:

As a result, the deliverables I want to accomplish in the next week are getting the tag to send pulses and the anchor to receive pulses. Once that is taken care of, I will be using some of the allotted slack time on my own schedule to catch up on the 1 MBPs load & field tests.

Team Status Update for 2/15/20

There remain 2 major questions regarding our success for the project.

  1. Can we program Decawave chips to receive signals and transmit them into a RaspPi?
  2. Can we pull off nanosecond level time sync

The first question seems less problematic since there is a LOT of documentation and forum work on the matter. We are still digging through it to understand, but we feel confident we can get it to work. We are struggling a little bit to get the DW1004C blink code working with the DWM1001 so we may need to push forward the purchase of our DWM1004 tags for proof of concept. It won’t incur significant changes to cost since we just need to order something earlier than expected.

The second we have 2-3 different approaches are going to try. Understanding which approach is likely to work and how to implement them is going to need professor help. We look to try each of the methods as a contingency for the previous. (First clock based only, then TCXO + I2C analog interface (RaspPi or Particle board)).

Luckily, work on the anchor-server communication network is proceeding smoothly. There were some hiccups early on with nonfunctional equipment, but we secured replacements and the networking software has been tested successfully between one anchor and one server. The next step is to test with multiple anchors and one server, which is happening this week per the initial Gantt schedule.

I think we are about a week behind on 2 of the 3 parts than we expected to be. But this is still the design phase and we have a lot of slack so hopefully, we can quickly get back on track.

Our updated Gantt Chart is below:

Gantt Chart for 02/15

Udit’s Status Report for 2/15/20

What was done this week:

The focus of this week was about doing enough preliminary work to validate our design decisions. For me, that meant doing enough research to feel confident about a timing solution that would work on paper.  I have extremely struggled with this goal. I feel like I do not have the technical expertise to understand many of the words I am reading.

Here is a summary of my research:

  • We need <10 ns accuracy between anchors to have a semi-accurate localization
  • There exist TDoA schemes that work without accurate time-sync but seemingly only in research papers and their accuracy results have been insufficient for our requirements
  • I have found at least 2-3 other systems who claim their TDoA anchors use a 38.4MHz TCXO oscillator with a UWB receiver with time sync over UWB with syncs every 150ms
    • Problem is, I don’t understand how any of this works. How does a clock at that slow speed ensure the precision of nanoseconds?
    • Why doesn’t a RPi clock with GHz speed not give nanosecond accuracy with sync?

Frankly, much of this is confusing me and I think I need faculty help. Tamal told me that the RPi clock should theoretically suffice, so I have been trying to get a Rpi4 connected and write a time measuring sync.

The first RPi I got didn’t work and then setting up headless (without a display) took a while. I have not written time code but I have the RPi setup.

That will be the goal for the next week along with getting some help understanding TCXO setups for the next week.

I would say this part of the project is behind our original schedule. That said, the original schedule was mostly assuming the design was done. We want to have this finalized by design next week.

Shiva’s Status Update for 02/15/20

This week, per the desired deliverables laid out in our team’s Gantt Chart, I researched network protocols, learned how to create a chat server and client network, and wrote programs for them in Python. I then successfully sent custom messages from a Raspberry Pi to a Macbook Pro over Wi-Fi.

Per the Gantt chart snap above, the project is slightly behind schedule. This is for two reasons. First, neither of the Raspberry Pi’s that were acquired last week did not post. I did not get my hands on a functioning Pi until this Monday, February 10th. Secondly, I flew into Boston on Sunday for a job interview on Monday, so could not get any work done those two days.

However, I anticipate getting back on schedule and completing my next deliverable, multi-anchor-server communication, by February 18th. This is because the chat server and client programs were designed from the start to support multiple connections. I recently got ahold of a second functioning Pi to test the multi-connection. After that, I want to complete the 1 MBPs load test deliverable by the 21st.

Rhea’s Status Update for 02/15/20

My work this week has mostly been focusing on understanding the Decawave boards and API.  I spent a large amount of time going through a lot of the documentation and examples for DWM 1001 chips and the PANS API.  I set up all the tools for flashing new firmware onto the boards and started working on writing the code to send UWB pulses from the tag.  But working on that made me realize that the PANS API did not give enough access to UWB on the boards.

My plan for next week is to take a look at the Deca Driver library.  That is a much lower level library and gives access to more of the board.  There’s some promising information in the DWM1004 documentation, which leads us to believe we may have to switch to the DWM1004 chips.  I’m going to try and get something working with the boards we currently have, but if it isn’t working by the end of lab Monday, we will probably switch to the DWM1004 chips.