 So let's come back to the hands-on session. We will continue with developing an application for the NucleoKit. Okay. So the scope of this session is to become more familiar with STM32.L4 and low-power capabilities. We will focus on the operating modes and low-power peripherals. The method of the learning which we will use will be developing application, low-power application from scratch and step-by-step. So this means we will not use any template, we will not use any demo application, we will develop everything on our own. The steps which we will follow are the following. So we will use the STM32 Cubemix application, we will create a Cubemix project, we will configure all the peripherals in a graphical way using this tool, then we will generate IDE project together with the code, and then we will use only the IDE, which is MDK ARM in this case, and we will add a user code, compile the application, flesh the microcontroller, and then we will evaluate the application by measuring the current consumption. So in terms of software tools, we will use STM32 Cubemix version 4.23. This is the latest version of this tool. Also we will need STM32 L4 Cubemix package, the latest one is 1.10, and this is a package which contains HAL and low-layer libraries for the devices. Then we need a STLink driver, so the software which will allow us to flesh the microcontroller, flesh the memory with our application. And the last thing which we need is the IDE, so this will be the MDK ARM, we need version 5, and also to be able to use this IDE, we need a software package for L4 family. I would like to highlight this one, especially because the most frequently missed software tool is exactly this one, so please double check if you have all the required tools. In terms of hardware, I mentioned it already, we will use the Nucleo STM32 L452RE with extension P. On the first glance you may see that it looks exactly the same like the STM32 Nucleo which you use and know I believe quite well, but in fact this is different. So on the top there is a STLink and of course it allows you to flash and debug the microcontroller. The only change is that USB here is not mini but micro one. And the rest here is a MCU board and of course it looks also quite similar to what you know, so there is a Morpho connector, there is a Arduino connector, there are two buttons, one reset and one user, there is one also user LED. And regarding rest of the components on the Nucleo kit, we have yes two buttons, one LED, and of course also the MCU in LQFP64 package. What is new here is the SMPS. In fact, there are two different SMPS circuits on this board, one you can find in the right corner and second one is located in the left corner. So just to be clear about it, this first SMPS is a DC-DC converter which can generate either 1.8 or 3.3 volts and this voltage is directly applied to VDD pins of the microcontroller. So in fact, this is nothing related to the special SMPS support feature embedded in STN32 because you can apply 1.8 or 3.3 volts to all STN32 devices because they have a wide range of supply starting from 1.7 up to 3.6. The special SMPS feature which is supported by the microcontroller is related to the left side SMPS. It consists of a DC-DC converter and also the switch and this circuit generates voltage with a level 1.1 volts. So it's quite unusual for STN32 and the reason is that this voltage is applied directly to so-called VDD12 pins and these pins are the new feature of the STN32L4 with extension P. So by using this solution, we bypass the embedded voltage regulator and we supply directly with this voltage so-called V-core domain and that's the reason behind that's the reason why we can reduce the current consumption of the micro. Is it clear to you? Okay. So now I would like to propose you doing hands-on with SMPS. At the beginning, I would like to provide you some preliminary information regarding this subject. So we know already that purpose of using SMPS with STN32L4 is to reduce significantly the current consumption of the micro and the implementation is that we have two new pins called VDD12 which we use to supply directly the V-core domain. In terms of design and implementation of SMPS, this is of course external circuitry. So there is a flexibility on your side how you want to implement this. SMPS consists of DC-DC converter and the switch and you can select which components from which vendor you want to use in your application. Also one information regarding identification of L4 devices which support SMPS. So there is a P at the end of naming of the devices. So you know now that Nucleo which you use ends with a P letter which stands for support for SMPS and the same is for devices. So if you look for the devices which support SMPS, you simply need to focus on this. So P at the end means support for SMPS. And the last statement in terms of the introduction to SMPS, we believe that this solution can be really useful for a wide range of applications because as I said at the beginning, there are plenty of applications which can benefit from current consumption reduction. But in fact, there is no significant limitation or drawback when you use this feature. So let's focus on the device which we have on the Nucleo kit. This is L4-5-2-R-E-T-X with a P at the end. And you can see that we highlighted here two pins which are named VDD-1-2. So these are the special pins which are new here. In normal device without the P at the end, these pins are simply GPIOs, okay? So here in this device, these GPIOs were replaced by VDD-1-2 pins and you can see that they are in the opposite side of the package just to balance the current which are flowing through the microcontroller. So it may bring you some difficulties in terms of hardware design, for sure. It's not maybe easy to route the two different lines from different corners of the package, but it has sense to put them on the opposite sides. And okay, the name of the pins is VDD-1-2, but I mentioned already that voltage which is generated by SNPS has a level of 1.1 volts, right? So in fact, there is a wide range of supply which you can apply to these pins. It starts from 105 volts and it ends at 132, okay? So now let's take a look what is the hardware implementation of this feature inside STM32. Let's start with a classical implementation which you can meet in every STM32 right now which ST has in portfolio. So there are VDD pins which goes inside the package of the MCU and these pins supply directly some of the resources of the microcontroller. At the same time, this voltage goes to the LDO regulator and this regulator takes this voltage as an input and generates output with a level of 1.0 or 1.2 volts. And this voltage is called V-core and it supplies directly so-called core domain and we should understand core domain as not only cortex M but also part of the logic and also the memory including the flash memory. So in fact, this is a huge part of the microcontroller. So now let's go on and let's see what is the difference between the standard product and this P special version of the product. So you see, you know already that we have new pins, new two pins VDD12 and they can be connected to the SNPS which is a DC-DC and the switch as well. So when the MCU starts to execute the code, it relies on the embedded voltage regulator. So the architecture is the same. You see that everything which was in standard product is also present in the P version of the product. So we start with a LDO and then we can decide if we want to use SNPS. So simply we enable the SNPS by GPIO. We just set high, a right pin and the DC-DC starts to work. We close the switch also by using the GPIO and the voltage is attached, is applied to the VDD12 pins, okay? So what is happening now is we have two voltages, V-core and VDD12 and there is embedded circuitry which monitors both of these voltages. And if there is a VDD12 present, then this circuitry automatically bypasses the LDO. So it is switched off and then VDD12 exclusively supplies the V-core domain. Is it clear to you? Okay. So just to make a short summary of the things which we discussed, the advantage of using SNPS is clear. We reduce significantly the current consumption of the microcontroller. The important remark is that SNPS can be used only in a selected operating modes, in fact in active modes. So it means run mode and sleep mode. And there's also one inactive mode which is top zero where SNPS can be as well used. So this means that we have a disadvantage of not supporting rest of the operating modes. So this means that in stop one, stop two, standby and shutdown, it is not possible to use SNPS. This means that current consumption in these modes is exactly the same like for product without this letter P at the end, okay? So it behaves exactly the same. And just to understand it better, SNPS cannot help you in a low power mode. And this means that you have to disable the SNPS, open the switch and then you can enter low power mode. Also the disadvantage of SNPS is that two pins were sacrificed, two GPIOs were sacrificed to act as a VDD one, two pins. So we have a less number of GPIOs which we can use for the application. Also disadvantage is that we have a larger PCB space because we need to have some space to put the DC-DC and the switch next to the microcontroller. And also the result of having these additional components is that we need to buy them. And of course the cost of the manufacturing of the PCB is a bit higher. So now let's take a look how the block diagram can look like in terms of implementation of SNPS. We know already that there is a L4 which supports SNPS. So the new solution is VDD one, two pins. And also there is a circuitry which monitors the voltage on these pins. We know also some information about the SNPS. So it consists of DC-DC converter and also the switch. So right now on the nuclear kit we have components from analog devices which is a DC-DC and also we have a switch which comes from TI. But in future in next year STU will offer the device which will embed both these components. So there will be device named ST1-PS02 and it will embed both DC-DC converter and the switch. So the missing brick which we didn't discuss yet on the slide are these pins. So these pins are used to control the SNPS. The minimum number of these pins which you need is two. One pin to enable the DC-DC converter. This is the one. And the second one is also the pin which you need to enable the switch. So normal operation is like this. You enable the DC-DC. You wait short period of time to make the voltage stable on the output of the DC-DC. Then you close the switch and then it works automatically because the embedded circuitry takes care about it. So optional pins which can be beneficial for such application is SNPS-PG which means power good. So you can see what is the time of the delay because power good signal tells you that, okay, voltage on the DC-DC is stable. Now we can close the switch. And also one additional pin is SNPS-VX. This pin allows us to change the voltage level on the output of the SNPS. Because some DC-DC converters allow you to have not fixed voltage, but it is configurable. That's good. Okay, thank you. So now let's move from the general diagram to the details. This is the schematics of the nucleo-kit. So starting from the left side, we have a VDD pin. And then there is a jumper which allows us to measure the current consumption. Then the voltage goes to the DC-DC converter which generates the 1.1 volt of voltage. And this voltage goes to the switch. Switch provides the voltage to VDD 1.2 pins of the microcontroller. And the gray block here is missing ST component. So we can see here that nucleo-kit is already designed to support this ST product which will come next here. But because of the fact that it is not available yet, we use the product from other vendors. So the design of nucleo-kit will not change in future. Only ST will stop using the components here and we will use the component from us. For purpose of controlling SMPS, we will use four GPIOs. These are PA4, PA5, PA6, and PA7. So we discussed already that these are pins to enable the DC-DC to close the switch, the power-good signal, and also the pin to control the output voltage of the DC-DC. And I would like to also provide you some information about the rules which we need to respect when we switch on and off the SMPS. So we start from here, from the reset state. Let's assume that microcontroller starts up. So there is a power on reset. We enter this area. So we are below 26 megahertz for the system clock. By the way, do you know maybe what is the default configuration of the clock setting for L4 family? What is the frequency of the MCU when it starts up? It's four megahertz, four megahertz. So clearly it's below 26, so we respect this rule. Then the SMPS is switched off, which means that we rely only on the embedded voltage regulator. And the voltage regulator is set to scale one, which means that it provides a voltage 1.2 volts, okay? So now let's assume we want to enable the SMPS and we want to increase the frequency even to maximum. So what we need to do is, first, we reconfigure the embedded voltage regulator from scale one to scale two. This means decreasing the voltage from 1.2 down to 1.0. So this is one point. The second point is that we are ready to enable the SMPS. So we are entering this area. We are applying the high state on the PA4. We are also applying high state on PA7. So the both DC-DC and the switch are enabled. So here we are running on the SMPS. We are not using any more LDO. And this is also the condition which allows us to increase the frequency of the micro because once the SMPS is working, we can go up with a frequency. So we are landing in this area. We are using 80 megahertz of the system clock. Yeah, is it clear to you? So yes, after this short introduction, I would like to propose you making this application from scratch. So we would do the following. We will run the MCU with a maximum frequency which is 80 megahertz. We will implement the very short application which is LED blinking just to make sure that MCU executes the code and nothing wrong is happening. And we will evaluate two scenarios. First one, when the SMPS is switched off, this will be our difference point. So we will measure the current consumption and we will compare it to the second scenario when the SMPS is switched on. So this will be a clear message for us what is the current consumption reduction. Is it okay for you? Yeah? Okay, so in terms of a block diagram, we will do the following. We will configure PA4 and PA7 as outputs to control both DC-DC and the switch. We will do the same for PB13 because it controls the LED. Then we will change the voltage regulator scale from default value which is one to two. Then we will enable DC-DC and the switch. So we will set high PA4, PA7. Later on, we will push the MCU system frequency to maximum which is 80 megahertz. And then, optionally, we can disable the GPIO clocks to reduce a little bit the current consumption. And at the end, we will toggle the LED by changing the state on the PB13 in the wild one loop. Okay? So now I would like you to open the CubeMix and please click on a new project in order to open the project wizard. Okay, so as a result, you should see a such window. So there is a project wizard which allows us to select the device. The easiest way is to use this part number search. So please use it and type there this name, STM32L452RE, okay? Once it is done, you should shrink the list of the records here in this window and you should see only few part numbers. So please select the one which has a P at the end. So this will be STM32L452RETXP. And double click on it, please. Then as a result, you should see the CubeMix window where the list of peripherals is on the left side and on the right side, there is a MCU pinout, LQFP64. So now from the pinout, I would like you to locate two pins, PA4, PA7. They are close to each other. I believe on the bottom of the package. And please click on each of them and this will allow you to open the menu with the settings for each GPIO. So please select GPIO output for both of them, PA4, PA7. Is it done on your site? Not yet, okay. Okay, I believe it is done on your site. So let's go on. Now I would like you to enable the pin for LED control. This is a PB14. And just to understand how this LED is controlled. So you can see that PB14 goes to the transistor base and there is a transistor switch which controls the LED here. So this implementation allows us to bypass the current consumption from MCU. So the normal implementation is like this, that there is a resistor LED and the current flows directly to the MCU. So just to avoid taking into account the current from LED on our measurements, this implementation allows us to keep the current outside the MCU, right? So we will just consume a little bit of current to control the transistor. So let's come back to the Qubemix. There is a PB14 pin and I would like you to find it and to configure it in the same way like we did for the other pins. So this means we click on the PB14 and we select GPL output. Now the last activity from this slide is that we look on the left side of the Qubemix. We look inside the Peripherals tree and we find CIS item, which stands for system. We click on it and the first feature which we can control is a debugging interface. So I would like to ask you to select Debug Serial Wire. As a result, you should see that two pins, PA14, PA14, becomes green. The CIS is on the left side. So in the Qubemix on the left side, there is a Peripherals tree and you can find the CIS inside them. Yeah, okay, I hope it's done on your side. So now we have a kind of a checkpoint, checkpoint number one, because we finished a configuration of the pinout. So the situation on your side should be like this. There are two pins, PA4, PA7, which are configured as a GPO outputs. The same thing should be for the PB14 which controls the LED, so GPO output. And the last thing, two pins, PA13, PA14, configured as a Serial Wire Debug interface inside the CIS. Is this the same on your side? Perfect. So now I would like you to change the top inside the Qubemix from the pinout to clock configuration. Inside this scheme, in the center of the scheme, there is a value of the system clock frequency. This frequency is named HCLK, and you should see a value of four megahertz. This is just the confirmation that MCU starts with this default clock settings, four megahertz. So this clock feeds the core, the memory, and all the peripherals. And this is not our scenario because we would like to use 80 megahertz, the maximum value. So now please click on this four megahertz value. Please remove the number four and type manually 80. And then please click Enter. The Qubemix will tell you that this is not allowed in the present configuration. So please click Yes to allow Qubemix to reconfigure the clock settings to enable the PLL. And as a result, you will get 80 megahertz. Is it working for you? Great. Okay, so now we finished working with Qubemix, in fact. We are ready to generate the code. So please go to the main menu. Please click on the project and generate the code. And as a result, you will see a new window which is a project settings. So I would like to ask you to fill in the three things here. First one is a project name. This should be empty by default. So please select your preferred project name. The second one is a project location. So the path where the files will be stored. And this can be also selected by you. Please make sure that the path is accessible by Qubemix and it will be possible to put their files because we had some examples that Qubemix was not able to write their files, so it was stalled. And the last thing is a toolchain and IDE. So default one is embedded workbench for ARM. This is not the IDE. This is not the environment which we use today. So please change it from IR of ARM to MDK ARM version five. And once it is done on your site, please click okay. Okay, as a result, when you click okay, you should see the progress bar, the green bar, and after a few seconds, the code should be generated successfully. So you should see this window, the code generation, code is successfully generated and the Qubemix will ask you what to do next. So please select the middle option, open the project. So once the code is generated and you open the project, you should see the error message saying that Kyle is not recognizing your device. Can you see it? Yes, so it's good. In fact, it's good. Yes, so Kyle is not recognizing the device with a P at the end because in the future it will be updated but for the time being, unfortunately, Kyle is not supporting this device. So it tries to open the pack installer because he thinks that updating the pack will help but it will not happen because even if you have up-to-date pack, it doesn't support the device. So I would like to propose you closing the pack installer. There will be another message saying that you can, do you want to select a different device and click yes, yeah, click yes to select a different device. You will be referred to the window with the settings or properties of the project and please use the search feature and type this device, STM32L452RET. This means that you will type the same part number but with a difference that there is no P at the end. Okay, so I will continue with a presentation. Now, please open the main C file inside the Kyle environment and we will add a user code. So what we need to do is to set high PA4 to enable the DCDC. Set high also PA7 to close the switch and optionally what we want to do is to disable the clocks for the GPIOs to reduce a bit a current consumption. So the code, which I would like you to type or to copy from the presentation is the following. We have a five function calls and we need to put them inside the user section two. The user section two is after the cupid initialization but before infinite while loop, okay? So it's the good moment to make our test. So the first two functions are related to setting the pins and you can see they are related to PA4, PA7. And the important remark is that we are not setting them high but we are setting them low. So this is, you can see, this is not consistent with the description. And the explanation is that I would like you first to evaluate this scenario without SNPS. That's the reason why we are setting these pins low. We are disabling the SNPS. We are making sure that we will not use it, okay? This will be our difference point. And the three additional function calls are related to disabling of the clocks. You can type it or you can copy it from the presentation just to make things faster. Is it done on your site? Yes or no? Is there anyone who still is working with it? Yeah. Okay, okay, I will wait. Yes. Please, please rather copy than type. It will be faster. Is it done on your site? Is there anyone else who is working? No, I think I will continue. So there is one additional thing which you need to add to your code. And this is the LED toggling. So the code is the following. We call two functions. One is a HAL GPO Togo Pin. So we change the state of the pin to opposite each time. This is for PB 14. So the pin which is connected to the LED. And additionally, we call the HAL delay function. I did it with a argument 500 which means 500 milliseconds just to see that LED is blinking. And we make a copy paste of this code inside section number three. And the section number three is infinite loop, okay? Okay, and this is the checkpoint for us because we finished the development of the code for the first part of the exercise which means that we have an application which is not using SNPS yet. So the next step is to compile the application and flash it to the microcontroller. For this purpose, you can select this icon for the compilation or alternatively you can click on F7 from the keyboard. Once the compilation is done and it will take some seconds to do it, you can connect the nuclear kit with a USB cable and then you can flash the microcontroller. You can do it also by icon or by pressing the F8. Okay. After flashing the microcontroller, please press the reset button and as a result you should see that LED is blinking. Great. So now it's time to measure the current consumption. I would like you to use the multimeters which are on the tables and you have a two jumpers, JP6 and JP8. JP6 is used to measure the total current consumption of the micro. On the left side, it measures the current consumption for VDD, VDD12 and SNPS as well. So the external DC-DC and the switch is taken into account as well. So I advise you to use JP6 because JP8 is related only to the SNPS. Yeah. So we use JP6, we remove the jumper, we put instead the connector and we measure the current consumption. Can anyone tell me what is the current consumption? 10. Great. It's a good result. Something about 10 milliamps. This should be the result. So I will show you my result. Here you can see the picture of the nuclear with two multimeters. One is attached to the JP6 and second one is attached to JP8. So we can see I measured something like 10 milliamps slightly less. So if you have the same result or similar one, that's perfect. Did you manage to do it? Okay. So now let's continue. And now it's time to come back to the Kyl, to come back to Main-C file. Let's modify the user code in the way that we will enable the SNPS. So here are the steps which we need to follow. We need to change the voltage regulator scale from default one to two. Okay. This is the precondition for the SNPS. Then we need to modify our function calls for the GPIOs because now they are on the low state. We want to make them high. And I would advise you to put also the small delay between two function calls of the GPIOs. Just to make sure that the voltage on the DC-DC is stable and then we close the switch. And the additional thing is there is a function which is called system clock config. It is responsible for setting the 80 megahertz for the MCU. This is what we generated from the Cuban mix, right? And this function call is at the beginning of your application. And we need to move this function from the original place to the place after GPIOs are set. Because you remember maybe from the slides that the rules which we need to follow are, we need to be below 26 megahertz. We enable the SNPS and then we can move to the higher frequency, yeah? So that's the reason why. We want, we need to move this function to be in line with specification. So we enable the SNPS first and then we change the frequency, yeah? Is it clear? So now I will present you the code. We are still in a user code section two, okay? We have already the function calls for the GPIOs, the two functions, PA4, PA7. What we are doing now is we are adding one function call for the voltage scaling. So HALPWR control voltage scaling. We change it from one to two by using this argument. So we add this function call. We keep it, we only modify it. Maybe we should... This function should be before the GPIOs, right? We have these GPIO functions. We put it before. This is the first modification. The second one is that we change the functions for the GPIOs from reset to set, okay? For both of them please. The third modification is that we put a small delay, so the HAL delay 100, 100 milliseconds between enabling the DCDC and closing the switch. And the last thing is that you need to find the function call for the system clock config, which is at the beginning of the application. And please remove it or at least comment it out. And you need to call this function after the GPIOs. So you can keep, of course, the disabling of the clocks, which we have already, and you can put it after the disabling of the clocks. Did you manage to do it? Not yet, okay, let's wait. Okay, so I assume you are progressing. And the last thing which we need to do with the code is, inside this function, the system clock config, QBemix generated for us part of the code which is responsible for voltage scaling. And we know that we want to use voltage scale two, but the QBemix generated the function where he tries to set the voltage scale to one because we use 80 megahertz of the system clock and it is needed for this condition. If you want to use 80 megahertz clock, normally you need to set the voltage scaling to one to have a maximum performance of the regulator. But in our case, we want to use SNPS and QBemix doesn't know about it. So that's the reason why we need to refer to body of the function of the system clock config and we need to comment out the voltage scaling because we want to keep this voltage scale two, okay? So you need to refer to main C file still and between the lines something like 160 and 190, you should find the appropriate code. So this function calls. And I would like you to comment them out. Somewhere in the main C between lines 160, 190, you should locate it. Did you manage to do it? Yes, okay. Or maybe there is someone who needs help. No? Okay, great. So gentlemen, if you manage to do this step, please compile the application, please flash the microcontroller again and we measure the current consumption again. So now please still use the JP6 at the beginning at least and I would be happy to hear the information what is the current consumption now. Great, great, great. Something between 3.7 and 4 is perfect. It is the expected value, okay? So I will show you my value. I did the same exercise. I measured with a two multimeters. So you see that I measured something about four milliamps. So what is the outcome? What is the message? We reduced the current consumption from 10 to four. Yeah, are we happy? Is it really a nice result? I think yes. And if you would measure now the current on the JP8, there will be no zero, but there will be a value. And in this case, there should be 3.3 milliamps. And this is also the message for us because previously it was zero, now it's 3.3 and you see that 3.3 goes here and the rest, which means less than one milliamps goes here. So this is also the information for us that huge part of the microcontroller is supplied with a V-Core. So it really makes sense to focus on this SMPS and to optimize it, right? Because it's core, it's memory, it's digital peripherals mostly, okay? How many devices will support this future? Very good question. So right now there's only L4 family which supports it and not all the part numbers, but you can find some part numbers from each subfamily, L4-3, L4-5, L4-7, L4-9, not all, but some of them for sure. In the future or right now there is a L4 plus which was introduced to the market, right? So the 130 megahertz and with some additional graphical features. In the coming weeks, there should be a new part numbers which will support SMPS as well. One day maybe, you know, I made it inside? Of course, it will be. Future STM32 low power will embed SMPS. Embed? Embed. But this is a long time. It's good I think for the first step, right? Okay, gentlemen, I hope you managed to follow my instructions and you reached the level of the exercise. The last things which I would like to tell you on the top of this exercise. Cubemix allows you or supports even more SMPS than we experienced today. So there was a remark why we are not using board selector. It is a good remark and it also of course makes sense. I wanted you to make everything step by step to have a clear understanding of the process. But for sure you can select board selector instead of MCU selector and you can select the P version of the nuclear and the GPIOs will be pre-configured for you already. Fine. Then Cubemix also provides a tool which is named current consumption calculator. It allows you quickly to evaluate the current consumption so let's say it selected that I want to use this clock, I want to use this peripheral, what should be the expected current consumption. Right now this tool supports the SMPS as well. On the top of the Cubemix, there is a so-called BSP package which stands for board support package. You have it already on your hard drives because it is part of the L4Cube package. So if you have a hull functions, if you have low layer functions, you have also this package as well. And you can see here the list of the functions which are very easy to use. They are very intuitive and they implement not only the things which we did today but also the reading of the power good signal, changing the voltage scaling and everything which we had to understand from scratch. So if you want to start very quickly with SMPS, you can consider using these functions. The additional thing which I would like to mention is that there is a very nice application note for the SMPS and it is named design recommendations for L4 family with external SMPS. Additionally, there is a L4 online training which provides roughly about 50 different presentations about L4. This is on the ST website. And the new chapter among these presentations is related to SMPS. Okay, so the time is running out. I would like to only quickly introduce you the topics which we didn't have today because the presentation which you got provides the slides for four different hands-ons. So we went through the first of them. The second is related to stop mode and low power timer. So this is the application for water meters and it allows you to enter the stop mode with the MCU and the low power timer which is embedded in the MCU allows you to count external pulses. So there is a mechanical wheel which is embedded in the water meters. So it's easy way to use the low power timer and stop mode to make the MCU consume a small amount of energy but it's still able to count the pulses even in the stop mode. So we can define for example that after counting 100 of pulses you can wake up the MCU to make a data processing and then it will go again to the stop mode, okay? So this is the second application. The third hands-on is related to standby mode and RTC. Standby mode allows you to reduce the current consumption even further comparing to stop mode and RTC allows you to wake up the MCU on a regular time base. So this is the hands-on for the devices which stays in low power mode for a very long time like sensors, like data loggers. And the last hands-on is related to sleep mode and so-called BAM which stands for batch acquisition mode. So this is the application, this is the hands-on for so-called always active, always on devices like fitness trackers because it allows you to enter stop mode or sleep mode, sorry. And still the DMA and the peripherals can operate and transfer the data to the SRAM. So core is sleeping, flash is disabled, but still you are able to get the data on a regular time base from the sensors or external devices, okay? So this is all from my side. Do you have any questions or remarks regarding this session regarding SNPS maybe? Was it okay for you? Yeah, okay, good. So now I would like to ask you to fill in the survey. Please take your time, we have still a few minutes. Thank you too.