ON Semiconductor Corporation (ON) Earnings Call Transcript & Summary

Hello, everyone, and welcome to today's web technology webinar, DevWareX the top choice for image sensor software brought to you via onsemi. This webinar will be a live demonstration explaining how to operate the basics of DevwareX and how this tool can make the development process shorter and more efficient. Due to this being a live demonstration, please in your focus towards the shared screen. I'm Kyli Miller with onsemi and I'll be your moderator today. At the end of this webinar, we'll be holding a Q&A session to answer any questions you may have. And during the webinar, you can type your questions into the chat box on your right, and we will answer any questions at the end of the webinar. This webinar will be recorded and posted at onsemi.com and you'll be notified via e-mail when the recording is available. Now let's meet today's presenters. John Medellin works at onsemi as a senior software engineer manager with over 40 years of software development and management experience. John has worked in both its established and start-up companies in Silicon Valley, and he is currently working at onsemi under the Image Sensor Group, where he manages the demonstration software and tools group. Now let's get started with our webinar.

Okay. Thank you. Are you bringing up the slide deck or shall I show that? Kyli? Just wait while I'm switching to audience. Is that visible? Okay. Yes. So I have -- like I said, 40 years experience in Silicon Valley as a software development, QA and also software development and QA management. Been employed at three different Silicon Valley starts which is very interesting, very dynamic and I've been in the tech industries of datacom, telephony and imaging 18 years here at onsemi. Something interesting about me is that I've done -- I was in competitive jump rope, my daughter started back when she was like 12 years old, and I went to one of the competitions and said, "Hey, I want to get out there and do that." And the coach of the team also I wanted to do that. So we joined the team. And we got our first year, we were -- for a while, we were the speed jumping -- team speed jumping rope national record holder, which was a lot of fun. And let me share my screen here real quick and here's our team. That's me right here and the four of us and also kind of something cool, I pulled up a demonstration. Now this is some kids doing it and we did this at about 1/4 of the speed. So you can see how fast they're going. It was a lot of fun and really enjoyed it. Okay. I am 50% Norwegian, 25% Irish and the other 25% is German and French. And I'm always lived in California, grew up in one town and graduated college in 4 years. So what we're going to do here is go through these various aspects of DevWareX and that includes the application itself and also being able to develop configurations on your own stand-alone applications, if you will. And this is just a -- and this is just an overview of -- give me second while this loads. Okay. And this is just kind of an overview of what we're going to be looking at. Okay. So let's get this started right. So when you install DevWareX, you're going to get a shortcut on your Desktop, and you connect your hardware via USB cable and that consists of harbor consists of a base board called the Demo3 and then a sensor head board. And I can't show that because I don't have an ability to, but we're just going to double-click this to start DevWare. The first thing DevWare's going to do is identify the sensor you have attached. And in this case, it was successful. And what you'll see over here on the left is the info dialogue. And that shows that we have a sensor 231 and shows the revision. It also shows you the DevWareX version that you're running. Here, we're running 6.1.43. This is a specific release number and the date of the release and then some other pertinent information, the size, for example, within hive. Now the other thing that happens is you -- a start-up wizard, would be launched. This is the way to get the sensor to start streaming. It consists of really three main things. One is a check box to be able for you to load the specific settings. These are the register settings that you need to have to stream an image and a play on starts. So we're just going to leave those selected. Now most sensors when you do this will come up with a secondary screen that allows you to select one of the more popular configurations. We're just going to select a very simple one called linear parallel and fire that up. And with any luck, we'll start screaming an image and -- streaming an image not screaming an image, and there we go. And then we have an image. You can use your mouse to zoom in and zoom out. Let me move this here. And you know how that started off a little green. Well, what it was doing was it was balancing out the auto white balance, we'll talk a little more about that. So we've gone through that. Now one of the things you can do is you go into the help and you can use the about button to show your installed versions and then also check for updates here. So I'm going to select this. Now this is telling me that there's new software updates available. It's also telling me I have the latest revision of the sensor attached. So if I go to update details, it's telling me that for the 231 product that I have attached here, there is a newer version. I have 6.1.40 installed and there is a new one, and then it tells you to contact onsemi in order to get that. You can also really look at the release notes of the current release. We won't bother you with that. Nothing to interest, right. Turning to interesting there. One of the top things here is you will see that there are various application controls up here, file where you can open up sensor data file. Now let me segue to that real quick. The main parts of sensor support are -- the first one is what's called the SDAT file, and that shows you all the registers. And this is what you used to identify the part and then control it. And the second is the NE file. And this is where all the sensor settings are, and we're going to go through that in a little more detail here in a minute, too. Okay. So there are file, edit, view. You can, for example, show the console for Python for you Python fans out there and various other aspects. That's something interested to talk about. So this is the [ goeie ] that we use as a -- what's called a dock. You can move this around in various aspects, various positions and get it locked. So for example, if you put this here, I would put it up there, if you wanted to get rid of it, you'd double click on the top there and then it flips again, and then we'll just close that for now. Another we showed help already. Another one is the documents. It's very important. There's a bunch of user guides that you can select when you're working on various aspects of specific controls. And there's also development guides that we have. And we're -- later on, we're going to go through that in a little more detail. But this is where you can find out various, again, detailed information about the development of stand-alone applications. Okay. The other part of this are the menu controls. Now you can ... [Technical Difficulty]

All right. I'm sorry about the technical difficulties. We'll get John right back online. Again, we do apologize for inconvenience. But don't forget, if you do have any questions, you can always ask in the Q&A chatbox. All right. And then to answer the question, yes, the video did stop, but our presenter is joining back in right now, and he'll be back momentarily. Thank you, everyone, so much for your patience. And again, we do apologize for the inconvenience.

Can you hear me now?

Yes, we can hear you, John.

Okay. I have no idea what happened. I was just chatting away. Okay. Where did I leave off that you guys heard me? Did I lose you again?

No, John, we can hear you, and we see your screen now.

Okay, great. Where about did I leave off. Do you remember?

I'm not sure.

Okay. Okay. Let me okay. Let me just jump back in here then. Okay. So I talked about these controls up here where you could grab a frame, let me just close this. And the other aspect of this is that there are custom tool bars that are up here. Now these are specific to each sensor. And the point of these is that they highlight the specific features of the sensors. So for example, here in HDR modes, there's ones you can select, linear mode, streaming on off and so on and so forth. Okay. So let's go in a little more detail. So the NE file, like I talked about a little -- maybe I talked about earlier, depending on where I got cut off. This has the settings for the sensor. And what I mean by settings is usually the modes. So in here, you'll see parallel modes. There's a long list of those, high spine modes, MIPI modes, and we can do edit and look at that. And so the first one that when we started this up, there was that secondary prompt, if you remember, when we said start. And this is the command that's in the NE file that is presented to you with the verbiage and then what's called the preset. And here is a preset. A preset is the list of register settings that are used to actually do the programming. So in this case, it does secondary loads. A load is the command to run that set. If I go and look at that one. Eventually, we'll get to the point of doing register settings. And here's an address of 3362 and then there's also internal state commands, and these are used to make the image look good. And basically, that's what all these are. The image settings can be done via registered address or they can be done by name, and we'll look into that a little more here. I am hopefully still audible. Kyli?

Yes John. We can still see and hear you.

Okay. I'm a little paranoid. All right. Very good. Okay. So we talked about custom toolbars, preset dialogue and then the info dialogue. Now to do a little more detail there on the inflow dialogue, let's do a stop here and do a play. You'll see that the frames per second, and this is from the sensor and then what's actually being displayed as well here for the image. Okay. So now let's go and look at -- one second, I have to restart this. I don't -- sorry for this technical reluctancy that I'm having. Of course, as soon as you start the webinar, I think you start going, haywire, so let's try this again. Okay. There we go. Now the other thing you'll notice here is that the frames are increasing. So the sensor is streaming. And then what we talked about a little bit was how this image was initially green and now it's getting adjusted. And what it's doing is it's trying to get the white balance correct to make sure this white is truly white. And let's go ahead and play around a little more with how that works. So I'm going to open up the graphs dialogue and select cumulative intensity and what you're looking for an image is -- and this is a Macbeth chart. This a standard type of chart we use to evaluate and image, the image quality and these are various colors that they chose and reds and greens and such, but the important one is the gray. And what you notice here on the graph is red, green, blue, that's the main three colors, is you want these to be equal. So this is a little off here, not too bad. But that tells you that it's pretty balanced as far as an image. And that's exactly what you're looking for. Now let's go ahead another aspect of DevWare, let's figure out, well, what's it actually doing to control this. And now you see it's writing a bunch of registers here. Now this is getting the color to match. And what I'm going to do right now is I'm going to turn on a separate light source. And then what you're going to see is quite a bit of activity. And now it's working very hard how these -- on the graph down here, it's unbalance, now what it's going to work at and is trying to get those balance, back in balance, and this looks like it's been [ pretty sticky ] for me. But the idea here is that I can go ahead and evaluate that and get these back in balance. Let me just turn that off and get back here. Okay. And so that's what the log does. Now I'm going to stop the log, a nice aspect of the log is you can double-click on register and I'll point you to the actual register that's going on there. And this happens to be the green gain and that's what it uses red, green and blue to balance out this image for gains. What I can do, too, is I can go ahead and play around with this. Let's do it clear here. And I've disabled the automatic balancing here. And I can play around with these gains, and you can see how it turns red, green and such. And if I enable the log, you can see that as well, but it's adjusting that register back and forth. Again, if I turn this back on, it's gonna take a little while, but it's going to eventually get these colors back in balance. There, it's pretty good. So let's go ahead to turn that off and clear that, close this. One aspect of white balance is what's called color temperature. And so if you've ever -- if you've gone to Home Depot and looked at getting light bulbs, you'll see that they have either incandescent or cool white or daylight. And here, this is measured as the illuminate and so the far left is usually incandescent and the far right is daylight. And if I pick up other light source here and turn it -- try to turn it on. You noticed that it starting to adjust this. And that's because now this is a mixture of the overhead lights I have in my office and also this other light source. So if I move this around a little bit, it's trying to balance it out again, I turn that off. It goes ahead and goes back to the original. Okay. So exposed usually referred as AE or auto white balance. And this does the initial adjustment to make sure that you can see the image well. You can see there, I'm adjusting it quite a bit. I can turn that back on to auto and it's going to go ahead and adjust that back, well, we've got set pretty close to what it was. Okay. Now moving on back to the log, I want to show you a few more things. So I'm going to go ahead and stop and clear. And one of the things that you -- the customer will do is they will use DevWare to modify an existing setting. And so let's go ahead and let's rerun that demo initialization. And let's see what it's doing here as far as these individual registers. So these are all the registers that preset had to write in order to get it streaming back again for that linear mode. And there's a bunch of -- and again, you can click any of these and go here. If you're curious of what this does, you can left click it and show high data sheet. And this one doesn't really have anything interesting. A little bit registered used to write or read the sequencer Ram. And you can scroll down here, read mode, same sort of thing. Go ahead and right click and show the data sheet. And in this case, this register has a bunch of individual bit fields. And so what the data sheet does, it will tell you what each one of these does. So in the case of read mode, it was setting it to zero. These are all the zeros here. Embedded data and read binning, skipping those sorts of things, horizontal mirror. So you can see that those are all clear. Another thing you can do is turn on time stamps, if you want to and see how long it took to run each command. Sometimes there's delays and what that takes. The other thing you can do is you can save this to a separate NE file, if you will -- if you want to. So this case, I'll go ahead and I'll save this and then go look at that. And here's that saved file. Now you can go in here and you can add things if you want to later on and some customers do that, they'll go ahead and adjust things as they want and then they have a new preset that they can run. So we could go ahead and load this into DevWare if we wanted to. And under the file command, open additional presets is another feature. And if I go back to where I saved that there's that file again. So we can load that in there. And there's that registered log. We just looked at it here, but basically there, it lets you do that. So that's a nice feature that allows you to do easy modifications of it. Okay. Let's see. What else is I wanted to do? Okay. So let's go ahead and modify an existing preset and loaded. So right now, let me close that. Right now, I have this handy chart here it shows you that there's normal and flip and mirror and rotate. So if we go to the output side here, we go to orientation, we can flip that 180 degrees and there's the sign tells you where we are. We can flip it back. Let's say, for whatever reason you want this mode to run in rotation 180 degrees. So then you're thinking, well, how do I know what that is? So you go to the log and enable it, and let me turn off, it's being quite chatty here right now. So let me turn that off. The white balance and now the color pipe is not adjusting anything, let's do a clear here. Let's go back to output size, and let's go ahead and rotate it. So there, it tells me image orientations is three. And you have to click these to refresh them. So I can go ahead and do a right click and let's say, should not be copy there. I'm going to do a copy. And now what I'm going to do is I'm going to edit this. This is the NE file right that we were looking at. And the first one that I was loading -- the second one actually, let's see that's for -- this one, I'm gonna copy then go and find it. Here we go. And now I should be able just to go here and do a control V. What did I do? Let's go back here and save this. Here we go. And I've saved that and now whenever I go in and I -- let's go back and change this back to normal. And I'm going to reload this. Do a reload. Now it's going to reread that file that I just got through. And if I read this with any luck, it will now be flipped and mirrored and let's see, what did I do wrong there. It still not rotated. Bare with me here. Well, it should have done that. Try this one more time. Is unable to log, turn off exposure again, turn off white balance, clear. Back here. Then copy, back to my file, we do this right before it streams. Save that back here. Do a reload, if I do this right. And there it is. So now we are able. So sorry for that little bit of confusion there. So the idea here is what we demoed was the ability to take an existing one of our presets that you used to initialize the sensor and then add something specific. And that's exactly what a customer would do. Now the other thing that's customers do is they do use DevwareX for testing out features, testing out image quality. But then what they also need to do is eventually on their system they need to convert it into their own separate language. So the language that we use within DevWare is in any file. And again, these field WR rights or individual registers and what a customer would do is take this file now that it's completed for the setup they did. And as a good example, I would have done another log and saved it, but then they'll write a script to convert that into their own language. And we usually -- we call these address data payers. So there's a register here and -- which is the address, 3520, and then the value that actually gets written to the register. Okay. So we're getting to close that up. So let me go back to my script here and what we're looking at. We talked about that. We'll turn this back into the normal. The sensors that we use most of the time are controlled connected via what's called I2C, it's a serial interface, electrical interface, and that's used to read and write these registers here. We also have the ability to put other devices on this I2C bus, if you will. And one of the things that you can do with that is within DevWare down here is peacock. And what this lets you do is go in and either on the registered itself -- sorry, the sensor itself, you can go ahead and play around with the register. So for example, we have this PLL multiplier. And this is an address 3030, so I can type in 3030 here. And I have 16 bits, so it's a 16-bit register. In this case, it's a 8-bit register, so let me do that. So if I do a get here, let's say it's 58. Do it get? Why do I have zero? Yes, there's my 58, sir. So it is -- in this case, it looks like an 8-bit register, but it's actually 16. So this shows that it's a value of 58. Now if I go ahead and change that to 57, for example, and do a set I can control that directly, and they're set to 57. So this is just an example of doing that. Now what you can also do is if there's a non-sensor device on that I2C bus this peek and poke gives you the ability to go ahead and read and write that. That can be anything like autofocus units, there's PMIx power module IC that customers use to control the power that goes to the chip, that's on the same I2C bus that needs to be programmed. And again, this gives customers a different kind of control those non-sensor devices that they could go ahead and play around with them and get them to work. You can also put that in NE file. There is a -- again, when we look at the regular NE file, and we get to this reg equals. There's a command called [indiscernible] reg. And what you do is you provide the address of that non-sensor device, and you can write -- it read and write, it's registers as well. So you get a lot of control over the NE file, you can also write Python to do that. So quite -- it's very flexible. And that's another aspect that customers use with DevWare to develop their devices. Okay. So far, so good. Let's go ahead and continue on here. The -- another nice feature of DevWare what's called The Watch and what you can do, let's go back to -- we were playing around with that flip mirror. So here, I can go ahead and again, I click here, go back to my registered dialogue. I right clicked it and I can add that to The Watch and let me spread this out a little bit. And here it shows a value zero. You can change that 100 times a second, if you want. And then if we go ahead and change that back to normal, you see the value here, it tells you what -- how it changed, the same thing here. If we go ahead and let's clear then log again, that's software exposure and white balance enabled here. Let's see, we're still streaming. Let me go ahead and here we go. Come back to normal and we're streaming images. Here we go. So let's say that I wanted to go ahead and do a watch on green gain. We can add that to the watch dialogue. And now when I go ahead and I'm going to put my hand in front here, you see that's moving around. And again, that's something else you can do. This is very useful if you are trying to tune the sensor. I get the settings right. You can put any number here that you want to. You can also do a save load, save this for later if you want to save these as a list, then loaded later in case on the next day or whatever you want to look at that. Okay. So that's the -- that's kind of the end of what I was doing for the -- what I wanted to show for DevWareX itself. The thing to keep in mind about DevWare is that it's just thick of features. And so it's difficult in a short amount of time to show everything. But my goal here was to go ahead and show you the main portions. These are the things that I use when I use DevWare on a sensor. And we have a very -- the next thing I want to go through is some of the documentation and also non-DevWareX types of things. So the idea here is to get you interested in how this is and then go and research more on how to do that. Anybody can download and install and run DevWareX. You do need the real hardware in order to use it. And so that's something that if you're interested, you can certainly do. Okay. So the last thing I wanted to go through was developing configurations, so we already went through and talked about the NE file and how you could do that. And let's edit this again, another strong aspect of DevWareX is you can run Python. And so to demonstrate this, I'm going to go to view and show the Python console. And this is very trivial type of command that I'm going to run, which is just to do a simple hello and so if I double-click this preset, you'll see that, that shows up in there. And again, there's a very rich set of commands there, the ability to read and write registers, grab frames and that sort of thing. And that's what a lot of customers do as well for their python. We have a rich set of samples, bare with me here. So in your installation folder, Aptina Imaging, under samples. We have a bunch of Python samples both in an NE file and also standalone, so you can run Python stand-alone. And what that does with Python and also, you can run C++ what that's called the app-based library. That gives you all the controls of DevWareX but without the [ SKU ]. So you can go ahead and create your own [ go ], if you want or even a script. For example, if you wanted to grab a bunch of images and ramp integration time from one value to the other, you could write a script that does that and save the files later on. And again, we have customers that do that. The -- so that's the first level of control that we have. The next level of control that we have is what's called a plug-in. And the first thing I want to do here is show you the documentation for this and here's a color pipe documentation that we have, this is on confluence. Now there's a lot of boxes here. But this gives you an overview. Let me just decrease this a little bit. It would be hard to read, but there. When you get an image from a sensor and in this case, we have what's called a Bayer sensor. So it's just the image. There's no other processing. We have software that makes this image look good. And how it looks good as it goes through a color pipe. And the -- again, I won't go through all this, there's just way too many. There is great documentation on how this works. But it gets the raw image and eventually will output it, be able to output it into an image that you can see. Now what this also lets you do is a plug in, it lets you tap into the color pipe at various aspects and write your own code to control it. So for example, if you wanted to do a different type of multi-exposure combinations or adaptive local tone mapping, those sorts of things, you can do that. And that -- so that's a nice set of additional control. And what's really nice about this in a sense, is that as a plug-in, what you do is you write your plug-in and whatever language you like. Most of the time that's going to be in C++ and you create a Windows DLL, and there is a plug-ins folder. And here are all the pre created plug-ins that we do, and I'll show you what one looks like, but it can really be anything. It can be what's called a headless, which means it has no control. It just manipulate the image or can have controls. And what's nice, again, is that you create this, compile it, create a DLL, and you put it in the plug-ins folder. And then when you run DevWare, it's automatically there for you. And the great thing about that is that it alleviates all the troubles if you would, with -- with having -- being able to being able to support it with the display and everything else. So it makes it a lot simpler for you. Okay. So let me close this.

All right. Thank you for the excellent presentation really quick. Don't forget that you can access the related content, which I will highlight for you right now. And you may also refer to our survey provided to take a poll. Now we have received several questions and we don't have much time, we'll go over a few, so we'll just jump right in. And if you would like to submit any other questions, just type them in the chat box. And if we can't get them to you today, and we can always email you with your response.

All right. First question for you, John. How do you check trigger and stroke functionality?