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

Table of contents

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

Author: gpolder

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?: Regarding robot kits there is a huge amount of them available, in this roadtest I show the Sparki robot and Lego Mindstorms. Regarding online training on robotics, there are quite e few courses available from universities as wel as from more commercial platforms like Udacity (programming the self driving car), Coursera, edX end so on.

What were the biggest problems encountered?: Programming some of the functions was quite tough.

Detailed Review:



First, I want to thank Element 14 and Texas Instruments for giving me the opportunity to review the TI Robotics Systems Learning Kit. It was a great experience to build the robot and to play around with the software. I learned a lot from from using the kit and the learning material on the TI educational website. The roadtest description mentions two types of the kit, basic and advanced, it was not clear which of the two should be provided. In the end told us that he just got five basic kits and that just one upgrade kit was provided by element14 itself. Unfortunately I was not the one selected for the advanced kit. Never mind I had a lot of fun with the basic one. Unlike other roadtesters I decided not to buy additional components but rather test just the provided basic hardware.

Here are some images of the kit just after its delivery in my mailbox:


My proposal for the RoadTest was to look at the curriculum with my daughter who just finished primary school this summer.

For three years I'm involved in organising Mindstorms Challenges  connected to our university:



In anticipation to this challenge I also taught children on the school of my daughter about robotics and programming.

For this roadtest review the plan was to take robotics to a next level, and together with my daughter go through the TI-RSLK Curriculum Modules and compare them with Lego Mindstorms. Unfortunately after receiving the kit and looking trough the course content, this plan was too ambitious, since the material is at least at college level. Having said that, I still see possibilities for using the kit at different knowledge levels. You can read about my ideas later in the review.


The complete course can be found here: https://training.ti.com/ti-robotics-system-learning-kit?ref_url=https%3a%2f%2feducation.ti.com%2fen%2ffaculty%2fti-robot…

Where it is announced as designed to supplement university curriculum.


For the remainder of the review I will first share my experiences when building the hardware. Then I will say some words about the software and the tools which are available. An important aspect is what exactly the purpose of the TI-RSLK curriculum is compared to the huge amount of available hardware and software tools for robotics in general. I will briefly discuss my view on this topic. Then a paragraph on how the kit can be used by primary school kids. I will conclude my review with a short summary.



Building the robot

