TI Robotic Systems Learning Kit (TI-RSLK) - Review

Table of contents

RoadTest: TI Robotic Systems Learning Kit (TI-RSLK)

Author: sebathorus

Creation date:

Evaluation Type: Development Boards & Tools

Did you receive all parts the manufacturer stated would be included in the package?: True

What other parts do you consider comparable to this product?: The other comparable kits I have used so far are trying to provide a quick way from kit to a working robot, by providing ready-made code or libraries, without going into much detail of the inner working. As a programming environment, usually Arduino IDE and Scratch (like) environments are used. The way proposed by TI-RSLK is quite different, exploring in detail components (and the theory behind them) which are used to build the robot. Also as development environment is used Code Composer Studio (other options are also suggested) which is a powerful tool for coding and debugging. An other tool associated with this kit which I liked very much is TExaS Display. In the absence of a real oscilloscope/analyzer, this tool was very useful to see controller ports and sensors behavior.

What were the biggest problems encountered?: Some of the labs were quite hard to solve without previous knowledge about embedded programming or assistance from a professor/trainer.

Detailed Review:

Hi all,


First, I want to thank Element 14 and Texas Instruments for the opportunity to be part of TI Robotics Systems Learning Kit basic review, it was a great experience and I learned a lot from materials associated with this kit and from using the kit itself.



The TI Robotics Systems Learning Kit (TI-RSLK) is a robotics kit targeted to teach embedded systems and applications and provide students with a deeper understanding of how electronic system designs work.

The course was developed in collaboration with dr. Jonathan Valvano.


The learning way proposed by TI-RSLK kit and supporting course, is quite different from the other learning kits (solutions) I have met by now, exploring in detail the parts which might be used to build a robot and the theory behind them. The main objective of the course is firmware development for the MSP432 in C, but general information about electronic components, voltage, current, signals measurements are provided.

As development environment is used Code Composer Studio (other options are also suggested) which is a professional tool offering powerful features for coding and debugging. I was not familiar with this tool but I had no issues installing it and learning what I needed to program and debug MSP432 in the course context. CCS is offered for free and have a cloud based version.


Although I was familiar with C programming, embedded C programming is something else and the learning curve was quite steep. The lessons and labs are building on the foundation laid upon previous labs and the student have to solve the requirements of most of the labs to be able to move forward and to solve the next labs. In the TI-RSLK Maze software bundle are provided some examples related to the objectives of each lab, NOT the solutions, in some of the cases serious work is required in order to achieve the lab objectives.

Each lab provide "Recommended readings" and "Troubleshooting" sections to guide students to debug circuits and applications, assuming something is not working as planned.


An other tool associated with this learning solution, which I liked very much, is TExaS Display. In the absence of a real oscilloscope/analyzer, this tool was very useful to see microcontroller and sensors behavior.


Other useful resource provided with TI-RSLK Maze software bundle is the datasheet section, I appreciate I have at hand the required info.




I received for review the basic version of TI-RSLK kit which covers the first 14 video lessons and labs.

I have tested this kit following step by step the video lessons and solving the associated labs requirements.

Video modules are presented by prof. Valvano and additional sources of information are suggested to students. Some of the topics are more difficult (timers, interrupts) and some labs were quite hard to solve without previous embedded programming knowledge or assistance from a professor/trainer. Maybe the most challenging topics should be split over multiple modules in order to give more details and make labs easier.

I managed to follow all 14 modules and accomplish the labs in about three weeks.


The structure of the modules is this:


Module 1 - Running Code on the LaunchPad using CCS

Details the using of CCS interface for opening and running projects, using editor, debugger tools and TExaS Display application.

- 1.1 TI-RSLK Module 1 - Lecture video - Running code on the LaunchPad using CCS

    - Download the TI-RSLK Maze software

- 1.2 TI-RSLK Module 1 - Lab video 1.1 - Installing CCS and tirslk_maze

- 1.3 TI-RSLK Module 1 - Lab video 1.2 - Getting started with CCS

- 1.4 TI-RSLK Module 1 - Lab video 1.3 - Running the TExaS logic analyzer

