Guide on Using your Robot

Pico's LED

Pico's Onboard LED

How to use:

The LED on the PicoW is activated by the wifi chip onboard (the big silver box opposite to the usb)
If is recommended to turn on the led in the first lines of your code so you know the code has been uploaded properly
see rcc-pico/dev/pico/using-robot-examples/led.cpp

Example Code:

Includes RCC library
Within main()function:

Setup for wifi chip (cyw43)
Turns on Pico's LED
Within while() loop, blinks led


                #include "rcc_stdlib.h"
                using namespace std;
    
                int main()
                {
                    stdio_init_all();    
                    sleep_ms(1500);
                    cyw43_arch_init(); //setup 

                    cyw43_arch_gpio_put(0,1); //turns on LED

                    cout << "gonna blink now;)" << '\n';

                    while(true)
                    {   
                        sleep_ms(300);
                        cyw43_arch_gpio_put(0, !cyw43_arch_gpio_get(0)); //blinks LED
                    }
                }

Raft-Input Sensors

Push Button

Our button:

This button is called a single-pole-single-throw or SPST
Button's name is B3F-1020
Link to Component on Digikey
Link to Datasheet

How it works:

The push button is connected with a shunt to gpio 22
When pressed, the button connects it to GND, and the pico reads LOW
see rcc-pico/dev/pico/using-robot-examples/button.cpp

Example Code:

Includes RCC library
Within main()function:

Turns on Pico's LED
Sets up button
In while()loop:

Checks if button is pressed


            #include "rcc_stdlib.h"
            using namespace std;

            int main()
            {
                stdio_init_all();    
                sleep_ms(1500);
                cyw43_arch_init(); //setup 
                cyw43_arch_gpio_put(0,1); //turns on LED

                rcc_init_pushbutton(); //set up button

                while(true)
                {   
                        if(!gpio_get(RCC_PUSHBUTTON)) //if gpio NOT high
                        {
                            //do stuff here when button pressed
                            cout << "PUSHBUTTON PRESSED!" << '\n'; 
                        }
                }
            }

Potentiometer

Our potentiometer:

This potentiometer is a linear 10kΩ variable resistor
Potentiometer's name is PT01-D120K2-B103
Link to Component on Digikey
Link to Datasheet

How it works:

The potentiometer is connected with a shunt on pin 28
When you twist the nob, the resistance changes
+3.3V passes through the variable resistor at all times
Potentiometer acts as a voltage divider

Read more here

Gpio 28 has an Analog-to-Digital Converter (ADC)
This converts the analog voltage to a digital value that the Pico can understand
The Pico has a 12 bit resolution ADC, which is how we get 4097 as the maximum value
see rcc-pico/dev/pico/using-robot-examples/pot.cpp

Example Code:

Includes RCC library
Within main()function:

Turns on Pico's LED
Sets up potentiometer's ADC
In while()loop:

converts voltage to a digital reading using adc_read()


            #include "rcc_stdlib.h"
            using namespace std;
            
            int main()
            {
                stdio_init_all();
                sleep_ms(1500);
                cyw43_arch_init(); //setup 
                cyw43_arch_gpio_put(0,1); //led on
            
                rcc_init_potentiometer(); //setup ADC
            
                while(true)
                {
                        int32_t pot_val = adc_read(); //values from 0 to +4097
                        cout << "raw value: " << pot_val << '\n';
                        sleep_ms(100);
                }
            }

Actuators

DC Motors

How a motor works:

Our motors are DC Brushed Motors
Here's a pretty good video
To control both the direction and speed of our motor, we use a motor controller

Our Motor Controller:

The robot has an L298N Module
Link to Datasheet
On the Module, theres a Dual H-bridge Chip, the L298
Link to Datasheet
This H-Bridge has 4 bipolar junction transistors (BJT)
Turning on/off the correct BJTs changes the motor's polarity, changing the direction the wheel spins
To control the speed of the motor, we use pulse-width-modulation (PWM)
By setting the %ON or the Duty-Cycle, we can change the effective voltage sent to the motor, changing its speed
see rcc-pico/dev/pico/using-robot-examples/motors.cpp

