Okay. So, if we have a trace and the trace tells you, no less blacklist, and it tells you what was executed. Well, if you have a list, you can also look backwards. If it is electronically and digital on a computer, we can do it automatically. So, it's not magic. So, we call that the context tracking system and we have 15 years already or so. So, that means, if you are interested in a trace on a certain spot and you say, ''I need to check this more carefully and I want to debug maybe backwards.'' Not on the target, the CPU doesn't execute backwards. But in the trace, you have all the information and you can go backwards, and we are using all the information from the target that is possible. So, the instruction set we use to recalculate backwards, we use the registers which are currently there, so if you stop in time with a trace, alters the CPU, then the registers are still valid and we can use them to calculate. If you say, ''Yes, the memory didn't change after you stopped, then we can use even the memory.'' But if you say, ''No, I did not stop the CPU, it continued, so the memory has changed." Then, we cannot use it and you need to uncheck this to have valid results. Okay. So, that is the background info. So, if you check for a certain spot here and you say, ''Well, that was interesting." Then, you make a right mouse-click, set CTS here, set CTS, set on a certain record here, and then you see that we have a change to yellow color here. At the beginning it says 'busy', calculating was reference to this line, and later it's done. If you are stepping forward-backward, we even mark on which assembler line you are. So, because you see regarding, here you don't see it was a record numbers. But, maybe you see it here a little bit like that. So, here is a record number and this is also 34, 34, 34, 34. All in one record, but you can step from here backwards. This would change this index counter here. Okay. So, the fun stuff is to go backward and when you were to click, then go forward again and it's nice, and you see the color change between CTS active or regular debugging on target. But the previous class, I talk to you guys about when you're debugging very difficult problems, this ability to get backward or to view what happened backwards in time is incredibly useful. Because if you've got a device that's just on your desk and you're testing it, and get a weird error, some unknown error, how did my program get to this line and up to this spot, just with JTAG only debugging. It can be very difficult to determine that. But capturing all this trace information where the program counter was, gives you this fantastic debugging ability to be able to step backwards in time and figure out how you got to worry where your code you we're not expecting it to be and it's extremely, yeah So, if you think about the regular JTAG debugging, it's like you are expecting something and maybe you don't know, it doesn't happen when I execute a loop 100 times or 120 times, and then you start iterating, you setting breakpoints and stopping. So, it is a slow process and if you just trace it's so much easier. Okay. The next slide is saying something about selective tracing. So, we focus on something. For example, if something happens again and again and you want only to see when it happens. This for example, happened four times here. We have a trace find all four function 13 and this was executed four times. We found it in the trace. For example here, function 13, that's the code. If you activate, the red stuff is all related here, the red frames to break system, because the easy triggering for the trace we handle by other break trigger unit. So, here, it's only ETM now that's triggering. So, we instruct the ETM to check for an address and every time the address comes up, then the trace is enabled and here's the address. So, function 13, and you find that function 13 has this address, start address SCC8. You see it's a frame, a range, its a range, so that's a full function that I marked, and I do it yellow marked, full range here, high-level language. So, if you say function 13 regarding the compiler, and for an L file it's just the start address, and it says it's a function going from here to there. But if you name it just the name function 13, that's just the start address. So, but if you check this box high-level language, that means we should understand this as a high-level language function and when we mark the full range. Marking the full range means, you have now a trace enable function here, for function 13, which means you start here and you continue tracing as long as the addresses belong to function 13. So, you can totally focused on this one and you see, we sampled only 192 records and we have the full code of the function and it was executed four times. We know that already from the statistics that's true for this application. So, you can really focus on what you want to see. Okay. There's a similar thing. This time it's not just enabling for certain address or address range. Now, this one is a little bit more, let's say independent. You can say, ''I have function number 17 and I have function number 73.'' All these functions, they should be all in the trace but nothing before and nothing behind. So, that would be TraceON / TraceOFF. It's a little bit too much color maybe, but all the same colors are belonging together. So, let's start with the red one. Red one is TraceON. You see TraceON here as a marker and you see it here as a blue marker. So, why do we have two of them? Well, that's because the green thing here, the little bar here on this scroll bar, you can click it and pull it to the left and right. So, this one is usually not seen at all. Our default shows only this part, so these markers are helpful. But if you put it to the rights, then you get more info TraceON / TraceOFF really has a name and you see the P in addition, and a P you find here also break listing, it says, ''Types of breakpoints as program with the action TraceON / Trace OFF.'' Defined for the address CIF and off for CIF plus/8 means eight high-level language lines. So, that is eight lines difference. Well, I covered here the last digit. So, just leave it that it's eight difference. Okay. Then, it was a little bit tricky to show you because we mark only Trace Enabler. That's the start of the tracing. So, where is TraceOFF? Well, TraceOFF is exactly here above. So, that was a tracing before and it stopped and then it restarted here with Trace Enabler. So, it's all in the spectra but you usually do not see this TraceOFF here so much. Trace Enabler tells you clearly where it starts. Here was registered on something. Register and answer is zero. But the TraceOFF here, that's where we have the four loop with I plus, plus. So, that switches off and here you see it I plus plus. So, that was the point where it switched off. It's a loop and it happens twice, so, it's twice recorded. Because I didn't want to count something that is part of on and off, I took something in between, and I took this answer zero. Answer zero is here, this address D1C. So, we have really D1C, you can see it here and there. I pasted this as an assembler info here, just in the middle we're no interesting info is because it's four times the same info here. Four times the same info that is for you in addition assembler line info, because answer equals zero, that is the assembler code that belongs here in between. So, that is how it works with on-and-off. Also here, you see, we have a big part of code, this loop here, and we have its minimum four times here, we counted. No, not four times, this one has 3,470 times. So, we haven't really opened this code blocks here. Still, we have only 97,000 entries. We could have millions. So, also on-off safes drift trace buffer and you can focus on what you want to see.