- 1.5 TI-RSLK Module 1 - Lab video 1.4 - Running the TExaS oscilloscope

     - in my case selecting COM 0 did not autoselect the COM port for SCOPE or LOGIC ANALYZER, I have to select it manually. If you are using Windows, from Device Manager you can find serial ports used by Launchpad:


Module 2 - Voltage, Current and Power

     - 2.1 TI-RSLK - Module 2 - Lecture video - Voltage, current and power - this module cover resistors, capacitor and LEDs

     - 2.2 TI-RSLK Module 2 - Lab video 2.1 - Measuring the reactance of a capacitor - review basic electronics needed to interface sensors and actuators to the microcontroller

     - 2.3 TI-RSLK Module 2 - Lab video 2.2 - Measure LED (I,V) response curve - measure voltage and current across the LED


Module 3 - ARM Cortex M

     - 3.1 TI-RSLK Module 3 - Lecture video part I - ARM Cortex M Architecture

          -  in this module Prof. Valvano talked about RISC versus CISC, about little versus big endian, Cortex M being low endian.

     - 3.2 TI-RSLK Module 3 - Lecture video part II - ARM Cortex M Assembly

          - a brief description of assembler, linker, loader, debugger.

          - develop and test an assembly function the maze robot might use to perform a numerical calculation.

     - 3.3 TI-RSLK Module 3 - Lab video 3.1 - Debugging the solution, visualization, breakpoint and step

          - In this lab is presented Arm Cortex-M, and some of the debugging techniques we can use in Code Composer Studio.


Module 4 - Software Design using MSP432

     - 4.1 TI-RSLK Module 4 - Lecture video part I - Software design using MSP432 - Design

          - This module is an introduction to C, a general-purpose programming language, in addition to the concepts of compiling and debugging using the MSP432 and TI Code Composer Studio.

     - 4.2 TI-RSLK Module 4 - Lecture video part II - Software design using MSP432 - C programming

          - Software Design

          - Call graph

          - Data Flow Graph

          - Successive refinement

          - doxygen

          - Abstraction (functions)

          - Modular design (header/code files)

     - 4.3 TI-RSLK Module 4 - Lecture video part III - Software design using MSP432 - Debugging - debugging on the MSP432 through controls (step, breakpoints), observing variables and functional debugging

     - 4.4 TI-RSLK Module 4 - Lab 4 video 4.1 - Debugging the solution, visualization, variables, step over

          - black boxing, white boxing, break points

          - interface a line sensor with the microcontroller

     - 4.5 TI-RSLK Module 4 - Lab video 4.2 - Debugging the solution, visualization, breakpoint, step over

          - are discussed debugging techniques, breakpoint on count, counting


Module 5 - Battery and Voltage Regulation

- 5.1 TI-RSLK Module 5 - Lecture video part I - Battery and voltage regulation

     - microcontroller power modes, power budget, voltage and current reduction

     - different types of batteries are described, comparison chart, capacity calculation

     - voltage regulation - linear regulator (inneficient->heat), switching regulator ()

- 5.2 TI-RSLK Module 5 - Lab video 5.1 - Measure voltage and current from battery

- 5.3 TI-RSLK Module 5 - Lab video 5.2 - Connecting motor driver and power distribution board

LAB: - warns about not using TExaS analyzer in this lab because more than 3.3V on MSP432 pins is not allowed. I use a voltmeter and an ammeter for this lab and I performed all the tests this setup allowed.


Before attempting step 5.4.2 - Voltage regulation tests, I had to do a minor repair to MDPDB board which was damaged during transport, more on this later.

Anyway, the functionality was not affected, power board giving a nice 5.00V. Measurement of MSP432 current consumption was within suggested parameters:


Because I was going to solder the power board to the batteries terminals, at this point, I soldered all pins and connectors to not have to go back and disassemble the chassis. Meantime I found the encoder boards available and bought them for future development.




Module 6 - GPIO

The final purpose of this lab is to interface the reflectance sensor to the robot and write the proper software to initialize and use GPIO pins to read the line sensor. To test the sensor output, the sensor is placed above a black line (black tape) put over a white background in order to create contrast.

This assumes the configuration of controller pins as GPIO, configuration of pins direction and performing the reading operation.

Logic analyzer and oscilloscope are used to visualize the line sensor output.

Topics discussed in this section:

- 6.1 TI-RSLK Module 6 - Lecture video part I - GPIO - MSP432

     - digital, timer, analog

     - describe GPIO pins and how they are organized - collection of pins -> port

     - negative and positive logic

     - digital interfacing, logic levels


- 6.2 TI-RSLK Module 6 - Lecture video part II - GPIO - Programming

     - describes the working of QTR-8RC line sensor

- 6.3 TI-RSLK Module 6 - Lab video 6.1 - Demonstration of how the reflectance sensor works


- 6.4 TI-RSLK Module 6 - Lab video 6.2 – Demonstration of the lab solution and testing the line sensor

     - I configured P6.0 as output

     - Use functions to provide software abstraction

     - Perform conditionals, loops, and calculations in C

     - Use the debugger to single step and visualize I/O registers

     - Set the direction register for GPIO pins

     - Perform friendly access to I/O registers

     - Visualize an input pin converting voltage into binary

     - Use an oscilloscope to visualize time behavior

     - Perform incremental design and testing

     - Conduct experiments to determine accuracy, monotonicity, specificity and noise

     - Integrate multiple sensor measurements into a single value


For sensor connection (and all hardware connection in general) I used the "Basic Kit Construction Guide". I choose to not solder wires on neither line sensor or launchpad board. I soldered the right angle pins on line sensor and connect it to launchpad with female-to-female wires.

The kit I got had missing the screws required to attach the line sensor to the spacers and to the chassis. In my part of the world I can find only metric screws which not fit the thread of provided spacers. So, I improvised some sensor mounts of the right size to achieve the required 3mm gap between sensor and black tape.



     At this point I mounted the launchpad on the chassis and I noticed that the provided plastic mounts were a little too short and the launchpad board was sitting on right encoder disc... This time my daughters arsenal came to rescue, result being this:




In the bellow captions from TExaS logic analyzer can be seen the output of the line sensor, when the sensor is moved over the black line.

- P7.0 over black line - on channel 0 can be seen a longer discharge time of sensor 1 capacitor vs other sensors which are above white surface.


- P7.0 is moved over white background and sensors 3 and 4 are now above the black tape


One last requirement of the lab was to integrate the readings of all 8 sensors from QTR-8RC board into a single value which reflect position of the robot over the black line.

This module was the most challenging so far and here the presence of a professor/lab assistant/trainer would have been helpful.


Module 7 - Finite State Machines

Topics discussed in this section:

- 7.1 TI-RSLK Module 7 - Lecture video part I - Finite state machines - Theory

- 7.2 TI-RSLK Module 7 - Lecture video part II - Finite state machine - Line tracker

- 7.3 TI-RSLK Module 7 - Lab video 7.1 – Running the FSM starter code

- 7.4 TI-RSLK Module 7 - Lab video 7.2 – Running the solution code and designing a better FSM


This module talks about FSM as an abstraction used to solve a problem by separating the system policies by the system working. The principles of FSM are inputs, outputs, states and states transitions. To define relation between inputs and outputs FSM uses a state transition graph (or a transition chart).

LAB is focused on testing a line follow robot implemented as FSM which use as line sensor (input) sw1 and sw2 from launchpad board and as actuators (motors) two onboard LEDs. Original implementation is purposely missing some states and can lose the line. Student is asked to add required states to solve this bug and also to deal with the case when robot goes completely off the line.


Module 8 - Interfacing Input and Output

- 8.1 TI-RSLK Module 8 - Lecture video part I - Switches

     - discuss positive logic - when close the switch the controller pin is tied to +3.3V and negative logic - when close the switch the pin is tied to ground

     - switch interface with pullup or pulldown

     - Ohm's law - choose the right series resistor for a LED circuit in order to limit forward current and protect the LED and controller pins

     - software driver - I/O functions

- 8.2 TI-RSLK Module 8 - Lecture video part II - Interfacing input and output - LEDs

     - fundamentals of LEDs and switches

     - connect LEDs to Launchpad

- 8.3 TI-RSLK Module 8 - Lab video 8.1 - Interfacing switches and LEDS and debugging (low volume)

The purpose of the lab is to interface switches and an external LED with the launchpad board and implement a basic alarm system using push buttons as input sensors for windows and a LED as a status indicator for the system. At this point, with the experience gained from previous modules, the lab requirements were easy to achieve.



