So, thank you, everyone, for joining. This is going just to be a fairly quick overview and not really a demonstration, but discussion about our gauge development kit. By short, I'll be calling it GDK. My name is Jared Casey. I'm on the GMAP team in the BMS group here in Dallas.

An outline of what we'll cover today, we'll talk about why you would want, why you would need a gauge development kit. I'll give you a GDK overview, then I'll briefly go through the connection process of the GDK.

Then I'll also talk about GDK plus Battery Management Studio, which we'll call bqStudio for short. In order to use the GDK, you're going to need bqStudio. And we'll talk about why that is in a little bit more detail.

And then finally, we'll round things off with the actual plug-in within bqStudio. And that's broken up into two parts on manual control and then the scriptable control.

So, why do you need this tool? If any of you have used any of our gauges in the past, I would imagine you've seen some kind of flow resembling this here that you're seeing on the slide. And the goal of GDK, plus with interacting with bqStudio, is to try to get this more of an automated or quicker process.

Because we don't want you to get you to having a device that's designed in. We want to get you to mass production, or get the customer to mass production as quickly as possible. So with this the GDK is going to allow some of these things, especially within the golden file or golden image generation, this will allow us to automate.

It's going to allow us to more easily set something, walk away, so that we can do something else and multitask, instead of having to monitor or watch things and hand-hold it all the way through. It will also help with the testing process, and you have this iterative approach of, you've got the initial image. You might do a little testing and then tweak some parameters in the golden image, and then finally once that's working out for you, you can move into the mass production phase.

So one of the things, probably the next two slides that we'll talk about are the two major tests that we typically have, or a lot of what we issues on. And one is you have a gauge, how do you select the type of chemistry that can be utilized?

One of the tests that we have with this is what we could call our relax-discharge-relax, or our R-D-R test. And you can see on the graphic on the right side of the slide, you charge the battery to full. You have a relaxation, and you want to discharge to empty, and you have some relaxation in.

The combination of GDK plus bqStudio, we have some sample scripts that will actually allow you just to set this up, plug in a couple parameters about the battery itself, and then the GDK will handle the rest in terms of the charging, the discharging, and the relaxation process.

And then from there you have the data. We have the match type chemistry selection tool that can allow you to utilize that data and figure out what chemistry you might want to use. Or this data can be sent to TI, or the BU here in Dallas. And we can let you know what chemistry match you might have from there.

So learning cycle is the other one. It's probably we hear more issues about this than we do the chemistry selection. And this is a very controlled test. It's a way for the gauge to learn the key maximum or resistance table of the battery that's going to be used for this application.

And there are different ways to start it out. But the test is pretty normal. It's controlled throughout that. And you can see this graphic. And you want to discharge to empty. Then you have a certain amount of relaxation that's needed. You'll charge to full, then you relax again for a certain amount of time. Then you'll discharge to empty. And then finally then some relaxation.

And with that, that's kind of the process that's going to allow the gauge to update the parameter that it's looking to update, and this learning cycle process. And I think we hear-- we get a lot of feedback on ADD, what type of cell, [INAUDIBLE], what's going on. And it can be very hard to debug.

And this test, so you can see, we're showing times of 5 hours of relaxation, 2 hours relaxation. These are roughly about a day. And if you do it an optimized way, you can do it in about 15 hours or so. And so the [INAUDIBLE] is going to help to where, one, it still might take a day. But it's just going to complete successfully. And you don't need to be there monitoring it the whole time.

And the other way is we do have optimization that we're incorporating into it as well, so that you can get the test completed in a quicker fashion.

So some of the lab setups that we've gone through, I guess, here in Dallas as well, but I've also seen throughout the States as well, the places in terms of setups you might have.

So in order to charge and discharge the battery, in order to cycle or exercise it, you need a power supply for charging. You're going to need an electronic load for discharging. Sometimes these have some intelligence built in to where the load might stop at a certain voltage, but sometimes they don't.

We've also seen it where might have some external meters, so that you can monitor current, you can monitor voltage. And so you can see this kind of setup might be a bit messy when you have-- so the basics of our gauging at the moment, you have an EVM. With the EVM, you'll have a battery connected to that EVM.

And then in order to interact with the GUI, whatever you might be using, whether it be EV software or Gauge Studio, or [INAUDIBLE], or one of those that might out there. You've got this EV2400, the EV2300. And that's taking the gauge I2C columns and converting it to USB packets and sending that to the PCs, so that you can interact with a field gauge using a GUI.

