[00:00:00] Chris: Welcome to the amp Hour. I'm Chris Gam of Contextual Electronics.

[00:00:03] Michael: Hi, I'm Mark Gilda. I'm co-founder of Hand Micro.

[00:00:06] Chris: Micro, and you're back for the third time on the amp hour. Welcome back, Michael.

[00:00:11] Michael: Thank you. Thank you for having me so many times.

[00:00:13] Chris: times. Oh, it's a pleasure to talk to you. And we're gonna be talking about all the things Amp Micro has been doing and kind of the various.

[00:00:19] Chris: Open source projects that, that you and you and Aunt Micro are a part of. So I'm, I'm excited to talk about that stuff. You and I are often at this time of year, usually, uh, this is gonna come out a little bit later, but usually you and I [00:00:30] are hanging out at the Zephyr booth at Embedded World, but, uh, I didn't make it there this year, and you're headed there in a day or two, so I'm, I'm sad I won't see you there.

[00:00:39] Michael: Yeah. Uh, I wish we could see each other there too, but, uh, I'm only going for one day this time. My team's there demoing a bunch of things, and indeed, we're at the every booth as well,

[00:00:48] Chris: Yeah. That's great. Well, let's, let's start right in there with, uh, Zephyr stuff. So you and I know each other from the Zephyr project. You're the, I think you were just reelected as the chair, marketing chair, is that right?

[00:00:57] Chris: Congratulations, Mr. Mr. Chairman, uh, doing your [00:01:00] work here in the amp hour, talking about marketing. So, uh, how, how does AMP Micro kind of work with the Zephyr Project and, what are some of the new things you've been working on? In Zephyr?

[00:01:09] Michael: Yeah. Oh, Zephyr has been pretty central to our story. Um, we've been involved with the project since almost the very beginning, , because it just, it makes sense. It structures data. It, makes microcontrollers a little bit more like Linux devices. , for those of you who don't know, Zephyr's, structured around device trees and, , data.

[00:01:29] Michael: Driven [00:01:30] flows that allow you to, , build your binaries and work with your hardware in a structured way, which is kind of a difference from how some other operating systems do it or how people do it in the bare metal world. And, uh, because of that, we've always liked Zephyr and, , started using it many years ago for all of our projects, whenever we can, of course afford it.

[00:01:50] Michael: There are clients who wanna use different things, but most of the time if we can have a say, we can use Zephyr

[00:01:55] Chris: Some of the hardware engineers listening right now, they lament the fact that it's more like Linux, but it's [00:02:00] actually, I.

[00:02:00] Chris: As a hardware person kind of coming up the stack, I always think like, man, this is so crappy to learn that stuff. But once you do, you start to kinda like, you're like, I see it now. Okay. All right. All right.

[00:02:10] Michael: That is, yeah, that is a little bit true. Yeah, of course. So there are some downsides. Definitely zephyr's, , build system and setup is sometimes challenging for people. Uh, and we're always trying to make the developer experience better. All kinds of help in that regard is, uh, appreciated.

[00:02:27] Michael: But once you cover this, this [00:02:30] initial kind of set apart, uh, it scales really well. It's a really good tool to like build actual products that have variants that can be ported across a range of hardware. All these kind of things that really become important as soon as you start rolling out, you know, complicated products and this is what we do.

[00:02:48] Michael: So kinda Zephyr was, was a great choice for us. It doesn't mean it's a great choice for everybody maybe, but like. Predominantly, if you're really looking to use it for like professional purposes, the, the investment pays off. [00:03:00] Definitely.

[00:03:01] Chris: Yeah. How much, how much has Ant Micro actually done that migration? Because like, that's one of the things I always think about is like, okay, Zephyr is great, like I've done some. You know, across chip porting type stuff. But like in practice, do you, do you see companies like actually doing that?

[00:03:15] Chris: Like being like, all right, well we're going from vendor A to vendor B because it is in Zephyr.

[00:03:20] Michael: Well, that does happen. It doesn't happen very often because I think people just prefer to have that option. They don't necessarily like to, you know, jump my controllers. If they're [00:03:30] comfortable with a certain vendor, they'll probably use them for as long as they can. But at the same time, just, just having that possibility is important because, uh, you don't wanna be stuck with a part that's no longer produced or, or something.

[00:03:42] Michael: We had this at the, in the chip shortage times. Some of us have already forgotten maybe. But

[00:03:47] Chris: No,

[00:03:48] Michael: it was really, it was real, right? Like you could suddenly get stuck with a product that you can't make anymore.

[00:03:53] Chris: Yep. Yep. That, that, I feel like that it sounds bad, but that was good for the Zephyr [00:04:00] project. You know, like a lot of the chip vendors were calling it Micro and other companies to be like, Hey, how do we get in on this? 'cause we wanna be able to not only.

[00:04:08] Chris: Like, have this as an option. 'cause our customers are asking for it. They're also asking it because new customers were walking in the door and being like, Hey, I can't get my chips from other vendor. I'd love to switch to you. Can you, can you supply this? And they're like, yes we can. If only we had the firmware and, and software, higher level tools, tooling built on top of it.

[00:04:25] Michael: Yeah, exactly. And I think maybe to, to illustrate how this is good, [00:04:30] um, we should look at the device three aspect and the way we use it with Reno and uh, Zephyr dashboard and so on. So essentially what we do is we look at the entire, uh, ecosystem of hardware supported in Zephyr, and not just Zephyr, by the way.

[00:04:43] Michael: We're also using Ubu and Linux in that way, but. Concentrating on Zephyr specifically. Zephyr has a really good data set about, um, you know, hundreds of platforms. It's like 800 maybe right now, where, um, all of them are described in one way. And, uh, everyone's trying to make sure that [00:05:00] this description is correct up to date, useful, uh, easily possible.

[00:05:05] Michael: There are tools to, you know, to process this data so we can take that data and process it to output Reno simulation files. And so if we have support for specific cores and peripherals that are included in specific associates on specific boards, that means that, uh, the layout, like how these things are arranged on the system bus and, uh, you know, what's, [00:05:30] where, which chip has how many ards and so on.

[00:05:32] Michael: All of this information we're getting from Zephyr, uh, and we can just generate that automatically. And assuming we have a model for a specific, let's say Uor or I Square C controller. That'll just work. And we can essentially run as many as I think 620 platforms in Reno now because of this. And of course, like we historically knew it was possible to do this, but it wasn't before we tried and we actually built the Reno Zephyr dashboard where [00:06:00] we take Zephyr, we built it across all the targets.

[00:06:02] Michael: We run simulation in a huge, massive CI with like thousands of, you know, because there's like 12 binaries across 800 boards. So it's what, 10,000 different binaries that we build. And then we run all of them in Reno. And actually most of them do run, right? So it's like binary compatible firmware running in simulation.

[00:06:22] Michael: The scale is like impossible without automation. We used to do this by hand, obviously we never got anywhere, you know, [00:06:30] near that number, right? We, we had like 50 demos and we're super happy. Oh, we have 50 demos right now. We have like, I dunno, 5,000 demos more

[00:06:37] Chris: more. Yeah. That's wild. And when you say the binaries there, you mean like those are kind of the, the test test programs, so like the philosophers table or whatever that's called, like the, the test programs that are running actually on the core interfacing with peripherals, like actually testing out the capabilities and showing that it's actually cross compiling to all these different targets.

[00:06:58] Michael: Correct. Yeah, the, so there's [00:07:00] some rust tests, some AI related stuff, a blinky, obviously these are like mainline, Zephyr applications because those actually scale across, um, a lot of targets.

[00:07:09] Chris: targets. Got it. Could you explain the, so Reno is, I think something we've, you and I have definitely talked about in the show before, but can you remind people what it is and then how people are using it?

[00:07:20] Michael: Absolutely. So Reno's a simulator that you can use to, uh, develop complex systems. We can do multi-node, we can do, you know, communication over interfaces like k ethernet, [00:07:30] wireless. We can of course simulate single nodes too as a consequence, right? Like if your system has N nodes and N is one, then Reno can do two.

[00:07:37] Michael: Uh, but I think it's most useful when you're building something complicated. And in fact, we've shown this recently, we've had a lot of interest from the space industry. We have a number of customers there and pretty much all of them have fairly complicated systems because subtle, a satellite or, or some other like space bound system just has to have like multiple my controllers in it.

[00:07:57] Michael: We have customers and automotive, same story. [00:08:00] You in a car, you'll find

[00:08:01] Chris: 200, 300 micros in there. It's nuts.

[00:08:04] Michael: So, so, so you can do that. And then of course, this portability aspect, this scalability aspect becomes extremely important because you, you can't just imagine to, to be doing all of these things by hand.

[00:08:16] Chris: Yeah, totally. So just to kind of draw a picture from Reno, kind of down, Reno is kind of coordinating peripherals and cores and all that other stuff.

[00:08:27] Chris: But then what is actually doing the, so like [00:08:30] you said, you know, the uar, if, if it's like a known uar, we can simulate that. What is actually doing that, like implementation of the simulation there? Is it, is that Nsim, is that QMU, is that some other, or is, is that actually Reno as well?

