Hey, everyone. Welcome to the TI Industrial session. This is a session on designing in emerging applications, ultrasonic sensing, and cap touch. This will actually be present by Leo Estevez from our [? COPs ?] team as well as Dennis Lehman. My name is Sheena, and I'll be the moderator for this session.

Just some highlights for you guys-- everyone will be muted for this session, so if you have a question, feel free to use that chat function and address that question everyone, and we'll try to get to it at the end of the presentation. Please also let us know if you're having any problems with hearing or seeing the presentation and we'll see what we can do. So with that, I'll go ahead and hand it off to Leo to get started.

Thanks, Sheena. So today, I'll be presenting specifically on ultrasonic liquid level sensing. This is one of many applications that we enable with our single-chip ultrasonic sensing solution. The first thing I'm going to talk about is our integrated single-chip solution, some of the test fixtures that we're using, and also the parametric design files that are available to also test for your own requirements, some of the transducers and trade-offs with these transducers, adverse operating conditions, which include issues commonly encountered such as foamy liquids and condensation in hot vapor environments, and Finally, I'm going to discuss some additional applications and then hand off the Dennis to discuss CapTIvate, and there'll be some demos and Q&A at the end of both presentations.

So at a high level, just some technology and cost comparisons, in-liquid sensors are prone to corrosion and mechanical failure and can't work with arbitrary containers, drink dispensers, coffee machines, et cetera. The additional cost of a transducer can be $0.50 in high volumes. The transducer can often be fit directly into the chassis of the tank or machine and doesn't require modification to the container itself. And ultrasonic-level sensing can enable resolutions at around 20 microns, which could enable feedback for flow control while dispensing fluid from a container or to a container. The average current consumption of our solution is less than 20 micrograms per measurement per second for battery-powered applications.

So this is a block diagram of our MSP43FR6046 family. We basically integrate a programmable pulse generator, which is capable of exciting transducers from 133 kilohertz to 0.5 megahertz, and integrated PHY. This signal output to one or multiple transducers. In this case, today, we'll be talking about a single transducer.

The signal's then received either by another transducer, but in today's examples, we'll be talking about the same transducer. It goes through a programmable gain amplifier, which can be set to a gain of negative 6.5 dB to 30.8 dB and then goes to a high-speed sigma delta ADC, which can sample up to eight megasamples per second, and then without intervention of our integrated MCU, goes to a low energy accelerator. And this low energy accelerator is capable of handling common signal processing functions such as correlation and filtering.

So this is a comparison between existing TDC zero-crossing approaches and our ADC-based correlation approach. One of the advantages of our solution is if you would like to implement your own method or algorithm, you don't have to use the algorithm set that we have. We have implemented several algorithms, not just for level sensing, but also for high-resolution flow sensing and liquid and gas. In any case, TDC zero-crossing will use a threshold with a timer, and that stop-- time-- the timer will be stopped when this particular threshold is exceeded. Then, after that, subsequent zero-crossings are found, and these are used to determine the absolute time of flight.

And one of the issues with this approach is that you're dealing with the signal directly, and so any variations that you have with the amplitude of the signal that's being received can cause problems in finding the zero crossing. So for example, if you get into some noisy environments and the signal is slightly lower and the signal goes up, then you might be looking at the wrong zero crossings, and this could throw your absolute time of flight measurement off.

So in our ADC-based approach, what we do is we digitally capture the signal, and the first thing that we do is we perform a full correlation of the input with the binary transmit pattern. So we're actually looking at a correlation between the signal that we transmitted and the signal that we received. We then compute the Hilbert transform of that signal so we're actually getting an envelope.

After that, we find the peak of that envelope and we calculate the threshold intersection using the peak of that envelope so it's actually normalized to look for this intersection. And then we correlate-- or excuse me, we interpolate to find exactly where that threshold crossing is. And one of the primary advantages we have in this approach is that we're dealing with the correlation of frequency information as opposed to just the amplitude of the signal, which is what most TDC zero-crossing techniques will do.

