Second magnetometer over spi?

[maholli]

from @ecburns33 in #2:

I am working to access an external magnetometer via the payload ports. The data sheet for the magnetometer states the device uses a SPI interface, so I am trying to write code to make this happen. Here is what I've written:

from pycubed import cubesat
import time
import board
import busio

spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)

When I run this code, the following error occurs:
ValueError: SCK in use

To my understanding the SCK is the clock that is used between the board and the external component to standardize data transmission. I've done a little digging and it seems the radio is also using the SPI (and therefore SCK) port. Is this why the "SCK in use" error occurs? If this is the case, is there a workaround, or do I need to access via another interface (I2C, UART, etc)?

You're setting the SPI bus up twice (which is why it's telling you SCK is in use). from pycubed import cubesat does all the initialization for spi, i2c, uart, etc... You can still initialize additional buses, but you need to use other pins. In your case, you don't need another bus, you just need to access the existing SPI bus. try this:

from pycubed import cubesat

spi_bus = cubesat.spi

Then proceed with initializing your external magnetometer from there. Oh and don't forget to set up your chip select pin. any of the remaining GPIO pins on the payload header will work.

There's also another example of of this scenario on code examples page: spi.py where I show how it initialize and use the SPI bus with and without the pycubed.py helper library.

Does this answer your question? Report back with how it goes!

[ecburns33]

from @ecburns33 in #2:

I am working to access an external magnetometer via the payload ports. The data sheet for the magnetometer states the device uses a SPI interface, so I am trying to write code to make this happen. Here is what I've written:
from pycubed import cubesat
import time
import board
import busio
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
When I run this code, the following error occurs:
ValueError: SCK in use
To my understanding the SCK is the clock that is used between the board and the external component to standardize data transmission. I've done a little digging and it seems the radio is also using the SPI (and therefore SCK) port. Is this why the "SCK in use" error occurs? If this is the case, is there a workaround, or do I need to access via another interface (I2C, UART, etc)?

You're setting the SPI bus up twice (which is why it's telling you SCK is in use). from pycubed import cubesat does all the initialization for spi, i2c, uart, etc... You can still initialize additional buses, but you need to use other pins. In your case, you don't need another bus, you just need to access the existing SPI bus. try this:

from pycubed import cubesat

spi_bus = cubesat.spi

Then proceed with initializing your external magnetometer from there. Oh and don't forget to set up your chip select pin. any of the remaining GPIO pins on the payload header will work.

There's also another example of of this scenario on code examples page: spi.py where I show how it initialize and use the SPI bus with and without the pycubed.py helper library.

Does this answer your question? Report back with how it goes!

Thank you so much for the help! I've heeded your advice and am still working to connect to the magnetometer. Based upon the hardware we're using (which I admittedly now understand to be overcomplicated), I have to make several connections in addition to the CS pin; the magnetometer also needs a RESET and DRDY pin to be used in order to make the connection. Here is an example wiring and C++ Arduino code provided by the manufacturer for reference:
http://wiring.org.co/learning/basics/magneticfield.html

I know I can translate most of the code to python for use on the Pycubed board, particularly the math. However, I am still struggling to make some of the connections to the pins as done by the pinMode() and digitalWrite() methods normally used in Arduino.
In referencing the CircuitPython busio library (https://circuitpython.readthedocs.io/en/latest/shared-bindings/busio/#busio.SPI), I see they have several built-in methods for writing to just the MOSI and CS pins, but there doesn't seem to be a way to write to an arbitrarily selected pin. What would be the easiest way to accomplish this? Thanks again!

[maholli]

@ecburns33 Fear not! 😄 There are PyCubed examples for this

• So in addition to the SPI bus, you're saying you need two more general purpose input/ouput (aka GPIO) pins called RESET and DRDY. Can do!
• Don't try and use busio for these pins, busio is for serial bus communication (like SPI or I2C). We just need general control of the digital pin. CircuitPython calls this digitalio.
  • See the pycubed digitalio example here for a taste of how this is done.

Now let's break this down.

1. Here's what the arduino code you linked says for the pins assignments and configuration.

   arduino code

   int SCLKpin = 8;     // magnetometer pin 1
   int MISOpin = 9;     // magnetometer pin 2
   int MOSIpin = 10;    // magnetometer pin 3
   int SSNOTpin = 11;   // magnetometer pin 4
   int DRDYpin = 12;    // magnetometer pin 5
   int RESETpin = 13;   // magnetometer pin 6
   int x = 0;        // magnetic field x axis
   int y = 0;        // magnetic field y axis
   int z = 0;        // magnetic field z axis
   int heading = 0;  // magnetic field heading
   
   void setup()
   {
     Serial.begin(9600);
     pinMode(WLED, OUTPUT);  // turn ON the board LED for diagnostics only
     digitalWrite(WLED, HIGH);
     pinMode(SSNOTpin, OUTPUT);
     pinMode(RESETpin, OUTPUT);
     pinMode(MOSIpin, OUTPUT);
     pinMode(SCLKpin, OUTPUT);
     pinMode(MISOpin, INPUT);
     pinMode(DRDYpin, INPUT);
     digitalWrite(SSNOTpin, LOW);

   Oh man... a little bit farther in the example I see what's likely the source of your confusion. ⚠ They are manually "bit banging" the SPI bus! That's insane and overly complicated. Also, they aren't using the chip select pin, which is very bad practice... We can do better.

   example of where they're "bit banging"

   // specific commands for the sensor
   
   void sendBit(int bit)
   {
     // send the bit on the RISING edge of the clock
     digitalWrite(MOSIpin, bit);
     delay(2);
     digitalWrite(SCLKpin, HIGH);
     delay(2);
     digitalWrite(SCLKpin, LOW);
     delay(2);
   }
   
   int receiveBit()
   {
     // receive the data on the FALLING edge of the clock
     digitalWrite(SCLKpin, HIGH);
     delay(2);
     int bit = digitalRead(MISOpin);
     delay(2);
     digitalWrite(SCLKpin, LOW);
     delay(2);
     return bit;
   }

   Now if you really wanted to, you could "bit bang" in CircuitPython as well. But let's take this one step at a time.

2. Let's first configure your pins. Remember:

   • Reading through pycubed.py helper library will show you examples of this as well. Plus, the SPI example I linked before also includes examples of setting up the chip select pin using digitalio)
   • To determine what pins I could use (assuming you're using the payload header), I referenced the Payloads & Interfacing with External Boards PyCubed page.
   setting up the SPI bus and GPIO pins in CircuitPython

   from pycubed import cubesat
   import board # to access the pin names
   import digitalio # for GPIO pins (RESET and DRDY)
   import time
   
   # pycubed import above already initializes the SPI bus
   # but we can assign it to a variable if you'd like
   spi_bus = cubesat.spi
   
   # setup chip select
   # I chose to use PB17, but you could use whatever you want
   cs_pin = digitalio.DigitalInOut(board.PB17)
   cs_pin.switch_to_output(value=True) # set it off (CS pins are usually inverted. High=off, Low=on)
   
   # setup RESET and DRDY
   # again, I just chose available pins
   reset_pin = digitalio.DigitalInOut(board.PB23)
   reset_pin.switch_to_output(value=False) # set it low
   drdy_pin = digitalio.DigitalInOut(board.PA20)
   drdy_pin.switch_to_input() # this is a pin we want to READ so it's an input

3. Now we're ready to operate your sensor. This is typically when we'd use a library someone else has made, but a quick google search for MicroMag2 shows this magnetometer is old enough that no one has made a library for it in CircuitPython (and the arduino library is 10 years old).

   • FYI: for some things, the magnetometer on-board PyCubed is almost as good as the MicroMag2. 0.3uT resolution with the BMX160 vs 0.02uT with the MicroMag2. But nevertheless, we'll continue with this example
   • Here's a link to the an old MicroMag arduino library. Which is what the folks in the link you sent should have been using (in my opinion).

   Now I don't have time to rebuild the library for you in CircuitPython, but I can show you what to do and point you towards examples of other libraries that use a DRDY pin.

   reset routine from arduino example

   // pulse the reset
   digitalWrite(RESETpin, LOW);
   delay(2);
   digitalWrite(RESETpin, HIGH);
   delay(2);
   digitalWrite(RESETpin, LOW);
   delay(2);

   equivalent CircuitPython reset

   # the reset pin is already low from when we initialized it
   time.sleep(0.02) # sleep for 20ms
   reset_pin.value = 1 # set it high
   time.sleep(0.02) # sleep for 20ms
   reset_pin.value = 0 # set it low

   Sweet, that was easy. Now how should we read data from this sensor without bit banging it like a caveman?

   1. The only other device I could think of that uses SPI and a DRDY pin is this ADC that I wrote a CircuitPython library for a couple years ago (note: DRDY isn't part of SPI it's just an extra thing the sensor manufacturer added to make reading data easier - or harder haha). The library file itself is just this .py file.

   2. You can use patterns from my ADS124S08 library to see how things are done. Also, you don't need a whole separate library file (for now). To make things easy for testing, just cram all your code into one file like my complete test script for you below.

      ⭐ Complete example for MicoMag ⭐

      from pycubed import cubesat
      import board # to access the pin names
      import digitalio # for GPIO pins (RESET and DRDY)
      from adafruit_bus_device import spi_device # this is an SPI helper library make managing the SPI bus simple 
      import time
      
      # pycubed import above already initializes the SPI bus
      # but we can assign it to a variable if you'd like
      spi_bus = cubesat.spi
      
      # setup chip select
      # I chose to use PB17, but you could use whatever you want
      cs_pin = digitalio.DigitalInOut(board.PB17)
      cs_pin.switch_to_output(value=True) # set it off (CS pins are usually inverted. High=off, Low=on)
      
      # setup RESET and DRDY
      # again, I just chose available pins
      reset_pin = digitalio.DigitalInOut(board.PB23)
      reset_pin.switch_to_output(value=False) # set it low
      drdy_pin = digitalio.DigitalInOut(board.PA20)
      drdy_pin.switch_to_input() # this is a pin we want to READ so it's an input
      
      # setup our spi_device helper object
      # note: I'm making a guess the magnetometer uses spi mode 0 (polarity=0, phase=0)
      # also notice we don't do anything with DRDY here b/c it's not part of SPI
      mag_device = spi_device.SPIDevice(spi=spi_bus, chip_select=cs_pin, baudrate=1000000, polarity=0, phase=0)
      
      # reset the magnetometer
      # datasheet says we have to reset it before every measurement so let's make it a function
      def mag_reset():
          # the reset pin is already low from when we initialized it
          time.sleep(0.002) # sleep for 2ms
          reset_pin.value = 1 # set it high
          time.sleep(0.02) # sleep for 20ms
          reset_pin.value = 0 # set it low
          time.sleep(0.002) # sleep for 2ms
      
      # create a blank cmd byte
      # byte arrays can be confusing if you haven't spent time with them before
      cmd_byte = bytearray(1)
      data_bytes = bytearray(2)
      def read(axis='', period=0, timeout=0.1):
          if len(axis) !=1 or not any(ax in axis for ax in 'xy'):
              raise ValueError("axis must be 'x' or 'y'")
          if period not in [2048]: # you can implement more periods from the datasheet
              raise ValueError("select a valid period or implement more from the datasheet")
      
      
          # breakdown of the cmd byte from the datasheet:
          # bits [1:0] = axis select, bits [6:4] = period select
          # I'm not going to worry about the other bits right now
          if   axis == 'x': ax_set = 0b01
          elif axis == 'y': ax_set = 0b10
      
          if period == 2048: per_set = 0b110
      
          # another option would be to set this outside of the read function so you don't waste all this time doing it       over and over again
          cmd_byte[0] = (0 & 0xFC) | ax_set  # mask all but bits 1 and 0 and then set them
          cmd_byte[0] = (cmd_byte[0] & 0x8F) | (per_set<<4) # mask all but bits 6, 5, 4 and then set them
      
          # putting this in a with statement automatically handles the CS pin and whatnot
          with mag_device as dev:
              mag_reset()
      
              # send cmd byte over SPI
              dev.write(cmd_byte)
              
              # wait for DRDY
              # while not drdy_pin.value:
              #     pass
              
              # OR datasheet says you can also just wait like this:
              time.sleep(timeout)
      
              # read out 16 bits (2 bytes) of data
              dev.readinto(data_bytes)
      
          # exiting the with loop closes the SPI connection
          result = (data_bytes[0] << 8) | data_bytes[1]
          return result
      
       # now you get to read the datasheet and determine how to convert the data into something useful :)
       print('raw data:')
       for _ in range(3):
           x_mag=read('x')
           y_mag=read('y')
           print('x: {}, y: {}'.format(x_mag,y_mag))

Whew! Ok well I ended up writing pretty much a full library and example. Hope this helps!

[ecburns33]

Max,
You're a total lifesaver! A big part of this project was migrating previously written code in native Arduino to Python code that could be run through the board. I'm sure the built in magnetometer will be plenty accurate for our purposes, but we had this old external one lying around and I thought it would be good practice to try to connect to it. Sorry for the late response, we've had exams this week and I've been busy with a couple of project deadlines.... I'll work on implementing your code this weekend. Thank you again for the help! So enabling to have a developer this willing to provide assistance!!

-Ethan

[maholli]

Happy to help! 😄

[ecburns33]

I have been working the past couple of days to implement your example. The only changes I have really made are changing the GPIO pins to the specific ones we are using and changing the value of period as initialized in the read() function to 2048. When I run the program, it goes to completion, but always outputs zeros for the data. I've tried checking the connections over and over again and replaced the Mag board with a spare just in case it was a dud, but I can't get the data to output. It seems to me your implementation follows the process to read data as prescribed on the product data sheet. Do you have any ideas for troubleshooting? Thank you always for the help.

[maholli]

@ecburns33 hmm here's somethings to try:

OH! What micromag version is your sensor? I see there are some examples that are powered with 5V. So that likely means that's what the digital VDD is expecting as well. Double check this. 5V is rarely used for these types of things these days, but if that's the case, the PyCubed's 3.3V logic wont be enough.

• Don't try to drive the micromag if you're supplying 5V.
• You'll need to level-shift all your signal lines going from the PyCubed to the micromag. Level shifters are easy to breadboard yourself if you have the parts, but you can also buy these adafruit boards to make it easy.

Troubleshooting tips I was writing when I stumbled upon the 5V thing:

1. use a big timeout value just in case there's something weird there. like this: x_mag=read('x',timeout=5)
2. See if the DRDY pin is every coming up:
   Add the following line: print('DRDY: {}'.format(drdy_pin.value)) after the mag_reset() line and again after the time.sleep(timeout) line and see what values you're seeing. If DRDY never goes high, that means there's something up with the sensor and how it's initializing.

[ecburns33]

@maholli Okay, I made the changes you suggested. Changing the timeout didn't reveal anything more. When I added the print(DRDY) lines, the DRDY always prints false..... could this be because the magnetometer isn't getting the required 5V?

[maholli]

Yep, seems like it. What does your datasheet say it requires? If the datasheet says 5V, make sure to add level-shifters to the signal lines before powering again.

You can snag 5V off the RF regulator (see below), but make sure to add level shifting on the signal lines before connecting those (basically anything except for 5V and GND). If you just want to see if your module powers on, you can disconnect everything -> connect only 5V and GND, -> and use a multimeter to see if DRDY ever goes high. (you could even do this with a benchtop power supply if that's easier)

The RF regulator is off by default. You turn it on with this line of python code:

cubesat.enable_rf.value = 1

You can solder to the ADJ or VRF1 pads (they're connected). Just don't accidentally solder to that 3.3V pad at the bottom of the jumper.

[ecburns33]

Max,
Just a quick update. I busted out a multimeter and began testing some of the pins on the MicroMag. I was using the same 3.3V connection like before and noticed some of the pins on the non-power side were responding like I commanded through the SPI interface, but others were not. I wanted to find another way to check if I had made the right pin connections, so I did a little digging around on my end and found a working ADCS demonstrator in one of our labs that used the same MicroMag. I used that to check the connections and noticed the power supply pin was off by one (my original wiring followed the manufacturer-provided procedure exactly, but I thought I'd move the power supply pin over by one to conform to the ADCS demonstrator wiring just in case). When I did this and ran the modified code, the DRDY pin immediately started switching as expected and the MicroMag started sending over valid data. Thank you so much for the help!!

Ethan