[00:08:43] Michael: It is renowned. Yeah. All of this is renowned. Uh, we have both prosor models and perfor models. We sometimes interface with other tools for like physical simulation or similar things. So Reno's absolutely very easy to integrate with other things. Uh, but like for the core simulation capabilities, this is [00:09:00] just Reno itself.

[00:09:00] Chris: we know itself. Okay, so, so you have your own model of like a Cortex M 33, for instance, and like, yeah.

[00:09:09] Chris: Interesting. So then what is, I guess you probably probably talked about the last time or one of the times you were on the show, but like, what is this, what is, I guess I've learned more about Zephyr since then too. Uh, what is actually doing that under the hood then? So then that's just like Python code or C or some other language that's just responding to um,[00:09:30]

[00:09:30] Michael: Yeah. For the course, it's c, it's a translation library, as we call it. So you take instructions from one architecture, you translate it to another, and traditionally that's been X 86 as the host, right? So I mean, most people used to only run X 86 machines as their, as their hosts, and then you would have to like translate, let's say armed, but, but now with Apple, we actually also have the ability to, to do arm as host.

[00:09:53] Michael: So it's basically translating from architecture A to architecture B, where those architectures could potentially be the [00:10:00] same. Um. Yeah, you're kind of, you know, uh, people have called Reno Docker for embedded, which is not accurate by any means, but it is kind of

[00:10:08] Chris: yeah, it kind of paints a

[00:10:08] Michael: capturing the metaphor. Yeah,

[00:10:10] Chris: yeah, yeah, yeah. Okay. Yeah, it's, it's good for me because it's, uh, two things that I have no idea how they work. Uh, uh, that is good. I, I, I know a little bit about both work, I think. Uh, okay. That's cool. And then when people are kind of gluing it all together, like the automotive and the space examples are interesting.

[00:10:27] Chris: So then the, [00:10:30] uh, so someone's writing high level control software, or sorry, test software for like a car. They want to like test like, uh, user stomps on the brake and then it fires, it fires system calls throughout the system and, you know, down the line, down over the can bus and it does this and this and this, and it triggers the system and that system.

[00:10:49] Chris: And, and you like wanna see the behaviors that respond as a, as a result. Yeah,

[00:10:53] Michael: Yeah, exactly. And you know, you can do it in many ways of course, but like, we believe that definitely simulation where you're running the real [00:11:00] binaries is at least one of the ways you should be doing it, right? Because theoretically you could, you know, mock things and model things on a higher level and just, you know, like completely avoid the hard oriented stuff.

[00:11:11] Michael: But in practice, of course, um. A complicated hardware system has so many ways to fail that, uh, it's, it's kinda better to, to have that kind of, uh, simulation capability in place where in the end you can take the production binaries and run the test and you're kind of saying, Hey, look, I've, I've tested those specific binaries and they do work.[00:11:30]

[00:11:30] Michael: Uh, and also like, in terms of continuous integration, it's just so nice to be able to, when you're contributing code into, you know, a, a systems firmer, um, you are testing the same exact binary, firmer that you're compiling for your target machine. And maybe you even have hardware and loop testing. You should, right, if you're building a car, um, and you'll be using those same binaries for, for like renowned simul and the harder loop simulation.

[00:11:53] Michael: I think this is very valuable.

[00:11:55] Chris: yeah. I feel like that was always a missing piece for me when I was like, starting out [00:12:00] with microcontrollers. I'm like, why would this matter? Like, I'll figure it out when I'm on the bench. But it's just, when you think about, I think the car's a great level of complexity.

[00:12:07] Chris: 'cause it's like if you're working on the, I don't know, the, like a window controller, like a, you know, up down window controller and the circuit board for that and the firmware for that. 'cause there is firmware in there now, I'm sure. Uh, and it's like tying up the lin bus and somehow, like the lin bus actually triggers, uh, you know, something down the line that like the ECU that's interfacing Lin bust and the can bus and those are all tied [00:12:30] together and like you cause a lockup like way down the line.

[00:12:33] Chris: But if you don't know that until the integration stage, like when you're actually like pushing the down button on your window in, in the test car, like that's, that is a. That's gonna throw everything into chaos. Yeah. Yeah, exactly. So

[00:12:47] Chris: that

[00:12:47] Michael: I mean the car industry is kind of specific in that, you know, especially in that, um, it's, um, both like ancient and uh, uh, and, and complex in some ways. But, uh, although it's close to people because everyone drives a [00:13:00] car, uh, but I can maybe use the example of the space industry in the sense that, you know, there's, there's a sudden boom in space exploration.

[00:13:08] Michael: There's a lot of companies building, um, satellites and so on, and we've been helping people, you know, get their stuff to orbit. We have this, uh, uh, great customer at Aerospace with whom we've been working kind of, uh, in a really rapid development project where, you know, from concept to orbit below one year, that was like the headline for it, right?

[00:13:27] Michael: So, and we built

[00:13:29] Chris: Well, one year [00:13:30] development and then like three years waiting for a launch window or something.

[00:13:33] Michael: No, no, actually with SpaceX you can pretty much get your stuff into space, you know? Uh, we did have a delay actually, so, uh, there was this like little, uh, glitch, uh, somewhere last summer, but, but it was a delay of one month, right? So, uh, it isn't so bad these days if you're launching something fairly standard.

[00:13:52] Michael: Um, and so, you know, we, we could build like, you know, the whole thing and simulation, you know, and [00:14:00] for example, the, like, as in many projects, this one also kind of, you know, there was a change of hardware somewhere at some point. And, uh, the fact that the things we're using are portable, both Zephyr and Reno, et cetera, it's like, okay, we're changing hardware now because reasons, but that's okay because the underlying abstractions are, are the same.

[00:14:22] Chris: and so what was the thing doing?

[00:14:25] Michael: Um, it's, uh, like a, uh, data center in space, let's call it. So, uh, a [00:14:30] processing system that, uh, uh, instead of beaming everything to earth, tries to process data onboard. Uh, the, the main computer there is the Jetson Orange actually.

[00:14:41] Chris: actually.

[00:14:41] Chris: Okay.

[00:14:42] Michael: so, so that was kind of, uh, I think maybe historical first getting that to orbit.

[00:14:48] Michael: And of course ET was doing, you know, the work related to, um, making it ru hard and so on within helping them with building the hardware. But, uh, um, they're kind of in charge of making this, you know, [00:15:00] space grade. Um,

[00:15:01] Chris: gonna say, uh, Nvidia chips aren't exactly, there're a kind of big, small,

[00:15:05] Michael: they're not by default yet. They're, they're just kind of consumer

[00:15:08] Chris: is not great for Rays.

[00:15:10] Michael: Yeah, yeah,

[00:15:11] Chris: Yeah.

[00:15:12] Michael: yeah. But there's a company called Cosmic Shielding Corporation that's also building those, uh, kind of shields for, for cos hardware. And, uh, that's what they've been using.

[00:15:22] Chris: okay. That, yeah. I'm sure that helps. Uh. They put

[00:15:25] Michael: yeah, this, this has been a great

[00:15:26] Chris: it. That's my sci-fi. My sci-fi brain's like, oh, you could [00:15:30] cover it in water that helps with space race. But is it, is it something else that actually, like, you don't wanna put lead up there Right.

[00:15:36] Chris: But, um, for shielding.

[00:15:39] Michael: yeah. But, but anyway, like these kind of projects are, are really awesome to work on. And, uh, there's this real challenges and, uh, and you can see how simulation just, just helps tremendously because, you know, you're not gonna be able to, you know, test in, in the real, uh, in the real world too much. Um, and we have also other customers who have been using Reno in space context [00:16:00] for, you know, testing.

[00:16:01] Michael: And, uh, we've even discussed like training where a lot of the time when you, when you wanna do training, you need like the full setup, lying flat on your. Desk and maybe you only have three of those, and every time you, you have to like, uh, get this thing running, you need actual engineers to, you know, turn it on and operate it for people to get trained in how to operate the mission.

[00:16:23] Michael: And the mission operators are not necessarily engineers, right? Uh, they, they might be, but uh, they, they might be other [00:16:30] kinds of people. And you can see how it's, it's kind of almost crazy that in order to like run the training session, you actually have to, you know, take engineers out of their like room, uh, where they're developing the thing to actually operate it as well in the testing room, whereas in the training room, right?

[00:16:49] Michael: Whereas with Reno, you could potentially just kind of do all these tests and simulation, uh, and because it's all like automated and scripted and there isn't like a five different MCUs you have to [00:17:00] flash or something, um, then you

[00:17:02] Chris: yeah. But how do you tie together the, so like this is always my, this is always the push pull, right? It's like, so in that case, I have a very specific like simulation and training versus the reality thing when I was at Samsung, oh, so many years ago, like 20 2006.

[00:17:17] Chris: So. They didn't let us touch the semiconductor processing equipment they sent us to like a training center. And like, you know, it was like using the control software that was not tied to the actual [00:17:30] plasma ets that were there. And so I like sat in a room for a week just like clicking on a UI interface that was like, oh, and now the wafer has moved into the container.