So for the specific experiments that I'm going to describe today, this is the ultrasonic configuration that was used. We have an MSP430 6043. We have a driver with an off-amp circuit to further amplify the signal. And we connect these to the same single transducer. In this particular set up here, this is actually a [? Jokhang ?] 200 kilohertz transducers. We've evaluated several transducers from various manufacturers, including [? Jokhang, ?] Audiowell, CeramTec, [? China ?] Ultrasound, et cetera, and we can provide specific information about the performance of these different transducers for this specific application. There's an app node. If you'd like to click on this, you can learn more about these specific types of experiments that I'm going to be showing you today.

So the first thing that we're going to talk about is the test fixture. And this is basically just a piece of plastic that's used to hold the transducer over a container. These parametric design files are provided in the app notes in OpenSCAD format. OpenSCAD is a freely available tool. You can download it here. You can literally take this code and cut and paste it into the tool, generate a 3D model that will act as your test fixture, and export to STL and 3D print. So all of our test fixtures are 3D printable without any support structures. And they print in roughly two to 20 minutes, depending on your 3D printer.

As you can see this is a 200-kilohertz transducer here. In this case, we have a 500-kilohertz transducer and we have a little bit of a collimator to make the signal slightly stronger. And we'll talk about why we need to do that. And in this particular test fixture, we're using 175-kilohertz transducer. So we have three different test fixtures today that are slightly different, and we'll be talking about three different transducers and explaining what happens with these different transducers in different scenarios.

So just to give you a high level, this is showing what happens to the attenuation of the ultrasonic signal-- in this case, a gas mixture of methane. So this is representing the percent methane. As we increase in methane, we get greater attenuation. But you can see there is also a function of the frequency of the transducer. So 1-megahertz transducers have significant attenuation, whereas the 100-kilohertz transducers have the lowest amount of attenuation. But you'll notice that as you change the gas mixture, the attenuation is not following a predictable curve so their characteristics about the gas that you have to take into account in what you're trying to do your level sensing, and those will affect which transducer you would choose for that.

So based on some experiments conducted here at TI, we found for some 175-kilohertz transducers, we were able to, with the 3.3 volts excitation, sense over a hundred-centimeter range, and with an eight pulse configuration. Obviously, if you use more pulses, you'll get better standard deviation, because you have more information to correlate. We were seeing anywhere from 100 to 500 nanoseconds with a minimum distance of 3.5 centimeters.

So there is a trade off here. If you want to sense very close to the transducer, you may want to go to a slightly higher frequency. For 200 kilohertz for example, we were able to sense reliably over a 20-centimeter range, 50 to 400 nanosecond standard deviation, and a minimum distance of 1 to 1.5 centimeters. 500 kilohertz, slightly shorter sensing range, and in this case, as you saw, we did use a bit of a collimator there. But you can achieve better resolutions, better standard deviation in measurement, and you can also sense at much closer distances.

So this is a summary of some 500 kilohertz experiments conducted. We have a GUI that goes with our EVM platform, and I'll provide the link for that at the end, where you can configure the sweep frequency for excitation. In this case, we excited from 490 to 540 kilohertz, so a 50-kilohertz sweep. You can see our gain was relatively high. In this case, we're at 21.5 dB. This is the AC signal that we were seeing. And this represents the measurements over time of the absolute time of flight. And as you can see here, we're roughly a standard deviation of 0.2 microseconds. So if we multiply this 0.2 microseconds times the speed of sound in air at room temperature, we'll get 68.6 micrometers. But because this is around trip, we can divide that by 2, this is giving us basically a resolution of 34.3 micrometers.

200 kilohertz at roughly 10 centimeters-- here, our sweep frequency was set to 170 to 220 kilohertz. This was obviously a lower frequency transducer. Gives us more energy, so our gain was actually reduced, here, in this case, to 18.8 dB. We are seeing in this case not as high resolution, roughly 0.4 microseconds, so 0.4 times 343 meters per second, 137.2 meters, divided by 2 gives us 68.6 micrometers one way.

