DEV Community: Ian Ndeda

Self-Aligning Satellite Dish in Rust: Final

Ian Ndeda — Fri, 29 Nov 2024 03:00:00 +0000

In this part, we'll be largely tying up loose ends in the application logic.

Requirements
Implementation
- Connections
- Auto
- Position Zero
Results
Recommendations

Requirements

1 x Raspberry Pico board
1 x USB Cable type 2.0
1 x HC-05 Bluetooth module
1 x HMC5833L Compass Module
40 x M-M Jumper Wires
2 x Mini Breadboards
2 x SG90 Servo Motor
1 x PTZ Kit
1 x GPS Module
2 x Relay modules
2 x 4.2V Li-ion Batteries
1 x DC-DC Step-down Converter
1 x Diode

Implementation

Connections

The electrical connections will be the same as from the last part. The magnetometer should now be mounted on the PTZ kit to properly capture the heading of the moving system as shown below.

Auto

We are now going to flesh out the auto arm of the application loop by programming for the automatic pan and tilt movements.

We have already found that compass headings obtained from the magnetometer vary significantly when tilted. Coupling a gyroscope with the magnetometer would be the proper solution to achieve tilt-compensated compass headings.

Our makeshift solution to this problem will be to check whether the auto loop is in its first iteration. If so, the PTZ kit must initially face up before determining the compass heading. This is to avoid readings distorted by tilting.

The AUTO_FIRST_ITER flag is set while toggling from manual to auto.

If, however, the auto loop isn't in its first iteration, the heading will be taken at a tilt and the value compared to adjusted_theta, which is simply the heading after the pan and tilt from the first iteration.

Refer to this algorithm for a clearer explanation.

Replace the Uart tests in our setup area with an announcing message: Self-Aligning Satellite Dish in Rust.

We do not need to print the raw GPS data and coordinates; we can just show the look angles and magnetic heading.

Add the following variables that we'll use.

let mut adjusted_theta: f32 = 0.;// adjusted theta; new theta to track, considers tilt
let mut heading = 0.;// magnetic heading
let mut ref_theta = 0.;// reference theta; initial value to be referenced for variance

In the auto arm after acquiring look angles, add the following to enable the auto alignment of the dish.

// Confirm theta == ref_theta from last iteration
// otherwise go back to first iteration
if theta.round() != ref_theta.round() {
    AUTO_FIRST_ITER.borrow(cs).set(true);
}

if AUTO_FIRST_ITER.borrow(cs).get() {
    // Tilt to face up for accurate heading readings
    tilt_angle = 90.;
    position_kit_tilt(pwm2, &mut tilt_angle);

    delay.delay_ms(250);// wait for tilt kit to arrive at 90 deg

    // Get the magnetic heading
    heading = get_magnetic_heading(&mut i2c0);

    writeln!(serialbuf, "> heading: {} deg.\n> tilt: {} deg.",
             heading.round(), &mut tilt_angle).unwrap();
    transmit_uart_data(
        uart_data.as_mut().unwrap(),
        serialbuf);
} else {
    let tilted_heading = get_magnetic_heading(&mut i2c0);// get the adjusted magnetic heading i.e. at a tilt
    heading = tilted_heading;
    theta = adjusted_theta;// we'll now track adjusted theta since we're at a tilt

    writeln!(serialbuf, "adjusted theta: {} deg.", theta).unwrap();
    transmit_uart_data(
        uart_data.as_mut().unwrap(),
        serialbuf);

    writeln!(serialbuf, "> tilted heading: {} deg.\n> tilt: {} deg.",
             heading.round(), &mut tilt_angle).unwrap();
    transmit_uart_data(
        uart_data.as_mut().unwrap(),
        serialbuf);
}

// Pan moded servo cw while heading != theta i.e.
// Dish is not locked with theta
while !heading_within_range(theta, heading) {
    if pan_clockwise(theta, heading) {
        pan(&mut delay, sio.as_mut().unwrap(), Direction::Cw);

        heading = get_magnetic_heading(&mut i2c0);

        writeln!(serialbuf, "Pan Cw: {} --> {}",
                 heading.round(), theta.round()).unwrap();
        transmit_uart_data(
            uart_data.as_mut().unwrap(),
            serialbuf);
    } else {
        pan(&mut delay, sio.as_mut().unwrap(), Direction::Ccw);

        heading = get_magnetic_heading(&mut i2c0);

        writeln!(serialbuf, "Pan Ccw: {} --> {}",
                 heading.round(), theta.round()).unwrap();
        transmit_uart_data(
            uart_data.as_mut().unwrap(),
            serialbuf);
    }
}

Afterwards clear the GGA_ACQUIRED_FLAG to say we are through.

GGA_ACQUIRED.borrow(cs).set(false);// clear the flag

Position Zero

In the manual arm, we need to write code for position Zero: when the system is generally looking North and facing up.

// Face 0° and look up
tilt_angle = 90.;
position_kit_tilt(pwm2, &mut tilt_angle);

delay.delay_ms(250);// wait for tilt kit to arrive at 90 deg

heading = get_magnetic_heading(&mut i2c0);

theta = 0.;

while !heading_within_range(theta, heading) {
    if pan_clockwise(theta, heading) {
    pan(&mut delay, sio.as_mut().unwrap(), Direction::Cw);

    heading = get_magnetic_heading(&mut i2c0);
    } else {
    pan(&mut delay, sio.as_mut().unwrap(), Direction::Ccw);

    heading = get_magnetic_heading(&mut i2c0);
    }
}

writeln!(serialbuf, "heading: {}   tilt angle: {}", 
     heading.round(), tilt_angle).unwrap();
transmit_uart_data(uart_data.as_mut().unwrap(), serialbuf);

Add the following helper functions:

fn tilt_up(phi: f32, tilt_angle: f32) -> bool {
    let tilt = phi - tilt_angle;

    tilt < 0.
}

fn heading_within_range(theta: f32, heading: f32) -> bool {
    // checks whether heading is +/- 2 of desired pan angle
    heading.round() == theta.round() || heading.round() == theta.round() - 1. 
        || heading.round() == theta.round() - 2.
        || heading.round() == theta.round() + 1.
        || heading.round() == theta.round() + 2.
}

fn pan_clockwise(theta: f32, heading: f32) -> bool {
    // Check if pan sd be cw or ccw 
    let pan = theta - heading;

    if pan.abs() < 180. {
        pan > 0.
    } else {
        pan < 0.
    }
}

Results

Here is the final copy of code after the above algorithm has been implemented.

❗ Do not forget to conduct one last calibration with the mounted magnetometer in its final position. You can load the final code from the examples/compass.rs to facilitate this.

The project is complete! We can now remotely control our model satellite dish via Bluetooth and give it commands to run either in auto or manual modes.

Load the program into the Pico in release mode.

cargo run --release

While in manual mode, giving the CW command has an appropriate effect on the value of the compass heading; the same with the CCW command.

The Zero command aligns the system North.

While in auto mode, the kit aligns to the look angles, starting with a pan until theta is achieved and then a tilt up to phi.

The PTZ kit is shown in the demonstration below while in auto mode. The selected GSO satellite is tracked when the entire system is rotated.

Recommendations.

This project took a naive and straightforward approach in fulfilling its objective. There is a lot of room for improvement. Some low-lying picks are listed below:

Introduce the RP2040's watchdog timer.Some of the code we wrote in the project is "blocking," which means that subsequent code must wait until it has finished running. Sometimes these code segments might not finish, freezing the software as a whole. We could use Async Rust or Rust's RTIC framework to write alternative non-blocking programs. We could also use a watchdog timer to break out of these extended loops.
Have more functions returning. In case of an error during a run, the function will simply return the error for handling instead of stalling the entire system.
Use a gyroscope to complement the magnetometer. This will enable the acquisition of tilt-compensated compass headings. Check this.
Implement the entire program as a state machine.
Produce an electrical schematic and PCB for the project.

Self-Aligning Satellite Dish in Rust: Pan Application

Ian Ndeda — Fri, 29 Nov 2024 02:00:00 +0000

In this part we'll implement the relays we tested in the previous example in the project.