There's no automation to this physically. So it's going to be time-consuming in that you set the charge. You let it charge up. You watch. You make sure it tapers to what you're wanting. Then you manually remove the charge. Same with the discharge, you set the load. You let it discharge. And then once it gets to the voltage to where you want to stop, you manually stop that.

And then the relaxation processes are going to be manual as well. And with 2 to 5 devices, the cost effectiveness is not that great. So here in Dallas, we've moved to a more automated process, to where we have-- I keep resource data. These things are expensive. But they do allow for 48.2 or [INAUDIBLE] columns in the back.

So we can more easily and I guess with less devices, we can connect to the fuel gauge. So you still see the same gauge setup and gauge battery EV2400, and then now only a handful-- I guess four cables-- going to the gauge to charge and discharge.

But moving on, we wanted to make it even more simple and more cost effective. So now what the GDK will allow, you can see with just a handful of connections, you've got a USB connection. You've got external power connection. Then you have the gauge connection. And with that you have everything that you need in order to go through these control tests. And we can talk a little bit later, you can go beyond the control tests that we recommend in terms of configuring the gauge.

So you see the mess, it's not really there. You have the I2C columns going between the gauge and the GDK. You've got the load and charger connections from the gauge to the GDK. The GDK allows to do external temperature if that's necessary. So you can do that. And then finally you've got USB and the external power.

And this is portable, and fairly convenient. And I've done it. You can do the charge, you can cycle battery overnight in a hotel room if you're traveling. This can be on an engineer's desk. You can stick it in a lab. We here in Dallas, we're building a GDK farm, if you will, so we have multiple GDKs on a desk just cycling different batteries or doing different tests.

So much more portable and much more convenient in terms of how you connect things, and what's required to get everything up and running. So that's kind of just showing you at a higher level, why you want to use this, what we've seen in the past in terms of types of equipment that are needed in order to use our gauges.

Here's kind of a more in-depth overview of what the GDK provides. It will give you a programmable load-- We'll talk a bit more about that later-- a programmable charger.

There's an on-board fuel gauge. It's the bq27421-G1A. However, when you order the GDK, it's going to come configured for an external EVM connection, and that's so you can test other fuel gauges besides the 4421. And we'll talk about the different gauges that we have supported at the moment.

With that you can get automated cycling. And you can also do customizable profiles. You get pulsed loads. You can do constant current and constant power loads.

And then with the tool, that being bqStudio, you still have the data logging that can be used for post processing the data and then evaluating how the data's performing.

So the benefits, we talked about this a bit before. It's clearly an easy setup. It's going to be more cost effective than all the equipment that you might have previously. You've got automation provided. So you can have automated running cycles, chemistry identification, and then things of this nature.

It's going to be a standard platform for evaluation. Right now it is just for I2C and single-cell fuel gauges. But depending on how we see things going with this, we'll roll that out into the multi-cell space potentially as well.

So here's a block diagram. This block diagram is also-- it's also in the user's guide. I think the height-- the resolution might be a bit more there. But just at a high level, just to kind of touch on some basic things. So you have your USB connection. You've got your external power. The external power is required. And so that's so that you can see-- it's what powers up the programmable-- as well as the programmable charger.

And then some of the things to note is that the GDK itself has a way to monitor current voltage and temperature. So you actually get-- not only do you get fuel gauge information that's being logged by bqStudio, you also get GDK information that's being logged. So you have two sets of data in terms of IVT. So that's useful for post-processing the data and making sure you have a third party thing in order to determine path charge, things of this nature that helps to compute accuracy.

You can see we have an NFC 430. We essentially just took the EV2400 and we cloned it. We just put that on the board. So you've got your EV2400. So there's your communication method from the fuel gauge going to the PC.

So if you get a GDK and you look at it, you'll actually see these sections outlined with filtering. And in the main ones that I would say are probably most important are you have the programmable load. You'll notice that with the heat sink there.

You have the EV2400. That's on the board. You also have the GDK control. There's a fuel gauge section. It's quite small, and then a GDK measurement section. And then the external columns, really what's going on there is you just have the ability to switch between either the on-board fuel gauge, or an externally connected fuel gauge.

Inside the GDK control section, we give you some LEDs that are going to help with indication. It's going to let you know, is it charging, is it discharging. You get different LEDs for that.

There are different fault conditions that are outlined in the user's guide to where there are certain instances that where the GDK control, it sees something going on, it's going to set a fault. Some of them may or may not prevent a charge or discharge. It depends on the type of fault.

Calibration, you typically won't see. That's more of a manufacturing type setup. So you should not see that LED. And the battery connection, that's going to be there for when you're utilizing the on-board fuel gauge maintenance.

So, let's talk about just really quickly, we're going go through the GDK connection process. What you're going to need for the GDK setup is of course the GDK itself. You'll need the EVM of what you're using. In this instance, it's a bq27421. You'll have a battery that you're testing.

You'll have a USB cable. And the type of cable it's using is type A to type B. Type A being the standard port that's going to be on a PC or laptop. The B is actually the other connection that you see on the GDK itself. It's the same type of cable that's utilized, so an EV2300 or 2400, so or those are fairly standard.

The power supply or dc jack. So we provide a common 2.1 millimeter. It's a center positive dc jack. And in the user's guide, we recommend the type of jack that you should use. It's a 6 volt, 2.5 amp.

You don't need-- you're not pinned down to just those settings of the dc jack. You can go to 5 volts. But you don't want to go above 6 volts. There's some protection circuitry on the board that will kick in when you go above 6 and 1/2 volts. So you really want to stay below that.

And then the amount of current that's supplied is really just going to be based on the type of battery that's you're testing. So if you want a 2-amp charge, you're going to need to make sure the adapter can give you those 2 amps. Otherwise, you could just do 1-amp adapter, b if that's all that you needed.

Alternatively, there are test points surrounding or near the dc jack. So if you had a power supply already that's something that you could utilize. And then finally, you'll need a I2C cable. That's going to come with the GDK itself. Nothing else-- the GDK will just be the I2C cable. It doesn't come with the dc jack.

So start off with connecting EVM. That's going to be basically something you've seen or probably done in the past. You connect your battery, the pack plus, pack minus, or maybe cell plus, cell minus, depending on the EVM that you have. Then you'll want to connect the I2C cable.

And then all our EVMs are going to have some kind of charger plus load plus, charger, minus load minus. Or maybe if you're using a pack side EVM, it will be pack plus and pack minus is what you would do for that.

So connect wires there. The shorter the better, and that's just so that you can avoid less resistance in between the voltage that the GDK is reading versus the voltage that the gauge is seeing.

Then you want to connect external power to the GDK. And then after that you can do the USB connection. Now you don't have to go in this order. You can do USB and then external power. The reason I say do external power and then do USB is just because it's when the GDK fires up, it's going to look for that external power. And if it doesn't see it, it's going to set a fault.

So you would need-- if then plug in external power, it should catch that it comes on. But if it doesn't, you'll need to reset the GDK. So it's just easier if you did external. Then you don't have to worry about any fault conditions.

However, I would say, if you're just looking for basic communication, as soon as you plug in the USB, the EV2400 will be powered, as well as the GDK control. So you actually have communication that's going to be established as long as you have the gauge connected. So if you just wanted communicate between the gauge and the GDK in bqStudio, you just need USB.

In order to get the charging and discharging functionality from the GDK, you need external power to be connected. After that, you then just combine the two. You've got GDK plus the EVM. So just take the I2C cable from EVM to GDK, then just connect the charger plus load plus, and the charger minus load minus to the GDK. And those are outlined on the board.

And the user guide talks about the hardware connection as well. So with that, it's more of a-- we don't walk you through what I did here on the slide set. But there's just an outline. Like you need to connects these headers, these jumpers; things of that nature. So all this is outlined.

So once you have all those connections you're done. And now we can move on to the interaction of bqStudio with GDK.

Now, let's talk a little bit about GDK and Battery Management Studio. Battery Management Studio itself does have a parts page. And we can see that down there on this bullet point, www.ti.com/tool/bqStudio. Also the GDK product folder, and we'll point to that later. It has link to actually getting the software, but it also points you to Battery Management Studio product folder as well.

And this is really the install. I mean most of the other software suites are fairly easy installs as well. Just unzip the file and click the setup executable. And just one thing I need to say, the GDK only will work with Battery Management Studio.

I think if you try to connect Gauge Studio, it might recognize the GDK. But the command set has changed since then. So you actually won't get any functionality out of it. So you'll need to use bqStudio in order to utilize the GDK.