Now, one point here is that we do have the ability to take measurements fairly quickly, roughly for absolute time to fight, 200 measurements per second. And so if you were just to take, for example, four measurements and average them, then you would get the square root of 4 divided by your standard deviation, so that would give you a divide by 2 of this number for your resolution. The trade off there is, of course, you're going to consume more power for that, but if your application doesn't care about power and it cares more about resolution, then you can take more measurements and beat down your mean and get better resolution.

175 kilohertz at 10 centimeters. Here, we're using a much narrower excitation frequency. We're going from 170 to 180. And part of the reason for that is that this is actually a much-- it's just a narrow band transducer compared to the other transducers that we saw. And so there's really no point in exciting outside of this band, because it didn't have much of a frequency response. We have a tool inside of our GUI that enables you to capture the frequency's response to the transducer, and then you can quickly see exactly what your excitation band should be. And that's also described in our documentation.

Here, you can see we didn't need nearly as much gain on this to get a reasonably good signal. As mentioned previously in the other slides, we're seeing a lot less attenuation at these lower frequencies. And this is also a larger, more sensitive transducer, so that also plays into that. Here, we're seeing 0.13 microseconds for the standard deviation in our measurements, which gives us 22.3 micrometers resolution per measurement.

So next, we start looking at some adverse conditions, which are common. Oftentimes, there'll be foaming in the liquid. If we're dispensing some type of fluid, let's say coffee, that has sugar and some other substances in it, or if it's a frappuccino, then you would expect-- you would hope, actually, to have some of this foam in here. And so what happens to the signal when it's being reflected in this foamy container? As you can see, this is the no-foam situation. We start introducing a little bit of foam, and you see the signal starts attenuating into the noise floor here. And then as that foam gets to this level, we can see that you can barely see the signal. Now, interestingly, even in this case, we can still extract the absolute time of flight, because what we're doing here is we're correlating this signal against the transmit pattern, which contains the frequency information. So we can still even see the signal, even though it's in the noise floor.

Another common situation that we run into with level sensing is condensation effects. And in these experiments, what we've done is we're looking at hot vapor or steam, so it's a hot liquid that's being dispensed, and then basically that vapor is condensing on the surface of the transducer. And as you can see here, it has also a negative effect on the signal. But even then, you can still see that we will capture the absolute time of flight, but the standard deviation goes up significantly-- in this particular case, up to 4.6 microseconds. But we can still detect it, and this is with the 200 kilohertz.

Interestingly, if we go to 175-kilohertz transducers and we look at the condensation effects, this is a much larger transducer, and it is putting out a lot more energy, so it does degrade the signal some. But it still looks quite good. And in these particular cases, you can see that we're closer to four microseconds on the standard deviation in our measurements, which is giving us around 0.68 millimeters resolution. And here, again, we have the ability to take multiple measurements quickly and average to get this resolution even higher in exchange for power, of course.

So these are some additional applications that we have app notes for. You can go to this link here for the EVM hardware and go to the technical documents section and you'll see additional app notes there. And one of the things that we found is oftentimes people that are looking for an ultrasonic level sensing solution in some of these devices are also wanting to do something beyond level sensing. And the nice thing about our solution is that you can multiplex between multiple transducers and different algorithms for different applications on the same SOC.

So if you wanted, for example, to combine level sensing with material or composition analysis, which is actually something people are generally interested in this combination, then that's possible on our platform by dialing in the different algorithms for these different things and the signaling mode and just MUX-ing the appropriate transducers, where they're located in the machine.

Everyone, I think, is aware of applications in distance measurement. These are actually fairly low-resolution applications, but of course we can do those as well. We also have the ability with our high resolution of doing noncontact vibration and motion sensing, which is, I think, interesting for machine monitoring training applications. Obviously, volumetric temperature measurement can be done, so any time you want to measure the temperature-- not just at the sensor, but over a volume of liquid or volume of gas, we can do that ultrasonically. And one of the most popular applications is airflow sensing. These are in addition to our traditional gas metering applications and water metering applications, which obviously we support. These are other segments in addition to those. And those gas and water metering applications are described in great detail, also on these pages, if you go here.