All the information for the complete curriculum can be found and the course website. Personally I found it convenient to use a pdf version which was announced as a free e-book. Other valuable information regarding the chassis was found on the website of pololu (https://www.pololu.com/docs/0J68/4). I started to build the robot using this information, but later I found the robot construction guide: http://www.ti.com/lit/ml/swrp249/swrp249.pdf, which was very helpful.

In the TI manuals there was no link to the schematic diagram of The Motor Driver and Power Distribution Board (MDPDB), which in my opinion is very worthwhile for the curriculum. Luckily I found it at the pololu site: https://www.pololu.com/file/0J1213/motor-driver-and-power-distribution-board-for-romi-chassis-schematic.pdf


Unfortunately there are differences in the instructions given in the free e-book and the robot construction guide.

For instance page 7 of the construction guide mentions to cut the VPU-VREG, VCCMD-VREG, and SLP L-R traces, where in the e-book only the VPU-VREG, VCCMD-VREG are mentioned. Also the instructions on page 62 of the e-book are confusing and not in line with the robot construction guide.

Number 1 in figure 4, is wrongly labeled. Furthermore here the instruction is to solder wires between the two boards, where in the construction guide headers are used. Since I didn't have access to the construction guide yet when working on this stage, my connections are partly with headers and partly direct.

Here is a list of the wire colours I used for the power (just for my own documentation).





Next step is to attach four 1.375in 4-40 Nylon standoffs to the robot chassis for mounting the launchpad board:

Also the breadboard is attached:


Page 63, point 10: "Align the standoffs with the four holes on the LaunchPad. Depending on where you choose to mount the LaunchPad, you may have to increase the side of the hole on the chassis to ¼ inch to accept the 4-40 screw."

Unfortunately the .25 inch screws were not provided in the kit, luckily I found some in my junk-box, which is a surprise, since in my country metric screws are mainly used, compared to imperial as used in the kit. Also the nylon screws (step 12) were lacking, so I was forced to use normal screws from my junk-box.


Time for a first test, here you see the result, code in this case is from InputOutput.c, which changes the color of the LD on port 2, depending on the switches. As you can see all works as expected.


There is an important warning on page 63:

Warning: Disconnect the VREG↔+5V wire when the LaunchPad USB cable is connected to the PC. Connect the VREG↔+5V wire when the robot is running on battery power.

So you have to be very careful when debugging, I don't know whether the board will fry when doing this wrong, didn't test that , but in my opinion this could be easily prevented by adding some extra electronics to the launchpad. Maybe just one diode already would do the job.


The basic kit unfortunately doesn't have the encoders, so I wired motors by directly solder them to the motor board.


When testing the motors I detected something weird, one of the motors didn't drive smoothly at duty cycle 1, and didn't work at all at lower duty cycles. I checked the voltage with my oscilloscope, and that looked bad compared to the other motor. I contacted Randal, because I thought the driver was broken. To be sure the problem really was in the driver circuit, I exchanged the motors. This learned me that the problem rather is in the motor in stead of the driver circuit. Furthermore after some tweaking and re-soldering the motors they both seems to work fine, which they continu to do up till now.


For driving the motor from the launchpad, the following connections need to be made to the motor board:






Next part is the mounting of the line sensor, again some screws were missing (#2-56 1/4"). As in Netherlands metric is used above imperial, I'v chosen my own solution, using small pieces of copper wire soldered to the line sensor board.




Also the bump sensors are attached and connected.



After connecting the bump sensors and the line sensor using pin headers, it appeared that more distance is needed between the two boards than allowed by the provided nylon standoffs. This also can clearly be seen in the construction guide step 7 in section 3, on page 26, as you can see on the image below:



I'v chosen to add additional standoff, and longer screws, metric in this case, but since the stand-offs are nylon, I managed to force the screws into them.


Finally I removed the breadboard, as it currently doesn't have any value for my planned experiments. If needed it can easily be mounted.



Programming the robot

The software development environment used in the curriculum is Code Composer Studio (CCS), an industry-ready IDE option that is provided by Texas Instruments for use with TI microcontrollers and embedded processors. The IDE is based on the well known open source Eclippse IDE and available for Windows, macOS and Linux. For this review I have used the macOS version. Since I'm a bit hesitating to install large software environments for just a small project like this roadtest I had a quick look at the web based environment CCS Cloud, which I have used with other launchpad boards in previous roadtests. Inquiring on the forum learned me that I better could stick to CCS Desktop.

(https://e2e.ti.com/support/development_tools/code_composer_studio/f/81/t/701045?tisearch=e2e-sitesearch&keymatch=rslk )


I did not regret about this decision, CCS has many features that make it very capable for professional engineers to develop firmware for real products. It comprises a suite of tools (optimizing C/C++ compiler, source code editor, project build environment, debugger, profiler) used to develop and debug embedded applications. It was very convenient to use. Compared to for instance an Arduino environment I was very happy with the real-time debugger. After downloading CCS, I got it up and running quickly, on macOS it was not needed to install any drivers.


The curriculum code is stored inside of a CCS project, which was also downloaded from ti.com.

After importing this tirslk_maze project I was debugging the input/output project within minutes.


The only problem I encountered is that the source files are based on the Windows file system, with a backslash '\' as separator between subfolders. On macOS as well as on Linux the folder separator is the forward slash '/'. Therefore I had to change this for all the #include statements in each source file:



#include "msp.h"
#include "..\inc\bump.h"
#include "..\inc\Clock.h"
#include "..\inc\SysTick.h"
#include "..\inc\LaunchPad.h"
#include "..\inc\MotorSimple.h"


#include "msp.h"
#include "../inc/bump.h"
#include "../inc/Clock.h"
#include "../inc/SysTick.h"
#include "../inc/LaunchPad.h"
#include "../inc/MotorSimple.h"

In order to get the robot running, a lot of code needs to be written. Information on how to write the code is in the lessons, on the website, the e-book, and the corresponding video lectures. It takes a lot of time to go through all of that. I myself didn't go through all the lessons because of lack of time. Furthermore as I only got the basic kit I didn't have most of the hardware covered in the curriculum. For module 11 the LCD, is even not available in the advanced kit. So I sticked to:

  • Module 6, GPIO, mainly on interfacing the line sensors
  • Module 8, Input and Output, for reading the bump switches and driving the LEDs.
  • Module 9, The stick timer for timing stuff, including the duty cycle for motor control.
  • Module 12, on controlling the motors.


The line sensor measures the discharge of a capacitor, that is affected by the amount of light reflected by a IR sensor.

I implemented the function Reflectance_Read(int time) that gives the pulse and measures the output after a certain time delay (time).

Below you see some oscilloscope measures, the yellow line is the delay time, in first instance as suggested in the course I set it at 1000 us.

The upper image is the reflection of a white surface, the second is black, in both cases the signal is decayed to 0 within 1000us as you can see from the images. This results in both cases in an output of 0.


When using a time delay of 500 us it works much better as you can see here:



I also programmed the other functions, which was quite tough once and a while, but in the end I succeeded in getting the robot to run.

Here is the main routine for a line following robot that drives back and turns 180 degrees when hitting an object:


void main(void)
    // write this as a robot challenge
    int data, position;
    int speed = 1500;
    while (1)
        data = Reflectance_Read(500);
        position = Reflectance_Position(data);
        if (Bump_Read())
            Motor_BackwardSimple(speed, 150);
            Motor_TurnLeftSimple(speed, 230);
        if (position == 0)
            Motor_ForwardSimple(speed, 5);
        if (position > 0)
            Motor_LeftSimple(speed, 2);
        if (position < 0)
            Motor_RightSimple(speed, 2);



Because this is an ongoing course, it is not the intention to help future students, by showing the code for the subroutines that read the sensors and drive the motor. Students have to learn themselves by writing their own code, so I will leave it with this.

Below in this review you will find a video, showing the robot running this code.


Some thoughts on the curriculum

According to the course website the TI-RSLK is a low-cost robotics kit and classroom curriculum which provides students with a deeper understanding of how electronic system designs work. The course comes with 20 learning modules covering basic to advanced topics and is targeted to teach embedded systems and applications.


The curriculum covers:

  • Electrical engineering concepts such as voltage, current, power and energy
  • Microcontroller interfacing with sensors, actuators and motors, concepts of pulse width modulation, flash ROM, analog to digital conversion, digital to analog conversion and serial data transmission
  • Software design and testing using multithreading and debugging
  • Fundamental theories such as Nyquist, Central Limit and Little's Law
  • Building systems using finite state machines (FSM), closed loop control, Bluetooth low energy and Internet of Things


In my opinion, which is in accordance with the description above, the curriculum is very basic and fundamental. Its focus is more on electronics, interfacing and low level programming than on real robotics. That doesn't mean that this course doesn't have much value. I think future robotic engineers needs to know about the nitty-gritty details explained in this course, but there is more knowledge needed for programming a self driving car for instance. Artificial intelligence, motion planning, machine vision, kinematics, deep learning, probabilistic techniques to name a few.


Here is a non exhaustive list of courses covering these topics:


State of the art systems use high level robot frameworks, like for instance ROS (ROS.org | Powering the world's robots ) which has a lot more functionality than the plain C language used in the TI-RSLK Launchpad. It might be possible to extend the kit with a Raspberry-Pi, running ROS, for high level robot control. The Raspberry-Pi can be connected to the launchpad that takes care of the low level interfacing to the sensors and motor. Looks like an interesting future project.


Kids can program the robot

As mentioned before my original plan was to look at the curriculum with my daughter who just finished primary school this summer. Unfortunately that doesn't make sense as this course is at university level. My daughter has a lot of experience programming Lego Mindstorms robots using open-roberta (https://lab.open-roberta.org// ), a scratch like graphical programming language for a large number of robot kits and controller boards, including micro:bit, Arduino and Lego Mindstorms. The nice thing with this open-roberta is that the graphical code generates source code for the specific target robot. Since open-roberta is open source, it is in principle possible to write an implementation for the TI-RSLK.

For this roadtest I wrote a very small wrapper, that translates the code which was generated for my daughters Mindstorms into functions used by the TI-RSLK. This way my daughters open-roberta programs runs on her Mindstorms robot as well as on the TI-RSLK.

Lets show how this looks like, below is a small open roberta program that does the same as the program I described above. It follows a line until the robot hits an object. After hitting the object the robot drives backwards, then turns 180 degrees and again follows a line:


Below is the source code generated by open-roberta:


#define TRACKWIDTH 4.0
#define MAXLINES 8 
#include "NEPODefs.h" // contains NEPO declarations for the NXC NXT API resources 
task main() {
    SetSensor(S1, SENSOR_TOUCH);
    SetSensor(S3, SENSOR_LIGHT);
    while ( true ) {
        if ( Sensor(S1) ) {
            RotateMotorEx(OUT_BC, -1 * SpeedTest(50), (10 * 360 / (PI * WHEELDIAMETER)), 0, true, true);
            RotateMotorEx(OUT_BC, SpeedTest(50), (180 * TRACKWIDTH / WHEELDIAMETER), 100, true, true);
        } else {
            if ( SensorLight(S3, "LIGHT") < 60 ) {
                SteerDrive(OUT_C, OUT_B, SpeedTest(50), SpeedTest(20), true);
            } else {
                SteerDrive(OUT_C, OUT_B, SpeedTest(20), SpeedTest(50), true);


By writing wrapper functions for Sensor, RotateMotorEx, SensorLight and SteerDrive, I got this code running on the TI-RSLK:


// open-roberta wrapper code
#define true 1
#define S1 0 // dummy for now, can eventually select bump switch
#define OUT_BC 0 //dummy
#define OUT_B 0 //dummy
#define OUT_C 0 //dummy
#define S3 0x18 // reflection sensors used
#define PI 3.14

int Sensor(int dummy)
    if (Bump_Read())
        return 1;
        return 0;

void Wait(int ms)
    SysTick_Wait10ms(ms / 10);

int SensorLight(int ports, char dummy[])
    int data = Reflectance_Read(500);
    if ((data & ports) == 0)
        return 0;
        return 100;

int SpeedTest(int robertaspeed)
    return robertaspeed * 30;

void SteerDrive(int dummy1, int dummy2, int speedR, int speedL, int dummy)
    Motor_ForwardSimple2Speed(speedR, speedL, 5);

void RotateMotorEx(int dummy1, int speed, int length, int type, int dummy2,
                   int dummy3)
    switch (type)
    int time;
case 0:
    time = length * 750 / abs(speed); // time needed for driving requested distance
    if (speed < 0)
        Motor_BackwardSimple(abs(speed), time);
        Motor_ForwardSimple(speed, time);

case 100:
    time = length * 2200 / abs(speed); // time needed for turning requested angle
    Motor_TurnLeftSimple(speed, time);

case -100:
    time = length * 2200 / abs(speed); // time needed for turning requested angle
    Motor_TurnRightSimple(speed, time);


// end wrapper code

On the video below you see the robot running the main code presented earlier as wel as the open-roberta code using the wrapper routines.

There is one difference to notice! The Mindstorms is equipped with a light sensor using just one light sensitive device, compared to the TI-RSLK line sensor with 8 optical sensors. This means that the open-roberta code follows an edge in stead of a line. So the robot turns one direction when detecting black and the other direction when detecting white, where the main TI-RSLK code detects the distance to the center of the line.

With the wrapper I can select one of the 8 sensors, but the behaviour using the open-roberta generated code is equal to the Mindstorms robot, resulting in more shaky driving compared to its normal behaviour, as you can see in the video.




The TI-RSLK kit is a flexible robot kit consisting of the TI MSP432 LaunchPad and a Pololu robot chassis. Although I got the basic in stead of the advanced kit and some small parts were missing I was able to create a flexible and fun robot. The software IDE (Code Composer Studio)  has many features that makes it very capable for developing software for this robot.

Although the curriculum is very basic and fundamental, as its focus is more on electronics, interfacing and low level programming than on real robotics, this knowledge is very valuable for future robot engineers.

In the end, by making some wrapper functions I was even able to make this robot available to the open-roberta platform.

  • I am waiting for my first roadtest kit to arrive, looking at reviews from past roadtesters. Just wanted to drop a line to say I found this to be a thorough review and a good standard to follow. Thanks!

  • Great review! I bought one of these kits for myself last year and found some of the reviews published earlier invaluable, as the instructions at university.ti.com did not always suggest the best way to do things (for example how and which way round to mount the MCU board on the chasis).


    Your approach using open-roberta looks really cool! I think you would definitely need something like that if you were going to get school kids to write code for the TI-RSLK - it's not that the concepts are particularly difficult, more the additional level of details required to get each lab working if you were only following Jon Valvano's lectures. I am a big fan of Prof Valvano's books and online courses but it took a very long time to complete some of the labs due to loose/ambiguous specifications and the requirement to dig deep into the data sheets to discover the necessary details. I enjoyed it but I can imagine beginners getting completely lost and giving up!

  • Sure, as you see it was not that difficult to make a wrapper for the generated Mindstorms NXT code.

    I'm sure that it is not too difficult to make a complete own implementation of the TI-RSLK in open-roberta.

    In that case the real line sensor, as well as the sensors from the advanced kit also can be implemented.

  • Really neat that you got it working with open-roberta. I may have to try that.


  • Super cool videos there at the end!  A very nice roadtest effort.