Requirements
Implementation
- Connections
- Pan
Results

Requirements

1 x Raspberry Pico board
1 x USB Cable type 2.0
1 x HC-05 Bluetooth module
1 x HMC5833L Compass Module
40 x M-M Jumper Wires
2 x Mini Breadboards
2 x SG90 Servo Motor
1 x PTZ Kit
1 x GPS Module
2 x Relay modules
2 x 4.2V Li-ion Batteries
1 x DC-DC Step-down Converter
1 x Diode

Implementation

Connections

❗ At this point the number of components used has grown so that the computer's USB port may not sufficiently provide power. An external power supply is therefore necessary. I used two 4.2V Li-ion 78000mAh batteries with a DC-DC converter.

Pan

Copy the pan function ,relay initialization pins and the sio handle under the loop's critical section from the previous example to the project.

Under the manual arm of the loop when the direction is selected as clockwise or counterclockwise we want to be able to pan appropriately.

For clockwise direction:

pan(&mut delay, sio.as_mut().unwrap(), Direction::Cw);

For counterclockwise direction:

pan(&mut delay, sio.as_mut().unwrap(), Direction::Ccw);

Results

This will be our updated code.

After flashing and running the program in the Pico, sending the CW command from the Bluetooth Terminal App should pan the PTZ kit clockwise and CCW counterclockwise.

In the next part of the project we'll finalize on the logic of the application.

Self-Aligning Satellite Dish in Rust: Pan Example

Ian Ndeda — Fri, 29 Nov 2024 01:00:00 +0000

Open the examples file, create a relays.rs file, and copy the last iteration of the project code. Clear the critical section inside the loop section.

You may also delete the wfi instruction.

We want to pan the PTZ kit through clockwise (CW) and counterclockwise (CCW) swathes alternatively.

The Relay table from the previous part shows that to pan CW we need to enable Relay 1 while 2 is disabled.

Requirements
Implementation
- Connections
- Pan
Results

Requirements

1 x Raspberry Pico board
1 x USB Cable type 2.0
1 x HC-05 Bluetooth module
18 x M-M Jumper Wires
2 x Mini Breadboards
2 x SG90 Servo Motor
1 x PTZ Kit
2 x Relay Modules

Implementation

Connections

The servos are here fitted into the PTZ kit.

Pan

For CW movement Relay 1 is enabled while 2 is disabled.

// Move servo CW: Relay 1 ON, Relay 2 OFF
sio.gpio_out.modify(|r, w| unsafe { w.bits(r.gpio_out().bits() | 1 << 16)});// Set pin 16 high
sio.gpio_out().modify(|r, w| unsafe { w.bits(r.gpio_out().bits() & !(1 << 17))});// Set pin 17 low

For CCW movement Relay 1 is disabled while 2 is enabled.

// Move servo CCW: Relay 2 ON, Relay 1 OFF
sio.gpio_out().modify(|r, w| unsafe { w.bits(r.gpio_out().bits() | 1 << 17)});// Set pin 17 high
sio.gpio_out().modify(|r, w| unsafe { w.bits(r.gpio_out().bits() & !(1 << 16))});// Set pin 16 low

The above can be combined into a single pan function like so:

fn pan(delay: &mut Delay, sio: &mut SIO, direction: Direction) {
    match direction {
        Direction::Cw => {
        // Move servo CW: Relay 1 ON, Relay 2 OFF
        sio.gpio_out().modify(|r, w| unsafe { w.bits(r.gpio_out().bits() | 1 << 16)});// Set pin 16 high

        delay.delay_ms(10);// delay

        // Put servo OFF
        sio.gpio_out().modify(|r, w| unsafe { w.bits(r.gpio_out().bits() & !(1 << 16))});// Set pin 16 low
        sio.gpio_out().modify(|r, w| unsafe { w.bits(r.gpio_out().bits() & !(1 << 17))});// Set pin 17 low
        },
        Direction::Ccw => {
        // Move servo CCW: Relay 2 ON, Relay 1 OFF
        sio.gpio_out().modify(|r, w| unsafe { w.bits(r.gpio_out().bits() | 1 << 17)});// Set pin 17 high

        delay.delay_ms(10);// delay

        // Put servo OFF
        sio.gpio_out().modify(|r, w| unsafe { w.bits(r.gpio_out().bits() & !(1 << 16))});// Set pin 16 low
        sio.gpio_out().modify(|r, w| unsafe { w.bits(r.gpio_out().bits() & !(1 << 17))});// Set pin 17 low
        },
        _ => {},
    }
}

The pan function moves the servo either CW or CCW depending on the selected direction for 10 milliseconds. Add it into our code.

Since we'll be using SIO to un/set the relay control pins we need to operate inside a critical section as the application loop shares it with the interrupts.

Add the following into the loop section:

cortex_m::interrupt::free(|cs| {
    let mut sio = SIO.borrow(cs).borrow_mut();

    for i in 0..=100 {
    pan(&mut delay, sio.as_mut().unwrap(), Direction::Cw);

    if i == 100 {
        for _ in (0..=100).rev() {
        pan(&mut delay, sio.as_mut().unwrap(), Direction::Ccw);
        }
    }
    }

    delay.delay_ms(500);
});

❗ Comment out the configure_compass function call at the set up area.

Results

We end up with this final copy of our code.

Running the code in the Pico should pan the servo clockwise and counterclockwise.

You may note again that the indication LED blinks at well after 1 second. This is caused by the Delay function we've introduced which blocks interrupts.

In the next part we apply these added functions to the main project program

Self-Aligning Satellite Dish in Rust: Pan Motor

Ian Ndeda — Fri, 29 Nov 2024 00:00:00 +0000

To pan the PTZ kit through 360°, one could simply use a servo motor that spans 360°. In that case, the code that drove the regular 180° servo could have been simply altered to enable the kit's pan. I, however, modified a 180° motor to become a regular DC motor by removing its electronic controller and connecting the power terminals directly.

Requirements
Implementation
- Modifications
- Connections & Operation
- Relays
Final Code

Requirements

1 x SG90 Servo Motor

Implementation

Modifications

To modify the servo, you only need to bypass the control circuitry—the green PCB—and directly connect the DC motor's power lines to the input lines.

Note the orange control line will now be redundant.

This turns the servo into a geared DC motor.

Connections & Operation

To operate this modified motor, we'll need two relays to control it's direction of rotation.

We'll have one line run from the positive terminal of the motor through a relay, Relay 1, and to either the 5V line of our circuit or the common connection depending on the action status of the relay.

The other line will similarly run from the motor's negative terminal through another relay, Relay 2.

The normally on (NO) terminals of both relays will be connected to the 5V line, while the normally closed (NC) terminals are connected to the common line of the circuit.

Initially, both relays are OFF, and the servo experiences no movement as both its terminals are connected to the common line. Putting Relay 1 ON while 2 is OFF, however, causes clockwise movement in the motor as its positive terminal will be on the 5V line while the negative will be on the common.

Relay 1 OFF while Relay 2 is ON results in movement in a counterclockwise direction. All this is summarized in the table below:

Relay 1 Enable	Relay 2 Enable	Servo Movement
0	0	OFF
0	1	Counterclockwise
1	0	Clockwise
1	1	OFF

Relays

The relays are controlled by enable pins, which in our case will be connected to RP2040's GPIO pins. We'll configure these as gp16 and gp17 for Relay 1 and 2 enable terminals, respectively.

// Configure GP16 for Relay 1 Enable
pads_bank0.gpio(16).modify(|_, w| w
               .pue().set_bit()// pullup enable
               .pde().set_bit()// pulldown enable
               .od().clear_bit()// output enable
               .ie().set_bit()// input enable
               );

io_bank0.gpio(16).gpio_ctrl().modify(|_, w| w.funcsel().sio());// set function as sio

sio.gpio_oe().modify(|r, w| unsafe { w.bits(r.gpio_oe().bits() | 1 << 16)});// Output enable for pin 16

// Configure GP17 for Relay 2 Enable
pads_bank0.gpio(17).modify(|_, w| w
               .pue().set_bit()// pullup enable
               .pde().set_bit()// pulldown enable
               .od().clear_bit()// output enable
               .ie().set_bit()// input enable
               );