So that's all I have for liquid level sensing. Sheena?

Thank you, Leo. So if any of you have questions for Leo, please go ahead and add those to the chat, and we'll go ahead-- we'll get to them at the end of this presentation. So now we have Dennis, and Dennis is going to talk through some of these emerging applications with our capacitive touch technology that you can find in the MSP portfolio. OK, take it away, Dennis.

Dennis, you're muted.

Yes, I just realized that. Thank you. Thank you, Sheena. So today, we're going to spend a few minutes and look at some tools that makes capacitive sensing design much quicker and easier than what you would normally consider. There's two aspects to doing capacitive touch designs. One is the PCB layout. The other, the actual configuration of sensor connecting it to an MCU and doing the sensor tuning. So we're going to look at those two aspects and show you a couple of software tools that will make that process very quick and easy and very painless.

So what we'll do first is we'll take a brief look at the CapTIvate-- overall CapTIvate technology, and then we'll go through automating the actual sensor design, which would be, how do you automate the PCB design itself? And then we'll look at using the CapTIvate Design Center to automate the sensor configuration and code generation part. And then as Leo had already talked about or mentioned the OpenSCAD, we'll do a demo on a couple of different designs for sensors. And if there's enough time left over, I'm going to sneak in a 3D demo that is one that Leo provided, so we'll have a chance to do that.

So you'll hear the term "CapTIvate." CapTIvate as a family of MSP, low-power MCUs that have a dedicated capacitive touch technology built into it. Depending on the device variant, you can go from one to 64 buttons. You can group these buttons-- or elements, as we refer to them-- into groups and create other sensors, like sliders, wheels, even a 2D touchpad. So they're very versatile. CapTIvate also supports both self capacitive and mutual capacitive on the same devices. It's configurable to however you want that to work on your system.

So CapTIvate technology is more than just capacitive touch on the MCU. It also includes our complete ecosystem, which is pretty well described in our CapTIvate tech guide. So when customers have questions, we first welcome to the CapTIvate tech guide. Here's the URL that you can look at. It describes everything that is related to CapTIvate, the MCUs, the technology, the GUI. And so what I generally recommend for someone who's wanting to get into capacitive touch, these are probably the primary things that you want to look at in the CapTIvate tech guide, the first being, which MCU would you choose depending on your application. If you want to know a little more about the actual technology and how it works, there's a chapter on that.

One of the more important ones is the sensor design guidelines. So when you've selected the MCU and you know what your application is, you're going to be laying out a board. You have to know how to route the signals, how big the sensors can be, things like that, how [INAUDIBLE] be. So all that's covered in the design guide chapter.

And once you've got the board made and you're going to use the Design Center GUI, this chapter steps you through and shows you how to use all the various features of the GUI. And we'll go through a few basic ones here in a moment to get an idea of how that works. There's also a section on development tools that are available for you to purchase, and you can look at and actually test and evaluate the technology. And then if you're getting started for the first time with CapTIvate, we have a dedicated chapter. It's the workshop chapter. And with that chapter, it takes you through the whole process of creating a brand new project, configuring the sensors, and doing the sensor tuning. In fact, there's a video online that actually [INAUDIBLE] through a process-- the whole process of designing a multisensor system and getting it tuned up in less than five minutes, so it's pretty cool.

I mentioned the tool, so this is just a few of the tools that we offer, but just to give you an idea what they look like. We have a few-- couple of the MCU boards for our 2633 and 2676 family. And then we've got these panels. The first one is a CapTIvate phone panel. And it is a mutual capacitive type of board, so all the sensors are mutual. And it allows you to evaluate the performance of mutual capacitance on a very complex layout, which, in this case, is a keypad. There's a wheel and a couple of sliders. The BSWP is a self-capacitor board, simple. Just has a keypad, a wheel, and a slide. So depending on the technology that you're thinking of using for your application, you can get these and play with them and see how they work. And then they all need this CapTIvate programmer board, which is used to do the programming and debugging, as well as the communication between the target MCU and the CapTIvate GUI.