[00:17:39] Chris: Right. And it is like, I don't know if that's actually reality and like, you know, like that's, so it's always that tying of the simulation to the reality. How do you, how do you actually validate that piece? Right? I mean, like the, the fact that it actually is doing in the physical world of what the simulation's saying.

[00:17:57] Michael: Uh, yeah, or the other way round, right? Like[00:18:00]

[00:18:00] Chris: right? Sure. Yeah. Yeah. Great. Yeah,

[00:18:02] Michael: on your use case. So definitely, you know, replacing everything with simulation is not possible. But like, we're always talking about the Pareto principle, where 80% of the time you probably want to be testing a simulation.

[00:18:12] Michael: And then like, once you know what's going on, once everyone's been trained and things are working, you know, you're pretty happy, you should still go and actually like, you know, see what the thing does in practice.

[00:18:23] Chris: practice.

[00:18:23] Michael: Uh, but you reserve that to really iron out the last details. You don't go and because like very typically [00:18:30] we've seen this over and over again, especially among our space customers.

[00:18:33] Michael: Many of them will reach out to us and say, you know, our hardware is not even available yet, or we have two copies or something.

[00:18:39] Chris: Right, right. It's so expensive.

[00:18:41] Chris: Or it's in space.

[00:18:42] Michael: yeah, you can't, you can't just, uh, very simply, um, scale it right? Like. You'll have the barriers of like physical location of the teams or, or maybe someone's traveling or, and, and then with pre they'll just grab a laptop and they'll do work.

[00:18:58] Chris: work.

[00:18:59] Michael: And that's kind [00:19:00] of the, the beauty of it.

[00:19:00] Chris: video. Yeah. What is the level of, I guess so, Hmm. Maybe that satellite's not a good example. If we can just switch back to the car for a second. Right. So like the, uh, the actual like actuation of a thing.

[00:19:15] Chris: Right. So I guess he could be. Deploying solar cells, right? So like I enter this command, it filters through all the different subsystems that need to do it, and then a, you know, a little arm on the, on the satellite deploys a solar cell. So like in Reno, how do you [00:19:30] actually, is it like you're watching a, a, a register and it's going from zero to one?

[00:19:34] Chris: Or is it like there's some other kind of like, visualization, like the, the thing has happened? Like how, how does the user know that?

[00:19:42] Michael: Oh, that's a very, uh, good segue really, because, uh, yeah, we are working on this, uh, obviously on some basic level it's a zero turn to one, right? Uh, but then you're thinking, okay, how can we, first of all, how can we like, plug this into the external world so that, or not maybe the physical world, but I mean like a simulated [00:20:00] physical reality.

[00:20:01] Michael: And that's one of the aspects we've been working on where, first of all, we have like a data ingestion format called construction data, uh, re uh, sensor data rest. And this rest format, um,

[00:20:11] Chris: wait, rest,

[00:20:13] Michael: res RESD, sorry,

[00:20:16] Chris: sorry. Aha. Okay.

[00:20:18] Michael: And, uh, so basically, um, you, uh, have a file that would, uh, kind of, uh, specify what data points happen, at what points in time.

[00:20:28] Michael: So it's like one [00:20:30] time access and multiple data points potentially. We've been working on this with like some consumer electronics customers, logistics customers, uh, and, and space customers to, use rest to have like a unified way to input data from the outside into Reno. And then of course the control loop happens in Reno and then, , outputs happen.

[00:20:49] Michael: So that's the ingestion part and I think this is kind of very useful to have standardized because, you're not like getting those data points independently. But you can first of all, [00:21:00] many customers have some data pools, right? They have specific data recorded maybe, or some synthetic data generator and so on.

[00:21:08] Michael: So we only need to convert it to that format and, we can use whatever people have,

[00:21:12] Chris: we, people have, can we like, make up a fake example? Can we go back to the two examples you're talking about? Or, or make up another example for, for like what would be in this res red, R-E-S-D-F, is that right? Reno Structured data format.

[00:21:24] Michael: uh, renal structured data sensor data, so just R-R-E-S-D without the f.

[00:21:29] Chris: res, [00:21:30] R-R-E-S-D. No.

[00:21:33] Michael: Let's imagine like a number of, um. Uh, data points as like acceleration, maybe temperature and pressure, let's say. Yeah.

[00:21:44] Chris: Sure.

[00:21:44] Michael: Uh, so we, we used to build drones. We still do, right? So sometimes we have customers building drones and, and you know, you need, like, you need to know what the acceleration is.

[00:21:51] Michael: You maybe need to know what the ambient temperature is, and pressure definitely to know as well. So like, you have those parameters and like all of them are important for a [00:22:00] control loop. And, uh, you know, you're, you have a file where just the data points are specified. You feed that into Reno. And it just like unfolds this data series, you know, in time of Reno has virtual time, right?

[00:22:15] Michael: So,

[00:22:16] Chris: So,

[00:22:16] Michael: this virtual time is correlated, right? , and, , every time Reno runs is gonna be the same like timeline. Like things don't happen randomly. They can if you want them to, right? You can actually change the seed or you can randomize things by [00:22:30] like, if you want it. But by default, if you're just gonna run the same script, it's gonna run the, the exact same thing, the, the, the exact same way also.

[00:22:39] Michael: Um, so yeah, you have this data and then

[00:22:41] Chris: too, because I, I imagine with like, uh, control data for a drone, you, it's tough to, like, you can't like tune it in situ. You can't be like, oh, well I'll just modify the PID, you know, the, the proportional element of, uh, you know, the, the drone's response on rotor one because then it's gonna crash.

[00:22:59] Chris: [00:23:00] Uh, you can't do that. Like while it's flying, maybe you could, but it, it's tougher. I feel like.

[00:23:04] Michael: Absolutely. Yeah. Yeah. So that's one of the things where simulation helps in, you know, finding, uh, like testing in a wide variety of use cases. Because normally you would test things, of course, like of course people when they're building products, they're not stupid. They're building those things and testing them in the field.

[00:23:20] Michael: But this testing typically takes like a lot of time. I remember when we were at University, Reno did not yet exist. We're working on these kind of systems. Like 80% of the time was just testing. Right? [00:23:30] Um, and testing, I mean like with a drone in your hands and, or like sensors mounting things to walls and things like this.

[00:23:37] Michael: Um. Then obviously you spend a lot of time testing, but you still don't test everything because you, like, you, you can't be bothered to, you know, do everything in simulation. You're like, okay, I'm on a computer, I can just like be creative. I'll come up with a new test scenario and it only costs me more compute power, which can be paralyzed, right?

[00:23:57] Michael: Like you can have a thousand Reno runs [00:24:00] across a thousand servers. So in practice, you know, you start getting like creative in terms of like what kind of corner test is gonna, you're gonna test. You can also do things like accelerate time. , if your system isn't like really busy, if it's not like busy looping on something, which is hard to simulate, but if, if it's mostly just, you know, reading something here and writing something there and maybe sleeping for a while, you can just squeeze the time and you can take like a, a week's worth of data and compress that to, let's say 15 minutes.

[00:24:27] Michael: Right? And. Now you've [00:24:30] tested the behavior of a system after a week, which normally takes a week, right?

[00:24:34] Chris: Yeah. Right, right,

[00:24:35] Michael: And I remember this Boeing problem,

[00:24:38] Chris: I can tell that this drone will not work at the heat death of the universe. Uh,

[00:24:42] Michael: yeah, maybe that can't be tested easily, but I remember those, those problems were like, something would happen after a year because like a counter would overflow.

[00:24:49] Chris: Oh yeah. That's a good one. Yep. Exactly. 32 bits is only so much, huh?

[00:24:53] Michael: yeah, so, so this can be testing simulation much easier. I'm not saying that, of course you'll always catch it because you have to be creative enough [00:25:00] to figure out that this could be a problem.

[00:25:02] Michael: But like if you figure it out, this could be a problem and re in real life, you wouldn't be able to test it very easily because, , you'd have to like write artificial maybe firmware and tests. Whereas in Reno you take the production binary and just say, okay, let's see what happens if a year passes and

[00:25:17] Chris: That's good. That's good. What about the variety of, stimulus that stimuli, I suppose that, um, that, like how, how creative can you be there?

[00:25:26] Chris: Right. Because it's like, uh, the temperature shoots up to, a hundred C, [00:25:30] it's like, okay, it's not gonna happen. But you could do that. I, I mean, like, that would be like testing, like boundary limits on center data, I guess. And

[00:25:37] Michael: Yes, absolutely. So, of course we can't simulate, like physically what's gonna happen if a hundred degrees happens and, you know, your, your hardware melts, right? This is not gonna be something you test in Reno. But

[00:25:47] Chris: probably gonna smack you in the face a different way.

[00:25:50] Michael: yeah, in the control, in the, in terms of the control loop, absolutely you can, you can do like a borderline criteria that are very difficult to assimilate in reality because, you know, you'd have to like heat up things very heavily [00:26:00] and, and that would break them in different ways.

[00:26:02] Michael: So testing the control loops in border criteria and border conditions, I, I'd say is also another great feature that you get with simulation. Yeah.