Example Code:

Includes RCC library
Within main()function:

Turns on Pico's LED
Sets up motor struct
Sets left and right to ENA and ENB
Enables PWM
In while()loop:

Sets motor power


                #include "rcc_stdlib.h"
                using namespace std;
                
                int main()
                {
                    stdio_init_all();
                    sleep_ms(1500);
                    cyw43_arch_init(); //setup 
                    cyw43_arch_gpio_put(0,1); //led on
                
                    Motor motors; //struct setup
                    MotorInit(&motors, RCC_ENA, RCC_ENB, 1000); //setup left and right
                    MotorsOn(&motors); //enable PWM
                
                    while(true)
                    {
                        MotorPower(&motors, 100, 100);  // %motor speed
                        cout << "motors going forwards" << '\n';
                        sleep_ms(100);
                    }
                }

Servo Motor

How a servo motor works:

Servo motors have a mini DC motor attached to a set of gears
Inside the servo, there is a potentiometer that knows the position of the servo
Servo motors are controlled by a PWM signal that corresponds to the desired position
The circuit inside has feedback built in to reach and hold the position set by the PWM signal
Since the servo wants a 5V PWM signal, use the level shifter on the raft
see rcc-pico/dev/pico/using-robot-examples/servo.cpp

Our Servo Motor:

MG90S Link to Datasheet

Example Code:

Includes RCC library
Within main()function:

Turns on Pico's LED
Sets up servo struct
Sets to GPIO 18
Enables PWM
In while()loop:

Sets servo position


                #include "rcc_stdlib.h"
                using namespace std;
                
                int main()
                {
                    stdio_init_all();
                    sleep_ms(1500);
                    cyw43_arch_init(); //setup 
                    cyw43_arch_gpio_put(0,1); //led on
                
                    Servo s3; //struct setup
                    ServoInit(&s3, 18, false, 50); //setup 
                    ServoOn(&s3); //enable PWM
                
                    while(true)
                    {
                        ServoPosition(&s3, 50); //50% of range (forwards)
                        cout << "servo facing forwards" << '\n';
                        sleep_ms(100);
                    }
                }

Sensors

Lidar Sensor

How the Lidar Works:

The lidar sends out beams of Infrared (IR) light
When the light bounces off an object, the beam is detected by the IR sensor within the Lidar
Based on the speed of light, it converts the timing to a distance

Our Lidar Sensor:

We're using the VL53L0X
Link to Datasheet
The sensor is teeny, to connect it to our Pico, we use the module pcb with header pins

How it communicates:

The sensor communicates with the Pico through inter-integrated circuit protocol (i2c)
SCL is the clock signal
SDA is the data signal
see rcc-pico/dev/pico/using-robot-examples/lidar.cpp

Example Code:

Includes RCC library
Within main()function:

Turns on Pico's LED
Sets up i2c on the Pico
Lidar's class setup
Sets to i2c1
In while()loop:

returns a distance in millimeters
a reading of >8000 means objects are too far away to detect


                    #include "rcc_stdlib.h"
                    using namespace std;
                    
                    int main()
                    {
                        stdio_init_all();
                        sleep_ms(1500);
                        cyw43_arch_init(); //setup 
                        cyw43_arch_gpio_put(0,1); //led on
                    
                        rcc_init_i2c(); //setup pico i2c

                        VL53L0X lidar; //class
                        rcc_init_lidar(&lidar); //setup lidar on i2c1
                    
                        while(true)
                        {
                            uint16_t dist = getFastReading(&lidar);
                            cout << "distance: " << dist << "\n";
                            sleep_ms(100);
                        }
                    }

IMU