So let's go and look at the-- automating the sensors designs. So the tool that we've decided to rely on and use is the OpenSCAD, which is actually a 2D or a 3D type of rendering for CAD design. And it's script based, so rather than actually drawing the lines and connecting different curves and things, it's actually a parametric type of a CAD tool. So you just describe the object that you want to create and tell it which parameters, and it'll generate the design based on the size and shape and all those things. And so we've got an application note, SLAA891 that goes through the whole process of using the OpenSCAD scripts which TI provides for doing sliders, wheels, and touchpads. So the scripts are already written. You can use them as they are, or you can modify them, if you want, for your own different type of applications.

We don't do buttons, because buttons are pretty simple. They're typically just a round or a square copper, so they're not very complicated. But when you've got multiple elements that make up a slider or a wheel [INAUDIBLE] and you have to concern yourself about how many fingers and how they're going to interdigitate, which gives you better linearity.

These become very, very difficult to draw if you had to draw these with a PCB editor. I know from experience that it takes-- very time consuming. And the last thing you want to do is create something and then have your marketing department come and say, oh, we changed something. We want this slider to be a little bit longer or wider, and you're like, OK, I've got to redo this. So this tool makes it really easy. You just change a few parameters and your design is re-rendered in just seconds, so it's a huge timesaver.

So, again, this is the OpenSCAD.org. That's where you can get the software. It is free. It is both 2D and 3D. And as I mentioned before, it's controlled by just basically a programming. And it's an example, actually, of a touchpad that's an elliptical that you might find as part of a headset, headphone. And you can see here this section of code is showing the parameters that the person would change or modify to meet their requirements in terms of the shape, the size, the number of columns and rows, which basically tells the kind of resolution that you want. So it makes it very, very simple to change. And this is a zoomed-in view.

So here, for example, on this particular slider, there is only a few things that you need to change, how many elements you want, how many tines-- or fingers, is what they're called, when you have interdigitation. You define your length and width, and there's some additional padding on the outside. And then you can specify the clearance and tip width, where you have the fingers that come in and interlace between each other. So you just set those up how you like them and then re-render the actual design.

And so to highlight that whole process, like I said, it only takes a few seconds. And this is what happens. You start with the script. You modify for the parameters for your design. You re-render it, and if it meets and looks like what you want to go with, great. If not, then you just have to go back and modify the parameter-- [COUGHS] excuse me-- and re-render it. Once you've got it in the size and format that you'd like, then you just simply export it to a DSX file, and then through your CAD package that you use for PCB layout, just import the DSX and get those primitives to the cover region. And voila, you're done. You have your sensor already designed and ready to go in copper, so it's very quick.

So that's the software tool that helps you quickly design PCB sensors. The other part is once you've got the board with the sensor on it, you have to get your MCU configured and programmed so it knows how to connect to the sensor. Likewise, you also need to be able to generate the code that's going to drive the sensor and ultimately talk back to the CapTIvate Design Center which allows you to do the actual tuning of the sensor so you get the right sensitivity and set your thresholds accordingly.

So here is a basic steps through going through the GUI are quite simple. You just start with [INAUDIBLE]. You drag down the MCU and you select which part you want to use. Then, like the MCU, you just drag down one of the sensors. In this case, it's a keypad. You can give it a name. You can select the capacitive mode that you're going to use, how many buttons there would be in this. And then you just repeat that for all the other sensors that might [INAUDIBLE] system. So this is an example of one of the EVM panels, the BSWP, which stands for Button, Slider, Wheel, and Procs, so this is the actual sensors that are used on that board.

Once you've got those placed on the canvas, now you need to go through the process or the steps of configuring the connections between the [INAUDIBLE] electrodes to the pins on the MCU. And so you can see here on the left there is a description of which sensor and which electrodes are related to that. And then you've got the port pins, which is the CapTIvate pins on the MCU. And then you've got-- here, this will be the time cycles or time slices and the connections between the actual moment on each sensor and the pin on the MCU.