io_bank0.gpio(17).gpio_ctrl().modify(|_, w| w.funcsel().sio());// set function as sio

sio.gpio_oe().modify(|r, w| unsafe { w.bits(r.gpio_oe().bits() | 1 << 17)});// Output enable for pin 17

Final Code

Rearranging our code so far we'll have this final copy.

In the next part we'll write an example application code that will continuously pan the PTZ kit.

Self-Aligning Satellite Dish in Rust: Servo Application

Ian Ndeda — Thu, 28 Nov 2024 23:00:00 +0000

The tilt motion of our PTZ kit will be controlled by PWM. We shall discuss the mechanics of the pan movement in the next part.

In the previous part we were able to get the servo to sweep through 180 degrees. We'll modify that code and create a function that can drive our servo to any given angle.

Requirements
Implementation
- Connections Diagram
- Functions
- Application
Results

Requirements

1 x Raspberry Pico board
1 x USB Cable type 2.0
1 x HC-05 Bluetooth module
1 x HMC5833L Compass Module
18 x M-M jumper wires
2 x Mini Breadboards
2 x SG90 Servo Motor
1 x PTZ Kit
1 x GPS Module

Implementation

Fix both servos into the PTZ kit.

Our kit will be constrained to move from 0° to 90°. The set-up will be such that at 90° the tilt part of the kit faces up and at 0° it stands vertically. On start-up it should be at 90° for accurate compass heading measurements.

The image above shows the pan kit at different angles. The dotted line traces the line of sight of the satellite dish's receiving device.

Connections Diagram

Please note that the servo motor here is mounted on the PTZ kit.

Functions

We will use code from the sweep function that we wrote for the example in the previous part together with all the changes introduced, i.e., importing CH and setting up delay.

We'll wrap these around another function tilt for cleaner execution and to help in code reuse later.

The tilt function takes the Direction and tilt_angle as arguments and ensures movement is constrained within the 0° - 90° range.

fn tilt(pwm: &CH, delay: &mut Delay, tilt_angle: &mut f32, direction: Direction) {
    if *tilt_angle >= 0. && *tilt_angle <= 90. { 
        // valid movts only if angle within range
        match direction {
            Direction::Up => {
                if *tilt_angle != 0. {// constrain angle within range
                    *tilt_angle -= 1.;// update tilt angle
                    position_kit_tilt(pwm, tilt_angle);
                    delay.delay_ms(1);// delay
                }
            },
            Direction::Down => {
                if *tilt_angle != 90. {// constrain angle within range
                    *tilt_angle += 1.;// update tilt angle
                    position_kit_tilt(pwm, tilt_angle);
                    delay.delay_ms(1);// delay
                }
            },
            _ => {},
        }
    }
}

fn position_kit_tilt(pwm: &CH, tilt_angle: &mut f32) {
    // facing up --> at 90 deg
    // standing vertically --> 0 deg 
    pwm.sweep((90. - tilt_angle.round()) as u16);
}

We have to introduce a global variable that'll hold the updated tilt angle.

static TILT: Mutex<RefCell<Option<f32>>> = Mutex::new(RefCell::new(None));

Initialize it and upload to the actual variable. The system should start with the tilt part of the kit facing up.

let mut tilt_angle = 90.; // initialize tilt angle i.e. kit facing up

position_tilt_kit(&pwm2, &mut tilt_angle);// start position of tilt

cortex_m::interrupt::free(|cs| {
    TILT.borrow(cs).replace(Some(tilt_angle));
});

Application

We can now use PWM in our application code.

In the manual section of the application code, under Up, add the following lines.

tilt(&pwm2, delay.as_mut().unwrap(), tilt_angle.as_mut().unwrap(), Direction::Up);

writeln!(&mut serialbuf, "tilt angle: {}", tilt_angle.unwrap().round()).unwrap();
transmit_uart_data(uart_data.as_mut().unwrap(), serialbuf);

Under Down:

tilt(&pwm2, delay.as_mut().unwrap(), tilt_angle.as_mut().unwrap(), Direction::Down);

writeln!(&mut serialbuf, "tilt angle: {}", tilt_angle.unwrap().round()).unwrap();
transmit_uart_data(uart_data.as_mut().unwrap(), serialbuf);

Results

Rearranging the code we end up with this final copy.

If you run it in the Pico, you should see the PTZ kit initialize facing up on power up and move either up or down depending on the commands given from the Bluetooth Serial App.

Up...

Down...

In the next part we shall implement the pan functionality that will enable the system pan to align with the theta of our look angles.

Self-Aligning Satellite Dish in Rust: Servo Example

Ian Ndeda — Thu, 28 Nov 2024 22:00:00 +0000

In this part, we'll use the configured PWM from the previous part to sweep a servo motor through 180°.

Create a new project file pwm.rs under examples, copy the contents of the last part into it and empty the loop section.

Requirements
Implementation
- Connections Diagram
- sweep
Final Code

Requirements

1 x Raspberry Pico board
1 x USB Cable type 2.0
9 x M-M jumper wires
2 x Mini Breadboards
1 x SG90 Servo Motor

Implementation

Connections Diagram

The electrical connections of the modules will be as shown below.

Sweep

Duty cycle in the RP2040 is achieved by writing a value to the PWM's counter compare register. This value is compared to the value we earlier fixed as the TOP wrap around value (50,000 in our case). The duty cycle can be thus compared: $Cycle=CCTOP+1Duty\ Cycle = {CC \over TOP + 1}$ .

We saw in the last part that the SG90 operates within a duty cycle range of 5 - 10% of a 50Hz PWM signal. With a TOP value of 50,000 this translates to a CC value range of 2500 - 5000.

However, this value seems to vary across suppliers. After testing I found my particular servo's range is 3 - 13%, translating to CC value of 1500 - 6500.

Applying these to a servo sweep of 0° to 180° and back.

Add the below example application code under loop.