So right now we're going through-- so the bqStudio I think we released it earlier this year. It's still a newer tool. So we're going through the process of making sure that all the configurations files are properly tested so that what we say is supported with bqStudio is actually supported with bqStudio. So in that right now, I'm showing are the different devices that we have.

So officially right now we have the bq27421, the bq27441, and the bq27621. We are working on the bq27742. But the other ones that I'm showing that have an asterisk by the name, those are just ones we have configuration files. They're not officially supported, as in they haven't gone through software quality pushing yet.

So we'll [INAUDIBLE]. So that that's something that we're working on. We're working on test plans to make sure that we can get these out. But what I will say is if you're testing with one of the devices, we can give you a configuration file so that you can use it. And we just have to say, look. Realize it's not completely tested at the moment. So if anything pops up, let us know so that we can make sure that that's addressed in the testing procedure or testing phase that we're taking it through.

But bottom line, is that if you have a device that you're wanting to test or utilize with the GDK, we can get you a configuration file. And from there it's a pretty easy setup.

So standard EVM connections that we have, I've talked about this real briefly. Is you have your PC, and the PC is going to connect through a USB or I2C adapter. That's going to be your EV2300 or EV2400. And then from there, you've got your I2C connection or maybe HDQ going through EVM. And your EVM has the battery.

And then from the PCB or EVM, you have your charger and load connection. So once again, we'll just recap what we've changed. You can see we have EV2400 on the GDK. The charger and the load are now also on the GDK. So then you remove the EV2400, that separate box and the separate boxes or devices that you have for the charger load. And everything just now connects to the GDK. That also being the USB connection from the PC goes to the GDK as well.

This is what I was talking about earlier, what's in the user's guide, you'll see this pretty much exactly in the user's guide. One thing, we have a recommended power-up sequence which talks external power first, then USB. That's not necessary, but it's what we recommend.

So once you have everything connected you can then go and start program, Texas Instruments, Battery Management Studio. That will launch bqStudio if you don't have a shortcut on the desktop or something. And when you first start up bqStudio, you won't actually see everything right here. You actually see a Welcome tab. And the Welcome tab will actually allow you to do a walk through, if you want that to be something-- it will just give you a high level. This is what's up.

However, you can just close that out. And once you close that Welcome tab, this is the screen that you would see. On the left, is what we're calling our dashboard. I think that's fairly common with the new tools that we're showing. It's going to let you know what device, as far as the USB to I2C. Adapter, it's going let you know what it sees.

But if you have a GDK connected, you'll have this GDK window. And then below that you'll see the actual gauge information. It's going to let you know what gauge it sees connected. It will give the firmware version of the gauge, the gauge's address. And then temperature information will be here. Then also you'll see voltage, state of charge, and the little battery icon. And then you'll see a little ammeter for current information

So something else to mention on there, so this all here showing the gauge with temperature and the voltage, SSE, and the current. That is all gauge . Information. It is independent of what you see here on the GDK. So the voltage, current temperature, whether internal or external, and all the status and fault information that is GDK information. It's not anything to do with what the fuel gauge of the [INAUDIBLE] is.

So you also see the Registers window, which is going to look really similar to what you see in EV software or Gauge Studio It's going to be the same thing. This is where, as we get later on, the Registers tab in [INAUDIBLE] is where you start logging the gauge information. So all the standard commands that all the gauges have, you have them here in this Registers window. And that's how you start the log of data ran.

And I'm sure if anyone, you look at the gauge, and something's happened. We always say, can we get a data log. So that's just something, a good habit to establish. It's always logging the data on Registers. It's going to give us information on what the gauge is seeing, and what it's doing. And that allows us to help debug issues accordingly.

The other thing is, is this screen shot was taking on, I guess, a fairly-- I don't know the exact resolution of the computer. But what you might see, there's a little tab here that shows you the [INAUDIBLE].

If you have like a 19-inch screen that's running on maybe like 1024 by 768, this tab might scoot over this way. So you won't-- in this plug-ins toolbar, you might not see all the plug-ins that exist. So if you go to the view, that will actually show you all the plug-ins that are there.

And so that's what I recommend checking, if it looks like something might be cut off. Because the GDK one might not be showing, even though you see this GDK window over here in the dashboard. That means that you can get to the GDK plug-in. It's just that the screen might be a bit too small.

So next screen we'll show is now let's talk about the actual-- get into the actual plug-in of the GDK. And when you click the GDK plug-in, you should see this tab come up. And every plug-in that you have will start populating this window here.