So your first question is, well, OK, so which pin do I choose? I mean, you can just arbitrarily just pick pins, but there's actually an optimized way to connect those. Number one, to use the most or the least amount of pins as possible and to use the least amount of cycle, which means you want to do fewer measurements so you can get your sensors measured quickly. So by clicking on the autoassign button, it will actually generate the optimized connections for the sensors that you've put together, and it'll tell you which connections on the MCU that you need. So you actually need to do this step first, before you go off your PC board. But once you've done this and once you've got your PC board done, then the next thing you want to do is you want to be able to generate some code.

So based on the sensors that you selected and the configuration that the Design Center put together, you click the Generate Source Code button, and it generates a software framework which is 100% enough to get you-- MCU [INAUDIBLE] and communicating to the CapTIvate Design Center. Later, you can come in, add to your code that you need for the specific application and the functionality. But this is just a quick way to get the code for your sensors up and running and working so you can tune them.

You import those either into code composers to view or IAR, either one. And once you've got the MCU programmed and communicating, you go into the-- back to the CapTIvate Design Center and enable the communications. And you should see data starting to come from each of the sensors. And it's displayed here in what we call the bar chart view. So if you were to run your finger across all of the electrodes, you would see something similar here, where these little red areas are the delta, the blue bars with the other colored lines above it are the baseline measurements.

So what we do with that in the tuning section is you'll go through and you'll change a couple of different parameters. One is the conversion gain and conversion count to set the sensitivity, and then modifying the touch prox thresholds. So what that does is sets the sensor so you've got the appropriate amount of sensitivity-- not too much and just enough, and the threshold, so that when you touch the button or touch the sensor, that you get the right detection with that sensor sensitivity.

Then the last thing you do is generate your final code. So again, it's the same button to generate source code, but this time, you select Update Existing Project. So this whole process literally just takes five or 10 minutes once you've got everything working and stuff. And the fact that it generates 100% of the code to get you started is a huge timesaver, so you aren't really writing any code. You're not having to dig through the data sheet to understand how to get the CapTIvate peripheral to work. That's all done automatically for you.

OK. So we've got some time now. We can look at a couple of the OpenSCAD demos. And the first one we'll take a look at, since it's actually one of the more difficult ones, is the touchpad. So sliders and wheels are relatively simple. There are usually three or four or five elements, different size or different shape or a different radius. Touchpads provide a 2D-type sensor. So now, much like the touchpad on your laptop, or even your phone, where you can move your finger around and track, CapTIvate can work with those types of sensors. And so what we've found is a lot of customers come and they say, well, we need to have a certain size or a certain shape, and how would you recommend that they lay out the board or lay out the sensors?

And so what we added to this OpenSCAD was a script for touchpads. And go ahead and bring this one up. So this is the actual OpenSCAD environment. In this case, it's rendering a 4 by 4 touchpad. And so you can see here in the scripts, it's very simple to specify what shape you want. You can do a circle or a square or a custom. And I'll show you a custom one here in a moment. You can specify the rows and columns. You can specify the width and the height and the spacing between the diamonds. And once you've got those specified-- in fact, I'm going to make this an 8 by 8, double the density on that.

So now, when I re-render it-- whoops-- now I've gone from a 4 by 4 to an 8 by 8. So, again, if originally the marketing said we only want to do a 4 by 4, and you go through the trouble of laying out a board or creating a sensor [INAUDIBLE] and they come back and say, oh, we changed our mind and want to do an 8 by 8 or a different thing, you can see it's just a matter of coming back in here in the script, changing a number, and re-rendering it. And then basically you do a File Export and save it to a DSX and import that into your CAD package. So this is a huge time saver. It works really well.