[00:26:12] Chris: Yeah. And I guess there's like combinatorial, like weirdness that could happen too. So it's like at, you know, the sense sensor one is doing this and sensor two is doing that, and for some reason those interact, you could have like, is there like data fuzzing you can do to like kind of

[00:26:25] Michael: We've actually been doing fuzzing. Yeah. Yeah. We haven't done as much of it as I'd like yet, [00:26:30] but I mean, this is a growing, uh, topic and I think, you know, more people wanna do it once they realize that you, you know, actually can do it. And they've, they've run out of the simple things to test, you know, and

[00:26:41] Chris: Yeah,

[00:26:41] Michael: realize, oh, we could do so, so much more.

[00:26:43] Chris: yeah. Yeah. That's interesting. Yeah, I mean, I imagine, like you said, with space customers too, like they only really get one shot, so they, they need to be really good at that stuff.

[00:26:51] Chris: And like having.

[00:26:53] Michael: and when you, when you mentioned fuzzing, like it, it reminded me of like the work we're doing right now with Autom mail for, [00:27:00] um, this kind of ties, ties for me with, with our canning framework. We have like this open source AI framework for well portable ai. You, as you might guess, we're kind of fans of portability and reusability and, uh, we're just demoing it at embedded well this week.

[00:27:14] Michael: So it's kind of fresh on my brain and, uh, basically, um.

[00:27:18] Chris: kenning. You said, what's, what does kenning stand for? Like, is that a, a, a topic? I don't actually know that, that that

[00:27:24] Michael: It is kind of a, a poetic expression, uh, means of expression, uh, in Icelandic [00:27:30] sagas where, uh, you'd have like a metaphorical expression that would typically begin with the same letter, uh, for describing something, you know, like poetically describing a ship to be like the, the warrior of the waves or something, you know, that would be a

[00:27:47] Chris: Oh, oh, I I used to do that all the time too. Episodes, uh, one through 2 55 of the amp power were alliterative titles. So,

[00:27:54] Michael: Yes. So that would be

[00:27:55] Chris: I'm, I'm quite a caner myself.[00:28:00]

[00:28:00] Michael: Do you have a skateboard maybe, or no? So, uh, no. So basically, um, Kenning is also using Reno, by the way, for, for simulating things. And because we can kind of, you know, define AI scenarios and run them across a variety of hardware, and this auto mail feature that we're adding is like trying to figure out the right parameters for your, uh, uh, for your, you know, uh, AI workload, right?

[00:28:29] Michael: So, [00:28:30] uh, it's pretty much kind of, uh, associates with my head with, uh, this fuzzing problem that you mentioned. Like you have to test a lot of things to figure out what's best, and, uh, with, with Auto ml, you kinda do it, and if you have a simulator, you know, you don't have to have hardware to, to try that, try that out and, and make it happen.

[00:28:48] Chris: So in this case, the, the a the neural network that's running here though is, is basically creating the variety of inputs for the, like a sensor.

[00:28:58] Michael: Um, I mean,

[00:28:59] Chris: [00:29:00] the AI piece? I guess the better question. AI is used so broadly these days, Michael. It's just, it is everywhere. It's, it's infecting my brain.

[00:29:08] Michael: That is true. That is true. It's more about the parameters of the network, really. I mean, you can manipulate the sensor values too, of course. And, and see what happens. So like, all of these things become variables. That's, that's maybe one of the reasons behind the complexity of the task is you both have like data sets, but also you have like maybe your neural net for example, which has like, you know, thousands of [00:29:30] parameters, sometimes millions, right?

[00:29:31] Michael: Like billions right now. Right? So, so, um, there's so many things to tweak and, uh, you have to have some way to benchmark if you're getting better or worse as you're tweaking those parameters. Um, so, so

[00:29:46] Chris: it's like you're creating like a feedback into the, into the control system, kind of like the, the AI control system that is,

[00:29:54] Michael: Although it's kind of, it's, it's, yeah, there's many ways to, to, to use this, but yes. [00:30:00] In, on, on a high level, yes.

[00:30:01] Chris: high level, so well, maybe we can make it a, a real test. Actually, it's a, a board I have on my bench.

[00:30:06] Chris: It's for the analog devices, max 32, 6 90 EV kit.

[00:30:10] Michael: Perfect. Because this is exactly the kit that we're demoing with. We're actually working on this

[00:30:14] Chris: Well, I'm looking at your website. So that's, uh, that, that was a, that was a

[00:30:17] Michael: smart.

[00:30:18] Chris: it was a lead it, but, okay. So you create a docker image with the Zephyr, the Kenning Zephyr runtime. Mm. So what is actually.[00:30:30]

[00:30:30] Chris: What is the kenning piece in on this kit? Right? So it has, it has the micros that you're targeting and stuff like that, but you're training it to do anomaly detection of something.

[00:30:42] Michael: Yeah, I mean, an only detection is basically, you know, can be any data source that's just, you know, supposed to behave in a way. But sometimes, you know, we have weird behaviors and it, I, I don't know even what our example is really tracking in terms of like the, the real variable that's being, uh, [00:31:00] analyzed, but, uh, it doesn't really matter.

[00:31:03] Michael: Right, because it's more about

[00:31:04] Chris: Right, right, right. Well, it matters only for hardware weenies who don't understand it. Like me. That's, that was me. Uh, so like a, so like a temperature sensor that might be on board.

[00:31:14] Chris: Right. And if

[00:31:14] Chris: it

[00:31:15] Michael: Or, or a vibration sensor or something. Like, I think vibrations are often used because you can imagine how like something's vibrating at a certain, like, uh, uh, frequency, you know, like something's running as normal and suddenly, you know, the, the, [00:31:30] the, the, the frequency changes, right? And like, what does that mean?

[00:31:33] Michael: Maybe something's broken. Right? You're trying to detect that anomaly.

[00:31:36] Chris: Yeah. And I feel like that's a, that's a really good example because writing just like a straight line, like threshold detection doesn't usually do the business there unless you're like, maybe if you're doing an FFT and you're like, oh, I always know that, like the, you know, the third harmonic is gonna spike or something.

[00:31:50] Chris: Like, maybe you do that, but like, if you wanna cover lots of cases and just say normal, not normal, that's a very good use case because vibration has a lot of data generated [00:32:00] and then some kind of weirdness that pops out as a not normal weirdness. You know, that's, that's, that's a good, a good use case, so Okay.

[00:32:09] Chris: Vibration.

[00:32:11] Chris: So

[00:32:13] Michael: Yeah, so anyway, like it's, it's more about finding the right training parameters and you know, like actually building the model for use on the micro control later. Uh.

[00:32:22] Chris: Uh,

[00:32:23] Michael: And, and, and you know, that process in itself is complicated because, you know, if you, if you're [00:32:30] gonna like, go and tweak everything yourself by hand, you're just gonna be like, okay, am I getting better Even?

[00:32:36] Michael: Um, maybe you are, maybe you aren't. So that's where you're using kind of a, a feed kind of control loop in a sense for, for like the training. And that's, that's basically what ML is.

[00:32:45] Chris: Got it. So auto ML is the thing that's all ultimately like the, the plumbing that's making it easier to build some of these models to like push down into the micro. Is that, is that a good

[00:32:56] Michael: Yeah. Mm-hmm. Yeah. And you still need to like [00:33:00] actually, you know, assess how it works in the end. So, uh, you have to have this like, execution control loop, right? But, uh, it's more about like, you know, executing it enough times that you run into this like, optimal solution that you think is good with given your data, right?

[00:33:19] Chris: Mm-hmm.

[00:33:20] Michael: Uh, and then you use that, um, that model for a while. And of course, like there are also, uh, uh, uh, more topics there, right? Because then you [00:33:30] can kind of continue retraining that model to fit better to, to the actual, uh, scenario. But here we're talking more about, uh, you know, the moment when you are developing the algorithm in the first place, and, um, trying to find the right parameters and tune them to the use case given

[00:33:48] Chris: I have specific another example that's, uh, from my past. That's just the, a counter example of why to use something like this. It would be like an a co-op I did many, many years [00:34:00] ago where I was like trying to detect it was actually on an FFT type of thing, and I was like, tweaking an FPGA and I generated all the logic and I'd run it all through this different thing.

[00:34:09] Chris: And then like four hours later after my computer crunched on, it'd be like, like the only thing I had on the output was like, again, just a zero or one, and you'd be like, Nope, didn't do it. Start it again. So I'd get like two runs a day and it was just me clicking a button and then trying stuff in between, but there'd be no.

[00:34:24] Chris: There'd be no, like loop cycling. It was always just Chris in the loop clicking go and trying [00:34:30] stuff and like having, I was a co-op, so I had no idea what I was doing. And so, but like being able to actually like model this and run a bunch of scenarios, like it would be better to run a thousand inputs and get some actual better data on the output.

[00:34:43] Chris: Uh, and then feed that back in.

[00:34:45] Michael: Exactly, and that's kind of, I, I don't wanna say it, but you know, like it's eliminating Chris from the Loop, right?

[00:34:51] Chris: Good. I, I didn't do much at all at that co-op 'cause I, I, I, I mostly just sat around. I mean, like, honestly, uh, I could have been doing other things,