And with that you'll have two tabs within the GDK plug-in. You get a Manual Control. And then you have the Scriptable Control. The manual control is we did that more of-- I think in the testing environment you're going to be operating more in the Scriptable Control tab. It gives you a lot more flexibility, a lot more power to do different things and emulate more what a system might be, as well as complete the different standard tests and control tests that we had mentioned previously.

But this is going to be just for maybe a customer visit, or if you just want to really quickly get a charge going, and really quickly getting a discharge going. You see the windows broken up into-- you have a charge control and then you have a discharge control.

So in the charge control, you just need to get the basic charging information, the voltage, the charging voltage that you want. And then you want to give it the charge current that you want. And then you have multiple options for charge termination.

You can do it off of current, state of charge, or in any capacity. You can do it in seconds, or you can do it off the fuel gauge, as he did. All these termination conditions are based off gauge information.

So the taper current being 50 million, it's not going-- so the 24-102, the charge that's on board, actually will let you go down that far. Or I think you might be able to. But it's not as tight as what the fuel gauge current is going to be reporting. So that's based off gauge. State of charge, it doesn't come from the charger, same as remaining capacity, seconds, and the FC bit.

So once you fill everything in, you've got your voltage, your currents, and your termination condition. And you select the Start button. You'll see everything will gray out and fade out. And that just shows you that, all right, you've kicked into a charge. At this point, you would see the charge LED come on, on the GDK, letting you know that it is in charging.

We actually did on the-- if you remember the sections that I mentioned earlier, the charger section, we do have all the LEDs that are inherent to the 24192 as far as providing information. So you get the stat LED. And you get the power grid LED. And then-- what's the default LED? So you get those LEDs with the charger as well, as the GDK indication LEDs.

And so you can see once we get started, you're going to see the gauge will eventually kick in to reporting some current. And then the GDK itself is going to start reporting current as well.

And in the Status window, you're going to see both the Manual Control and Scriptable Control. It's just letting you know what bqStudio is doing. So like the task that started with a charge, and the termination condition was when the taper current reaches 150 million.

So here is more information on the-- I guess the charge control was offered. So it is the bq24192. So with that we limited the charge current. And that's more of a heat theme from the load perspective. We can talk about that later in terms of what we might do in the future on where things go. Because I know some of you might know the 24192 will actually go to 4.5 amps. But we have limited that to roughly around 2 amps.

So you can go down to roughly 103 milliamps up to about 2 amps in terms of the fast charge current. Pre-charge, we didn't really limit anything on that, so 128 up to 2048. The charging voltage is programmable. So you can go down to almost 2.5 and up to 4.4.

And then this table that you see here, it's also going to be in the user's guide. The different termination methods that are with the manual control are the taper currents that have charged your main capacity, the time, and the flags.

And the flags register to the FC bit and flag register. With the scriptable control, we did add a couple more. I think we added path charge, and then maybe another bit or so from the gauge. It might just be the path charge. But in the user's guide we describe all the termination methods. And we let you know if it's available in manual control, or if it's available in scriptable tool, or is it available in both?

Moving on to the discharge, it's essentially the same thing. You just have a couple options that you need to choose. So you get the different discharging modes, that being constant current, constant power, and pulse load.

And within each one, you either choose-- for constant current you let the bqStudio know what type of current do you want, and when it comes to power, what type of power do you want. And once again, as I mentioned before, we limit you. It's a 2-amp max. And that is mainly due to heat, when it comes to discharge.

So even if you are in constant power mode, bqStudio is going to make sure that what you're asking for at the max power, it's not going to be above the 2-amp range, or not the max power, but the max voltage, that's the lowest voltage of what we're going to look at in terms of the highest current that we need to offer.

So we're just going to make sure that you don't violate that condition. If it does see that you're going above that, it's going to block you from putting in the type of constant power.

Then for the pulse load, we let you define the high and the low values of the pulse load. It doesn't matter. One doesn't need to be higher or lower than the other. It's just how we called it. It's essentially symmetrical. So it doesn't really matter how you fill it out.

You can go to zero on one of them, if you wanted. And then the max on the other side would have to be 2 amps. That's as high as you can go.

The period, the period is you can go from 50 milliseconds all the way up to 45 seconds. And then the duty cycle, you can go from 10% all the way up to 90%. The discharge cutoff, that's default from the GDK. It's set to 2800 millivolts. I would imagine you don't need to change that, only if maybe if the circuitry on the battery pack that's being utilized is a little bit different than what's standard.