So I mentioned that you can do circles and squares. You can also do custom. And when I say custom, that means you can actually-- for example, if the shape of your product maybe is not a square or a rectangle, but maybe it's elliptical. In this case, it's like for an ear phone or a headphone, then you can actually take a DSX drawing from like AutoCAD or whatever that you would use to specify the perimeter. You can actually bring that into OpenSCAD-- and like I've shown here, you can say, hey, this is my file, and I'm going to specify it as custom. So it'll actually import that DSX file and use that to basically trim the perimeter to be whatever the outline or the shape of that product is. So it's really a cool thing that you're not just limited to squares and circles. You know, you can do whatever shape that you need.

So if I go back to looking at just some of the simple ones, when we first talked about slider-- a slider-- much simpler than a trackpad. But still, you have to draw the different fingers or tines, as they're called, between each of the elements. And so drawing this or changing the pattern would be very difficult. So the code [INAUDIBLE]-- the code that actually runs this is very simple.

They're just simple commands that will basically go through and are translated into the physical layout, the size, the shape, and builds it up so it completes a complete sensor or a complete object that you can then export. Well, the code that actually makes this slider is really just right here. This is what you see. This code is very simple. So that [INAUDIBLE] parameters that you use to specify the dimensions is all that it takes to create one of these objects. So again, the amount of time it takes to do this by hand is very, very difficult and time consuming, but by using a script like this, it makes that so much easier.

Then to go to the next step, where you have a slider that is-- basically, the two endpoints are brought around together to create a wheel, essentially. Same thing. So you can now create whatever wheel size that you want. And if you want to change the number of elements-- let's say we're going to go to a six. You re-render it. And that's six [INAUDIBLE]. That works out pretty good. So you can see now that by using this OpenSCAD and these scripts that are provided by TI, you now have a very short path to your elements so that you can lay them out on your PC board, get your PC board back, get it hooked up to your MCU, and get the actual software running and your system tested and tuned and ready to go. So this really, really saves a lot of time.

So what I'm going to do now is I'm going to-- we're going to go and look at the 3D aspect of this OpenSCAD. So what we were doing was just looking at the 2D. They were all flat designs. But if you're doing things in 3D like Leo is doing with his ultrasound-- and these are the perfect application for creating objects for 3D printers, which is what Leo does. So here, you can see the model. Based on this simple code to create the two objects, which is a flat disk he calls the lid, and then the cylinder here. So these simple commands are basically what describes how this is put together. If you wanted to go through, and let's say we wanted to make this tube longer, the cylinder longer, you can just simply come in here and change that length, and then just do the re-render, and you've got longer tube.

Likewise, if you wanted to change the lid radius-- let's make that 200, get really big. [CHUCKLES] So you can see the power of this software and the scripts, that you just simply change a couple of values and you can dial in whatever exact size and shape that you need for the application.

So given that, back to where we were-- so basically, I covered all the two software tools that we've got for automating and the PCB design as well as the CapTIvate GUI for doing the-- generating the code and the sensor configuration. So with that-- oops-- what we're going to do, is that should be the last slide. Oops. There we go. Sorry about that. And I'll turn that back over to Sheena. Let me get that moved over here first.

Awesome. Thank you, Dennis. So if anyone has any questions at all, feel free to enter them in the chat now, and we can definitely see if Leo and Dennis can answer some of them. OK. All right, so I don't see any questions in the chat right now. But I just want to say thank you to Dennis and Leo. Very interesting presentation showcasing a few of the technologies that you can get from the TI portfolio, but specifically the MSP microcontroller portfolio. And I want to say thank you to everyone in the call today for joining us.

All of the recordings, every session as well as the presentations, are going to be available for you to view, download, take a look at by next week. So you'll be receiving an email with links to the presentation on demand, as well as you'll be receiving a post-event survey. I know surveys are not the most fun thing to fill out, but it really helps us cater our events in the future to make sure that they're helpful to you guys. And we really do take that feedback into account so that we can improve the content for the future Tech Days as well as other training events.

So, yes, I see someone in the chat has asked to share the links. So yes, we will definitely share those links via email after the presentation, and probably around next week. So thank you guys again for your time today, and have a great rest of your day.

Thanks, Sheena.

Thank you.