[00:34:58] Michael: Yeah. And uh, [00:35:00] also with like those small devices, remember that you have limitations like memory, you know, where maybe some of the models are really cool, but you can't run them anyway. They're just too, too big. So you have to like, you know, uh, push the boundaries in different directions and see, you know, which, which kind of model works best, uh, given constraints.

[00:35:20] Michael: And, and I'm, I, I think this given constraints element is, is very interesting because what Kenning does is, you know, uh, you can look at not just one micro [00:35:30] controller. Like right now we're running this for this one example, micro controller. But of course, like. There's a lot of micro growth in the world, even among devices.

[00:35:37] Michael: There's a lot of them. So

[00:35:39] Chris: yeah.

[00:35:39] Michael: might imagine that you might formulate your automobile problem in like, okay, given a family of micro controllers with different memory sizes and capabilities, let me try to optimize, uh, where I'm optimizing across, not just like the parameters, the results, but also like, I'd [00:36:00] like to use the cheapest possible microbe, but at the same time if that was like really cutting my performance, uh, in half, you know, or something, then maybe I'm not that interested in, in kind of over architecting this or, or over like simplifying this.

[00:36:15] Michael: I, maybe I'm okay with using something bigger if it gives me better results. So you can start thinking like more cross-platform across like family, um, in your

[00:36:27] Chris: benefit analysis really. That's almost what that is.[00:36:30]

[00:36:31] Michael: And, and that maybe also brings us to like the system designer concept, right? Where one of the things that we're trying to do very heavily is, you know, try to reason about the world's hardware in a structured, systematic way. There's, so much of it and, it's just hard to pick. And people tend to just gravitate towards whatever they have on their desk and what they like.

[00:36:52] Michael: And that's fine. Like humans are humans. It's, it's good to use stuff that sits well with you. But at the same [00:37:00] time, uh, if you could have some way to like, have all of the world's hardware at your reach and the ability to like really pick what's best for your use case, I think that will be very valuable and that's what we're trying to achieve.

[00:37:12] Michael: Um, it's essentially a portal that we're building.

[00:37:15] Chris: building.

[00:37:16] Michael: Uh, which takes the data sources like Zephyr, like Reno and Ubo and, and other things. Uh, we also have like an open source hardware, um, repository, like, like,

[00:37:28] Chris: like,

[00:37:29] Michael: uh, [00:37:30] dataset we can call it, uh, which we constantly develop because we're building hardware, right? One of the things that we do is we, we build devices and when you're building devices, you're building hardware.

[00:37:39] Michael: You are essentially putting together hundreds of components, right? And for all of those components, we have open source footprints and blender models so that we can first of all use them with Kai card, uh, efficiently and in like a structured way. And secondly, we can generate really nice photorealistic visualizations.[00:38:00]

[00:38:00] Michael: We've also recently like done like thermal simulations, EMC simulations and so on. Also of open source tools. So we're kind of building out like an open source toolkit for, for hardware design. You can really do great hardware design these days with open source tools. And, uh, we have this open source library that we also like digest as a data source and you put it all together and get like a Wikipedia of, of hardware, and that's what we're building.

[00:38:22] Chris: we're building. Okay. So I went in and I clicked on the CH 32 VW three EVT board [00:38:30] and now I can go and simulate it in Reno. I can build different things for it because it got ported to Zephyr, which is bonkers.

[00:38:39] Chris: Um, so you kind of show all the things that are built, all the samples that are built for it, all of the things that are on the board. This is probably too simple

[00:38:47] Michael: Yeah, this is, this one actually isn't simulated yet. I mean, funnily enough, if you look at the, if you hover over the board itself, you'll see that the MCU there, you can actually click it, right? There's a hot area, you can click it. [00:39:00] That's like at ESP 32, which I dunno, you've seen it's been on the news recently and not in a good way.

[00:39:06] Michael: So maybe you pick something else. Uh, let's, let's grab a, we actually have a board called Environment Sensor. If you could take a look at that one,

[00:39:16] Chris: Okay.

[00:39:17] Michael: because I think that showcases some of the things that are maybe not available as assets for other boards.

[00:39:22] Chris: Yeah. That ESP 32 thing was a bit overblown. I think I, I knew it when I saw it.

[00:39:27] Chris: I knew it when I saw it. It's not remote execution or [00:39:30] anything

[00:39:30] Chris: anyways,

[00:39:31] Michael: But so here, if you look at that one, you'll have like a render and a photo side by side, because we have this board, we've built that board. So we have a photo of it, but we have a render and like, they're very hard to tell apart. Right? Um,

[00:39:43] Chris: Oh yeah. That's cool. Yeah. There's like a little drag slider that's actually like the overlay of the render over top of the physical you're saying?

[00:39:49] Chris: Yeah.

[00:39:50] Michael: Yeah, and you can even like, uh, the last button on the bottom is to like flip it around and then you can see is the render that turns around because of course we don't, we can't turn the photo [00:40:00] around. We're working on like the ability to also just, uh, have a 3D rotable board. It's kind of, you know, a bit more difficult because of

[00:40:09] Chris: DigiKey where they take 360 photos and they stitch 'em together, sort of, they don't even stitch 'em together. They just swap between them.

[00:40:15] Michael: Yeah, yeah, you could do that. But generally speaking, like what interests us is, for example, the fact that we have, you know, we have the whole bomb we've built in Kai CAD and all of the components, if you hover over them, you're gonna see that they're, um, actually active. You can kind of click on one of [00:40:30] them.

[00:40:30] Michael: If you click on the SDM 32, which we're using there, you're gonna see like a specific enclosure. You're gonna see that's an instance of a specific SOC because, uh, this associate exists in multiple enclosures. Right. And, um, and if you click add it again, you're gonna, you know, go to, um, you know, what this SOC has inside and which boards it's found on and all these kind of things.

[00:40:55] Michael: So there's a lot of like

[00:40:56] Chris: Yeah. So we're diving down. It's got five ADCs, three can, one [00:41:00] clock, four Ds, three DMAs. Okay. And then how are those, how are those being used? Like those individual. So it's kind of like a, you're creating like logical kind of trees of all these peripherals and things like that, but ultimately, what do you do with those?

[00:41:16] Michael: Yeah, maybe let's go to another board that actually has a simulation demo enabled for it. I just realized that this one doesn't. Um, so maybe go with like some like 96 boards, arrow Core two. This is also an [00:41:30] STM, but this is like just a standard Zephyr target.

[00:41:33] Chris: target.

[00:41:33] Michael: And this one also has an SOC on it, as you can see.

[00:41:36] Michael: But it also has like all those Zephyr samples and this time they say past, right?

[00:41:42] Chris: Oh yeah. Okay, I see.

[00:41:43] Michael: And when in their past,

[00:41:45] Chris: will link all these things in the show notes for people too if you wanna follow along as you're listening. Sorry about that. Uh, this is the arrow, arrow board, two arrow core two from S 96 boards. Okay. And so we're just looking at this and clicking around on here.

[00:41:57] Chris: Um, yeah. I see. So now we're [00:42:00] clicking on, so this is now simulated at the highest level. So, so Reno is simulating the, all of the peripherals that are on the board. So the TM 32 talking to what else is on here, uh, buzzer. Um,

[00:42:12] Michael: Yeah, maybe not all of them because of course, uh, the samples do what they do, right? So blinky blinks an LD and whole world prints on a, et cetera. Um, it would be interesting to have like a test that just tries to test everything and just, uh, you know, uh, [00:42:30] just reacts to whatever is on the board. It's, it's not completely impossible, but of course, like this kind of demo does not really exist in Zephyr, so we're not running it.

[00:42:38] Michael: We could maybe build one. So anyway, point is, um, the, these have been executed in our ci, so for all of them, you'll see if you click on them, you'll see the U outputs and, uh, you'll see a trace. Those traces are actually pretty cool. Uh, it's uh, like a standard tool that we're using. Speed, scope, um. Can you full screen them?

[00:42:58] Michael: Actually, maybe, [00:43:00] maybe not here. But, uh, in, in general, um, tracing is like something you get for free with Reno and, uh,

[00:43:08] Chris: uh,

[00:43:09] Michael: we're showing this, but of course, like you can also download the assets. There's like a button and all of these assets are available and you can run this yourself and a CoLab and you can run it, you know, locally there.

[00:43:20] Michael: There's many ways you can kind of reproduce those results. They're not like stuck in our portal. This is just a way to visualize them. But this is all like public information and all the [00:43:30] binaries. We've heard it from a customer. That was a funny story. We went to, to a customers and, uh, they were like, oh yeah, yeah, we're using your binaries to, to test stuff out.

[00:43:37] Michael: You know, like we're trying to run some Zephyr, uh, on some board. And we were, you know, we didn't wanna like compile our own binary. We just grabbed one from your portal and run it and it worked. So.

[00:43:50] Chris: so how would you imagine, so like I look at this designer, the designer dot an micro.com, and it has, so like the example of this, a core two.

[00:43:59] Chris: How would [00:44:00] you expect, I would use this in design, ma design decisions that I'm making as a hardware designer or a firmware designer as I moonlight as sometimes

[00:44:09] Michael: On, on a like most basic level. I mean, you can see what's supported in Zephyr Renos, et cetera, which is already a nice feature. But, uh, more ambitiously. I think what we're looking for is you could click on this board and say, Hey, I want to remix that specific board and build something similar, but not quite the same.

[00:44:27] Chris: Okay.

[00:44:28] Michael: And we have that [00:44:30] capacity generally because we have, like this VSD, this designer system designer, if you click it, there's an actual like diagram editor in there.

[00:44:38] Chris: okay.

[00:44:39] Michael: And this editor contains a lot of the things that are in, in the portal in general. But of course, like we're still working on making it, you know, good enough for you to be able to seamlessly just.

[00:44:49] Michael: Click, like, Hey, let me rework that board and just, you know, change stuff around. Uh, and, and then of course,

[00:44:57] Chris: kind of like a discovery, discovery tool sounds like For [00:45:00] sure. So like, I wanna be in this ecosystem, so I wanna see what's kind of enabled in this ecosystem that actually is, that is useful. But then ultimately what is the, uh, like what is the decision point that you expect someone would make versus maybe building up a board on their bench?

[00:45:15] Chris: I.

[00:45:17] Michael: I believe that's, you know, a lot of the time when we're talking about systems, uh, at least here, uh, at, in micro, right, we would first start with Slice. And even when, when customers approach us, right, they would start with some kind of a high level [00:45:30] diagram, essentially. Like they would say, you know, I'd like a board that, you know, communicates over this to ca over can and, um, does this and like has those kind of sensors and they're gonna describe it to you in words.

[00:45:42] Michael: And maybe you tell them, Hey, where's a grade? But maybe we should draw a diagram. And the first thing you do typically is you draw a diagram, and we saw this over and over again with people, draw a diagram and that diagram would be like unstructured and you know, it would maybe contain errors because someone thinks that a certain device has four U [00:46:00] words and then it only has three.

[00:46:01] Michael: Right?

[00:46:01] Chris: Ah, okay. Yeah. And

[00:46:03] Michael: it's, you know,

[00:46:04] Chris: that's actually kind of interesting because that's, that's often a, a like a plumbing, the data sheet kind of exercise that is non-trivial, right?

[00:46:12] Chris: I mean, like, especially if you're doing it across, uh, you know, different families, different. Vendors that that alone could, could start to tease out some, some viable things. Um,

[00:46:24] Michael: correct. Yes. So we're trying to automate that process where you're not like drawing on your napkin, [00:46:30] you're drawing in a structured system that tells you if you're thinking wrong. And then once you draw this, it becomes a collateral, like part of your project where you can verify your assumptions against what you drew in the first place.

[00:46:44] Michael: So you can, you know, maybe even draw an abstract associate and say, you know, it has this, this, this, and this. And then maybe the system tells you, oh, you know, there's like 20 micros that fulfill your requirements here. Mm.

[00:46:57] Chris: See, now that starts to get into like the, [00:47:00] I always bristle so much when all the people approach the amp hour and you know, me and Dave and every, everyone else, and they're just like, I, I will design the entire system for you. I'm not saying you're trying to do this, but it's like, we have this new AI tool and we'll figure stuff out and we can design an Arduino from our AI AI tool.

[00:47:18] Chris: And I'm like, that's not useful. Like, the stuff you're talking about useful, but like the, uh, man, I get, I'm, I am, uh, I feel like a lot of the, the, a lot of the tools that are coming into the [00:47:30] space right now are solving trivial problems. The stuff you're describing, some of that is non-trivial problems and so

[00:47:38] Michael: Thank you. Yeah, I mean, I, I think that's because we're always working with real projects, right? We're always having customers building pretty complicated stuff. We're doing some, some really nice, like augmented reality project right now, or robotics, you know, they come with like a special set of problems that aren't Arduino level

[00:47:54] Chris: level.

[00:47:55] Michael: and, and we're not like VC funded where we have to like show proof of [00:48:00] concepts all the time for someone to be happy.

[00:48:02] Michael: Uh, I mean, we like showing proof of concepts because they're a good way to gather feedback, but like, we're, we're not forced to. And what we really are trying to solve is our own problem, right? Reno was created to solve our own problem. And so assistant designers, like, how do you navigate? So we recently came up with this funded feature where we just wanna show all the SOCs being used across all of our customer cases.

[00:48:23] Michael: And this is already immense value. Like this is very trivial to do because you just, I mean we had, we codified, so we use system designer [00:48:30] internally and internal instance to codify the products that we work on, right? And those projects you typically like say, you know, I have this board with this OC on it and I'm running this kind of binary on it, et cetera.

[00:48:42] Michael: So you have like hardware, software components. You're trying to match them. You're trying to build like a complete hardware software bomb of your system. But like even the ability to just show like, here's the amount of different microcontrollers and application processors we've been using in all of those projects, you sometimes realize, oh my god, yeah, I didn't remember we did [00:49:00] that.

[00:49:00] Michael: Right? Like, human brain is really weird. Where, uh, after a while you just forget basic facts. And if you don't have a good system that keeps track of all this and uh, you can just go back in history. So maybe if you go to explore and you take a look at, uh, there, there's like, uh, the Axiom camera there. I might have mentioned it in the past.

[00:49:20] Chris: past,

[00:49:21] Michael: Mm. If you, if you go explore

[00:49:23] Chris: I'm on, I'm on that now.

[00:49:24] Chris: Yeah, sure.

[00:49:24] Michael: like you can blow it up with the switch view button that just explodes into a [00:49:30] number of boards.

[00:49:31] Chris: Yeah, that's neat.

[00:49:32] Michael: And, and this is like the complexity of stuff that we've built in the past. And, and you just, after a while, just forget like, what was the sensories there?

[00:49:40] Michael: Like, was there like a, a Xix outscale board, or maybe it was a zinc, or you know, did we use a TK one or TX one? Like, and here you have all of this codified, and so you can kind of go back in time and revisit your past solutions and say, oh, that was actually a nice concept there. Uh, let's, let's maybe reuse this.

[00:49:59] Michael: Uh, [00:50:00] and it's also a funny way to preserve, like, uh, you might be a fan of these kind of things where, you know, you kind of we're excited about some devices that came up in the past that like were, uh, released into the market and 10 years later you can't even like buy them anymore. Right. So, and if you wanted to see what's inside, you can't because you can't.

[00:50:23] Michael: See them and nobody had bothered to document them like those 10 years ago. So, uh, we're not of course like claiming that we're [00:50:30] gonna be like, you know, the way back machine of, of all hardware. Uh, but you could use that in, in this capacity where, like, for example, documenting the Axiom Project, this is in the past for us, this is many years ago, but it was still a useful exercise to, to do that.

[00:50:47] Michael: Um,

[00:50:48] Chris: This seems like this one's a little bit more complex. Like this is, I, I feel like one of the push pulls on this is gonna be like, I don't have time to document at this level. Right? This is so [00:51:00] like, I'm sure what you'll say is like, well, if you're starting from the beginning with it, then you, you know, you build it up over time and, and you really start to see that sort of benefit.

[00:51:08] Chris: I could see some other benefits though. So like going back to that like U art and like peripherals and things like that. Um, that, that is a straight ahead benefit for the smallest of boards that I, I could see. Do. Does, does the system designer. Deal with the kind of the, uh, multi assignment problem on chips.

[00:51:29] Chris: So like I [00:51:30] have, so like for example, I use the NRF 91 60 a lot. That's the cellular module from Nordic and it's great. And it talks about how about it's got all these different peripherals in which I'm sure actually I should go to that chip here in a second. I'll go to that sip. Um, but the, uh, one of the problems is that you can only use four.

[00:51:49] Chris: So like you have all of these flexible spy I square c, uur, you know, blocks that are in there, but you only get four total. And so like there's that problem that like the firmware only [00:52:00] allows it 'cause there's only so many flexible blocks. And then there's also like the kind of multi pin assignment problem where, you know, I might be using, you U are at one and I want use ice squared C two, but ice squared C two uses the same pins as UR at one.

[00:52:14] Chris: So like how does that get kinda handled?

[00:52:16] Michael: That is actually a very good question because, um, analog devices has been working on this. Uh, they have like a VS code extension, uh, specifically for like pin maxing and these kind of, you know, problems. There's other vendors also [00:52:30] looking at, you know, trying to, to solve this well. And, uh, we're, we're kind of looking to, you know, create generic ways to do this.

[00:52:36] Michael: We don't have that featured in the designer itself yet, but, uh, I think this is kind of a necessary thing to, to solve.

[00:52:44] Chris: that would

[00:52:45] Michael: no,

[00:52:45] Chris: yeah, super useful, right? 'cause

[00:52:46] Chris: then

[00:52:46] Michael: definitely looking at it. Yeah. And, and there are, like the stuff that Analog has done is actually open source. So they've been really great and, and you know, just going all in on like open source, um.[00:53:00]

[00:53:00] Michael: Which is good because like as, as long as it's like a single vendor standard, you know, the problem is that you'd have to support like 20 ways to describe it, and it's just not feasible to, to maintain this kind of thing. Whereas if it's an open standard, you maybe can afford to figure out like a way to, to just share because it's just, you know, a thing you have to do.