Inertial Measurement Unit (IMU)

IMU's measure acceleration and angular velocity in all 3 axes

How it works:

Inside there are MEMS devices (micro-electrical-mechanical-systems)
Plates the size of nano-meters are setup in an interlocking finger pattern
When the device is accelerating or rotating, the plates move, changing their capacitance
The device converts that change in capacitance into i2c signals for the Pico
This Page has some cool gifs showing the types of motion

Our IMU:

MPU6050 Link to (long) Datasheet
see rcc-pico/dev/pico/using-robot-examples/imu.cpp

Example Code:

Includes RCC library
Within main()function:

Turns on Pico's LED
Setup i2c
Sets up imu class
Begins communication with imu
Calibrates sensor
In while()loop:

updates pico on all the data
gets angular velocity around z-axis


                #include "rcc_stdlib.h"
                using namespace std;
                
                int main()
                {
                    stdio_init_all();
                    sleep_ms(1500);
                    cyw43_arch_init(); //setup 
                    cyw43_arch_gpio_put(0,1); //led on
                
                    rcc_init_i2c(); //setup i2c

                    MPU6050 imu; //class
                    imu.begin(i2c1); //adds to i2c1
                    imu.calibrate(); //hold robot still
                
                    while(true)
                    {
                        imu.update_pico(); //updates data
                        float angvel_z = imu.getAngVelZ(); //call function to get data
                        cout <<" z rotation: " << angvel_z << "\n";
                        sleep_ms(100);
                    }
                }

Encoders

Optical Interrupt Sensors

The encoder is made from a wheel with slits which is attached to each wheel of the robot
The optical interrupt sensor sits around the encoder wheel
The sensor has an IR LED (which is always on) on one side
The other side has an IR photoresistor (which changes resistance when it detects the light)
When the light is able to pass through the encoder wheel, the led on the sensor turns on

Using Interrupts:

Just like the led on the sensor turns on and off when the wheel rotates, the pico detects these changes through hardware interrupts
Each time the signal changes from LOW to HIGH or HIGH to LOW, the pico adds a count

Two functions to know:

getCount() returns current count
setZero() resets the count
see rcc-pico/dev/pico/using-robot-examples/odom.cpp

Example Code:

Includes RCC library
Within main()function:

Turns on Pico's LED
Sets up classes for left and right
In while()loop:

Gets count for both wheels
If left count is over 100, resets left count
If right count is over 200, resets right count


                #include "rcc_stdlib.h"
                using namespace std;
                
                int main()
                {
                    stdio_init_all();
                    sleep_ms(1500);
                    cyw43_arch_init(); //setup 
                    cyw43_arch_gpio_put(0,1); //led on
                
                    Left_Odom left; //class
                    Right_Odom right; //class

                    while(true)
                    {
                        int left_count = left.getCount(); //current left count
                        int right_count = right.getCount(); //current right count
                
                        if (left_count>=100){
                            left.setZero(); //resets left count
                        }	
                        if (right_count>=200){
                            right.setZero(); //resets right count
                        }
                
                        cout << left_count << " | " << right_count << '\n';
                        sleep_ms(100);
                    }
                }

Guide on Using your Robot

Jump to:

Pico's LED

Pico's Onboard LED

How to use:

Example Code:

Raft-Input Sensors

Push Button

Our button:

How it works:

Example Code:

Potentiometer

Our potentiometer:

How it works:

Example Code:

Actuators

DC Motors

How a motor works:

Our Motor Controller:

Example Code:

Servo Motor

How a servo motor works:

Our Servo Motor:

Example Code:

Sensors

Lidar Sensor

How the Lidar Works:

Our Lidar Sensor:

How it communicates:

Example Code:

IMU

Inertial Measurement Unit (IMU)

How it works:

Our IMU:

Example Code:

Encoders

Optical Interrupt Sensors

Using Interrupts:

Two functions to know:

Example Code: