RoadTest: TI Robotic Systems Learning Kit (TI-RSLK)
Author: jomoenginer
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?: Parallax Boe-Bot Robot Custom TM4C123GXL Actobotics Peewee bot
What were the biggest problems encountered?: The spacing for the QTR-8RC Reflectance Sensor Array took a bit of adjusting to get the sensor to detect the line properly. Also, the screws to mount QTR-8RC were missing from the kit as were the screws to mount the Sharp IR Sensor. The later Labs (18-20) switched to TI-RTOS so there were some conflicts with the code written in the previous labs. The tabs on the motors are very fragile so care must be taken to ensure these are not broken if they were used without encoders then the encoders were added later.
Detailed Review:
I am grateful to have been selected as one of the RoadTesters for the TI-RSLK Robotics System Learning Kit. I would like to thank Randall Scasny (rscasny) and the rest at element14 as well as those involved from TI for the opportunity to review this awesome Robotic Kit. Also, I would like to thank Dr. Jonathan Valvano from The University of Texas at Austin for creating such a comprehensive curriculum for learning Embedded Systems with the TI-RSLK as well as for providing a ton of educational content online for free through his web sites and with the multiple MOOCs on edX. Dr. Valvano was also kind enough to send me a special board that is being worked on as an option to the TI-RSLK Kit which I cover at the end of review.
This has been a very educational couple of months with a lot of material that was covered. I do however apologize for taking longer than the stated deadline to complete this RoadTest, but hopefully the info I provide makes up for the delay.
When I submitted for this RoadTest, my intent was to look at the subject matter as it was intended, as a learning tool for Engineering Students who would cover the material in a Engineering Degree program. The material might be good for an individual who is looking to go beyond the Arduino ecosystem or programming in Blocky, although it does take some work to get through the labs properly. But, the learning experience would be well worth it for someone looking to get a deeper understanding of Embedded Systems.
The TI Robotics System Learning Kit (TI-RSLK) is an excellent kit for an university level engineering program where Embedded Systems and Robotics are part of the curriculum. The Basic Kit includes a versatile SimpleLink™ MSP432P401R LaunchPad™ development kit featuring a 48MHz ARM® Cortex®-M4F MCU, a QTR-8RC Reflectance Sensor Array for line following, a Pololu Motor Driver and Power Distribution Board with two DRV8838 motor drivers, a Pololu Romi Chassis, 6 Bump switches for obstacle contact identification, 6 rechargeable AA batteries, multiple breadboard wires and parts for creating breadboard circuits. The Upgrade Kit includes a SimpleLink™ Bluetooth® low energy CC2650 Module BoosterPack plug-in module, SimpleLink™ Wi-Fi® CC3120 Wireless Network Processor BoosterPack™ Plug-In Module, 3 Sharp GP2Y0A21YK0F Analog Distance sensors, Romi Encoder Pair Kit and the mounting parts for the Sharp sensors. To accompany the TI-RSLK, 20 Learning Modules were created covering a range of topics from basic IDE install and code load to the TI-RSLK to wire connectivity with Bluetooth Low Energy and Wireless Network Programming. Each Module includes down-loadable curriculum documents including an Introduction, Lecture, Lab Exercises, Activity suggestions and Quiz questions. Also, all but Module 20 include a series of Lectures providing information to help complete the module as well as a Lab Solution video showing what the end result for the Module should look like. These modules are done in a progressive manner, in that each module, for the most part, has a dependency on a previous module. Thus, code created in one module may propagate through the following modules where the same code is reused. In most cases, if this prerequisite is not complete, then some of the modules code examples will not work.
The lectures and software development, along with the TI-RSLK hardware make up the perfect platform for learning Embedded Systems and Robotics at a Systems level from, as Dr. Valvano states, a bottom up approach.
The TI-RSLK Basic Kit includes the following components.
TI-RSLK Basic Kit from element14
https://www.newark.com/element14/robot-basic-kit/basic-robotic-kit-education-hobby/dp/43AC8495
TI-RSLK TI University:
TI-RSLK Maze Edition curriculum (Modules 1-19)
20 Learning Modules:
Dr. Jon Valvano data
http://users.ece.utexas.edu/~valvano/arm/msp432.htm
Pololu TI-RSLK Part details
https://www.pololu.com/category/240/ti-robotics-system-learning-kit-ti-rslk-parts-and-accessories
With the TI-RSLK Basic kit, a student can obtain a sound foundation of Embedded Systems and to learn how to program various features to enable functionality of an Embedded System. The included MSP432P401R offers exposure to ARM processors, one of the most popular MCUs in the embedded industry. To mount the MSP432 and includes sensors, a Pololu Romi chassis is included providing a versatile robotic platform with a multitude of configuration options. For movement, a Pololu Motor Driver and Power Distribution Board with two DRV8838 motor drivers has been added giving the TI-RSLK to power to move about. The 6 bump switches can be utilized to add physical sensors to a robot to assist in navigating an area. With the QTR-8RC Reflectance Sensor Array, the TI-RSLK can be used in line following challenges as well as to autonomously navigate a pre-defined course such as in a warehouse. This is a great starting platform to learning Embedded Systems which can be expanded with more functionality as the learner progresses in their studies.
TI-RSLK Basic Kit Unboxing
Modules 1-14 of the TI-RSLK provide the foundation of learning Embedded Systems. These modules take the student from installing the Code Composer Studio IDE and associated software modules necessary for completing the Lab, to understanding how Real-Time Systems work and how the concept can be used with a robotic platform.
In this first module, the student is walked through the process of getting the development environment configured by installing Code Composer Studio (CCS) and the associated lab code. The first step was to download Code Composer Studio from the TI website; Latest at the time of this writing is 8.1.0.00011
Code Composer Studio download link:
http://www.ti.com/tool/CCSTUDIO
Once the CCS install software is downloaded, executing the file initiates the install process. During the install process, a window will appear prompting to select Product Families to be installed. Ensure to select at least the Simplelink MSP432 option.
In the Select Debug probes window, various debug probe options are provided. Select at least the TI XDS Debug Probe Support option and perhaps the SEGGER J-Link if one is used.
Once Finish is pressed, the install process will start and will take several minutes to complete.
When the install process is successfully completed, start Code Composer Studio at which time a pop-up window will appear to select a workspace to save edited code in.
With CCS up and running, download the tirlsk_maze code labs and associated software and unzip it.
From CCS, click on File->Import to import the software packages into CCS.
Select CCS Projects and click Next.
In the Import CCS Eclipse Projects windows, navigate to where the TI-RSLK Maze software is located and click OK.
A list of Discovered projects will appear.
Select all, and do not select the other options. Then click Finish
The Software Labs and Examples will be listed under Project Explorer.
The projects listed with Labxx are Lab files and the others are example files. The 'inc' folder holds common code that is used throughout the Labs.
Lab 1 Notes
The Software Starter Projects used in Lab 1:
These Software Starter Projects provide a good introduction to CCS and loading code on the MSP432. In particular, the Input_Output example will validate that CCS and the associated toolchains are properly installed and the MSP432 is functioning. This is equivalent to the old Hello World example used in beginning programming examples.
In my case, I did receive a couple of Warning messages when compiling the examples. One was with the Compiler version since the version used when the software modules were created was older than the one installed on my system. This was corrected by going to the project's Properties page and selecting the installed Compile version.
Also, when starting the debug session on the MSP432, I received a Warning regarding an Update to the TI XDS110 USB Debugger Probe.
I just clicked Update to update the Firmware, but I did have to physically power cycle the MSP432 for the board to be recognized again.
When running the Texas example, which will be an on going situation throughout the Labs, to run a block of code, the name of the running function needs to be renamed 'main' or a main has to be added to the file in order to run the code.
Example:
int main(void) {
//int LogicAnalyzerMain(void){
Also, to get the Texas Display Logic Analyzer and Oscilloscope to work, the associate COM port to the MSP432 Application/User UART must be noted. This can be found from Device Manager on a Windows system.
The notes in the course state that Texas Display will pick up the appropriate COM port to run with. However, in my case it picked up a non MSP432 COM port and would not auto associate with the proper COM port so I had to manually set it from the listing in Device Manager; COM7 in this case. Also, it did not seem to pick up the MSP432 on COM 7 if another USB device was connected to the computer such as a Webcam
UART example output from CCS Terminal
Texas Display Logic Analyzer
Module 2 covers a brief review of how Voltage, Current and Power are related in a circuit and how to measure these values with lab tools such as an Oscilloscope to ensure the proper values are used to prevent damage to components. OHM's Law is discussed to show the relation between Current, Voltage and Resistance in electronics circuits.
OHM's Law:
V/I = R
Where V is Voltage, I is Current, and R is resistance.
The module also covers basic circuits such as R/C (Resistor / Capacitor) circuits, LEDs, DC Motors, and Inductors and why these would be needed in an Embedded System. Capacitance Reactance is covered as well and demonstrated by use of a R/C circuit and a signal generator input.
Reactance of a Capacitor:
V/I = X = 1/(2πfC)
Where V is the AC amplitude of the voltage, and I is the AC amplitude of the
current.
Lab 2 Notes
The Software Starter Projects used in Lab 2 :
In Lab 2, there are exercises used to demonstrate the Ohm's Law, Reactance of a Capacitor, and Voltage-current response of an LED material discussed in the lecture. These use the MSP432 and components on a Breadboard along with a Signal Generator from Texas Display to generate a simulated AC signal to perform the experiments. The Texas Display is a handy tool that can be used in case an actual Oscilloscope or Logic Analyzer is not available. An Excel Spreadsheet is provided to calculate the measured values such as Capacitance Reactance.
Circuit used Capacitance Reactance.
This Lab example uses the Lab2main code in the Texas project so the following change is required in the TexaSmain.c file to run the code
int main(void){ //
//int Lab2main(void){
From the MSP432 LaunchPad, P4.4 is used for the Scope input and P4.5 is used for the output frequency. Pressing either SW1 or SW2 will cycle the signal output through values 100Hz, 500Hz, 720Hz, and 1000Hz.
Capacitance Reactance example at 1KHz from Texas Display
As the frequency changes, the Measured Values can be added to the table to calculate the end values such as Capacitance Reactance in this case.
The table shows the difference between the measured values during the Lab and what as prepopulated in the table.
In Module 3, a brief introduction to the ARM Cortex M architecture and the associated Assembly Language is cover. Some may question the need to include a discussion on Assembly Language, however this is a program geared toward Engineering students thus having an understanding of how a program written for an Embedded System impacts the memory and register usage of an MCU is very helpful. Embedded Systems typically have a limited amount of memory thus care must be taken to ensure this memory is utilized in the most optimum manner. The module also covers the items that make up the CCS IDE such as the assembler, linker and debugger as well as how to use the debugger to set break-points and watches on variables to perform code debug.
Lab 3 Notes
The Software Starter Projects used in Lab 3 :
Software Starter Projects::
generator),
In this lab, only the MSP432 is required to code the assembly code. This lab simulates the functionality of the Sharp GP2Y0A21YK0F sensor, although the Sharp sensor is not part of the Basic kit. What is expected to complete the lab is to create a Convert function in file convert.asm coded in assembly where a list of values are passed to the convert function and the result is placed in register R0. The expected value it returned in R1 and the values are subtracted from each other with the result placed in R2 to indicate if there is an error. Register R4 is used to keep tract of the number of correct results and register R6 keeps track of number of errors. Thus the goal is end up with a value of 16 in R4 and 0 in R6 and R2.
NOTE: For those with little to no Assembly Language experience, this will be a difficult Lab to complete without an instructor or lab assistant.
End result of running the convert code.
Lab 4 covers the basics of software design utilizing examples of call graph, data flow graph, successive refinement, abstraction (functions) and modular design (header/code files) and how these can be applied to programming for the TI-RSLK to solve the Maze. For Agile fans, this is not covered. These are good concepts to understand which help with structuring the design of code for a particular project. Also, the C programming language is covered in a more detail showing programming concepts such as Logic/shift operations, Conditionals, Loops, Functions and Variables. Again, the Sharp GP2Y0A21YK0F sensor is used as a reference for creating code that could be used to create a Maze solution where decisions to turn left or right or avoid a wall are outlined. Also, Software design building blocks such as Sequential, Conditional, Iterative are briefly described. The module covers debugging code in more depth showing how to step through code or set break-points, observe variable status by adding Watch Expressions and Functional debugging. This lab starts to get into the meat of programming the TI-RSLK in C and how to create code in an organized manner.
Lab 4 Notes
Software Starter Projects::
Lab 4 takes the material discussed in the lecture and applies it to a Maze navigation simulation using the 3 Sharp GP2Y0A21YK0F sensors as a reference for wall avoidance. Similar to Lab 3, a Convert function is coded by the learner where simulated Sharp IR ADC values are used to determine the Robot position in the Maze such as if is to go Straight, Turn Left or Right , Blocked or at a Left Joint or Right Joint.
Lab 4.1 involves testing the Covert function that is written during the Lab exercise by passing in a series of control values. In Lab 4_2, a Classify function is created to take 3 simulated IR values and determine the required responses to navigate the maze as with the Sharp IR sensors. Lab 4_3 is an enhancement of the prior labs and was not attempted.
Lab 4_1 Result
As with the previous Lab, 16 values are passed to the Convert function, however in this case variables are used to show the distance passed in , the number of correct convert results, and the number of errors from the convert process. This should result in correct = 16 and errors = 0;
Program 4_2 with added tests for maze conditions
LeftTurn result
RightTurn result
n Module 5, the assembly of the Romi Chassis is introduced but only partial assembly for the power Lab. The assembled Chassis with the Motor Driver and Power Distribution Board (MDPDB) and MSP432 are used to understand the power requirements for the TI-RSLK and hot the parts work together to provide the various voltages and current values to power the bot. In order to make the assembly more flexible, I added headers to the areas where it is instructed to solder wires to the MDPDB. This allowed the removal of the connections without soldering the connections.
NOTE: Before soldering the battery connections to the motor board, ensure all of the necessary headers and connections have been made. .
NOTE: Cut the Jumpers on the Motor Board (MDPDB)
VPU-VREG
VCCMD-VREG
SLP-L-R (For Optional Adapter board)
The assembly instructions can be found in the Basic Kit Construction Guide:
http://www.ti.com/lit/ml/swrp249/swrp249.pdf
Lab 5 Notes
Software Starter Projects:
The exercises in Lab 5 covers measuring the current from the MDPDB ensuring the values are current before connecting the
MSP432 LaunchPad or other devices thus preventing damage to these devices.
After verifying the voltage and current values were correct, Lab 5.4 was performed to test the power consumption of the MSP432 and MDPDB.
This took approx 24 hours to discharge the batteries to the point the MSP432 LED no longer shown and the LED on bread board does not light.
Battery readings after 24 hours:
BAT1 – 3.3v
BAT2 – 1.2V
In Module 6 of the TI_RSLK, the chassis is assembled to include the QTR-8RC sensor which is connected to the MSP432 LaunchPad to introduce programming GPIO ports, a common means of interfacing devices in Embedded Systems. The QTR-8RC Reflectance Sensor Array has 8 IR sensors on it which is used to identify an object under the bot such as a line or the end of a table or a series of lines to indicate a stopping point. The QTR-8RC is interfaced through Port 7 and Port 5 of the MSP432 which is the underpopulated J5 of the LaunchPad, thus a header has to be added or the wires from the senor have to be soldered to the board.
The module covers the C code necessary to initialized the GPIO ports on the MSP432 and how to interface the sensor from the MCU. Also covered is how an IR sensor converts light to a voltage and how this data can be used by and the TI-RSLK to control the bot.
Note: The kit I received was missing the #2-56 screws to mount the QTR-8RC Chassis. Holes in chassis (slots) are too narrow for the 4-40 screws. Had to drill them out.
Reference the Construction guide for building the TI-RSLK chassis
http://www.ti.com/lit/ml/swrp249/swrp249.pdf
QTR-*RC Mounted under Romi chassis
Lab 6 Notes
Software Starter Projects:
the LaunchPad),
Documents used for this module.
Meet the MSP432 LaunchPad (SLAU596)
www.ti.com/lit/ml/slau596a/slau596a.pdf
MSP432 LaunchPad User’s Guide (SLAU597)
www.ti.com/lit/ug/slau597f/slau597f.pdf
QTR-8RC Reflectance Sensor Array data
https://www.pololu.com/product/961
In Lab 6, the interfaces required to code the Reflectance.c is provided where multiple functions are to be coded to interface the QTR-8RC. This code will be used in many of the subsequent labs so it is a important not to skip this lab.
Projects GPIO and InputOutput are used as examples of how to configure and initialize the GPIO ports of the MSP432 and how the data from these interfaces can be used to make other program decisions. For the QTR-8RC, P5.3 is used to turn the QTR-8RC on and off and P7.0-P7 are used as inputs to read in the values from the sensor. The CCS Debugger can be used to observe the values read to ensure the connections and the code are working properly.
TI-RSLK Lab 6
In Module 7, Finite State Machines are introduced as a means to create conditions, or states, where if a particular input is read, this input could be associated with a particular state to control the bot. The lecture covers Finite State Machine theory including Mealy vs Moore, the two most popular Finite State Machine (FSM) methods. The standard Traffic Light example is covered which depicts how a FSM can be used to set the state of a system based on a particular input and then transition to other related states to complete an entire transition. With regards to the TI-RSLK, this could be applied to control when the bot encounters a Right or Left Joint in the maze and to control it through the turn until it is running straight again. This is a cool programming tool that has many uses especially in the Robotics arena.
Example of state machine from Lecture doc.
Lab 7 Notes
Software Starter Projects:
Only the MSP432 LaunchPad is required for this lab.
First of Lab 7 part was to implement a Finite State Machine to blink the on-board LEDs when the buttons are pressed. There was an issue with this where the end state would periodically end up in the wrong state.
I stated in video that I did not know why the LED was toggling when a button was pressed, but it was from the FSM where the states were transitioning between a turn (Right or Left) and center due to the location of the state in the FSM instance. This is expected
TI-RSLK Lab 7-1
Part 2 Lab 7 was used to correct the issue with the FSM the first part of the lab by implementing more states to cause a transition from Left to straight when off line. Also, a Left1, Left2, Right1, Right2 states were created to cover the slight turn and then straight states. Off line states were implemented to handle cases where the bot was off the line after either going right or left.
TI-RSLK Lab 7-2
In Module 8, interfacing GPIO devices such as switches and LEDs are discussed along with how these can be used by Engineers in Embedded Systems design. Switches are a common means of input that can be found in many Embedded systems even around the house hold; Microwaves, TV remote, Game Controllers, Computer Keyboards and so on. To determine the state of a system, or even with debugging, LEDs are excellent devices to give a visual indication that a particular even occurred; Red LED indicating an error condition in an Embedded System is one such case. This module covers how to interface input and output devices and how they can be linked to create a chain of events. On the TI-RSLK, Bump switches are used to determine if the bot has encountered an obstacle to it can make the necessary course correction when navigating an area. Here, Tactile switches mounted on a solderless breadboard and connected to the MSP432 LaunchPad will be used to simulate window contacts in an alarm system.
Lab 8 Notes
For this lab, 3 Tactile Switches, the Solderless Breadboard, MSP432 LauchPad and associated jumper wires are required.
To set up this lab, there are functions in Lab08_Switches_LED project such as Security_Init(void), Security_InputSensors(void) and Security_OutputAlarm(uint8_t data) are to be coded to complete the lab. These along with the connected hardware is used to create a n alarm systems simulation.
TI-RSLK Lab 8 Interfacing Input and Output
In Module 9, the SysTick Timer is introduced and how it can be utilized to create a Pulse Width Modulation (PWM) signal for controlling devices such as the DC Motors or an LED. The ARM MCU includes a SysTick Timer which performs Timer and Counter operations to create time delays and to trigger interrupts periodically The SysTick can be loaded with a 24-bit value to set the timer as a down counter that runs at bus frequency. This feature can be used to create an accurate Timer delay that the system can use to control the triggering of events just as a motor turn or the blink state of a LED. The modules describes how the SysTick can be used to create a PWM run the DC Motors on the TI-RSLK as well as control the speed the motors turn.
Lab 9 Notes
Material needed for this lab:
In Lab 9, the SysTick timer is utilized to create a simulated PWM signal by passing in a series of values to a function that has to be created. This then used to Blink an LED at a rate where the LED appears to be breathing; blinking at various rates with increased and decreased frequency.
TI-RSLK Lab 9 SysTick
In Module 10, techniques that can be used to debug Real-Time Systems is covered. This includes utilizing the SysTick timer from the previous lab as well as arrays and Flash ROM to create debug dumps where data is stored when an event is triggered and can be used to determine the state of the system at the time of the event. The lab takes the information from labs 6, 8 and 9 to create a periodic timer to trigger when the debug data is saved. Also, the Bump switches are introduced and mounted to the TI-RSLK chassis. The bump switches connected to the MSP432 are used to collect obstacle identification by means of a bump switch press. The concept of multi-threading is introduced by collecting the QTR sensor and bump switch data in the background via the SySTick timer interrupts and indicating the value red via the RGB LED from main.
Lab 10 Notes
Software Starter Projects:
Material needed for this lab:
In Lab 10, the SysTick Timer will be used to trigger reads from both the QTR-8RC sensor array as well as the Bump switches. The result of this is saved in the Debug buffer by way of Debug_Dump. These values can then be read during a debug session as if it were in a failed state. Two functions are added to Reflectance.c, Reflectance_Start and Reflectance_End, to initiate the read from the QTR-8RC sensors and then to stop reading.
The bump switches require having the wires that interface to the MSP432 to be soldered on.
Bump Switches with wires attached.
Bump Switches Mounted on TI-RSLK
TI-RSLK Lab 10 Debug
In Lab 11 the Nokia 5110 LCD as an output display device. Although the Nokia LCD is not part of the TI-RSLK part list, it is a good tool to add to show how to display data to a user via an external source. The interface to the Nokia LCD is through SPI so this is also a good introduction to this serial connection which will come in handy in the later labs if using the Advanced or Upgrade kits. The concept of busy-wait is introduced to ensure the writing to the LCD is complete before starting another series of writes.
Lab 11 Notes
Software Starter Projects
Material needed for this lab:
The main framework of the code for the Nokia Display is provided except for some of the processing of data to the display such as lcddatawrite, lcdcommandwrite, Nokia5110_OutString, Nokia5110_OutUDec, and Nokia5110_OutSDec. The UCBUSY and TXBUF are used to create a busy-wait condition to ensure previous data is finished writing to the display before any new data is written to it.
TI-RSLK Lab 11 Nokia 5110 LC
n Module 12 the DC Motors are finally introduced. The module covers the fundamentals of Electromagnetic Fields along with Ampere's Law and Faraday-Maxwell with regards to the effect on Force by current and magnetic field. Also, the interaction between the MSP432 and the DVR8838 motor driver with relation to driving the DC motors is covered. Optional driver circuits such as using a TIP120, MOSFET, and TI L293 H-Bridge are described. The connections to the MDPDB to the MSP432 LaunchPad is shown where it is connected to Ports 1, 2 and 3 of the MSP432.
NOTE: Page 20 of construction guide appears to have the polarity of the motors mixed in the different motors
Motor Driver and Power Distribution Board data
https://www.pololu.com/product/3543
Lab 12 Notes
Software Starter Projects
In Lab 12, the DC Motors are finally added to the TI-RSLK chassis. With the motors in place, the code to turn the motors can be created. This is performed by the use of a PWM signal similar to what was used in Lab 9. A MotorSimple.c file is provided with the basic interfaces to Initialize the Motors as well as create Forward, Backward, Right and Left code. Here bit banding is used to send the values to the motors. This is used in place of using the motor encoders which are not part of the Basic kit.
Bit-banding code example:
//#define P2OUT (HWREG8(0x40004C03)) /*!< Port 2 Output */ // For bit-banding of bit 6 of P2OUT, n=0x4C03 and b=6. // 0x42000000 + 32*4C03 + 4*6 = 0x420ED896+0x18 = 0x420ED8AE // Port2.6 // For bit-banding of bit 3 of P2OUT, n=0x4C03 and b=7. // 0x42000000 + 32*4C03 + 4*7 = 0x420ED896+0x28 = 0x420ED8B2 // Port2.7 #define P2OUT_6 (*((volatile uint8_t *)0x420ED8AE)) /* Port 2 Output, bit 6 is DC*/ #define P2OUT_7 (*((volatile uint8_t *)0x420ED8B2)) /* Port 2 Output, bit 7 is DC*/
The second part of the lab involves reading the current from the Motor Board both at reset and while the motors are moving. My demo only covers the motor movement from the coded MotorSimple file.
One thing to note, the tabs on the DC motors where the wires attach are very fragile, so caution needs to be taken if the wires are connected for this lab and the encoders are added at a later time.
TI-RSLK Lab 12 DC Motors
In previous modules, software timers were implemented to create PWM signals, however this is not the most optimum way to perform this. Software timers take an excessive amount of CPU cycles to run. In Module 13, Hardware timers are introduced to enhance the performance of the system. To create the PWM outputs to the motors, Timer A0 is used and Timer A1 is used to create a periodic interrupt to be used to control a hardware device. Periodic Interrupt timers are timers that trigger an interrupt at a per-determined timer event. This can be used to read values in from sensors and other tasks that do not need a continuous interface.
In the Lab, a task is created which collects the Reflectance or Bump Switch data from the QTR sensor by passing the sensor read function as a pointer to TimerA1 function which in turns sets up the Timer interrupt event. This data is then used to control the direction of the motors such as when performing a line following exercise.
Lab 13 Notes
Lab 13 involved coding both the TimerA1 functions as well as the Motor functions which will be used in the labs that will follow. As the TimerA1 interrupt triggers, a read from the QTR sensors or the Bump Switches is performed where the data read is used to determine the position of the TI-RSLK on the line when running the line following exercise. To handle the interrupt event, an interrupt service routine (ISR) is created where the code to process the event is placed.
TI-RSLK Lab 13
In Module 13, Periodic Interrupt Timers were used to control the reading of sensor data, in Module 14 Priority Interrupts are introduced as an alternative. The MSP432 provides hardware interrupts on Ports 1-6 where if an event such as a button press is seen, an interrupt can be triggered and associated code is executed. This behavior gets the system closer to a Real-Time System. A Real-Time System can be either a Hard Real-Time System where a strict deadline is set for an event to be processed, or a Firm Real-Time System where an event can be missed without negatively impacting the entire system, or Soft Real-Time System where the missed timed event must be processed are soon as possible.
Lab 14 Notes
Software Starter Projects
It is important to note that interrupts are only on Ports 1-6, thus Ports 7-10 do not have this feature. I ended up adding 6 tactile switches to the breadboard to simulate the bumper switches since the bump switches were connected to port 8. Port 4 was used in this case. A new Bump Switch file is create to add the new Priority Interrupt code. Here a PORT4_IRQHandler is created which is called when a bump switch event occurs and returns the switch pressed.
TI-RSLK Lab 14 Real-Time Systems
Line Following Solution
TI-RSLK Lab 14Line Following
The Basic Kit is required.
Includes:
Upgrade Kit Unboxing
Modules 15-20 of the TI-RSLK require either the Advanced Kit or the Upgrade Kit or similar components to complete the labs. For this RoadTest, the Upgrade Kit was provided which included a CC3120 Wi-Fi module BoosterPack, a CC2650 Bluetooth Low Energy BoosterPack, 3 Sharp GP2Y0A21YK0F Analog Distance sensors and a ROMI encoder pair kit for the DC Motors. Both Modules 15, 16 and 18 utilize as well as enhance the code that was created in the previous modules. However, Modules 19 and 20 use TI RTOS where much of the previous code has been implemented in the RTOS code.
In Module 15, analog signal conversion to digital data is discussed and how these values can be used to interface sensors such as the Sharp IR sensors. This data can be read into an Analog to Digital Converter (ADC), and then the converted digital data can be analyzed to determine items such as distance, range or color. The Nyquist Theorem is covered where it can be applied to convert analog data to digital data. The Sharp GP2Y0A21YK0F Analog sensor is shown to be quite noisy, thus some filtering is required to clean this up. Noisy signals can be cleaned through either hardware with something like a Low Pass filter to remove Aliasing, or digitally through code where multiple signal samples are taken and code is created to attempt to clean the signal up. An example of this could be implemented with the TI-RSLK is with determining the distance from a wall or obstacle such as when solving a maze. In the Lab, a Low Pass Filter is provided in the LPF.c file. The associate a code is used clean some of the signal from the Sharp IR sensors.
Lab 15 Notes
Software Starter Projects
ADCSWTrigger (busy-wait ADC interface, simple digital filter, periodic interrupt
sampling),
Material needed for this lab:
In Lab 15, the Sharp GP2Y0A21YK0F Analog Distance sensors are used to create a Data Acquisition System using ADC14 from the MSP432 to read in the analog values from the senors and convert the data to digital representation of the distance. Since these sensors are quite noisy, Low Pass Filter code has been provided and is used in the ISR used to read the values from the Sharp sensor. Also, 3 10 uF tantalum capacitors have been placed between the 5v signal and ground for each of the Sharp sensor again to help clean the in bound signal.
This lab required referencing the MSP432 Datasheet, specifically for the ADC14 values since this is used to create the code to read the Sharp sensors. (NOTE, in the MSP432 data sheet from ADC14 to Precision ADC ). The Sharp sensors use ADC14 channels 17, 12 and 16 so code had to be created to implement this. UART0 was used to output data to a serial console to ensure the calculations were correct.
MSP432 Datasheet
http://www.ti.com/lit/ug/slau597f/slau597f.pdf
TI-RSLK Lab 15
In Module, an expansion of Timer A is covered where it is applied to the Motor Encoders creating a Tachometer type reading from the motors. Here, the concepts of Clock input and prescale as they apply to Timer A are discussed. The MSP432 has 3 Timers (0-3) with mapping in the Nested Vector Interrupt table each with 2 entries in the table. The timers are set so when the motor turns, the encoder creates a signal on the attached pin to the MSP432 triggering an Interrupt. This then fires the IRQ associated with the motor encoder that triggered the event causing a Capture task to run to collect the data. In the case of the TI-RSLK, Timer A3 is used so the interfaces from the Motor board are connected to the MSP432 accordingly.
From the Lab Documentation
The Associated Interrupts for Timer A3 are 14, and 15
INTISR[14] Timer_A3 TA3CCTL0.CCIFG
INTISR[15] Timer_A3 TA3CCTLx.CCIFG (x = 1 to 4), TA3CTL.TAIFG
NVIC Table from Datasheet
Lab 16 Notes
Software Starter Projects
Material needed for this lab:
In Lab 16 a TA3InputCapture.c file is provided where the 3 Timer A3 configurations will be added. The datasheet data shown previously is required to set the appropriate values for each of the motor encoders to its associated Timer A3 timer Interrupt. This is mapped with P10.4 associated with TA3CCP0 and P8.2 associated with TA3CCP2; INTISR(14) and INTISR(15) respectfully. As the motors spin, an interrupt is triggered causing the appropriate TimerA3 ISR to be called. The FlashProgram code used in a previous lab will be used to collect this data
The provided Motor Encoders are required to be attached to the DC Motors for this Lab.
NOTE: If wires were soldered to the DC Motors previously, care must be taken to ensure the tabs from the motors are not removed when unsoldering the connection.
TI-RSLK Lab 16 Tachometer
Module not attempted
Module 18 expands on the previous lab examples of utilizing a UART by implementing a First In First Out buffer for EUSCI_A0. A FiFO can be used as a buffer for incoming data where the oldest data received will be first data read. This is useful for when the data being read can not keep up with the data being written. The module also goes over some details regarding the implementation of a UART and how the signal is formatted. This includes how the Send/Receive frame is structured, what Baud rate is, and what is Bandwidth. The MSP432 has 8 separate UARTs with UART0 attached to the USB port on the LaunchPad. When data is sent to a UART, an interrupt is triggered on TXIFG and data is written to UCAxTXBUF. As data is read in, the data is bit shifted so the oldest data is is the lower bit.
From Module 18 Lecture data
Lab 18 Notes
Software Starter Projects
Material needed for this lab:
In Lab 18, a FiFo.c is provided with the interfaces for implementing a Fifo queue. This code must be written to complete the Lab. There are Test functions in Lab18_UARTmain.c which can be used to test the Fifo code for correctness. Once the code has been tested and is working properly, the UART code associated with EUSCIA0 can be run. Using a Serial Terminal to the MSP432, values can be input where they are read in through the Fifo queue and processed to control the bot.
Note: To get the Serial Console output to show properly, a Carriage return (“\r”) had to be added. This can be accomplished with the following commands:
EUSCIA0_OutChar(LF);
EUSCIA0_OutChar(CR);
Also, there is code listed in the Lab 18 documentation as an example of creating a table of structures to control the motor directions. There are errors in the code so it did not compile when added to the existing code.
Const table listed in Lab has an incorrect entry for Right
const Cmd_t Table[8]={
{ "Stop", &doStop},
{ "Go", &doGo},
{ "Back", &doBack},
{ "Left", &doLeft},
{ "Right", &doFast}, // Should be doRight
{ "Slow", &doSlow},
{ "Fast", &doFast},
{ "Sensor" &goSensor}}; // Missing commaModule 19 introduces the Bluetooth Low Energy connection protocol with the use of the TI CC2560 BoosterPack module. The CC2650 connects to the MSP432 and adds remote connection and control of the TI-RSLK through BLE. The module covers basic concepts of BLE and how this is used in the IoT realm. The BLE profile is shown where it includes Generic Attribute Profiles (GATT) and Services which are used to send and receive data to a device. The advertising frame is covered is some detail showing how the frame is used to carry the GATT payload to and from connections.
TI CC2650
Lab 19 Notes
Software Starter Projects
Material needed for this lab:
Lab 19 covers the addition of Bluetooth Low Energy through the use of the CC2650 BoosterPack Plug-In Module. In the Lab19_BLE Code, an AP.c file is provided with the Implementation of the BLE protocol for the CC2650. This code is used to create an interface to the TI-RSLK to control it's movement. The code for the Cmd Table was used to send values to the Motors to control their direction by input from the BLE interface.
Lab19 Running BLE connection from Raspberry Pi with BlueZ
TI-RSLK Lab 19 BLE
Module 20 is the final Lab in the TI-RSLK curriculum and is the only module that does not have videos for the lecture of labs. The module introduces another popular IoT Wireless connection by means of Wi-Fi. The TI CC3120 Wireless Network Plug-In Module. Some information regarding netowork communication is provided include the OSI model, TCP Four Way Handshake between devices as well as a client server image. Primarily the SimpleLink ecosystem is covered with the association of TI RTOS and the CC3120. TI RTOS is introduced since it is used with the CC3120 instead of the code from the previous modules.
CC3120 data
http://www.ti.com/tool/CC3120BOOST
Lab 20 Notes
Software Starter Projects
Material needed for this lab:
Lab 20 is not part of the main software download for the TI-RSLK curriculum so it must be downloaded and installed separately. It also has some dependencies on other software packages which have to be installed to run the code examples. The lab uses a Network Terminal example to test that the CC3120 and working properly and can connect to a local router. This will not work if the router is set to not broadcast the SSID. The example only works with broadcasted SSIDs.
The Lab20 code is used to create a connection with a local router and then pull down the current time and weather information using RESTFul GET and Post APIs. The same Lab20 code is used to connect to the IFTTT and simulate a button press which then sends an email of the event. This requires setting up an IFTTT account and creating a Webhook. This did take some time to get things working together but it did seem to work although the email took between 30 and 40 minutes to receive after an button_pressed event was sent.
Download Lab 20 code
Download the SimpleLink MSP432P4 SDK from
http://www.ti.com/tool/SIMPLELINK-MSP432-SDK
Download the SimpleLink Wi-Fi SDK Plugin from
http://www.ti.com/tool/simplelink-wifi-cc3120-sdk-plugin
Import the Network Terminal Program SimpleLink CC3120 SDK Plugin
1. File → Import → CCS Project and navigate to
C:\ti\simplelink_sdk_wifi_plugin_1_60_00_07\examples\rtos\MSP_EXP432P401R\demos\network_terminal
Result of the network_terminal exercise:
Network scan
Result of the network_terminal exercise: Network scan: user:scan -n 4 --------------------------------------------------------------------------------------------- | SSID | BSSID | RSSI | Ch | Hidden | Security | --------------------------------------------------------------------------------------------- 1 | Hal9000 | 70:73:cb:bb:8e:ef | -80 | 1 | NO | WPA2 | 2 | NETGEAR15_EXT | b0:39:56:a9:94:5b | -88 | 1 | NO | WPA2 | 3 | HP-Print-2E-Officejet Pro 8620 | 6c:c2:17:54:88:2e | -84 | 2 | NO | OPEN | 4 | NETGEAR12 | a0:04:60:39:3b:a0 | -66 | 3 | NO | WPA2 | ---------------------------------------------------------------------------------------------
NOTE: Could not connect to hidden SSID
Lab20 Output from NIST:
============================================ CC3220S Get Time and Weather Demo Example Ver: 0.1.0 ============================================ CHIP: 0x30000000 MAC: 2.0.0.0 PHY: 2.2.0.4 NWP: 3.3.0.0 ROM: 0 HOST: 2.0.1.27 MAC address: f0:c7:7f:17:ec:a1 ============================================ **** Starting main loop **** Using hardcoded profile for connection. Device came up in Station mode [WLAN EVENT] STA Connected to the AP: SSIDNAME , BSSID: <MACADDR> [NETAPP EVENT] IP Acquired: IP=IPADDR , Gateway=IPADDR Device has connected to SSID Device IP Address is IPADDR Start getforecastdata strlen: 153 retval: 153 Date: 2018-09-04, Symbol:light rain CUR: MIN:22.96 MAX:26.09 Date: 2018-09-05, Symbol:light rain CUR: MIN:23.07 MAX:29.72 Date: 2018-09-06, Symbol:scattered clouds CUR: MIN:22.78 MAX:27.5 Date: 2018-09-07, Symbol:light rain CUR: MIN:23.05 MAX:28.76 Date: 2018-09-07, Symbol: CUR: MIN: MAX: Server time-c.nist.gov has responded with time information Mon Sep 4 2018 18:42:23
Lab20 IFTTT Applet ran
Email from IFTTT button_pressed event
A BeagleBone Black running the Mosquitto MQTT Broker along with the SimpleLink MQTT Client example were used to send commands to the TI-RSLK via MQTT.
************************************************* CC3120 MQTT client Application ************************************************* Device came up in Station mode [WLAN EVENT] STA Connected to the AP: MYSSID , BSSID: [NETAPP EVENT] IP acquired by the device Device has connected to MYSSID Device IP Address is 192.168.3.100 .CONNACK: Connection Success Client subscribed on /Broker/To/cc3120 ,Client subscribed on /cc3120/MotorStop ,Client subscribed on /cc3120/MotorGo ,Client subscribed on /cc3120/MotorBack Msg Recvd. by client TOPIC: /cc3120/MotorBack PAYLOAD: 0 QOS: 0 Msg Recvd. by client TOPIC: /cc3120/MotorBack PAYLOAD: Back QOS: 0 Msg Recvd. by client TOPIC: /cc3120/MotorStop PAYLOAD: Stop QOS: 0
TI-RSLK Lab 20 W-Fi
TI-RSLK Lab Maze Runnin'
I would like again to thank Randall, the folks at element14, those involved at TI, and Dr. Jon Valvano for this opportunity to RoadTest such an awesome Embedded Systems learning tool. The TI-RSLK overs a wide variety features that covers many aspects of Robotics, Autonomous vehicles and Embedded Systems. The TI-RSLK would be a great addition to any Engineering program where there is a focus on Robotics and Embedded Systems. It certainly gives a real world look at designing these type of systems. I look forward to working with the kit even further and as well as using the kit for Robotic Competitions in the Robotic club I belong to. My apologies once again for not getting this RoadTest in at the scheduled time. I did want to get this in as soon as possible though.
When I signed up for this Roadtest, I purchased the associated book Embedded Systems Real-Time Interfacing to the MSP432 Microcontroller by Dr. Jon Valvano. I did have the previous set of book that are focused on the TM4C123 series of boards from TI, but for the RoadTest I wanted to have this book since it is focused on the MSP432. When I received the book, I noticed in the from cover image, there was a second board, a green board, under that MSP432 LauchPad. Upon further investigation, I seen that the board is stamped with RSLK on the front. After looking on the web for this board, I decided to contact Dr. Valvano directly to see if this board was available for purchase. To my surprise, he just sent me a board with the necessary components. After completing the Labs for the main part of the RoadTest, I went to work soldering the components on this RSLK Adapter Board and then disassembling the TI-RSLK. Once the voltages on the board were verified, I completed the assembly of the bot with the new board. Compared to the previous state of the TI-RSLK, this board really cleans up the cabling of the bot. I did had some female headers where the Sharp IR sensors connect to and I added a Arduino Header where the Nokia 5110 LCD goes , but this ended up to interfere with the placement of the MSP432. I modified this a bit by adding an angle header and another Arduino header so the LCD is out a bit further and higher than the MSP432. In the end, this was a great addition to the TI-RSLK and really cleaning up the connections. Everything worked perfectly right off the bat. One note though, there is no 5v from the Adapter Board to the MSP432, so the main Motor Board has to be turned on when testing the Sharp IR sensors and such.
I would like to thank Dr. Valvano and the folks at TI for allowing me to include this board to the RoadTest. Hopefully it gets added to the kits once it is ready for production.
Embedded Systems Real-Time Interfacing to the MSP432 Microcontroller
https://www.amazon.com/Embedded-Systems-Real-Time-Interfacing-Microcontroller/dp/1514676583/
Adapter Board Disassembled
Adapter Board assembled Top
Adapter Board Assembled Bottom
Adapter Board mounted in Chassis
TI-RSLK Adapter Board Option
Top Comments
Hi Jon,
Great RoadTest, very comprehensive. That was really nice of Dr. Valvano to send you the optional board and parts.
Thanks. Yeah, I feel luck that Dr. Valvano sent the Adapter Board. You never know until you ask.
I did not mentioned it in the Review, but the Adapter Board has Tantalum capacitors and LM6134 connected…
Thanks DAB. I just wish I had completed it sooner.