[00:53:23] Michael: It's, it's not secret sauce really. Right. It's kind of a frustrating thing that Oh, everyone always, [00:53:30] uh, um, doesn't like dealing with, but has to. So it'll be great if we could just solve it for everyone. Right.

[00:53:36] Chris: Yeah, that would be good. I think another thing would be, would be interesting for me is again, like thinking about this kind of tool, having this man, the number of times that a, a vendor would walk in and they'd be like, yeah, I can sell you this great new chip and it solves all your problems needs, and you know, you're using TM 32 and I'm selling this free scale chip, rest in peace free scale, or whatever it is.

[00:53:59] Chris: [00:54:00] Right. And, and then, you know, like, and then what they're saying to you though is as the engineer is like. Hey, engineer, I would like to waste your time so that you go and look if this is a possibility, and the engineer just says, no, I, I'm not doing that. Like you, we kinda talked about this at the beginning, like why, why people don't switch ships in the first place.

[00:54:17] Chris: But if it was literally like the, if the sales person walked in and they were very savvy and they had access to system designer and for some reason you signed an NDA with them as a customer and you said, Hey, take a look at this system design, [00:54:30] see if your chips fit in, gimme a better price. Like that would actually be a really interesting, like, use case as well.

[00:54:35] Chris: Where now like I, as the engineer, I benefit from basically like a marketplace system. I benefit from Zephyr and seeing that yes, actually the code will be ported over to this new system. I see that actually, yes, this new chip set that, you know, the vendor is, is pushing me on will cover all my use cases.

[00:54:52] Chris: And maybe even to the point of, like you were saying, with all these simulations, they even went and ran it for me. Like they ran, ran some like test code on it and like, yeah, [00:55:00] it's no problem. Like that would be the ultimate. Like use case in my mind where it's like truly making my life easier as a hardware

[00:55:08] Michael: Yeah, no, I mean, this is a great idea, of course. And, uh, this is of course out in the future still, right. I wish

[00:55:14] Chris: course. Yeah. Yeah. Yeah. I don't expect it to be, but I'm

[00:55:16] Michael: but yeah,

[00:55:16] Chris: I'm just dreaming this as up as we're talking about it. Right. But like, these are

[00:55:19] Michael: kind of wanna get to a point where whoever's more open and has better silicon wins, right? Like,

[00:55:25] Chris: Yeah, totally. Yeah.

[00:55:26] Michael: as that. And, uh, artificial barriers where [00:55:30] people just try to wall people off and, uh, make their stuff like us.

[00:55:34] Michael: You know, weird and, uh, niche as possible just doesn't work anymore. And especially with the complexity of the current systems, like they're getting, you know, bigger and, and you need like more skills to even program an MCU because maybe there's like a, you know, three cores of different architectures and you know, there's an an n accelerator in it and suddenly you're like struggling with a lot of things at the same time.

[00:55:59] Michael: And [00:56:00] obviously, like everyone's thinking about ways in which this could be simplified, but the worst possible result is everyone comes up with their own way to do it. And then,

[00:56:10] Chris: exactly.

[00:56:11] Michael: you know, you, you're still stuck with, okay. As long as I, I stick with like one vendor, maybe I'm fine. But, uh, you know, um, I don't think that's a good reality.

[00:56:21] Michael: And, and historically, um, we've still been, you know, reusing solutions as much as we could. Nobody wants to really like jump around and switch [00:56:30] microcontrollers all the time, but you do want to be able to just make a pick and just look at the features of the silicon and the price point maybe. But, uh, more importantly, just like the ease of use and the ease of use, um, I think should be measured in how much open source software is available for this MCU.

[00:56:49] Michael: Right? That's, that's my measure of, of ease of use. If, if there's Zephyr, if there's Reno, this, this, this, this, I'm like, I know I'm gonna manage to run [00:57:00] my stuff on this versus please download x, y, Z studio and like sign three NDAs to get

[00:57:06] Chris: Yeah, yeah, yeah, yeah.

[00:57:07] Michael: It's like, okay, I don't have time for this.

[00:57:09] Chris: Yeah. Yeah. Well, and I mean, I, I think there's some, I, I'm much closer to the side you're talking about with the, you know, like at least open source in that case is the ultimate backstop of like, okay, I can get at the code if I need to.

[00:57:21] Chris: I can always go and hire Michael and his team to like help me as well. That sort of thing is, is really important there too. Uh, I feel like vendor support [00:57:30] is another like kind of X factor that. Again, as a hardware engineer in the past it was always like, well, you know, yeah, we might pay another 20 cents for vendor A over vendor B, but their support team's amazing and like literally then, but like the swap ability that we're talking about here, if you could, if you could say that and just removes that from the, from the scenario, like, okay, now we can just swap over to the whoever, whichever vendor is supporting us most.

[00:57:57] Chris: Right? We, our tooling runs across [00:58:00] multi-vendor and if vendor A is gonna help us more, we talk to them more, we give them more business. And it's like this dynamic, it's almost like a pricing power kind of thing where, yeah, maybe you're getting 'em on price, but you're also able to like shift business to them and say, more of your chips will make it onto our boards.

[00:58:14] Chris: The better supported we are with manufacturing, with support, all that sort of thing too.

[00:58:19] Michael: And by the way, these things are related, right? So, um, if you're a vendor and you're really providing good support to people, and, uh, typically you're also more open because it's easier [00:58:30] to, you know, support people. Well, if things are just available and online and you're not spending your time just ship, sending people binaries over email, right?

[00:58:38] Chris: Yeah.

[00:58:39] Michael: You, you're, you're writing good documentation. Maybe you're, you know, organizing webinars to explain things. You're, uh, still, it's a lot of work to support customers if you're a silicon company, but I think it gets infinitely easier if you're just more open. And, uh, so I think these things go kind of hand in hand a little bit.

[00:58:56] Michael: I mean, I could imagine, of course, a good, uh, you [00:59:00] know, a vendor that. Provides open source data, but like zero support. That, that's fine. Like, it would be a a very interesting model too. Uh, but I think typically what will happen is that, you know, the vendor will provide both like more open source collateral and better support just because, you know, even his own team is like, is more productive, right?

[00:59:20] Michael: They, they're like, they can navigate all of those things, uh, easily and point to links. Like, you know, you can send someone a link, right? And here's the thing, [00:59:30] you don't have to like say, please log in with your credentials. I remember we were buying some proprietary tool and like the amount of time we spent just like getting a license and trying to log into places and it's, it's just ridiculous.

[00:59:42] Chris: is there anything more like defeating as an engineer to be like you, you know, like, okay, I'm gonna go sign up for this new tool.

[00:59:49] Chris: Alright, it's proprietary, I'm fine, I'll get it, whatever. And you put in your information, you think you're getting a sign up, and then it's like, thank you. We will get back to you in 48 to 72 hours.

[00:59:57] Michael: Yeah.

[00:59:58] Chris: What? What? [01:00:00] No, that is not how this is supposed to work.

[01:00:02] Michael: Yeah, yeah, of course. Like, I, I wish

[01:00:04] Chris: office and shake your hand and say hello to you and make sure they get their commission.

[01:00:08] Michael: yeah, I think that's, yeah, that's maybe one of the problems is there are things that you can just easily buy. And of course a lot of the new SaaS wave companies and so on, they have a very different approach. Like, you, you wanna buy something, you just click a button that's there.

[01:00:21] Michael: So, so it's definitely, there is a good way to sell things that are proprietary and, you know, come with like a good user experience and everyone's happy. So I definitely don't [01:00:30] wanna be like saying it has to be free, otherwise, you know, go away. We, we ourselves, you know, charge people for services. So it's, it's not that proprietary stuff is bad or charging money is bad.

[01:00:41] Michael: It's just like very often, unfortunately, experience is horrible on many fronts. Uh, you both pay for it, but also as you said, you get like mistreated kind of, and

[01:00:51] Chris: yeah. It's like, oh, you're big, but you're not big enough to get all of our attention. So take the scraps. You get pian [01:01:00] talk. Can tell Chris is at a small company right now. Uh,

[01:01:05] Michael: so, but, but in any case, we're trying to fix at least some of these problems. We're definitely not gonna be able to fix everything. But the good thing is we're working with, you know, for example, right now, this demo with, with analog devices, right?

[01:01:16] Chris: Yeah, yeah,

[01:01:17] Michael: they've been

[01:01:17] Chris: so you, you were helping on the, on the vs code stuff as well. 'cause they, I, I had talked to Kevin, oh, I forget Kevin's last name, sorry. At Analog, um, Townson. Yeah. And, uh, yeah, so I, I know he's doing a lot of the Zephyr stuff there. [01:01:30] I tried out their tools. It's interesting.

[01:01:32] Michael: That, that is their great work. No, no, no. The, the, the initial set of plugins is absolutely them. But we're working on the auto ML plugin with them right now. And, uh, of course, like they're basically doing, I. Things that we probably would've done, just, just like they did to them, right? Like I saw the, the plugins they released last year and, uh, I was really excited.