The thing that's more important is going to be the terminate voltage value. And that's going to fall within the discharge termination. And you get multiple options with that. You get the voltage. You can do state of charge again, the remaining capacity in seconds, and all these that I'm showing here are related to the fuel gauge once again.

So just like on the charge, once you fill in all this information and you click Start, you can see that everything else should gray out. It will become disabled. You'll start to see discharge current flowing. The discharge LED on the GDK will light up, and you'll know that you're in discharge mode.

More about the programmable load on the GDK. The range is roughing about 5 milliamps to 2 amps. You get a resolution of about 1 milliamps. So you can go-- if you wanted to do 1999, it's going to try to give you 1999 milliamps of discharge current.

You can do constant current, constant power. You get a pulse load. And then here the termination method, you get terminate voltage, date of charge, remaining capacity in time. We did also add some more, and once again this is outlined in the user's guide.

For the scriptable control, you actually get path charge. And I think we do SSE1 and SSEF, which is more gauging information that you could terminate on if you wanted to.

So I think the most-- for the manual control, I think it's fairly straightforward. You can get something up and running fairly quickly. So I think where the power of the GDK comes in and where we let loose a little bit more, is on the scriptable control.

So with the scriptable control, you're going to get 15 different commands. And we'll talk about those commands in just a bit. So when you go from manual control tab to the scriptable control tab, every time you start the GDK plug-in-- let's say I closed it out. And I brought it back up, and I go to Scriptable Control tab, every time you open up this tab, you will see this default script. And the default script just gives you a high level, here are the different commands that you can do. And then within it, you will see the actual commands themselves.

Now we don't go through all the commands. But you see the high-level ones or the ones that we imagine are going to be used the most, so the logging, or the charging, or the discharging, and things like that. It will actually show you an example of how to use that command.

Now something I will say is that we tried to make the default script very generic. But before you try executing the default script, you want to make sure that nothing's going to violate any parameters that might be specific to your battery. So make sure that you see that what the charging voltage and charging times and discharging currents, and things like that are not going to be anything dangerous or not fitting your batteries spec, if you will.

This is more of just a high-level to show you how to implement it, and go from there. Some of the scripts that we're looking at, we have developed a couple of scripts. And we're just going through a testing phase. And we will eventually-- hopefully within the next week or two, be posting these on the GDK product page.

And these will just be scripts that allow you to more easily-- I'm going to do this chemistry selection. so the R-D-R test. Or I want to go through and optimize learning cycle or something of this nature. And we'll give you an outline of that. And with that, hopefully you'll just have to change a couple of defined parameters. And we'll talk about what that means in just a bit. And by changing that, it means you just execute the script, and everything should be scalable from there.

So the top of the plug-in, you're going to see five buttons on the left, and then a divider, and then two buttons on the right. The ones on the left, so the far left one, is just you create the new script. You just start with a blank screen, and you can add things accordingly.

The one with the star is just if you-- let's say you had a new one, or you're working with something else. And you're like, I want to reload the default one so that I can get more information, or get kind of the basic-- all right. This is how that command is used. You can do that through load the default script.

You can load a script that you've previously been working on, or let's say when we get to the point to where they are online, you can then just download those from online, and then plug the script accordingly. You can also save a script that you might have been editing.

Or you can say add, if you don't want to overwrite the current script that you had, and you just want to make a new one. And then the two buttons on the right are just start executing a script or stop executing a script.

So here are the 15 commands that we have. I'll spend the most time on, I guess, the top four. So as I mentioned, the GDK itself, when you're looking at bqStudio, you get the dashboard. And we had that little GDK window on the dashboard. It's GDK information. So you can actually log that.

And as you can see here, you just give it the path to log. And you give it the interval or the number, how long the logging interval is. It's going to be default to 1 second logging. But you can change that all the way down to, I think, 250 milliseconds, and all the way up to-- I don't think we actually put a limit on there.

So if you wanted to do 10-minute logging. That's something that you could do. With that you would then, as I said, to get the gauge information you want to go to the Registers plug-in in bqStudio, start the log from there. That's going to give you the gauge information.

And then to get the GDK information, you would then go to the Scriptable tab, and make sure that you're executing the log commands so that you get the GDK data.

Then from there you've got your charge command. Look, it's going be very close to this Manual Control, in that you've got to get it the charge voltage, give the charge current, give the termination method, and then the termination method's value.

