Radar System Engineering: From Requirements to Deployment - MATLAB & Simulink
Video Player is loading.
Current Time 0:00
Duration 39:08
Loaded: 0.42%
Stream Type LIVE
Remaining Time 39:08
 
1x
  • descriptions off, selected
  • en (Main), selected
    Video length is 39:08

    Radar System Engineering: From Requirements to Deployment

    Overview

    Multifunction radar system design spans a range of tasks starting with requirements analysis. Once requirements are understood, the process moves to design and implementation, integration and testing, and eventually to field data analysis. In this webinar, we will show how you can integrate these tasks using modeling and simulation tools.

    Through a series of examples that include airborne, ground-based, shipborne, and automotive radar systems, we will start with the requirements analysis work and translate the results into designs that can be simulated with probabilistic models and I/Q signal level models. We will show how these modeling options help you pick the right level of fidelity for the project phase you are working on. You will learn how synthesized radar data can be used to improve your design choices, how design models can be shared across organizations, and how testing data can be used to shorten integration cycles. 

    Highlights

    You will learn how to:

    • Perform link budget analysis and evaluate design trade-offs interactively with the Radar Designer app
    • Connect your radar workflows including requirements and architecture analysis, system design, and verification
    • Simulate radars using statistical models and signal-level models
    • Model closed-loop, multifunction radars
    • Deploy radar signal processing algorithms to processors and FPGAs

    About the Presenter

    Rick Gentile works at MathWorks where he is focused on tools that support radar and sensor fusion applications. Prior to joining MathWorks, Rick was a Radar Systems Engineer at MITRE and MIT Lincoln Laboratory, where he worked on the development of many large radar systems. His focus was on signal processing and system integration. Rick also was a DSP Applications Engineer at Analog Devices where he led embedded processor and system level architecture definitions for high performance signal processing systems. He received a B.S. in Electrical and Computer Engineering from the University of Massachusetts, Amherst and an M.S. in Electrical and Computer Engineering from Northeastern University, where his focus areas of study included Microwave Engineering, Communications and Signal Processing.

    Recorded: 23 Aug 2022

    Hello. My name is Rick Gentile. I'm the product manager for radar and sensor fusion products at MathWorks. Welcome, and thank you for attending this webinar on Multifunction Radar System Development.

    Our goal is to make MATLAB and Simulink the preferred platforms to develop radar systems from the analysis of real data to using more simulations for the design, deployment, integration, and testing of radar systems. Now, in 2021a, we launched Radar Toolbox, which is focused on helping engineers design, simulate, and test multifunction radar systems.

    In this webinar, I'll show you how Radar Toolbox helps with the analysis, modeling, and simulation across the entire radar lifecycle. I'll go through examples that demonstrate four areas of focus, radar system engineering, radar scenarios and data synthesis, multifunction radar, and AI applications and radar. Now, it's important to be able to evaluate your radar system performance early in the design cycle. And this could be at the project start or this could also be at the stage where you're considering an upgrade.

    So if we look at the building blocks for the radar system, the antenna and RF, signal processing, data processing, and resource management control, we can think of a bunch of different parameters that describe the radar, things like operating frequency, and bandwidth, and the types of information that you would normally use for your design, the hardware, the processing, scanning. These are all aspects that need to be considered as part of your design trade-offs.

    Now equally important to the system, the hardware and software design of the system, we have to account for all of the complexities of the environment, as well as the target. Now, for the environment, this includes everything from clutter to atmospheric conditions, precipitation. These are all aspects that make radar system design challenging. For this, we've introduced a set of functions that I'll just quickly scroll through here that give you an idea of the types of functions. We have detection and tracking statistics, radar equation-based ones, environment and clutter, and also functions related to synthetic aperture radar.

    Now these functions are all focused on helping you make calculations and also generate plots that are required as part of the radar design process. So Radar Toolbox includes many built-in plots and metrics that let you compare the predictive performance with a requirement that you set for your system, for example, the signal to noise ratio available at the input of the receiver for any given range compared to the detectability threshold. This is an example of a stoplight chart, which makes it easy to visualize which requirements are met, which ones still need work.

    Additional plots that can be generated are shown here. So these are the types that you can use these functions that I showed you to generate these plots easily with either the app that I'll go through next, scripts, or some combination. So here you see on the top left the scene geometry. You can look at the Blake Chart for vertical coverage, clutter-to-noise ratio over range, and range/doppler coverage as well. I'm going to show you these actually in action when I talk about the app.

    I showed you quickly the list of functions. But for SAR and also for MTI radars, we have several sets of functions and several examples that you can use to get started in that up front portion to do the design and analysis. Now later when we get into the modeling and simulation portion of the webinar, I'll show you these same types of applications and how you can generate IQ data or probabilistic detections and tracks from these types of systems as well. I scrolled through quickly just to make you aware of the functions. It's hard to go through each of the functions in a webinar format like this.

    So I just wanted to make you aware of them. But one thing that I do want to expand on is an app that we introduced with Radar Toolbox, which is called the Radar Designer app. I'm going to show you this app in the next demo.

    But just to give you an idea, there's five built-in configurations that you can use to get started. These are just to help you because there's so many parameters you can figure for a radar. Once you customize these to your own radar systems, you can save them and share them with your colleagues or pick them up in a later session to do further evolution.

    The purpose of the app is really to help you evaluate radar designs compared to your thresholds and your objective requirements for given scenario conditions, so a specific target in a specific environmental condition. The nice thing about this as is the case with all of the apps that we have in the radar area-- when you're done, you can generate a script and/or format a report that you can then use to further extend.

    Let's take a look at the app in a demo. You can see there's a couple of different aspects. The tool strip may look familiar if you used an app before. This has the ability to create a new session or open an existing session. You can save the session you're in and pick up later or you've got the ability to generate pre-configured plots, clutter-to-noise ratio, detectability, environmental losses, probability of detection versus range, and range/doppler coverage.

    Over on the left, you can see the radar parameters. This starts with things like the frequency, the bandwidth, the power, PRF. There's hardware information. When you get started, you can pick a new session.

    As I showed, there's multiple pre-configured systems. In this case, I'm going to open up a session that I've created in the past. So this will be the design that I'm having here where I'm looking at the performance of the system to detect a small target. You can see on the left the types of parameters that I've included here.

    It's possible to add a design or duplicate the one you're looking at. In this case, you can also look at probability of detection versus the maximum range. The panels here allow you to quickly generate the plots directly to analyze what you're looking at. On the bottom, you can see that the design parameters either show up as green, yellow, or red. This, again, indicates whether or not you're meeting your thresholds, your objectives, or neither, or both.

    The environmental parameters are rich. You can include here-- if I uncheck free space, you can see the different types of parameters that start to pop up. Here I'm changing to Curved Earth. I've got other information about the atmospheric model I'm going to use, the surface type of the Earth, as well as precipitation information, rain, gas, or fog in the propagation environment.

    In the middle, you can see the information on the signal-to-noise ratio versus range, the environmental losses. Here I'm evaluating the design against a small target. So I've changed the cross section here. I've got a swirling model. I can give some information about the target. And as I scroll through the design, I'm able to verify that my design is met.

    Now we have a whole set of examples that walk through this in more detail, as well as a short video. So I encourage you to take a look at this in more detail. One of the things that we do here now is whatever design we create in the system, whether it's one or more radar system designs that we're comparing, we have the option of exporting this information. And we've got two ways to export the information.

    One is going to be where we generate the code to generate the plots that we created there, in this case, the signal-to-noise versus range plot. The nice thing about this is when you hit Export and you get this code, you can now run it in MATLAB and generate the plots. And you also have the functions that were used to create that analysis.

    The other option was to generate a matrix report. And if you do that, what you end up with is the full set of metrics that you created in the design. So, again, a MATLAB script, if you run it, you're able to generate the table of information that you used in your design. Notice also at the bottom there's a line that's commented out. That actually gets generated if you uncomment it, you can then run that line of code and generate a spreadsheet with this information.

    So, again, I run the code here. You see the XLS file is generated, as well as a metrics table in MATLAB that has all the key information for your design. Again, this could go into a report or it could be shared with your colleagues. One of the areas that we highlight in the functions that I talked about is detectability, building up a analysis that says whether a specific target will be detected. We can take that information and then with our mapping tool box plot on a map.

    So in this case, I've got radar in the distance. And I've got terrain with an aircraft flying over in sort of a corkscrew maneuver over the terrain. And you can see in this view anywhere where it's red there's no line of sight to the radar. And as the altitude increases, you can see the non-red colors animating. And that means that the target is in the line of sight during those times.

    Now, probably, if you've been working in radar, you know that line of sight doesn't necessarily mean the target is detectable. But with the analysis function that we used in the app and in the radar system engineering section of the toolbox, I can then iterate on the design to increase the detectability. So what you see on the left is red here is actually-- it's either there's no line of sight or the SNR is not sufficient to detect the aircraft for this system configuration.

    So here green is it's detectable. And red means that either there's no line of sight or the SNR is too low. So it gives you a way to iterate on that upfront design and also map it to some kind of terrain as well to figure out how this will look.

    We've also connected the workflows to our Simulink products, including Simulink as a platform but also with System Composer where we bring in requirements in Simulink requirements and connect them to radar architectures that we can build in System Composer. We use apps like the Radar Designer and the Sensor Array Analyzer. Maybe you're familiar with Phased Array System toolbox, as well as the Pulse Waveform Analyzer to further refine the design of the system.

    And then we connect the radar requirements to the radar architecture we build to the design parameters. And we're able to have traceability. What's nice about this is for folks that build larger systems, being able to generate traceability matrices from both the requirements to the design and also connecting and closing the loop with test. So we have two sets of workflows, one that takes it through requirements and to architecture and design and then one that further extends that to the detailed design to Simulink test process.

    And in this example, what we do is we build up the Monte Carlo testing and walk through how we can generate the testability matrix and show how we can add test scripts to verify that the requirements are met. And this is a great process to also automate how to handle changing requirements. This happens a lot on large projects where the requirement will change. And what's nice about this linkage and this integration is that when the requirement changes, you can ripple through architecture, design, and test and highlight immediately which pieces of the system are impacted by that requirements change. And that greatly simplifies the management of that process, right?

    So this is really through this traceability matrices and the testability matrix to figure out what's been tested, how does it relate back to the design, and how do I manage change? There's examples in Radar Toolbox that walk you through this. And this will be a topic of a future webinar. But if you're interested, also, I encourage you to check out our website.

    The other big piece that we've added in is the improvement and expansion of the radar scenario. So this is really about authoring surface air and space scenarios. And for this, you can generate platforms and targets. You can give them radar signatures that vary with the aspect angle, that the radar sees the targets. They're also frequency dependent. You can model trajectories with kinematic properties, acceleration, velocity.

    You can use waypoints to generate these kinds of systems. And you can mount radars on various platforms. And the nice thing about it is that the radar doesn't have to be mounted in the same direction the platform moves.

    So you can have a UAV with a radar mounted off the side. And that radar can also be electronically scanning. We have the concept of INS sensor. This helps for platform self-awareness and helps with the frame conversion as you have complex scenes like you see on the right.

    And the other thing is that you can generate radar data now for I/Q signals, which is something that Phased Array System Toolbox has enabled for a while but also at the detection and track level. Another nice thing that's been included is the ability to perturb ground truth and sensor parameters to increase testing robustness. What this means is you can define a radar sensor. You can define trajectories either for the platform that the radar is on or the targets that move around the radar. And with just a few lines of code, you're able to perturb those to generate lots of data from a single data set.

    In terms of radar target models, I mentioned the ability to model RCS by aspect angle, azimuth and elevation, and also the frequency dependency. So this evolves to a cuboid world of target parameters. We have functions to help you with generating RCS for basic shapes. You can put those kinds of targets together to form multi-scatterer objects.

    And through superposition, you can build up more complex structures. If you prefer to have solved systems, our entire toolbox is a great place to solve for RCS as well. Lots of examples in Antenna Toolbox toolbox to do that. If you have that from collecting in a chamber, or from field testing, or from other solvers, it's easy to map that data into the RCS pattern container that we use. And then in any of the models that we have, you can digest those and use the RCS you've pulled from your other sources.

    Of course, with the complexities of a large theater system and building on what I talked about where the sensor may not be mounted on the platform in the same direction, it's very important to have the option for multiple frames. And so we consider the global frame, the platform frame, and then also a local frame on the platform. It's local to the sensor to account for the bookkeeping as platforms are banking and the radar beam is looking in a certain direction. Being able to keep track of all that is also a key aspect of the scenario generation portion.

    Radar Toolbox provides the building blocks and the modeling components to help you generate I/Q signals directly. Now, these types of models are sometimes called waveform level models or physics-based models. I'll talk some more about those as we move forward in the webinar. But radar models in Radar Toolbox also can be used now to generate detections, cluster detections, or tracks. And these types of models are referred to typically as measurement-level models, or probabilistic, or statistical models.

    Now, for the physics-based model, we can account for all of the basic building blocks in the system. This is everything from the waveform or waveform libraries, the antenna design, perhaps it's a phased array front end polarization, frequency, transmit and receiver gain, peak power. These are all aspects of the radar that are required. And the idea here is that the signal that you return from the reflection of the target or the environment is then processed. Signal processing algorithms can be applied to generate detections or cluster detections.

    And whether it's automotive or in aerospace and defense applications or commercial applications, you have the ability to layer on top of the basic radar model to extend the fidelity, for example, Antenna Toolbox can be used to design and solve the antenna structure to use as the front end of the radar. RF toolbox, RF Blockset can be used to extend the baseband modeling to include the effects of imperfections in the system or distortions through circuit envelope simulation.

    A lot of different models to get started with. I just showed two here. We have a lot of collateral on our website and our product pages around I/Q modeling. And we'll talk some more about it in this session as well.

    Now, one of the new things that we've added in is something called radar data generator. And this is the radar model that we use to define the statistical or probabilistic models that includes where the sensor is mounted, what type of scanning parameters, the detection reporting specific information that gets generated when we build a scenario and use this as our sensor model. You could see also it includes things like measurement resolution bias.

    With one parameter, we can move between detections, cluster detections, or tracks. We'll talk some more about that. We also have some information about, of course, as you'd expect probability of detection and probability of false alarm, all the detailed parameters that you can use to model your system.

    When you do configure it to generate tracks, you also have additional settings that you can focus on to determine the information around the track information. I'll show you an example of that coming up. There's a lot of parameters here to configure. They all have smart defaults to actually get it running quickly. The out-of-box default settings are set to run quickly. So really with just a few parameters, you can start generating radar data.

    Now the thing is if you want to customize this for your own radar system, once you've set these parameters, you can put it under configuration control and then share it with your colleagues as well to represent the radar that you're looking at or perhaps the radar that your company builds or evaluates. We're going to use this building block to generate radar detections in our statistical models coming up. So I want to start with an example where we do that. And I'm going to focus on probabilistic models. And in one case, we're going to generate detections, and I'm going to show you how easy it is to turn the switch to generate tracks directly from the same model.

    So in our system, we've got a scanning radar that we set up. You can see on the left the scanning is first done in azimuth. And then we increase in elevation. And we just repeat. So you can see the beam pointing on the right and the scanning pattern looking out the boresight of the radar.

    Of course, this looks like a saw tooth in azimuth and a stepwise change in elevation. And when we run this kind of a system, we're able to generate radar detections. And in our scenario here, we have two targets.

    The position errors that are generated from the detections are based on where the target is located in the scene and also the radar parameters that we've modeled. So you see for target one and target two we've plotted the position errors over time. These are statistical detections that get generated that we could then use to either model a system to get an idea if it was going to work or also if we were going to feed a tracking algorithm. Perhaps I'm developing a tracker and I want to get test data to be able to test that.

    Now, in some of the cases where you might be generating tracks you want to feed into a larger system of systems or maybe you're building a track level fuser, you can generate tracks and track covariances directly. And so I'll show you this on the next slide. But with very little code, you can switch between the same thing. So you've got colleagues on your team that some are doing signal processing. Some are doing tracker design. Some are doing system engineering and looking at the whole system.

    You can just turn one knob and be able to generate different kinds of data from the same system to start with. So you notice also the information here. The detections for target one also translate into tracks. And in the case of a track, you can see that the target's actually moving in this direction along this line.

    And the track covariances are generated as well. So as the tracks are being generated, they start to converge and get closer as you'd expect to some target that was in track. And you also see that for target two where you start off with a larger covariance. You get additional measurements. And over time, you can see the covariance gets smaller.

    Notice also how these track to the sizes of the information. So in this case, target one actually has additional measurements. But the RMS error for each of the measurements is much larger. And that's based on where the target is in the scene and at the actual parameters of the radar how they generate detections.

    Let's take a look at some MATLAB code here. So the Radar Data Generator has many parameters. And as I mentioned, there's a lot of defaults that probably just work out of the box for you.

    In this case, we've customized it. You can see I've just highlighted this target report format detections, as highlighted in yellow. So in this case, for the first portion of the example, we're just generating detections. Just like in our Sensor Fusion or Tracking toolbox, we have this object detection format that we use where we give the time that measurement was taken, information about what the measurement is, measurement noise, which sensor it came from, and some additional information, including, in this case, the SNR of the target in our object attributes.

    Essentially, this is defining the measurement of radar detection. Now, with one change, really just a few parameter change, we're able to set instead of detections, which I have up here-- I set it to tracks, and I give it the track coordinates, which in this case is for our big scenario. And now, instead of being able to generate the detections, we're generating tracks. And in this case, it looks a little bit different, right?

    There's some additional information from between a track and a detection. But this is really what we're using in the previous plots that I showed you to generate detections or tracks. So very simple to move between these, generate a scenario, and hook up the radar data generator model.

    Now I'm going to show a simple example here that builds on that radar data generator to build a starting point for you for IQ simulation. Right? So you have the option of building up an IQ simulation from the start in all the building blocks that I talked about earlier, waveforms, and antenna arrays, and all the aspects of the system. So for this example, I want to show a simple scenario.

    Radar is in the middle. It's the blue square. And we've got three targets that are in the field of view of the radar. The radar has a beam. It's going to be scanning around, mechanically, in this case, through the field of view. So I just have it on one target just to illustrate what's going to happen here.

    So this is the ground truth. Now I'm going to define a radar data generator here that's rotating, right? This is going to be-- this means that this beam is going to rotate around. I give it an update rate, where it's located. And with a simple loop, I'm able to generate detections. You see I've got this sensor model. Sensor is radar data generator. I've got three targets in the scene. I'm advancing the simulation time. And with this loop, I can build up detections.

    Now, I'm only running this through one time. But in the end, what I've got is if I run this code, I can see that the diamond, which is statistical detection, shows up on each of these targets. OK? Pretty simple so far. Nice small loop, simple to define the radar definition, and we end up with three detections. OK? So that's sort of a real simple case of a measurement model.

    Now, if I take that definition of my radar data generator-- and that was what I referred to as the sensor definition on the previous slide-- and I put that into another building block that we have that we call radar transceiver, now I can use that same definition, same scenario, and put it in a very similar-looking loop. The only difference in this loop is that we've got the sensor IQ definition here that's going to generate a signal instead of a detection.

    And then we're going to process-- by the way, when we generate the signal, and look at the signal here for one of these targets, it's going to look like-- as you'd expect, there's going to be some range. We're going to get a detection. And we can process this data. And in this case, it's a simple threshold detector, but you can imagine adding your own signal processing or using one of the building blocks that comes with Radar Toolbox, CFAR detector for example, and generate the detections that go onto that same signal.

    When I run this now and generate the detections from that system, I've got a set of detections now represented by the circles here to show that from a ground truth standpoint, the triangle, the diamond-- the green diamond-- is statistical detection, and the circle is the IQ detection that's been processed from our signal. OK? Why is this important? Well, it's important because you can, again, use the same scenario to live between the different abstraction levels. You can have the same model that's shared across different disciplines on the team to be able to generate data for this kind of system. And it's also a way for you to get started easier.

    So you can roll up your sleeves and build up your IQ from the start, but if you've been working in the probabilistic level and you want to move to IQ, this is a simpler way to transition into the IQ model. So now I want to look at a little bit more detail of the radar transceiver that we have here. This is just a little bit deeper view of sensor IQ, which includes the building blocks for what goes into a radar, right? This is the one that we use to generate the IQ data. And you look down the list, you can see the familiar building blocks I talked about earlier, waveforms, transmitters, transmitter antenna, receiver antenna, and so on.

    Now, to make the model match what we do in the probabilistic world, the specific parameters for things like the waveform or the transmitter can be accessed directly. And what's nice about this is if I just look at what sensor IQ transmitter array sensor is, this is what my beam pattern looks like. It's kind of an idealized beam pattern.

    But I can leverage building blocks in the Toolbox to extend. So if I want to, for example, change the antenna pattern, I build up a small linear array with four elements and use the cosine and 10 element as a system. And now I have a new pattern. I could do the same thing with waveform. I could do the same thing with specific radar parameters. So now I've got the starting point for my IQ model. The theme here is same scenario across different abstraction levels, and also an easier path to go from probabilistic where you just configuring the radar data generator and running it through this function, this radar transceiver workflow, to build your starting point IQ model.

    OK. So with that example in place, it's a very simple example in terms of the scenario. A single radar with three targets is more focused on the plumbing of the workflow. But I want to remind you that this type of modeling architecture scales to larger systems. You see multifunction radar, air traffic control systems, maritime surveillance, networks of radar systems, satellite-tracking radars, space debris-tracking radars, so lots of examples where this can be applied to larger system models.

    Now, while we're on the theme of radar data synthesis, I also want to highlight an aspect of radar data synthesis, which is in micro-Doppler, so the ability to model and process systems that have exhibited micro-Doppler features. Here you see aspects of pedestrians and bicyclists, things like propellers. Any rotating objects can be modeled, and the micro-Doppler can be used to extract features and determine things like what the object is, what type of motion it's using.

    We also make it easy to simulate multipath propagation effects. And this includes scatterers, the transmitter and the receiver, from reflections off objects in the scene. I'm going to show you an example next that's automotive-focused that really highlights the nature of the multipath features.

    All right, let's go into a little more detail now using an automotive example. And for this, we'll use the radar data generator and a scenario that we built in Automated Driving Toolbox to build up the reflections from multiple bounces, so, in this case, either a guardrail or other objects in the scenario. And the idea here is that we can build up something that looks like what a system would see.

    So you can imagine here the ego vehicles, the blue vehicle. The other objects are there. You see the guardrails on either side. And you can generate the detections directly from these kinds of systems. And we have examples that help you focus on building up these ghost detections due to multipath as well as a great example that connects to multi-object tracking with our Sensor Fusion or Tracking Toolbox, where you can evaluate the impact of these ghost detections on trackers as well. So I encourage you to take a look at these in more detail if you're interested in multipath.

    We also have continued to expand what we do for clutter returns. And this is very helpful for the signal and data processing algorithms. You can use your array. You can define a patch of clutter, and different examples that show clutter being generated, and then also signal processing algorithms that you can use to remove the clutter from the scene. I also highlight here an example where we use the GPU to accelerate the simulation of clutter in the model.

    We also model polarization. And I highlight this example because this is something that shows the performance of a model of NEXRAD compared to the system performance of actual system itself. We use the polarization data from the National Weather Service, in this case, to generate the scenario that we're building. And, essentially, we simulate a polarimetric Doppler radar, and we look at the returns. In this case, weather is the observation in the radar system.

    So that brings us into the next section. And this is the area for multi-function and cognitive radar. And I want to mention here the algorithms for processing a radar data cube. So this is really an output of what you would get from your IQ simulation. This includes algorithms for beamforming, match filtering, Doppler processing, also algorithms around generating the detection, so CFAR, 1D, 2D CFAR detection generation clustering.

    So what happens when I get multiple detections from the same object, same target? I want to be able to cluster those together. We have algorithms to do that that are based on DBSCAN, and then, finally, including multi-object tracking. Now, we include a multi-target tracker in the Radar Toolbox. We've got some nice cross-product workflows that show you how to extend for more complex applications using Sensor Fusion or Tracking Toolbox. So I'll show you an example of that coming up.

    I also want to mention that with MATLAB Coder, HDL Coder, and GPU Coder, you can build up code that you can deploy to hardware. And for signal processing, you can do all of the signal processing algorithms in single-precision C code using MATLAB Coder. And this includes things like beamforming-- the ones I just mentioned, beamforming, DOA overestimation, CFAR, range Doppler.

    From an HDL standpoint, we also provide workflow examples that you can use to go through and implement these also on an FPGA. And then, finally, for data processing, these are typically deployed to a processor. So, again, MATLAB Coder can be used to generate multi-object trackers. This is an area where it really helps you speed up the simulation if you generate C code and run them by large factors. We have examples that show benchmarking on that. So I encourage you take a look at those if you want to either prototype onto hardware or, in some cases, simulate-- or accelerate the simulation speed as well.

    Now I want to talk about example for search and track radar. And this is something that we've been building out, where we can generate the echo, perform the signal processing, and use the information from the detections to feed a tracker. The tracker can then predict where the targets will be. We can feed that information to a radar manager to determine what the next waveform will be or where the next beam should be pointed.

    With Radar Toolbox, we've expanded how this is done. And we have a really nice example to show active and adaptive tracking in a multi-function system. So in the previous example that I just showed quickly, that was actually an IQ model where we were generating detections from a phased array-based system and doing all the signal processing that goes with a changing waveform.

    This is a longer simulation scene, and it consists of six maneuvering targets. And what you see is the radar is scanning through these, and on the bottom, you can see this item 0 here, this is how much resources are allocated each second. Anything that shows up here in 0 is a search job. And anywhere that's 1 through 6 is reflecting where we're tracking an object.

    So the idea here is that you can evaluate your system and see how much time and how many resources are spent on different aspects of your radar task load. And as part of this activity-- we've talked about this already-- but we generate this scenario. We've got the radar model. We're generating detections. And then we're pointing the beam in areas where we think the targets will be. And then when we're not doing that, we're searching for other targets.

    In the example, we go through active tracking, which is basically that the same revisit rate is used for all targets. And the downside of that is that you can get good tracking performance, but you'll use up more resources for tracking. And, as an example, at some point, when you get too many targets, you'll stop searching for new targets.

    So with adaptive tracking, you can change the revisit rate based on whether the target's maneuvering. That is, if the targets are maneuvering more often, you can increase the revisit rate for those targets. And for objects that aren't maneuvering, you can expend less energy on them from a radar resource standpoint. So you basically do updates less often.

    And in that same scenario, just by applying adaptive tracking, you can increase the amount of resources that you apply for searching for new objects or new targets in the field of view, and you can still get the same results from your tracking scenario. So this is an important aspect because it brings some of the things we talked about together, right?

    I've got the ability to set up a complex scenario. I've got the ability to model the radar scene. And if I need to, I can focus on specific areas at the IQ, similar to what I showed in the search and track radar just a few slides ago. But I also can then evaluate the performance using some of the metrics that are there to say, well, can I expend less energy on these targets, focus the energy where I need to, that is, when a targets maneuvering, give it more energy so we keep the object in track during those times?

    OK. Before we end, I want to talk about artificial intelligence for radar applications. Now, MathWorks has a range of workflows across the full spectrum, everything from the up-front data collection, data synthesis, pre-processing and transforming data that we feed into networks, wide range of tools with Deep Learning Toolbox and Stats and Machine Learning Toolbox to build the models, and then a whole range of options to accelerate and deploy to platforms like processors, FPGAs and GPUs.

    Now, Radar Toolbox is focused on creating data sets and accessing data sets for radar, so really about data synthesis, using the data synthesis techniques that we talked about earlier in the webinar. And we have a series of examples that span a full range of options, from classifying targets and waveforms, classifying our fingerprints, estimating channels, identifying targets and SAR images, and detecting anomalous conditions in trackers from radars.

    We've also added in example workflows to show how to use the signal labeler, which is part of Signal Processing Toolbox. This is a great way to label signals that you've collected off of instrumentation, or radar systems, or radios. And the workflow shows how to bring the signals into the labeler and also manually label the data, but also to write custom functions to go label regions of interest. Now, this can be used to do things like finding interference sources that are of interest, where you write a function in MATLAB, and you're able to go out and have that function operate on each of the signals and find the region in the signal where the conditions you're looking for exists.

    The other nice thing about the labeler is you get different metrics and dashboards to look at. You get the progress of your labeling, for example. In this bottom portion here, you show the label distribution across different waveforms, so lots of visibility into the progress you're making on the waveform labeling as well as the different categories by label information. And I've included the example to take a look at for further information.

    OK. Well this brings us to the end of the webinar. Before we go, I'd like to just point out some of the resources we have to get started. We have over 50 examples in Radar Toolbox that you can use to get started in each of the areas that I described. The other thing that I want to point out is there's lot of cross-product examples. So if you already use MATLAB and some of the other toolboxes, Radar Toolbox provides you a path, as I've shown in multiple examples, to further integrate with the rest of the workflows that MathWorks provides.

    Now, we have a lot more information on our website. If you would like to visit it, I've included the link here. I encourage you to take a look at it. And there's other resources as well that you can find there, directly on the website. Thank you, again, for attending this webinar. I'm going to take a quick break, and then I'm going to go through the questions. I'll be back to answer the questions. And, once again, thank you for your time today.

    View more related videos