[01:01:49] Michael: It's, it's good stuff, right? Well designed, you know, nice to look at, nice to use. Uh, so we're, we're kind of following that playbook and, uh, and, uh, automobile plugin will be, you [01:02:00] know, part of that family.

[01:02:01] Chris: Got it. Yeah. I feel like having the, it, it has been a big unlock for a lot of the Zephyr tooling. You know, like when we, when Zephyr Yeah. When Zephyr was kind of getting started, not started, but like when I, when I started with Zephyr at Goliath at least, it was like a lot of command line only.

[01:02:18] Chris: And now there's just been more and more vs. Code plugins just kind of brings, kind of like broadens the base, what opens the tent a little bit more and, and, uh, makes it kind of more, it's not a pure [01:02:30] IDE right? It's not like, uh, uh, uh, eclipse IDE that gets delivered to you again as a, like a dot XE that goes in on windows, which some people expect.

[01:02:38] Chris: Uh, but I think it's, uh, it's kind of a good middle ground that, that makes it a little more accessible,

[01:02:45] Michael: Yep. No, absolutely. I'm excited for Zephyr and, uh, pretty much everyone is at least asking about Zephyr. Not everyone's using it yet, but it's definitely out there. And, uh, at some point [01:03:00] it'll just like the economies of scale just, just happen and you have to use Zephyr because other people require it and you know, you have kind of no choice almost.

[01:03:09] Chris: yeah, I think a lot of the vendors kind of following each other as well has been beneficial for, again, as hardware engineer, it's like I get to see that they all want to put more support in and I'm happy to see it.

[01:03:21] Chris: And kind of more options that I can switch between is, is better for me. Um, kind of opens up the

[01:03:26] Michael: and sometimes we help them too, right? Like there, there's been vendors whom we've [01:03:30] kind of brought on to Zephyr. And of course, like ultimately you want them to also build up the capacity internally. But, uh, uh, you know, sometimes you need a little push and, and that's what we're here for as well.

[01:03:41] Chris: That's great. Yeah. we did not talk about your chip stuff. Uh, you've been doing CHIPS Alliance stuff. You've, I think the first time you came on, you were talking about CHIPS Alliance, uh, very quickly. If what, what is kind of going on in the CHIPS Alliance world?

[01:03:56] Michael: Ooh, lots of things. So maybe one major thing is katra, a [01:04:00] root of trust. That's been kind of, uh, uh, that's joined Trips Alliance as a project. And that project involves some big guys like Google, Microsoft, A MD, and Nvidia. And, uh, we've been helping them to, you know, uh, first of all just, just kind of maintain and develop the core, the risk five CP core in that system that's kind of at the core of the system, let's say.

[01:04:22] Michael: And, and then, uh, also some other, you know, peripheral io as well as just like purification and, and some integration. So [01:04:30] generally speaking, Katra, uh, is this root of trust project that multiple parties have aligned on and, you know, uh. They want to continue developing it so that ultimately everyone can adopt it for their chips, that they're gonna sell to them in the data center.

[01:04:50] Michael: And those chips will have like, unified security, they will have, you know, the same RTL in there, the same software, uh, making sure that, you know, the supply chain [01:05:00] stays, you know, uncompromised, that everything's as advertised. So calypso's really, really a huge endeavor in trying to increase the security of servers, um, prevent like, you know, malicious actors and so on.

[01:05:13] Michael: And I think it's very important, um, in these times. Um, and like supply chain security in general is something that we look at from multiple perspective also with, with the system designer, right? Um, so I'm very happy that Kali's there and, uh. I'm happy to be involved as well because [01:05:30] it's a multi-party project where you have to collaborate, like you're forced to collaborate even though maybe in some other fields, those companies are rivals, right?

[01:05:38] Michael: Uh, but for security, they just have to figure out a way to make it uniform because you're not gonna have a hundred suppliers, uh, you know, develop a hundred different security solutions to be tested a a across like a number of, uh, cloud solution providers. You know, like the, the, the complexity explodes.

[01:05:57] Michael: You have to like unify, you have to [01:06:00] standardize, and that's what CHIPS Alliance is about. It's like you find a common goal in the hardware space because, and software is much more. Uh, well known as, as a problem and much more widespread to, yeah, we're gonna build an open source project to solve everyone's problem.

[01:06:16] Michael: In hardware, it's a little bit less common. Of course, there are standards, right? But very few open implementations of standards, and that's what chips size is trying to change, is that you don't only get a standard and now go [01:06:30] implement your own version of it, and then everything's different anyway. Or you have to like really carefully certify everything,

[01:06:37] Chris: everything.

[01:06:38] Michael: but instead it's like, here's a standard, but also here's an implementation.

[01:06:42] Michael: Just go and use this implementation and we're gonna like, pull resources to develop this implementation together. Maybe with some, you know, different ways to modify it here and there, but like generally speaking, you know, 99% of what you're doing is exactly the same. So we can vouch for IT security, we can even like do [01:07:00] a.

[01:07:00] Michael: Formal certification process, which you know, you can just piggyback on, right? That's, uh, what, um, Calera is about,

[01:07:09] Chris: is about. Okay. Yeah, it's interesting. Yeah, we had, uh, guest, uh, Laura on this show talking about, it was the first time I'd ever heard of RU Trust's stuff. So I, you know, I'm not in the server world, but it did seem like, like the, how are you sure that the server you're talking to is the server you think it is?

[01:07:24] Chris: That is kind of always the, that feels like that's the core of things. And, and so it seems like the clip project is [01:07:30] kind of helping move towards that, like, again, across multiple vendors and, and so that every, everybody kinda has a common language for understanding which server they're talking to at the time.

[01:07:40] Michael: Yeah. And as a last kind of comment here is that, uh, the re the, because everyone's kind of forced to collaborate here, you can also think about unifying workflows and building open source tools that help you be more efficient across companies, not just inside a single company. We can just, we can afford, because a single company can always afford to just [01:08:00] like, you know, purchase one stack from someone and sign all the relevant NDAs and just get going.

[01:08:05] Michael: Right? But maybe Company two does the same thing except they're using a different vendor, right? And Company three is using a mix, and then like, it's really hard to collaborate versus like thinking about how to build this into a scalable infrastructure where some of the tools are maybe open source and some of the tools are maybe more standardized so that you can, you know, more easily just, uh, make people exchange artifacts and talk about things [01:08:30] without having to, uh, you know.

[01:08:33] Michael: Fully copy another company's set up top to bottom right, which, which might be even impossible.

[01:08:40] Chris: Yep.

[01:08:40] Michael: So yeah, it's a fun challenge to have and we're happy to be solving this. And there's a lot of good little open source projects that are kind of coming out of it because we, we can have to solve real problems.

[01:08:51] Chris: Yeah, that's great. Well, Michael, where can, uh, people find out more about you? An Micro Chips Alliance, stuff like that?

[01:08:57] Michael: Yeah, so we've actually built a new [01:09:00] site called Offering dot on micro.com, and this offering is like an interactive website with, uh, you know, uh, different parts of our, uh, work. So like hardware, software, ai, cloud, um, Reno, of course, um, and fpg and ASIC stuff. And if you go there, you'll see like a bunch of interactive slides with some cool graphics that, you know, you can kind of click around and make things happen to illustrate different, you know, problems that we're solving.

[01:09:25] Michael: So there's gonna be a slide for Katra, there's gonna be a slide for, um, our work with [01:09:30] Ator, for example. There's gonna be slides for many slides for Reno, actually some slides for Kenning. Uh, so you'll be able to get a feeling for what do these things actually do. And the cool thing is, because they're open source, most of the time you'll, you'll just get a link and like, here's the GitHub revo, right?

[01:09:44] Michael: Or here's.

[01:09:44] Chris: Yeah.

[01:09:45] Michael: blog note that describes how to run it on your computer. Uh, that I think is the, the, the nicest part is that, yeah, it, it's kind of a sales pitch, but it's also like a repository of good technologies you can try out for yourself.

[01:09:57] Chris: This looks like Index J on here.

[01:09:59] Chris: Huh? [01:10:00] Like the slide, the slide, uh, software. Something like it? No, sorry. The, in the, the slide software That looks like the slide software is Index J, or No, I've used that for pro uh,

[01:10:12] Michael: yeah. I think it's originally is based on reveal

[01:10:14] Chris: Reveal. Oh, cool. Oh, reveal. Oh, maybe that's what it is.

[01:10:17] Michael: Yeah. Mm-hmm.

[01:10:18] Chris: Yep.

[01:10:19] Chris: Okay. Cool. Well that's great. Yeah. This is a,

[01:10:21] Michael: Have a good eye for this. Yeah.

[01:10:22] Chris: lot of stuff in here. Wow. This is really cool. Um. Well definitely, uh, offering aunt micro.com. [01:10:30] Find Michael online. Lots of different places. And, uh, yeah, it's, uh, thanks for, thanks for being back. I'm sure we'll have have you on a fourth time to talk about all the new things you've you've done in the meantime.

[01:10:38] Chris: So thanks for being here, Michael.

[01:10:40] Michael: Thank you so much for having me. Have a good day. Cheers.

[01:10:44] Chris: Alright, I'm gonna stop here and.

[01:10:49] Michael: Thank you.