Then what we have here that's waiting for termination, we say it's optional, because it's by default, true. What this is saying is, we allow you to say, all right. Let's say you're charging. And I set a charge operation. And I start going. But let's say that while it's charging, I want to do something else. Like maybe I want to read SSE, and if SSE gets to a certain point, actually I want to do something else, maybe start a discharge or import a GG, or something of this nature.

This is what this allows you to do. If you set the weight for termination false, the script will actually move forward, and other commands that are below this charge operation. And so with that, we can get into-- as you'll see later on-- you'll have math functions, you have jump functions and looping.

So this is how we allow you to branch off and do some really interesting things that will probably more likely look what the end system might be doing. So same thing with the discharge, break it up into your constant current or constant power, just because the amount of arguments that go into that command are a little bit less than your pulse load.

You get the current value, the power value, the termination method; those all fairly same between the different discharges. Pulse flow, you need to give it the high value or the low value, the period, and the duty cycle, along with the termination method and termination value.

And then moving on, you have the relax operation. You just give the number of minutes that you want the script to relax. The label, it needs toN be unique, and it works in conjunction with the loop command and the jump command. So I'll go to the loop command and you see in the loop command, you give it the unique label and the number of times that you want to loop between that point to where the loop command is seen, and where the label is placed.

And then I'll jump down to the jump command that's essentially what the label is doing. You get the condition, the label and where you want to go if this condition is true. And then you can also use variable names and some test values. So that's kind of how you get this IF, ELSE, or maybe SWITCH statement type mentality within the script.

The include, what that was is we thought that as things get more and more popular, you might have a certain set of commands that you-- or a certain set of operations that you use fairly consistently. And so if that's the case, you can move that to its own script. And then you can just call that script in a new script that you might be developing, so that it can make how you read the actual script in the screen, maybe a bit more easy. And it's not a long or convoluted, per se. Because you do have the ability to make these scripts fairly complicated, if you will.

Then the define, what that's going to do, you can actually get a variable name. So let's say when you look at the sample scripts that we're going to publish, I do a lot of things like I'll define design capacity. And that-- let's just say I'm using a 2-amp hour battery. So I define design capacity of 2,000.

And then from there what I can do is the learning cycle, we say you want to do a charge out of C by 2 rate. Or you want to do a discharge in between the by C by 10 and C by 5. So then what I can do is using this define command and the design capacity, I can say, well let me just define a variable that's called DC by 5.

And so I just do a division of the design capacity by 5, and that gives me my discharge rate. And so that way up to the top of the script, I can define all these parameters. And then it makes looking at the script and what it's doing a bit more straightforward.

But you can also do other things with the define command. So you see the low-level commands that we give you, I guess, below it's the next one down after export. You go import export then low-level command. And all these commands, they are outlined in the user's guide. We give you the opportunity to query the gauge.

You can execute some standard commands. But you can also do some of the gauge control sub-commands. So with that, if let's say you just wanted to check with the firmware version of the gauge was, or the hardware version was, you could store that in a variable and move on from there.

The import and export, as I said before, that's just a gauge configuration. You can either import it, or you can export it.

The sleep and halt are also fairly straightforward. Sleep is just you're letting the script rest for however many seconds that you specify. The halt is just, what it's going to do is, let's say you did a charge. But you didn't want to wait for termination. And you wanted to execute a couple of things. But after these execute and you're done and everything checks out, you can then say, all right. I'm good with just letting the charge operation finish. So if you send the halt command it's just going to let that charge or discharge operation complete.

And then I talked about the math and the jump previously. And those are detailed more in the user's guide, as far as all the different math operations you have. You can do bit-wise operations. You do the basic add, subtract, multiply and divide.

And then the jump is, once again it works in conjunction with the label to where you can do some branching. That's how you get your ELSE, your IF THEN, your switches and things like that.

So here's a link for GDK. This is the product folder that if you go to the TI website and you search GDK, and you type in GDK, this should come up. It is the actual order boards, the bq27gdk000evm. And that product folder, you will see the GDK's user's guide. It's a detailed document. It's going to give you all the information you need for the different script commands, the different configurations, potential firmware updates that might come in the future.

The Quick Start Guide is-- you might have seen it with our 421 or the 621 device. It's just kind of a way, how can we get you up and running pretty quickly. So just at a high level, so here's the connection. This is what you need to do. And then here starting at bqStudio and on moving from there.