Module 9 - SysTick Timer

The purpose of this module is to learn how to use SysTick timer to manage time in order to create accurate time delays and generate PWM output.

It is presented the functionality of 24bits SysTick timer and pulse width modulation also how to measure pulse times and period using logic analyzer.


- 9.1 TI-RSLK Module 9 - Lecture video part I - SysTick Timer - Theory (caption text don't match video)

     Topics discussed in this part:

     - create delays

     - generate periodic interrupts

     - SysTick initialization ()

- 9.2 TI-RSLK Module 9 - Lecture video part II - SysTick Timer - PWM (caption text don't match video)

     Topics discussed in this part:

     - SysTick is a built-in timer

     - measure elapsed time

     - create software delay

     - PWM with software delay

     - PWM provide high precision outputs

     - PWM used for dimming, DAC, motors control

- 9.3 TI-RSLK Module 9 - Lab video 9.1 – Demonstrating running heartbeat by adjusting the duty cycle

     - demo of LED heartbeat

- 9.4 TI-RSLK Module 9 - Lab video 9.2 – Demonstrate running sine wave output to adjust power

     - demo of RC filter operation



First part of the lab covers the generation of a heartbeat wave used to change the brightness of a LED. The cycle is controlled by the student using SW1 and SW2 switches.

Student is required to write and test a delay function using SysTick.

Second step is to implement a wave with sinusoidal wave using a ready made table with 100 pulse-time values.

Next  step is to add switch functionality, to start/stop the heartbeat.

The last step in this lab is to build an analog low pass filter and implement a PWM DAC. This step makes an analogy between proposed RC circuit and a motor circuit, by comparing the LED response time (order of nano seconds) with the RC/motor response time (order of miliseconds). If the response time of a device is slow compared to the applied PWM signal, the device will respond to the average of the signal applied.

For example the LED will respond fast and blink (turn on and off) at a higher frequency since the motor response is seen as the number of rotations per minute (motor did not start and stop completely).


Measurements with the TExaS analyzer did not show the exactly expected values for duty cycles, but reflect changes of the duty cycle, changing duty cycle to 50%, 25%, etc is shown on analyzer. A sample of the generated PWM signal:



Topics discussed in this modules:

     - Measure resistance and voltage

     - Measure pulse time and period with a logic analyzer and an oscilloscope

     - Create accurate time delays

     - Implement PWM output

     - Use PWM output to create time-varying behavior

     - Create a simple analog low pass filter

     - Balance the tradeoffs between range, resolution, and precision



Module 10 - Debugging Real-Time Systems


     I started this module by connecting the bumper switches following "Basic kit construction guide" instructions, to ports P4.0, P4.2, P4.3, P4.5, P4.6, P4.7. Although it was not a complicated task by itself it goes quite slow because after cutting and peeling the plastic insulation from connection wires, wires were pretty hard to solder due to tick (or simply very resistant) enamel coating of the wires. After I struggle with the first two wires I took my time and clean the wires with a sharp blade. If I'll do this again, I'll use male to female wires and solder the male part directly to bumper switch pins, I think this would work faster and better.

     The extra spacers I mounted because launchpad touched the encoder disk, proved very useful, without them I would not had enough space to connect wires from the switches to the ports under the launchpad. In conclusion, the launchpad mounting spacers should be a little bit (5-10mm) longer.



   This module deals with flash memory operation, debugging techniques (minimally intrusive debugging) for real time systems and how to generate periodic interrupts using SysTick.

  - 10.1 TI-RSLK Module 10 - Lecture video part I - Debugging real-time systems - Theory (caption text don't match video)

     Minimally intrusive debugging

          - dump

          - thread profile


          - erase - slow (ms)

          - program - slow (ms)

          - read - fast


     - 10.2 TI-RSLK Module 10 - Lecture video part II - Debugging real-time systems - Interrupts

          - context switch - stack

          - vector - ISR

          - Initialization - arm

          - interrupts priority

          - interrupts enabling (I bit)

          - Synchronization - global variables

                                       - static variables

          - Profiling - tripple toggle 


     - 10.3 TI-RSLK Module 10 - Lecture video part III - Debugging real-time systems - SysTick interrupts

          - periodic interrupts - sample sensor data at fixed rate

          - sample ADC at fixed rate

          - send to DAC at fixed rate (audio)

          - transmit messages

          - digital controller - FSM, linear controll system (motor control)

          - data put in global/static variable, mailbox (var + flag), array, FIFO

          - SysTick periodic interrupts - countdown - when switch from 1 to 0 trigger interrupt

          - manage possibly conflicting interrupts executions - change ports, bit-banding, disable-access-re-enable interrupts


     - 10.4 TI-RSLK Module 10 - Lab video 10.1 – Demonstrate running the line sensor/black box recorder

          - a short demo of storing line sensor readings and visualize them in CCS


First part of the lab require to implement a function to read line sensors, based on the knowledge from Module 6 but  using SysTick generated interrupts.

Next step is to interface the bump sensors. I connected them to port 4 pins 2-7 and used internal controller resistors configured in pull-up mode. I used TExaS analyzer to check if  switches are working, here sw1, 2 & 3 are pressed and released (channel 0, 2 and 3):


The function created to read bump switches is called every time at the end of the line sensors reading routine.

Next task is to implement the debugging dump using two 8 bits arrays to store line sensor and bump switches readings.


Module 11 - Liquid Crystal Display

The LCD is not part of the basic kit, I'll try to find one and use it on the robot since a display is very useful to display debug info.


Module 12 - DC Motors

Topics discussed in this module:

     - 12.1 TI-RSLK Module 12 - Lecture video part I - DC motors - Physics

          - motor electrical model

          - motor mechanical model

          - DC motors - F=I*L*B, R,L, emf


     - 12.2 TI-RSLK Module 12 - Lecture video part II - DC motors - Interface

          - drive circuits for DC motors - design considerations

          - drive a TIP120 transistor and a MOSFET

          - drive a H-bridge

          - description of P channel H bridge like DRV8838


     - 12.3 TI-RSLK Module 12 - Lab video 12.1 – Demonstrate motor fundamentals

          - demo of how variation of duty cycle affects voltage, current and speed of motor


     - 12.4 TI-RSLK Module 12 - Lab video 12.2 – Demonstrate robot moving in a preset pattern


The goal of this module is to mount motors and wheels on the chassis and interface the motors to the LaunchPad using the motor driver board. To make the robot move, driver board should be connected to the LaunchPad which will provide the required control signals. Understanding how duty cycle, voltage and current combine to affect speed is required when building your robot.

I assembled mechanical parts and connected LaunchPad and MDPDB together using "Basic kit construction guide" instructions.


First part of the lab require that student to write a software driver to control the motors states.

In the second part of the lab, these functions are used to drive the motors and perform electrical measurements on them.

To measure the current consumption of the motors I used a stack of conductor-insulator-conductor interleaved between one of the batteries and chassis contact:


With the robot suspended above the table I tested functions to run each motor at a time and both motors at the same time. I measured the voltage, current and number of wheel rotations relative to duty cycle:






Module 13 - Timers

Topics discussed in this module:

     - 13.1 TI-RSLK Module 13 - Lecture video part I - Timers - Periodic interrupt

          - SMCLK - system module clock = 48MHz/4 = 12MHz

          - TASSEL - timer select (00-TAxCLK, 01-ACLK, 10-SMCLK, 11-INCLK)

          - TA0CCR - set the period

          - PWM Mode - up/down count - up to CCR0(10)

                                                          - count down to 0

     - 13.2 TI-RSLK Module 13 - Lecture video part II - Timers - Pulse width modulation

     - 13.3 TI-RSLK Module 13 - Lab video 13.1 – Timer generated PWM outputs to spin motors

     - 13.4 TI-RSLK Module 13 - Lab video 13.2 – Interrupt latency

This module covers using hardware generated PWM in place of previously developed software PWM. Software parts are required for high level functions.

The lab uses Timer_A0 to create PWM outputs on P2.6 and P2.7 pins which are connected to PWML and PWMR pins of the motor driver board. The period of both outputs is set at 100Hz making motors to respond to the average level of the signals. The drivers have to be re-written to use hardware PWM.

Next step is to use Timer_A1 to create an additional periodic interrupt which check bump switches and stop the robot when a collision occur.


Module 14 - Real-Time Systems

     The purpose of this module is to interface bump sensors with the LaunchPad for collision detection and use edge-triggered interrupts for faster response. The software reading the sensors is moved from a periodic interrupt to an event driven trigger. Reading of the sensors occur in the interrupt service routine and the collision task is configured as a higher priority task.

     The final result of this lab is very similar to previous lab, except it uses edge-triggered interrupts for faster response in case of collisions.

     - 14.1 TI-RSLK Module 14 - Lecture video part I - Real-time systems - Theory - nok caption

          - Tasks - periodic

                      - aperiodic

                      - sporadic (faults)

          - Latency

          - Response time

          - Priority

          - Hard real time, soft real time, not real time

          - were discussed techniques to improve real time behavior (appropriate priorities, avoid disabling interrupts, avoid loops inside ISR)


     - 14.2 TI-RSLK Module 14 - Lecture video part II - Real-time systems - Edge triggered interrupts - nok caption

          - Interrupts and the NVIC

          - execute profiling

          - edge-triggered interrupts - select an edge

          - polling vs vector

          - acknowledgement

           - two-switch periodic polling - polling have higher latency

         - IV register - when 2 or more pins of same port are triggered


     - 14.3 TI-RSLK Module 14 - Lab video 14.1 – Real-time response using edge triggered interrupts for your bump switches

          - is presented the behavior of the robot in case of collision when edge triggered interrupts are used.


In the bellow video can be seen the behavior of the robot. I used a little longer waiting times between steps.


Modules 13-Timers and 14-Real time systems were the most challenging so far requiring a significant amount of time to understand the concepts and solve the labs. Still, they are doable without prior knowledge in embedded C programming and without the help of a professor or trainer. Reading the additional resources suggested along video lessons and labs will definitely help.


This module is the last one covering TI-RSLK Maze Edition Basic kit, modules from 15 to 19 are covering the advanced version of the kit.

During the next period I'll try to find at least some of the components which are part of the advanced kit, I already found the encoders, because I think they are a worthy addition to robot.


I recommend using the Datasheet folder provided with TI-RSLK Maze software and I selected a couple of links I found useful during this review:



     https://www.pololu.com/product/3543 - Romi motor driver and power distribution

     https://www.pololu.com/product/961/ - line sensor array

     https://www.pololu.com/product/1520 - geared motors

     https://www.pololu.com/product/3542 - encoder kit


Possible improvements:

- On the course side:

     - split the most challenging modules in order to present the information more gradually and make the labs a little easier. This is especially desirable for hobbyists/individuals who are learning by themselves without support from a professor/trainer.

     - in some video modules the caption don't match the presentation, the caption text is switched between lessons.

     - in the "Basic Kit Construction Guide" document some of the pictures are low quality, I was not able to use them as reference since I could not read labels on the boards. Much better in this aspect is the Datasheet folder included with TI-RSLK software bundle.


- On the hardware side:

     - the geared motors and the Motor Driver and Power Distribution Board are not detailed in video lessons or labs, but detailed description can be found on Pololu website or Datasheets folder - driver board and motors.

     - the kit I have got, came with one of the capacitors from power distribution board broken.


Because the power board was packed together with heavier parts (motors, mounts, screws, chassis, etc) during transport, one of the protruding capacitors was hit and snapped off. Fixing it was trivial but a better packing would spare anyone from future troubles.



- the kit is packed in a nice box, designed to hold the robot components. It even have a handle to carry it around, to school or hackerspace. Unfortunately it have no supports inside, allowing robot and the rest of accessories to roll and spread inside (and exposing them to damage as I explain earlier). I think with a small effort, some cardboard organizers can be fit inside (it took less than 30 minutes for me to make them) to improve the protection of the components. I'm sure a professional designer can find a better solution.


     To sum up, I think the TI-RSLK Maze Edition Basic kit together with accompanying video lessons provide a very good tool to start embedded programming in C or to improve already acquired knowledge. While I was comfortable with the electronics, mechanics and measurements part, I learned a great deal about MSP432 LaunchPad and about various programming and debugging techniques.

While the associated course use C as programming language, I think hobbyists and students can explore other programming options, like Energia.


Thanks for reading this and happy coding



PS - one last challenge, find the giant octopus image