// Servo sweep trhough 180
for ccv in 1500..=6500 {
    pwm2.cc().modify(|_, w| unsafe { w.a().bits(ccv) });
    delay.delay_ms(1);

    if ccv == 6500 {
    delay.delay_ms(500);
    for ccv in (1500..=6500).rev() {
        pwm2.cc().modify(|_, w| unsafe { w.a().bits(ccv) });
        delay.delay_ms(1);
    }
}

delay.delay_ms(500);

❗ You may have to tweak the above values for your servo.

At this point it we shall have to add the Delay function to our program. We begin by introducing its handle.

let mut delay = Delay::new(cp.SYST, 125_000_000);

Delay is acquired from the cortex-m crate:

use cortex_m::delay::Delay

❗ We shall comment away the configure_compass function call at the setup section of our code to allow the program to run without the compass being physically attached. Otherwise, the blocking writes of I2C we included earlier in the series will stop the code coming after from running.

Flashing the code thus far into the Pico should sweep the servo from 0° to 180° then 180° back to 0° every half a second.

We can refactor the above above application code into a function sweep as below.

pub fn sweep(pwm: &pwm2, mut degrees: u16) {
    const BASE: u16 = 1500;// here pwm at position 0 degrees

    degrees = BASE + (degrees * 24);// ~28: movt by 1 degree 
    unsafe {
        pwm.cc().modify(|_, w| w.a().bits(degrees) );// move by one degree * no of degrees
    }
}

Import the pwm channel.

use rp2040_pac::pwm::ch::CH;

Our application code will now be:

// Servo sweep through 180
for deg in 0..=180 {
    sweep(pwm2, deg);
    delay.delay_ms(10);

    if deg == 180 {
    delay.delay_ms(500);
    for deg in (0..=180).rev() {
        sweep(pwm2, deg);
        delay.delay_ms(10);
    }
}

delay.delay_ms(500);

Flashing this into the Pico should have the same sweep results as before.

Final Code

The final code up to this point can be found here.

In the next part we apply the PWM in our overall project

Self-Aligning Satellite Dish in Rust: Servo

Ian Ndeda — Thu, 28 Nov 2024 21:00:00 +0000

We'll use servo motors, specifically the SG90, to actuate our PTZ kit. Servo motors are driven by pulse width modulation(PWM) signals.

Servo
Implementation
- PWM
Final Code

Servo

The SG90 is a microservo that can rotate through 180 degrees. It is operated by pulse width modulation (PWM) signals oscillating at 50 Hz. A pulse with a period of 1.5 ms (7.5% duty cycle) will position it to 0 degrees, 2 ms (10% duty cycle) to 90 degrees, and 1 ms (5% duty cycle) to -90 degrees. Feeding a signal with duty cycles ranging from 5 to 10% should therefore sweep the motor from 0 to 180 degrees.

❗ Testing of the servo at different duty cycles is necessary to ascertain the positions at a given duty. There's some variance from one servo to another.

Implementation

PWM

PWM is a common technique used to supply variable power to a system.

The RP2040 has 8 PWM slices, each with two output channels that can be run at different duty cycles. We shall use pwm2 with its second channel for this project.

First we'll need to configure the pins associated with pwm2. The PWM pin map below shows that we can select one of the following pins for pwm2: gp4, gp5, gp20, or gp21. We shall use gp20 in this project.

Under Pins configure the pin.

// Configure GP20 as PWM channel 1A
pads_bank0.gpio(20).modify(|_, w| w
                            .pue().set_bit()// pull up enable
                            .pde().set_bit()// pull down enable
                            .od().clear_bit()// output disable
                            .ie().set_bit()// input enable
                            );

io_bank0.gpio(20).gpio_ctrl().modify(|_, w| w.funcsel().pwm());// connect to matching pwm

The programming parameters for the RP2040's PWM are set using the below formula.

fPWM=fsysperiod=fsys(TOP+1)×(CSR_PH_CORRECT+1)×(DIV_INT+DIV_FRAC16) \begin{split} f_{PWM} &= {f_{sys} \over period}\\ &= {f_{sys} \over (TOP + 1) \times (CSR\_PH\_CORRECT + 1) \times (DIV\_INT + {DIV\_FRAC \over 16})} \end{split}\\

Where:

TOP is the upper limit count of the PWM's counter,
CSR_PH_CORRECT is the phase correction selector that determines whether the PWM's counter counts backwards from TOP,
and DIV_INT and DIV_FRAC are further used in dividing the counter to acquire a final PWM output.

For a wrap value of 50,000 and with phase correction enabled we can get the divider values below:

DIV_INT+DIV_FRAC16=fsys(TOP+1)×(CSR_PH_CORRECT+1)×fPWM=125,000,000(49,999+1)×(1+1)×50=25+0 \begin{split} DIV\_INT + {DIV\_FRAC \over 16} &= {f{sys} \over (TOP + 1) \times (CSR\__PH\_CORRECT + 1) \times f_{PWM}}\\ \\ &= {125,000,000 \over (49,999 + 1) \times (1 + 1) \times 50}\\ \\ &= 25 + 0\\ \end{split}

We will therefore set our DIV_INT as 25 and DIV_FRAC as 0.

// pwm2 set up
let pwm2 = dp.PWM.ch(2);// Acquire handle for pwm slice 2
resets.reset().modify(|_, w| w.pwm().clear_bit());// Deassert pwm

// Configuring pwm2
pwm2.csr().modify(|_, w| w
            .divmode().div()// free runnning counter determined by fractional divider
            .ph_correct().set_bit()// enable phase correction 
            );
pwm2.top().modify(|_, w| unsafe { w.bits(50_000) });// sets the wrap value: TOP
// For a fpwm of 50Hz w/ top of 50000 div need to be 25
pwm2.div().modify(|_, w| unsafe { w.int().bits(25).frac().bits(0) });
pwm2.csr().modify(|_, w| w.en().set_bit());// Enable pwm2

Final Code

Rearranging the code we get this final copy.

In the next part we shall run an example showing PWM in operation.

Self-Aligning Satellite Dish in Rust: Compass Application

Ian Ndeda — Sun, 24 Nov 2024 21:46:01 +0000

In the previous part we were able to receive raw magnetometer data from the HMC5833L module and process it to acquire magnetic heading and strength. We will now apply those functions to our self aligning dish project.

The magnetic heading is important for the project as it allows our mock dish to ascertain its orientation in its attempts to align to the look angles.

Requirements
Implementation
- Connections Diagram
- Functions
Results

Requirements

1 x Raspberry Pico board
1 x USB Cable type 2.0
1 x HC-05 Bluetooth module
1 x HMC5833L Compass Module
15 x M-M jumper wires
2 x Mini Breadboards
1 x Neo-6M GPS Module
Serial Bluetooth App

Implementation

Connections Diagram

Functions

Let's organize the compass configuration code we developed earlier under a function: configure_compass.

fn configure_compass(i2c0: &mut I2C0, uart: &UART0) { // Configure and confirm HMC5833L
    let mut writebuf: [u8; 1];// buffer to hold 1 byte
    let mut writebuf2: [u8; 2];// buffer to hold 2 bytes
    let mut readbuf: [u8; 1] = [0; 1];
    let serialbuf = &mut String::<164>::new();

    // ID the compass
    // Read ID REG A
    writebuf = [IDENTIFICATION_REG_A];
    i2c_write(i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
    i2c_read(i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();
    let id_a = readbuf[0];
    writeln!(serialbuf, "Id reg a: 0x{:02X}", id_a).unwrap();
    transmit_uart_data(&uart, serialbuf);

    // Read ID REG B 
    writebuf = [IDENTIFICATION_REG_B];
    i2c_write(i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
    i2c_read(i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();
    let id_b = readbuf[0];
    writeln!(serialbuf, "Id reg b: 0x{:02X}", id_b).unwrap();
    transmit_uart_data(&uart, serialbuf);

    // Read ID REG C
    writebuf = [IDENTIFICATION_REG_C];
    i2c_write(i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
    i2c_read(i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();
    let id_c = readbuf[0];
    writeln!(serialbuf, "Id reg c: 0x{:02X}", id_c).unwrap();
    transmit_uart_data(&uart, serialbuf);

    if id_a == 0x48 && id_b == 0x34 && id_c == 0x33 {
        writeln!(serialbuf, "Magnetometer ID confirmed!").unwrap();
        transmit_uart_data(&uart, serialbuf);
    }

    // Set compass in continuous mode & confirm
    writebuf2 = [MODE_R, 0x0];
    i2c_write(i2c0, HMC5883L_ADDR, &mut writebuf2).unwrap();

    writebuf = [MODE_R];
    i2c_write(i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
    i2c_read(i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();

    let mode = readbuf[0];
    writeln!(serialbuf, "Mode reg: 0b{:08b}", mode).unwrap();
    transmit_uart_data(&uart, serialbuf);

    //let mode = readbuf[0];
    if (mode & 1 << 1) == 0 && (mode & 1 << 0) == 0  { 
        writeln!(serialbuf, "continuous mode set.").unwrap();
        transmit_uart_data(&uart, serialbuf);
    } else if (mode & 1 << 1) == 0 && (mode & 1 << 0) != 0 {
        writeln!(serialbuf, "single-measurement mode set.").unwrap();
        transmit_uart_data(&uart, serialbuf);
    } else {
        writeln!(serialbuf, "device in idle mode.").unwrap();
        transmit_uart_data(&uart, serialbuf);
    }

    // Set data output rate & number of samples & confirm
    // sample avg = 8; data output rate = 15Hz; normal measurement cfgn
    writebuf2 = [CFG_REG_A, 0b01110000];
    i2c_write(i2c0, HMC5883L_ADDR, &mut writebuf2).unwrap();
    writebuf = [CFG_REG_A];
    i2c_write(i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
    i2c_read(i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();

    let cfg_a = readbuf[0];
    writeln!(serialbuf, "cfg reg a: 0b{:08b}", cfg_a).unwrap();
    transmit_uart_data(&uart, serialbuf);

    // Set Gain & confirm
    // gain = 1090 LSB/Gauss
    writebuf2 = [CFG_REG_B, 0b00100000];
    i2c_write(i2c0, HMC5883L_ADDR, &mut writebuf2).unwrap();

    writebuf = [CFG_REG_B];
    i2c_write(i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
    i2c_read(i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();

    let cfg_b = readbuf[0];
    writeln!(serialbuf, "cfg reg b: 0b{:08b}", cfg_b).unwrap();
    transmit_uart_data(&uart, serialbuf);

    if (cfg_a == 0b01110000) && (cfg_b == 0b00100000)   { 
        writeln!(serialbuf, "cfg regs set.").unwrap();
        transmit_uart_data(&uart, serialbuf);
    }
}

Create another function get_magnetic_heading which returns the heading. We shall sample a number of readings to get a more accurate reading.

fn get_magnetic_heading(i2c0: &mut I2C0) -> f32 { 
    // Read raw data from compass.
    // Capture 50 heading samples and return the average
    let mut count = 0.;
    let samples = 50.;
    let mut headings = 0.;

    while count != samples {
        // Point to the address of DATA_OUTPUT_X_MSB_R
        let mut writebuf = [DATA_OUTPUT_X_MSB_R];
        i2c_write(i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
        // Read the output of the HMC5883L
        // All six registers are read into the
        // rawbuf buffer
        let mut rawbuf: [u8; 6] = [0; 6];
        i2c_read(i2c0, HMC5883L_ADDR, &mut rawbuf).unwrap();

        let x_h = rawbuf[0] as u16;
        let x_l = rawbuf[1] as u16;
        let z_h = rawbuf[2] as u16;
        let z_l = rawbuf[3] as u16;
        let y_h = rawbuf[4] as u16;
        let y_l = rawbuf[5] as u16;

        let x = ((x_h << 8) + x_l) as i16;
        let y = ((y_h << 8) + y_l) as i16;
        let _z = ((z_h << 8) + z_l) as i16;

        // North-Clockwise convention for getting the heading
        let mut heading = (y as f32 + 185.).atan2(x as f32 + 75.);

        heading += MAGNETIC_DECLINATION*(PI/180.);// add declination in radians

        // Check for sign
        if heading < 0. {
            heading += 2.*PI;
        }

        // Check for value wrap
        if heading > 2.*PI {
            heading -= 2.*PI;
        }

        heading *= 180./PI;

        headings += heading;

        count += 1.;
    }

    headings/samples
}

Under the auto arm in the application code we can add the code below to print the magnetic heading.

heading = get_magnetic_heading(i2c.as_mut().unwrap());
writeln!(&mut serialbuf, "heading: {}", heading.round()).unwrap();
transmit_uart_data(uart_data.as_mut().unwrap(), serialbuf);

This will print out the current heading of our mock dish during operation.

Results

Organizing all the code thus far we'll have this final copy.

Loading and running the program in the Pico, we can now be able to see the magnetic heading of our system.

In the next part we look at how we can actuate the PTZ kit so that it aligns with a chosen satellite.

Self-Aligning Satellite Dish in Rust: Compass Example

Ian Ndeda — Sun, 24 Nov 2024 21:43:00 +0000

Create a new file compass.rs under the examples directory and copy the contents of src/main.rs into it. Clear the super loop. We will replace it with an example application code to test the compass section of our project.

Requirements
Implementation
- Connections Diagram
- Raw Data
- Calibration
- Magnetic Heading & Strength
Results

Requirements

1 x Raspberry Pico board
1 x USB Cable type 2.0
1 x HC-05 Bluetooth module
1 x HMC5833L Compass Module
15 x M-M jumper wires
2 x Mini Breadboards

Implementation

Connections Diagram

Raw Data

Under loop we'll read from the HMC5883L's data registers and wait for interrupts.

From the Compass' manual we find that we only have to point to the address of DATA_OUTPUT_X_MSB_R and the pointer automatically updates to read the values from the remaining data registers.

Place the constant DATA_OUTPUT_X_MSB_R.

// Data Registers.
const DATA_OUTPUT_X_MSB_R: u8 = 0x03;// HMC5883L

❗ Please note the order in which the magnetometer produces the output: x, z and then y.

            // Read raw data from compass.
            // Point to the address of DATA_OUTPUT_X_MSB_R
            writebuf = [DATA_OUTPUT_X_MSB_R];
            i2c_write(&mut i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
            // Read the output of the HMC5883L
            // All six registers are read into the
            // rawbuf buffer
            let mut rawbuf: [u8; 6] = [0; 6];
            i2c_read(&mut i2c0, HMC5883L_ADDR, &mut rawbuf).unwrap();

            let x_h = rawbuf[0] as u16;
            let x_l = rawbuf[1] as u16;
            let z_h = rawbuf[2] as u16;
            let z_l = rawbuf[3] as u16;
            let y_h = rawbuf[4] as u16;
            let y_l = rawbuf[5] as u16;

            let x = ((x_h << 8) + x_l) as i16;
            let y = ((y_h << 8) + y_l) as i16;
            let z = ((z_h << 8) + z_l) as i16;

            // Prints raw data
            writeln!(serialbuf, "x: {}  y: {}  z: {}", x, y, z ).unwrap();
            transmit_uart_data(uart_data.as_mut().unwrap(), serialbuf);

Building and loading the program into the Pico will give us raw data from the magnetometer.

cargo run --example compass

Raw compass data should be regularly sent to the Serial console.

Calibration

We can conduct a simple test for our magnetometer to check for accuracy. On a flat surface turn the magnetometer through 360 degrees while recording the output values.

For more reliable results try and conduct the test away from permanent magnets like those in speakers to avoid too much hard iron distortion.

Have the printed raw data into an Excel sheet or similar software and plot the x, y and z points on a scatter graph. A reasonable circle should result. If the circle is not centered at the graph's origin the compass requires calibration.

A quick and dirty solution to this is to introduce offsets that will roughly bring the circle's center to the origin of the graph. Perform the test again until a reasonable circle is achieved. For my case I found that I had to add 75, 185 and 115 to the x, y and z coordinates.

Note that these values will be different at different locations. This lopsidedness of the circle is due to magnetic noise from the vicinity of the magnetometer. Introducing a permanent magnet near it for example will result in different values.

Before deploying the project we should remember to conduct another calibration while the magnet sits in its final position.

Correct the printed raw data.

            // Prints raw data
            writeln!(serialbuf, "x: {}  y: {}  z: {}", x + 75, y + 185, z + 115).unwrap();
            transmit_uart_data(uart_data.as_mut().unwrap(), serialbuf);

Magnetic Heading & Strength

We can now calculate the magnetic heading from the raw data above. There are a number of configurations with which to translate this raw data.

We shall use the North-Clockwise convention as it has the x-axis pointing North which aligns with our final project design.

            // North-Clockwise convention
            let mut heading = (y as f32 + 185.).atan2(x as f32 + 75.);

Continue by adding the magnetic declination to the heading value, converting to radians, handling any instances of overflow and finally converting back to degrees for printing.

Do not forget to declare the declination constant. This value is different for every location. You can check for your area here.

const MAGNETIC_DECLINATION: f32 = 1.667;

            heading += MAGNETIC_DECLINATION*(PI/180.);// add declination in radians

            // Check for sign
            if heading < 0. {
                heading += 2.*PI;
            }

            // Check for value wrap
            if heading > 2.*PI {
                heading -= 2.*PI;
            }

            heading *= 180./PI;

From the raw magnetic data the magnetic strength can also be calculated. We first factor in the Magnetometer Gain we set in the earlier part.

            // Calculating mag strength
            let x = (f32::from(x) + 75.)/ 1090.;
            let y = (f32::from(y) + 185.)/ 1090.;
            let z = (f32::from(z) + 115.)/ 1090.;

            let mag = (x*x + y*y + z*z).sqrt();

Printing the results...

            writeln!(serialbuf, "{} deg. {} uT", heading.round(), (mag*100.).round()).unwrap();
            transmit_uart_data(uart_data.as_mut().unwrap(), serialbuf);

Results

Here is the final code of this part.

Flashing into the Pico we should be able to see the printed values of the raw magnetic values the heading and magnetic strength.

In the next part of the series we'll apply the above to our larger project.

Self-Aligning Satellite Dish in Rust: Compass

Ian Ndeda — Sun, 24 Nov 2024 21:41:51 +0000

In our project we'll need to know the magnetic heading at any given position to help in precise alignment of the kit. For this we'll use a HMC5883L magnetometer module which communicates with other devices via I2c.

Requirements
Connections
I2C Configuration
HMC5883L Configuration
- Identification
- Mode
- Out Rate and Gain
Final Code

Requirements

1 x Raspberry Pico board
1 x USB Cable type 2.0
1 x HC-05 Bluetooth module
1 x HMC5833L Compass Module
15 x M-M jumper wires
2 x Mini Breadboards

Connections

I2C Configuration

The I2C peripheral of the Pico will first need to be configured to enable communication with the HMC5883L. The Pico board has two similar I2C peripherals. We'll use I2C0 for this project.

Like most peripherals the I2Cs have associated pins which have to be configured. I2C0 can use gp4 as its data pin (SDA) and gp5 as its clock pin (SCL).

Under pins section in our set up we configure the pins as below.

// Configure gp4 as I2C0 SDA pin
pads_bank0.gpio(4).modify(|_, w| w
               .pue().set_bit() //pull up enable
               .od().clear_bit() //output disable
               .ie().set_bit() //input enable
               );

io_bank0.gpio(4).gpio_ctrl().modify(|_, w| w.funcsel().i2c()); 

// Configure gp5 as I2C0 SCL pin
pads_bank0.gpio(5).modify(|_, w| w
               .pue().set_bit() //pull up enable
               .od().clear_bit() //output disable
               .ie().set_bit() //input enable
               );

io_bank0.gpio(5).gpio_ctrl().modify(|_, w| w.funcsel().i2c());

We first have to attain a handle for I2C0.

// Set up I2C
let mut i2c0 = dp.I2C0;
resets.reset().modify(|_,w| w.i2c0().clear_bit());

The Pico will be set as the master and the magnetometer as the slave. The Pico's manual provides important information for this configuration.

i2c0.ic_enable().modify(|_, w| w.enable().clear_bit());// disable i2c
// select controller mode & speed
i2c0.ic_con().modify(|_, w| {
    w.speed().fast();
    w.master_mode().enabled();
    w.ic_slave_disable().slave_disabled();
    w.ic_restart_en().enabled();
    w.tx_empty_ctrl().enabled()
});
// Clear FIFO threshold
i2c0.ic_tx_tl().write(|w| unsafe { w.tx_tl().bits(0) });
i2c0.ic_rx_tl().write(|w| unsafe { w.rx_tl().bits(0) });

We have to set up the COUNT registers before using the I2C. From the RP2040's manual we learn that the minimum SCL high and low values are 600ns and 1300ns respectively.

These are used to find the high and low count periods which are used to program the respective counters.

// IC_xCNT = (ROUNDUP(MIN_SCL_HIGH_LOWtime*OSCFREQ,0))
// IC_HCNT = (600ns * 125MHz) + 1
// IC_LCNT = (1300ns * 125MHz) + 1
i2c0.ic_fs_scl_hcnt().write(|w| unsafe { w.ic_fs_scl_hcnt().bits(76) });
i2c0.ic_fs_scl_lcnt().write(|w| unsafe { w.ic_fs_scl_lcnt().bits(163) });

We finally have to perform spike suppression and program the data hold time during transmission.

// spkln = lcnt/16;
i2c0.ic_fs_spklen().write(|w| unsafe {  w.ic_fs_spklen().bits(163/16) });
// sda_tx_hold_count = freq_in [cycles/s] * 300ns for scl < 1MHz
let sda_tx_hold_count = ((125_000_000 * 3) / 10000000) + 1;
i2c0.ic_sda_hold().modify(|_r, w| unsafe { w.ic_sda_tx_hold().bits(sda_tx_hold_count as u16) });

I2C0 is now set up. We equally have to configure the HMC5883L.

HMC5883L configuration

First we'll write helper functions for reading and writing the I2C lines.

Configuring the magnetometer requires writing to specific registers. The below functions are light tweaks from the rp2040-hal crate. Overall we follow three steps:

Disable the I2C
Write the slave address
Enable the I2C

fn i2c_read(
    i2c0: &mut I2C0,
    addr: u16,
    bytes: &mut [u8],
) -> Result<(), u32> {
    i2c0.ic_enable().modify(|_, w| w.enable().clear_bit());// disable i2c
    i2c0.ic_tar().modify(|_, w| unsafe { w.ic_tar().bits(addr) });// slave address
    i2c0.ic_enable().modify(|_, w| w.enable().set_bit());// enable i2c

    let last_index = bytes.len() - 1;
    for (i, byte) in bytes.iter_mut().enumerate() {
        let first = i == 0;
        let last = i == last_index;

        // wait until there is space in the FIFO to write the next byte
        while TX_FIFO_SIZE - i2c0.ic_txflr().read().txflr().bits() == 0 {}

        i2c0.ic_data_cmd().modify(|_, w| {
            if first {
                w.restart().enable();
            } else {
                w.restart().disable();
            }

            if last {
                w.stop().enable();
            } else {
                w.stop().disable();
            }

            w.cmd().read()
        }); 

        //Wait until address tx'ed
        while i2c0.ic_raw_intr_stat().read().tx_empty().is_inactive() {}
        //Clear ABORT interrupt
        //self.i2c0.ic_clr_tx_abrt.read();

        while i2c0.ic_rxflr().read().bits() == 0 {
            //Wait while receive FIFO empty
            //If attempt aborts : not valid address; return error with
            //abort reason.
            let abort_reason = i2c0.ic_tx_abrt_source().read().bits();
            //Clear ABORT interrupt
            i2c0.ic_clr_tx_abrt().read();
            if abort_reason != 0 {
                return Err(abort_reason)
            } 
        }

        *byte = i2c0.ic_data_cmd().read().dat().bits();
    }

    Ok(())
}

fn i2c_write(
    i2c0: &mut I2C0,
    addr: u16,
    bytes: &[u8],
) -> Result<(), u32> {
    i2c0.ic_enable().modify(|_, w| w.enable().clear_bit());// disable i2c
    i2c0.ic_tar().modify(|_, w| unsafe { w.ic_tar().bits(addr) });// slave address
    i2c0.ic_enable().modify(|_, w| w.enable().set_bit());// enable i2c

    let last_index = bytes.len() - 1;
    for (i, byte) in bytes.iter().enumerate() {
        let last = i == last_index;

        i2c0.ic_data_cmd().modify(|_, w| {
            if last {
                w.stop().enable();
            } else {
                w.stop().disable();
            }
            unsafe { w.dat().bits(*byte)}
        }); 

        // Wait until address and data tx'ed
        while i2c0.ic_raw_intr_stat().read().tx_empty().is_inactive() {}
        // Clear ABORT interrupt
        // self.i2c0.ic_clr_tx_abrt.read();

        // If attempt aborts : not valid address; return error with
        // abort reason.
        let abort_reason = i2c0.ic_tx_abrt_source().read().bits();
        // Clear ABORT interrupt
        i2c0.ic_clr_tx_abrt().read();
        if abort_reason != 0 {
            // Wait until the STOP condition has occured
            while i2c0.ic_raw_intr_stat().read().stop_det().is_inactive() {}
            // Clear STOP interrupt
            i2c0.ic_clr_stop_det().read().clr_stop_det();
            return Err(abort_reason)
        } 

        if last {
            // Wait until the STOP condition has occured
            while i2c0.ic_raw_intr_stat().read().stop_det().is_inactive() {}
            // Clear STOP interrupt
            i2c0.ic_clr_stop_det().read().clr_stop_det();
        }
    }

    Ok(())
}

Import I2C0.

use rp2040_pac::I2C0;

Add the TX_FIFO_SIZE constant.

// Global constants
const TX_FIFO_SIZE: u8 = 16;// I2C FIFO size

Create buffer to hold data to be sent and received via I2C.

// Buffers
let mut writebuf: [u8; 1];// buffer to hold 1 byte
let mut readbuf: [u8; 1] = [0; 1];

Identification

We can begin by confirming the identification of the HMC5883L. The chip has three Identification registers, A, B and C, holding the values 48, 34 and 33 respectively.

To read a register in the compass we first have to send the slave address with the command bit set to read followed by a pointer to the address whose contents we want to read.

Reading ID Reg. A for example we have to send 0x3D 0x10.

Before proceeding further we should create the magnetometer's addresses constants to help write cleanly.

Add the following to our global constant section

// Slave Address
const HMC5883L_ADDR: u16 = 30;

// ID
const IDENTIFICATION_REG_A: u8 = 0xA;// HMC5883L
const IDENTIFICATION_REG_B: u8 = 0xB;// HMC5883L
const IDENTIFICATION_REG_C: u8 = 0xC;// HMC5883L

Continuing the configuration...

// Configure and confirm HMC5833L
// ID the compass
// Read ID REG A
writebuf = [IDENTIFICATION_REG_A];
i2c_write(&mut i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
i2c_read(&mut i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();
let id_a = readbuf[0];
writeln!(serialbuf, "Id reg a: 0x{:02X}", id_a).unwrap();
transmit_uart_data(&uart_data, serialbuf);

// Read ID REG B 
writebuf = [IDENTIFICATION_REG_B];
i2c_write(&mut i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
i2c_read(&mut i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();
let id_b = readbuf[0];
writeln!(serialbuf, "Id reg b: 0x{:02X}", id_b).unwrap();
transmit_uart_data(&uart_data, serialbuf);

// Read ID REG C
writebuf = [IDENTIFICATION_REG_C];
i2c_write(&mut i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
i2c_read(&mut i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();
let id_c = readbuf[0];
writeln!(serialbuf, "Id reg c: 0x{:02X}", id_c).unwrap();
transmit_uart_data(&uart_data, serialbuf);

if id_a == 0x48 && id_b == 0x34 && id_c == 0x33 {
    writeln!(serialbuf, "Magnetometer ID confirmed!").unwrap();
    transmit_uart_data(&uart_data, serialbuf);
}

Flash the program thus far into the Pico. The compass should be positively identified.

Mode

We have to set the compass to be in continuous mode.

To read a register in the compass we first have to send the slave address with command bit set to write followed by a pointer to the address to which we want to write. The data to written then follows.

Setting the compass in continuous mode for example requires that we write 0x0 to the MODE Register. Sending 0x3C 0x02 0x00 writes 0x0 to the MODE register pointed by 0x02.

First we create a buffer capable of holding two bytes.

let mut writebuf2: [u8; 2];// buffer to hold 2 bytes

Introduce the MODE Register pointer in the global constants.

// Mode Register.
const MODE_R: u8 = 0x02; // HMC5883L

Configuring the compass...

// Set compass in continuous mode & confirm
writebuf2 = [MODE_R, 0x0];
i2c_write(&mut i2c0, HMC5883L_ADDR, &mut writebuf2).unwrap();

We can now read the contents of the register to confirm that the magnetometer has indeed been correctly set.

// Set compass in continuous mode & confirm
writebuf2 = [MODE_R, 0x0];
i2c_write(&mut i2c0, HMC5883L_ADDR, &mut writebuf2).unwrap();

//writebuf = [MODE_R];
//i2c_write(&mut i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
i2c_read(&mut i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();

let mode = readbuf[0];
writeln!(serialbuf, "Mode reg: 0b{:08b}", mode).unwrap();
transmit_uart_data(&uart_data, serialbuf);

//let mode = readbuf[0];
if (mode & 1 << 1) == 0 && (mode & 1 << 0) == 0  { 
    writeln!(serialbuf, "continuous mode set.").unwrap();
    transmit_uart_data(&uart_data, serialbuf);
} else if (mode & 1 << 1) == 0 && (mode & 1 << 0) != 0 {
    writeln!(serialbuf, "single-measurement mode set.").unwrap();
    transmit_uart_data(&uart_data, serialbuf);
} else {
    writeln!(serialbuf, "device in idle mode.").unwrap();
    transmit_uart_data(&uart_data, serialbuf);
}

Output Rate and Gain

The data output rate and gain can be set in a similar manner.

First add the Magnetometer's address pointers.

// Configuration Register A
const CFG_REG_A: u8 = 0x0;// HMC5883L

// Configuration Register B
const CFG_REG_B: u8 = 0x01;// HMC5883L

For a sample average of 8, data output rate of 15Hz and normal measurement configuration we'll have to write 0b01110000 to CFG_REG_A.

// Set data output rate & number of samples & confirm
// sample avg = 8; data output rate = 15Hz; normal measurement cfgn
writebuf2 = [CFG_REG_A, 0b01110000];
i2c_write(&mut i2c0, HMC5883L_ADDR, &mut writebuf2).unwrap();
writebuf = [CFG_REG_A];
i2c_write(&mut i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
i2c_read(&mut i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();

let cfg_a = readbuf[0];
writeln!(serialbuf, "cfg reg a: 0b{:08b}", cfg_a).unwrap();
transmit_uart_data(&uart_data, serialbuf);

For a gain of 1090 LSB/Gauss we have to write 0b00100000 to CFG_REG_B.

// Set Gain & confirm
// gain = 1090 LSB/Gauss
writebuf2 = [CFG_REG_B, 0b00100000];
i2c_write(&mut i2c0, HMC5883L_ADDR, &mut writebuf2).unwrap();

writebuf = [CFG_REG_B];
i2c_write(&mut i2c0, HMC5883L_ADDR, &mut writebuf).unwrap();
i2c_read(&mut i2c0, HMC5883L_ADDR, &mut readbuf).unwrap();

let cfg_b = readbuf[0];
writeln!(serialbuf, "cfg reg b: 0b{:08b}", cfg_b).unwrap();
transmit_uart_data(&uart_data, serialbuf);

if (cfg_a == 0b01110000) && (cfg_b == 0b00100000) { 
    writeln!(serialbuf, "cfg regs set.").unwrap();
    transmit_uart_data(&uart_data, serialbuf);
}

Flashing the code we should be able to monitor the configuration of the compass.

Final Code

The updated and rearranged code will be as so.

In the next part we'll run a simple example to demonstrate the working of the HMC5833L.

Self-Aligning Dish in Rust: GPS Application

Ian Ndeda — Sun, 24 Nov 2024 21:35:00 +0000

We'll now apply the code from our preceding example program to our overall project.

Requirements
Implementation
Connections
Results

Requirements

1 x Raspberry Pico board
1 x USB Cable type 2.0
1 x Neo-6M GPS Module
9 x M-M jumper wires
1 x HC-05 Bluetooth Module
2 x Mini Breadboards
Serial Bluetooth App

Implementation

We will simply add all the new sections from our previous part in the series, the GPS example, into our continuing project in src/main.rs.

The flow of the program shall be a continuation from the final Command part of the series.

Move the code in examples/gps.rs to src/main.rs and modify the application code in the main loop as per the chart below.

In manual mode we should see the particular command we give i.e. Clockwise, Counter Clockwise etc. In auto mode the system should continuously acquire and display GPS data in raw and processed form.

Connections

The electrical connection will be the same as that from the immediate previous part.

Results

This is the final code to be run on the Pico.

Highlights of all the changes from the previous section can be found here.

Flash the application code into the Pico.

At this point our board should be performing a number of functions:

It should be blinking regularly ¹
It should be able to receive commands remotely via Bluetooth
It should receive GPS data from the Neo-6M module and acquire look angles from those.

Toggle the board into auto mode and you'll see the GPS raw data, GPS coordinates and look angles printed regularly on the Bluetooth terminal.

In the next part of this series we'll acquire the magnetic heading of our model satellite dish.

Since we are using a lot of blocking reads and writes, we shall not always have clean 1-second blinks, as they will be at times prevented by a busy function. Some functions, such as transmit_uart_data, block further operations until they are done. ↩

Self-Aligning Dish in Rust: GPS Example

Ian Ndeda — Sun, 24 Nov 2024 21:34:00 +0000

In this part of the series we'll receive raw data from the Neo-6M GPS module and process it to give us readable GPS coordinates.

Create a new directory at the same level as the src directory. Inside this examples directory create a gps.rs file in which we'll write our example program. Copy the final code from the previous part into this file.

Requirements
Implementation
- Connections
- Raw GPS data
- GPS Coordinates
- Look Angles
Results

Requirements

1 x Raspberry Pico board
1 x USB Cable type 2.0
1 x Neo-6M GPS Module
9 x M-M jumper wires
1 x HC-05 Bluetooth Module
2 x Mini Breadboards
Serial Bluetooth App

Implementation

Connections

Connect the various modules to the Pico as shown below.

Raw GPS Data

Modify the super loop by clearing it and checking if the GGA_ACQUIRED flag is set. If so we shall read the received data.

    loop {
        cortex_m::interrupt::free(|cs| {
            let mut uart_data = UARTDATA.borrow(cs).borrow_mut();
            let mut buffer = BUFFER.borrow(cs).borrow_mut();

            if GGA_ACQUIRED.borrow(cs).get() {
                // Transmit raw data from gps
                write!(serialbuf, "\n{}", buffer.as_mut().unwrap()).unwrap(); 
                transmit_uart_data(
                    uart_data.as_mut().unwrap(),
                    &serialbuf);
                GGA_ACQUIRED.borrow(cs).set(false);// clear the flag
            }
        });

        cortex_m::asm::wfi();// wait for interrupt
    }

Flash the program into the Pico.

cargo run --example gps

Open the Bluetooth terminal and flash the program into the Pico with the GPS module connected. We should see the raw GPS data on the terminal every second like so...

NB❗ You have to keep the GPS module where it can have a view of the sky. If indoors, please note that it may take a good while to lock onto satellites.

Continuous blinks every second is an indication of the module acquiring sufficient GPS data.

GPS Coordinates

We should now process the raw GPS data received into location coordinates. This can be achieved by implementing the below algorithm.

Before we implement the algorithm we need to create a Position struct to hold the dish's coordinates.

struct Position {
    lat: f32,
    long: f32,
    alt: f32,
}

impl Position {
    fn new() -> Self {
        Position {
            lat: 0.,
            long: 0.,
            alt: 0.,
        }
    }
}

In the main section we'll declare and initialize our position.

let mut position = Position::new();// gps position struct

We can now implement the parsing algorithm.

use heapless::Vec;

fn parse_gga(buffer: &mut String<164>, position: &mut Position) {
    //  Updates position of earth station
    let v : Vec<&str, 84> = buffer.split_terminator(',').collect();

    if !v[2].is_empty() {// latitude
        let (x, y) = v[2].split_at(2);

        let x_f32 = x.parse::<f32>().unwrap_or(0.); 

        let y_f32 = y.parse::<f32>().unwrap_or(0.); 

        if x_f32 + (y_f32/60.) != 0. {// if reading valid i.e. != 0 update position
            position.lat = x_f32 + (y_f32/60.);

            if v[3] == "S" {
                position.lat *= -1.;
            }
        }

        if !v[4].is_empty() {
            let (a, b) = v[4].split_at(3);

            let a_f32 = a.parse::<f32>().unwrap_or(0.); 

            let b_f32 = b.parse::<f32>().unwrap_or(0.); 

            if a_f32 + (b_f32/60.) != 0. {
                position.long = a_f32 + (b_f32/60.);// if reading valid i.e. != 0 update position

                if v[5] == "W" {
                    position.long *= -1.;
                }
            }

            if !v[9].is_empty()  {
                let c = v[9];
                position.alt = match c.parse::<f32>() {
                    Ok(c) => {
                        //Put LED indicating valid GPS data ON
                        //unsafe { *SIO_GPIO_OUT |= 1 << 25 };
                        //sio.gpio_out.modify(|r, w| unsafe { w.bits(r.gpio_out().bits() | 1 << 25)});
                        c
                    },
                    Err(_) => position.lat,// replace w/ last position
                };
            }
        }
    } 
}

Update the main loop to update and transmit GPS coordinates via Serial Bluetooth App. Add the following code below the one from the previous section.

// update the coordinates from the nmea sentence
parse_gga(buffer.as_mut().unwrap(), &mut position);

// Transmit gps position 
let lat = position.lat;
let long = position.long;
writeln!(serialbuf, "lat: {}  long: {}", lat, long).unwrap();
transmit_uart_uart_data(
    uart_data.as_mut().unwrap(),
    serialbuf);

Update our main loop to update and transmit GPS coordinates.

Flash the program.

cargo run --example gps

The GPS coordinates should now be displayed on the terminal

Look Angles

We can further calculate for look angles using the below function which implements a satellite look angle calculator.

fn get_look_angles(lat: f32, long: f32, alt: f32) -> (f32, f32) {
    // Earth Station in radians
    let le: f32 = lat*PI/180.; // Latitude: N +ve, S -ve??
    let ie: f32 = long*PI/180.; // Longitude: E +ve, W -ve??
    let _h: f32 = alt; // Altitude

    // Satellite position in radians
    const _LS: f32 = 0.;// Latitude
    const IS: f32 = 50.*PI/180.;// Longitude

    // Determine Differential Longitude, b
    let b = ie - IS;

    let mut theta = (((le.cos()*b.cos())-0.151)/(1.-(le.cos()*le.cos()*b.cos()*b.cos())).sqrt()).atan();
    let mut ai = (b.tan()/le.sin()).atan();

    // Convert into Deg.
    theta *= 180.0/PI;
    ai *= 180./PI;

    // Azimuth Angle
    let phi_z = {
        if (le < 0.) && (b > 0.) {
            360. - ai
        } else if (le > 0.) && (b < 0.) {
            180. + ai
        } else if (le > 0.) && (b > 0.) {
            180. - ai
        } else {
            ai
        }
    };

    (theta, phi_z)
}

Import PI from the core library that'll be used in the get_look_angles function.

use core::f32::consts::PI;

Also import the micromath crate to facilitate the function.

use micromath::F32Ext;

In the toml file under dependencies add:

micromath = "1.1.1"

Update the loop section to calculate the look angles and transmit via uart0.

// Calculate look angles
(theta, phi) = get_look_angles(
    position.lat,
    position.long,
    position.alt);

writeln!(serialbuf, "theta: {}  phi: {}", theta, phi).unwrap();
transmit_uart_uart_data(
    uart_data.as_mut().unwrap(),
    serialbuf);

We will the continue with initializing both theta and phi in the set-up section.

    // Variables
    let (mut theta, mut phi) = (0., 0.);

Results

The final code will be this.

Highlights of changes made are here.

Flashing this into the Pico, we should be able to receive the raw GPS data from the Neo-6m module and calculate look angles.

In the next part we continue with the application of the above in our main program.

DEV Community: Ian Ndeda

Self-Aligning Satellite Dish in Rust: Final

Table of contents

Requirements

Implementation

Connections

Auto

Position Zero

Results

Recommendations.

Self-Aligning Satellite Dish in Rust: Pan Application

Table of contents

Requirements

Implementation

Connections

Pan

Results

Self-Aligning Satellite Dish in Rust: Pan Example

Table of contents

Requirements

Implementation

Connections

Pan

Results

Self-Aligning Satellite Dish in Rust: Pan Motor

Table of Contents

Requirements

Implementation

Modifications

Connections & Operation

Relays

Final Code

Self-Aligning Satellite Dish in Rust: Servo Application

Table of Contents

Requirements

Implementation

Connections Diagram

Functions

Application

Results

Self-Aligning Satellite Dish in Rust: Servo Example

Table of contents

Requirements

Implementation

Connections Diagram

Sweep

Final Code

Self-Aligning Satellite Dish in Rust: Servo

Table of Contents

Servo

Implementation

PWM

Final Code

Self-Aligning Satellite Dish in Rust: Compass Application

Table of contents

Requirements

Implementation

Connections Diagram

Functions

Results

Self-Aligning Satellite Dish in Rust: Compass Example

Table of contents

Requirements

Implementation

Connections Diagram

Raw Data

Calibration

Magnetic Heading & Strength

Results

Self-Aligning Satellite Dish in Rust: Compass

Table of Contents

Requirements

Connections

I2C Configuration

HMC5883L configuration

Identification

Mode

Output Rate and Gain

Final Code

Self-Aligning Dish in Rust: GPS Application