RobolaboWiki - User contributions [en]

LaTeX

2026-03-26T10:57:06Z

Blancal:

<h1> Installation </h1>
<pre>
apt-get install texlive-full
</pre>

<h1> Latex Manuals </h1>
<li> [http://www.robolabo.etsit.upm.es/publications/courses/2020-Latex_Manual1.pdf Manual 1 ]</li>
<li> [http://www.robolabo.etsit.upm.es/publications/courses/2020-Latex_Manual2.pdf Manual 2 ]</li>
<li> [http://www.robolabo.etsit.upm.es/publications/courses/2020-Latex_Manual3.pdf Manual 3 ]</li>

<h1> Templates </h1>

<ul>
<li> Trabajos Fin de Titulación (Pure Latex with Makefile) : [[http://www.robolabo.etsit.upm.es/wikiFiles/templateTFT_v2023.tgz templateTFT_v2023.tgz ]]</li>
<li> Trabajos Fin de Titulación (Overleaf): [[http://www.robolabo.etsit.upm.es/wikiFiles/2023-LatexOverleafTemplate.zip 2023-LatexOverleafTemplate.zip]]</li>
<li> Presentaciones: [[http://www.robolabo.etsit.upm.es/wikiFiles/tfg_presentation.tgz pres_template.tgz]]</li>



</ul>

Some considerations you need to define in src/tft.tex:
<ul>
<li> If you want a double-side printing

<pre>
\documentclass[twoside,a4paper,11pt]{book}
</pre>
or a single-side printing
<pre>
\documentclass[oneside,a4paper,11pt]{book}
</pre>

<li> The template has two colors to be implemented for titles and headers: orange
<pre>
\usepackage[orange]{tft}
</pre>

or black

<pre>
\usepackage[black]{tft}
</pre>

<li> If compiling with latex (as with makefile provided), this line should be uncommented:

<pre>
\usepackage[dvipdfm]{hyperref} % Use it if compiling with latex (default on makefile)
</pre>

On the contrary, if using pdflatex (as for example overleaf), this line should be uncommented:
<pre>
\usepackage{hyperref} % Use it if compiling with with pdflatex (default on overleaf)
</pre>

</ul>

<h1> Bibtex </h1>

Bibliography style for the different elements to cite inside the document.
ALIAS is referred to the name of the bibtex element that you are going to cite it.

<h2> Article </h2>

<pre>
@ARTICLE{ALIAS,
author = {{AUTHOR}},
title = {{TITLE}},
journal = {{JOURNAL}},
volume = {{VOLUME}},
number = {{NUMBER}},
pages = {{PAGES}},
year = {{YEAR}},
}
</pre>

<h2> Collection of books </h2>

<pre>
@INCOLLECTION{ExIncollec01,
author = {{AUTHOR}},
title = {{TITLE}},
booktitle = {{BOOKTITLE}},
editor = {{EDITOR}},
publisher = {{PUBLISHER}},
address = {{ADRESS}},
pages = {{PAGES}},
year = {{YEAR}},
}
</pre>

<h2> Conference proceedings </h2>

<pre>
@INPROCEEDINGS{ExInpro01,
author = {{AUTHOR}},
title = {{TITLE}},
booktitle = {{BOOKTITLE}},
publisher = {{PUBLISHER}},
address = {{ADRESS}},
pages = {{PAGES}},
year = {{YEAR}},
}
</pre>

<h2> Technical Report </h2>

<pre>
@TECHREPORT{ALIAS,
author = {{AUTHOR}},
title = {{TITLE}},
institution = {{INSTITUTION}},
number = {{NUMBER}},
year = {{YEAR}},
}
</pre>

<h2> Books </h2>

<pre>
@BOOK{ALIAS,
author = {{AUTHOR}},
title = {{TITLE}},
publisher = {{PUBLISHER}},
address = {{ADRESS}},
year = {{YEAR}},
}
</pre>

<h2> PHD Thesis </h2>

<pre>
@PHDTHESIS{ALIAS,
author = {{AUTHOR}},
title = {{TITLE}},
school = {{SCHOOL}},
year = {{YEAR}},
}
</pre>

<h2> Web Links </h2>

<pre>
@MISC{ALIAS,
author = {{AUTHOR}},
title = {{TITLE}},
howpublished = {\url{LINK}},
year = {{YEAR}},
note = {[Online; accessed DATE]}
}
</pre>

<h1> TikZ </h1>

Some problems have been reported when compiling TikZ with TexLive 2009.

<h2> Compilation Problems </h2>
Whether compiling you get:

<pre>
I can't find file tikzlibrary
</pre>

Then, it is possible you have problems with TexLive and need to install new TexLive version.

Download TexLive 2011 image:

<pre>
wget http://ftp.oleane.net/pub/CTAN/systems/texlive/Images/texlive2011.iso
</pre>

Mount the .iso image as root:

<pre>
mount -o loop -t iso9660 texlive2011.iso /media/cdrom
</pre>

Install TexLive:

<pre>
./install-tl
</pre>

Choose the following options:

<pre>
Options -> Create SymLinks -> [Chose Standar Dirs]
Install
</pre>

<h2> Compilation works, but not pictures shown </h2>

Get last pgf package:

<pre>
wget http://downloads.sourceforge.net/project/pgf/pgf/version%202.10/ \
pgf_2.10.tds.zip?r=http%3A%2F%2Fsourceforge.net%2Fprojects%2Fpgf%2F&ts= \
1338847489&use_mirror=netcologne
</pre>

Unzip the downloaded file.
Substitute the old pgp package by the new downloaded one:

<pre>
mv tex/generic/pgf/* /usr/share/texmf/tex/generic/pgf/*
</pre>

Execute as superuser:

<pre>
texhash
</pre>

<h2> DVI problems </h2>

dvipdfm does not completelly supports tikz options.
Modify it by dvipdfmx

<h1> Videos on Beamer </h1>

In [[media:videoLatexTemplate.tgz | videoLatexTemplate.tgz]] there is an example with two different options to include videos on beamer.

<ul>
<li> The first one inserts the video on the pdf.
There is a <i>video2image.sh</i> script that converts a video into different frames (.EPS).
It requires ffmpeg and sam2p.

Later on <i> animategraphics </i> is in charge of moving the frames:

<pre>
\animategraphics[autoplay,loop,width=6cm]{<NUM_FRAME>{mov/<VIDEO_FOLDER>}{<FIRST_FRAME>}{<LAST_FRAME>
</pre>

<li>
The second one inserts an image that one pressed launches a player.

<pre>
\movie[externalviewer]{\includegraphics[width=0.5cm]{figs/<FIG_ICON>}}{mov/<VIDEO_FILE>}
</pre>

</li>
</ul>

To compile you need to run:
<pre>
make videos
make
</pre>

<h1> Memory size limit </h1>
If you get something like this: TeX capacity exceeded, sorry [main memory size=5000000].

Run
<pre>
kpsewhich texmf.cnf
</pre>

Edit, the file that it outputs regardless it says not to touch

Add the follwing line:
<pre>
main_memory = 8000000
</pre>

Now you need to update the system:
<pre>
fmtutil-sys --all
</pre>

After that, it should work

Nucleo Boards for Control Systems

2023-02-06T11:11:22Z

Blancal:

__TOC__

To install STM32CubeIDE and to run a Hello World example, please check it here: http://wiki.robolabo.etsit.upm.es/index.php/Nucleo_Boards

<h1> GPIO read and write </h1>

<h2> Read from a GPIO</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Write to a GPIO</h2>
- High level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- Low level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Theory </h2>

The encoder used in the laboratory is a position sensor that uses a two-channels hall effect sensor. It is a quadrature encoder that is attached to the motor shaft and which provides a resolution of <b>48 counts per revolution</b>. This means that, for a complete turn of the motor shaft, the encoder provides a value of 48 counts. The hall sensor requires an input voltage, Vcc. Additionally, the output of the encoder comes from reading the output of the two channels, channel A and channel B, of the hall sensor. These two channels are square waves which are 90º out of phase.

<h2> Encoder Configuration in STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Theory </h2>
One method that is often used to control the speed of a DC motor is the Pulse Width Modulation (PWM) method. The speed of the electric motor depends on the modulator voltage. The greater the voltage, the faster the rotation of an electric motor. The use of this PWM can be used to control motor rotation through changes in PWM duty cycle or PWM pulse width. When the duty cycle is 0%, the motor will stop completely. When the duty cycle is 50%, the motor will rotate at half the speed of the maximum speed and when the PWM is 100%, the motor rotates with maximum speed.

<h2> Main registers </h2>
<h3> Prescaler (PSC) </h3>

The prescaler is a register that divides the timer clock frequency to obtain a specific frequency.
Specifically, the frequency reduction is applied using the following formula:

f_PWM = f_CLK / (PSC + 1)

Therefore, if the frequency to set is the same as the frequency of the clock, the PSC register must be set at PSC=0.
The STM32 timers allow a prescaler value up to 65535, through 16 bits registers.

<h3> Auto Reload Register (ARR) and Capture Compare Register (CCR) </h3>
The ARR register storages the maximum value that the counter can reach before going back to zero.
Moreover, the CCR registers the value of the corresponding timer counter after which the output PWM signal goes from high to low level.
Every channel of the timer used to generate the PWM will have a different CCR register (for example, CCR1 and CCR2 for channels 1 and 2).
In this way, the value of the CCR together with the value of the ARR define the width of the pulses and, therefore, the duty cycle of the PWM signal:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
This is the register that storages the value of the counter used to generate the PWM.

<h2>PWM Configuration in STM32CubeIDE</h2>

To configure a timer as PWM, the first thing to do is to select one of the timers that could be configured as a PWM generator.
Additionally, also the channels that will be used as PWM output must be decided.

<b>Advice:</b> As different PWM outputs are needed, it is recommended to use different channels of the same timer to the extent possible.

The main timers that can be set as PWM are: TIM2, TIM3, TIM4 and TIM5, with 4 different channels each of them.

<b>Advice:</b> It is recommended to use the timer and the corresponding channels that match directly with the pins that feed the H-bridge to modulate the speed of the motor. Otherwise, the PWM output signals must be bridged with the H-bridge input signals.

Therefore, the pins that the channels of the timer are using need to be checked in the "Pinout" section of the STM32CubeIDE.

Once the channels of the timer have been activated, some parameters and the configuration of the timer must be changed.

Main parameters:
<ul>
<li><b>Clock Source:</b> Clock of the timer. The Internal clock option must be selected. Moreover, it must be checked that the frequency of the clock that is being used is the one desired. This could be checked within the clock configuration tab of the STM32CubeIDE. </li>
<li><b>Channel x:</b> Configuration for the channel x of the timer. The option “PWM Generation CHx” must be selected, in which x will be the number of the channel to configure.</li>
<li><b>Prescaler (PSC):</b> Parameter to introduce the value of the PSC register.</li>
<li><b>Counter Period:</b> Parameter to set the value of the ARR register.</li>
<li><b>Pulse (16 bits):</b> Parameter to mofidy the CCR register.</li>
<li><b>Mode: </b> The PWM mode 1 must be selected.</li>
</ul>

Additionally, within the code, the timer to use must be initialized following the structure below:

<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

The CCR value can be modified by introducing the following instruction:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

in which CCR1 indicates that we are accessing to the channel 1 register, new_ccr is the new to set and htimx refers to the timer x (for example, htim2 or htim3).

In the same way, to modify the register of the channel 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T11:10:43Z

Blancal:

__TOC__

To install STM32CubeIDE and to run a Hello World example, please check it here: http://wiki.robolabo.etsit.upm.es/index.php/Nucleo_Boards

<h1> GPIO read and write </h1>

<h2> Read from a GPIO</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Write to a GPIO</h2>
- High level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- Low level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Theory </h2>

The encoder used in the laboratory is a position sensor that uses a two-channels hall effect sensor. It is a quadrature encoder that is attached to the motor shaft and which provides a resolution of <b>48 counts per revolution</b>. This means that, for a complete turn of the motor shaft, the encoder provides a value of 48 counts. The hall sensor requires an input voltage, Vcc. Additionally, the output of the encoder comes from reading the output of the two channels, channel A and channel B, of the hall sensor. These two channels are square waves which are 90ª out of phase.

<h2> Encoder Configuration in STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Theory </h2>
One method that is often used to control the speed of a DC motor is the Pulse Width Modulation (PWM) method. The speed of the electric motor depends on the modulator voltage. The greater the voltage, the faster the rotation of an electric motor. The use of this PWM can be used to control motor rotation through changes in PWM duty cycle or PWM pulse width. When the duty cycle is 0%, the motor will stop completely. When the duty cycle is 50%, the motor will rotate at half the speed of the maximum speed and when the PWM is 100%, the motor rotates with maximum speed.

<h2> Main registers </h2>
<h3> Prescaler (PSC) </h3>

The prescaler is a register that divides the timer clock frequency to obtain a specific frequency.
Specifically, the frequency reduction is applied using the following formula:

f_PWM = f_CLK / (PSC + 1)

Therefore, if the frequency to set is the same as the frequency of the clock, the PSC register must be set at PSC=0.
The STM32 timers allow a prescaler value up to 65535, through 16 bits registers.

<h3> Auto Reload Register (ARR) and Capture Compare Register (CCR) </h3>
The ARR register storages the maximum value that the counter can reach before going back to zero.
Moreover, the CCR registers the value of the corresponding timer counter after which the output PWM signal goes from high to low level.
Every channel of the timer used to generate the PWM will have a different CCR register (for example, CCR1 and CCR2 for channels 1 and 2).
In this way, the value of the CCR together with the value of the ARR define the width of the pulses and, therefore, the duty cycle of the PWM signal:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
This is the register that storages the value of the counter used to generate the PWM.

<h2>PWM Configuration in STM32CubeIDE</h2>

To configure a timer as PWM, the first thing to do is to select one of the timers that could be configured as a PWM generator.
Additionally, also the channels that will be used as PWM output must be decided.

<b>Advice:</b> As different PWM outputs are needed, it is recommended to use different channels of the same timer to the extent possible.

The main timers that can be set as PWM are: TIM2, TIM3, TIM4 and TIM5, with 4 different channels each of them.

<b>Advice:</b> It is recommended to use the timer and the corresponding channels that match directly with the pins that feed the H-bridge to modulate the speed of the motor. Otherwise, the PWM output signals must be bridged with the H-bridge input signals.

Therefore, the pins that the channels of the timer are using need to be checked in the "Pinout" section of the STM32CubeIDE.

Once the channels of the timer have been activated, some parameters and the configuration of the timer must be changed.

Main parameters:
<ul>
<li><b>Clock Source:</b> Clock of the timer. The Internal clock option must be selected. Moreover, it must be checked that the frequency of the clock that is being used is the one desired. This could be checked within the clock configuration tab of the STM32CubeIDE. </li>
<li><b>Channel x:</b> Configuration for the channel x of the timer. The option “PWM Generation CHx” must be selected, in which x will be the number of the channel to configure.</li>
<li><b>Prescaler (PSC):</b> Parameter to introduce the value of the PSC register.</li>
<li><b>Counter Period:</b> Parameter to set the value of the ARR register.</li>
<li><b>Pulse (16 bits):</b> Parameter to mofidy the CCR register.</li>
<li><b>Mode: </b> The PWM mode 1 must be selected.</li>
</ul>

Additionally, within the code, the timer to use must be initialized following the structure below:

<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

The CCR value can be modified by introducing the following instruction:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

in which CCR1 indicates that we are accessing to the channel 1 register, new_ccr is the new to set and htimx refers to the timer x (for example, htim2 or htim3).

In the same way, to modify the register of the channel 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T10:41:50Z

Blancal:

__TOC__

To install STM32CubeIDE and to run a Hello World example, please check it here: http://wiki.robolabo.etsit.upm.es/index.php/Nucleo_Boards

<h1> GPIO read and write </h1>

<h2> Read from a GPIO</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Write to a GPIO</h2>
- High level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- Low level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Theory </h2>

The encoder used in the laboratory is a position sensor that uses a two-channels hall effect sensor. It is a quadrature encoder that is attached to the motor shaft and which provides a resolution of <b>48 counts per revolution</b>. This means that, for a complete turn of the motor shaft, the encoder provides a value of 48 counts. The hall sensor requires an input voltage, Vcc. Additionally, the output of the encoder comes from reading the output of the two channels, channel A and channel B, of the hall sensor. These two channels are square waves which are 90ª out of phase.

<h2> Encoder Configuration in STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Theory </h2>

<h2> Main registers </h2>
<h3> Prescaler (PSC) </h3>

The prescaler is a register that divides the timer clock frequency to obtain a specific frequency.
Specifically, the frequency reduction is applied using the following formula:

f_PWM = f_CLK / (PSC + 1)

Therefore, if the frequency to set is the same as the frequency of the clock, the PSC register must be set at PSC=0.
The STM32 timers allow a prescaler value up to 65535, through 16 bits registers.

<h3> Auto Reload Register (ARR) and Capture Compare Register (CCR) </h3>
The ARR register storages the maximum value that the counter can reach before going back to zero.
Moreover, the CCR registers the value of the corresponding timer counter after which the output PWM signal goes from high to low level.
Every channel of the timer used to generate the PWM will have a different CCR register (for example, CCR1 and CCR2 for channels 1 and 2).
In this way, the value of the CCR together with the value of the ARR define the width of the pulses and, therefore, the duty cycle of the PWM signal:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
This is the register that storages the value of the counter used to generate the PWM.

<h2>PWM Configuration in STM32CubeIDE</h2>

To configure a timer as PWM, the first thing to do is to select one of the timers that could be configured as a PWM generator.
Additionally, also the channels that will be used as PWM output must be decided.

<b>Advice:</b> As different PWM outputs are needed, it is recommended to use different channels of the same timer to the extent possible.

The main timers that can be set as PWM are: TIM2, TIM3, TIM4 and TIM5, with 4 different channels each of them.

<b>Advice:</b> It is recommended to use the timer and the corresponding channels that match directly with the pins that feed the H-bridge to modulate the speed of the motor. Otherwise, the PWM output signals must be bridged with the H-bridge input signals.

Therefore, the pins that the channels of the timer are using need to be checked in the "Pinout" section of the STM32CubeIDE.

Once the channels of the timer have been activated, some parameters and the configuration of the timer must be changed.

Main parameters:
<ul>
<li><b>Clock Source:</b> Clock of the timer. The Internal clock option must be selected. Moreover, it must be checked that the frequency of the clock that is being used is the one desired. This could be checked within the clock configuration tab of the STM32CubeIDE. </li>
<li><b>Channel x:</b> Configuration for the channel x of the timer. The option “PWM Generation CHx” must be selected, in which x will be the number of the channel to configure.</li>
<li><b>Prescaler (PSC):</b> Parameter to introduce the value of the PSC register.</li>
<li><b>Counter Period:</b> Parameter to set the value of the ARR register.</li>
<li><b>Pulse (16 bits):</b> Parameter to mofidy the CCR register.</li>
<li><b>Mode: </b> The PWM mode 1 must be selected.</li>
</ul>

Additionally, within the code, the timer to use must be initialized following the structure below:

<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

The CCR value can be modified by introducing the following instruction:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

in which CCR1 indicates that we are accessing to the channel 1 register, new_ccr is the new to set and htimx refers to the timer x (for example, htim2 or htim3).

In the same way, to modify the register of the channel 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T10:41:13Z

Blancal:

__TOC__

To install STM32CubeIDE and to run a Hello World example, please check it here: http://wiki.robolabo.etsit.upm.es/index.php/Nucleo_Boards

<h1> GPIO read and write </h1>

<h2> Read from a GPIO</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Write to a GPIO</h2>
- High level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- Low level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Theory </h2>

The encoder used in the laboratory is a position sensor that uses a two-channels hall effect sensor. It is a quadrature encoder that is attached to the motor shaft and which provides a resolution of <b>48 counts per revolution:</b>. This means that, for a complete turn of the motor shaft, the encoder provides a value of 48 counts. The hall sensor requires an input voltage, Vcc. Additionally, the output of the encoder comes from reading the output of the two channels, channel A and channel B, of the hall sensor. These two channels are square waves which are 90ª out of phase.

<h2> Encoder Configuration in STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Theory </h2>

<h2> Main registers </h2>
<h3> Prescaler (PSC) </h3>

The prescaler is a register that divides the timer clock frequency to obtain a specific frequency.
Specifically, the frequency reduction is applied using the following formula:

f_PWM = f_CLK / (PSC + 1)

Therefore, if the frequency to set is the same as the frequency of the clock, the PSC register must be set at PSC=0.
The STM32 timers allow a prescaler value up to 65535, through 16 bits registers.

<h3> Auto Reload Register (ARR) and Capture Compare Register (CCR) </h3>
The ARR register storages the maximum value that the counter can reach before going back to zero.
Moreover, the CCR registers the value of the corresponding timer counter after which the output PWM signal goes from high to low level.
Every channel of the timer used to generate the PWM will have a different CCR register (for example, CCR1 and CCR2 for channels 1 and 2).
In this way, the value of the CCR together with the value of the ARR define the width of the pulses and, therefore, the duty cycle of the PWM signal:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
This is the register that storages the value of the counter used to generate the PWM.

<h2>PWM Configuration in STM32CubeIDE</h2>

To configure a timer as PWM, the first thing to do is to select one of the timers that could be configured as a PWM generator.
Additionally, also the channels that will be used as PWM output must be decided.

<b>Advice:</b> As different PWM outputs are needed, it is recommended to use different channels of the same timer to the extent possible.

The main timers that can be set as PWM are: TIM2, TIM3, TIM4 and TIM5, with 4 different channels each of them.

<b>Advice:</b> It is recommended to use the timer and the corresponding channels that match directly with the pins that feed the H-bridge to modulate the speed of the motor. Otherwise, the PWM output signals must be bridged with the H-bridge input signals.

Therefore, the pins that the channels of the timer are using need to be checked in the "Pinout" section of the STM32CubeIDE.

Once the channels of the timer have been activated, some parameters and the configuration of the timer must be changed.

Main parameters:
<ul>
<li><b>Clock Source:</b> Clock of the timer. The Internal clock option must be selected. Moreover, it must be checked that the frequency of the clock that is being used is the one desired. This could be checked within the clock configuration tab of the STM32CubeIDE. </li>
<li><b>Channel x:</b> Configuration for the channel x of the timer. The option “PWM Generation CHx” must be selected, in which x will be the number of the channel to configure.</li>
<li><b>Prescaler (PSC):</b> Parameter to introduce the value of the PSC register.</li>
<li><b>Counter Period:</b> Parameter to set the value of the ARR register.</li>
<li><b>Pulse (16 bits):</b> Parameter to mofidy the CCR register.</li>
<li><b>Mode: </b> The PWM mode 1 must be selected.</li>
</ul>

Additionally, within the code, the timer to use must be initialized following the structure below:

<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

The CCR value can be modified by introducing the following instruction:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

in which CCR1 indicates that we are accessing to the channel 1 register, new_ccr is the new to set and htimx refers to the timer x (for example, htim2 or htim3).

In the same way, to modify the register of the channel 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T10:40:26Z

Blancal:

__TOC__

To install STM32CubeIDE and to run a Hello World example, please check it here: http://wiki.robolabo.etsit.upm.es/index.php/Nucleo_Boards

<h1> GPIO read and write </h1>

<h2> Read from a GPIO</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Write to a GPIO</h2>
- High level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- Low level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Theory </h2>

The encoder used in the laboratory is a position sensor that uses a two-channels hall effect sensor. It is a quadrature encoder that is attached to the motor shaft and which provides a resolution of <b>48 counts per revolution:</b>. This means that, for a complete turn of the motor shaft, the encoder provides a value of 48 counts. The hall sensor requires an input voltage and the output of the encoder comes from reading the output of the two channels, channel A and channel B. These two channels are square waves which are 90ª out of phase.

<h2> Encoder Configuration in STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Theory </h2>

<h2> Main registers </h2>
<h3> Prescaler (PSC) </h3>

The prescaler is a register that divides the timer clock frequency to obtain a specific frequency.
Specifically, the frequency reduction is applied using the following formula:

f_PWM = f_CLK / (PSC + 1)

Therefore, if the frequency to set is the same as the frequency of the clock, the PSC register must be set at PSC=0.
The STM32 timers allow a prescaler value up to 65535, through 16 bits registers.

<h3> Auto Reload Register (ARR) and Capture Compare Register (CCR) </h3>
The ARR register storages the maximum value that the counter can reach before going back to zero.
Moreover, the CCR registers the value of the corresponding timer counter after which the output PWM signal goes from high to low level.
Every channel of the timer used to generate the PWM will have a different CCR register (for example, CCR1 and CCR2 for channels 1 and 2).
In this way, the value of the CCR together with the value of the ARR define the width of the pulses and, therefore, the duty cycle of the PWM signal:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
This is the register that storages the value of the counter used to generate the PWM.

<h2>PWM Configuration in STM32CubeIDE</h2>

To configure a timer as PWM, the first thing to do is to select one of the timers that could be configured as a PWM generator.
Additionally, also the channels that will be used as PWM output must be decided.

<b>Advice:</b> As different PWM outputs are needed, it is recommended to use different channels of the same timer to the extent possible.

The main timers that can be set as PWM are: TIM2, TIM3, TIM4 and TIM5, with 4 different channels each of them.

<b>Advice:</b> It is recommended to use the timer and the corresponding channels that match directly with the pins that feed the H-bridge to modulate the speed of the motor. Otherwise, the PWM output signals must be bridged with the H-bridge input signals.

Therefore, the pins that the channels of the timer are using need to be checked in the "Pinout" section of the STM32CubeIDE.

Once the channels of the timer have been activated, some parameters and the configuration of the timer must be changed.

Main parameters:
<ul>
<li><b>Clock Source:</b> Clock of the timer. The Internal clock option must be selected. Moreover, it must be checked that the frequency of the clock that is being used is the one desired. This could be checked within the clock configuration tab of the STM32CubeIDE. </li>
<li><b>Channel x:</b> Configuration for the channel x of the timer. The option “PWM Generation CHx” must be selected, in which x will be the number of the channel to configure.</li>
<li><b>Prescaler (PSC):</b> Parameter to introduce the value of the PSC register.</li>
<li><b>Counter Period:</b> Parameter to set the value of the ARR register.</li>
<li><b>Pulse (16 bits):</b> Parameter to mofidy the CCR register.</li>
<li><b>Mode: </b> The PWM mode 1 must be selected.</li>
</ul>

Additionally, within the code, the timer to use must be initialized following the structure below:

<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

The CCR value can be modified by introducing the following instruction:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

in which CCR1 indicates that we are accessing to the channel 1 register, new_ccr is the new to set and htimx refers to the timer x (for example, htim2 or htim3).

In the same way, to modify the register of the channel 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T10:38:26Z

Blancal:

__TOC__

To install STM32CubeIDE and to run a Hello World example, please check it here: http://wiki.robolabo.etsit.upm.es/index.php/Nucleo_Boards

<h1> GPIO read and write </h1>

<h2> Read from a GPIO</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Write to a GPIO</h2>
- High level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- Low level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Theory </h2>

The encoder used in the laboratory is a position sensor that uses a two-channel hall effect sensor. It is a quadrature encoder that is attached to the motor shaft and which provides a resolution of 48 counts per revolution. This means that for a complete turn of the motor shaft, the encoder provides a value of 48 counts. The hall sensor requires an input voltage and the output of the encoder comes from reading the output of the two channels, channel A and channel B. These two channels are square waves which are 90ª out of phase.

<h2> Encoder Configuration in STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Theory </h2>

<h2> Main registers </h2>
<h3> Prescaler (PSC) </h3>

The prescaler is a register that divides the timer clock frequency to obtain a specific frequency.
Specifically, the frequency reduction is applied using the following formula:

f_PWM = f_CLK / (PSC + 1)

Therefore, if the frequency to set is the same as the frequency of the clock, the PSC register must be set at PSC=0.
The STM32 timers allow a prescaler value up to 65535, through 16 bits registers.

<h3> Auto Reload Register (ARR) and Capture Compare Register (CCR) </h3>
The ARR register storages the maximum value that the counter can reach before going back to zero.
Moreover, the CCR registers the value of the corresponding timer counter after which the output PWM signal goes from high to low level.
Every channel of the timer used to generate the PWM will have a different CCR register (for example, CCR1 and CCR2 for channels 1 and 2).
In this way, the value of the CCR together with the value of the ARR define the width of the pulses and, therefore, the duty cycle of the PWM signal:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
This is the register that storages the value of the counter used to generate the PWM.

<h2>PWM Configuration in STM32CubeIDE</h2>

To configure a timer as PWM, the first thing to do is to select one of the timers that could be configured as a PWM generator.
Additionally, also the channels that will be used as PWM output must be decided.

<b>Advice:</b> As different PWM outputs are needed, it is recommended to use different channels of the same timer to the extent possible.

The main timers that can be set as PWM are: TIM2, TIM3, TIM4 and TIM5, with 4 different channels each of them.

<b>Advice:</b> It is recommended to use the timer and the corresponding channels that match directly with the pins that feed the H-bridge to modulate the speed of the motor. Otherwise, the PWM output signals must be bridged with the H-bridge input signals.

Therefore, the pins that the channels of the timer are using need to be checked in the "Pinout" section of the STM32CubeIDE.

Once the channels of the timer have been activated, some parameters and the configuration of the timer must be changed.

Main parameters:
<ul>
<li><b>Clock Source:</b> Clock of the timer. The Internal clock option must be selected. Moreover, it must be checked that the frequency of the clock that is being used is the one desired. This could be checked within the clock configuration tab of the STM32CubeIDE. </li>
<li><b>Channel x:</b> Configuration for the channel x of the timer. The option “PWM Generation CHx” must be selected, in which x will be the number of the channel to configure.</li>
<li><b>Prescaler (PSC):</b> Parameter to introduce the value of the PSC register.</li>
<li><b>Counter Period:</b> Parameter to set the value of the ARR register.</li>
<li><b>Pulse (16 bits):</b> Parameter to mofidy the CCR register.</li>
<li><b>Mode: </b> The PWM mode 1 must be selected.</li>
</ul>

Additionally, within the code, the timer to use must be initialized following the structure below:

<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

The CCR value can be modified by introducing the following instruction:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

in which CCR1 indicates that we are accessing to the channel 1 register, new_ccr is the new to set and htimx refers to the timer x (for example, htim2 or htim3).

In the same way, to modify the register of the channel 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T10:38:03Z

Blancal:

__TOC__

To install STM32CubeIDE and to run a Hello World example, please check it here: http://wiki.robolabo.etsit.upm.es/index.php/Nucleo_Boards

<h1> GPIO read and write </h1>

<h2> Read from a GPIO</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Write to a GPIO</h2>
- High level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- Low level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Theory </h2>

The encoder used is a position sensor that uses a two-channel hall effect sensor. It is a quadrature encoder that is attached to the motor shaft and which provides a resolution of 48 counts per revolution. This means that for a complete turn of the motor shaft, the encoder provides a value of 48 counts. The hall sensor requires an input voltage and the output of the encoder comes from reading the output of the two channels, channel A and channel B. These two channels are square waves which are 90ª out of phase.

<h2> Encoder Configuration in STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Theory </h2>

<h2> Main registers </h2>
<h3> Prescaler (PSC) </h3>

The prescaler is a register that divides the timer clock frequency to obtain a specific frequency.
Specifically, the frequency reduction is applied using the following formula:

f_PWM = f_CLK / (PSC + 1)

Therefore, if the frequency to set is the same as the frequency of the clock, the PSC register must be set at PSC=0.
The STM32 timers allow a prescaler value up to 65535, through 16 bits registers.

<h3> Auto Reload Register (ARR) and Capture Compare Register (CCR) </h3>
The ARR register storages the maximum value that the counter can reach before going back to zero.
Moreover, the CCR registers the value of the corresponding timer counter after which the output PWM signal goes from high to low level.
Every channel of the timer used to generate the PWM will have a different CCR register (for example, CCR1 and CCR2 for channels 1 and 2).
In this way, the value of the CCR together with the value of the ARR define the width of the pulses and, therefore, the duty cycle of the PWM signal:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
This is the register that storages the value of the counter used to generate the PWM.

<h2>PWM Configuration in STM32CubeIDE</h2>

To configure a timer as PWM, the first thing to do is to select one of the timers that could be configured as a PWM generator.
Additionally, also the channels that will be used as PWM output must be decided.

<b>Advice:</b> As different PWM outputs are needed, it is recommended to use different channels of the same timer to the extent possible.

The main timers that can be set as PWM are: TIM2, TIM3, TIM4 and TIM5, with 4 different channels each of them.

<b>Advice:</b> It is recommended to use the timer and the corresponding channels that match directly with the pins that feed the H-bridge to modulate the speed of the motor. Otherwise, the PWM output signals must be bridged with the H-bridge input signals.

Therefore, the pins that the channels of the timer are using need to be checked in the "Pinout" section of the STM32CubeIDE.

Once the channels of the timer have been activated, some parameters and the configuration of the timer must be changed.

Main parameters:
<ul>
<li><b>Clock Source:</b> Clock of the timer. The Internal clock option must be selected. Moreover, it must be checked that the frequency of the clock that is being used is the one desired. This could be checked within the clock configuration tab of the STM32CubeIDE. </li>
<li><b>Channel x:</b> Configuration for the channel x of the timer. The option “PWM Generation CHx” must be selected, in which x will be the number of the channel to configure.</li>
<li><b>Prescaler (PSC):</b> Parameter to introduce the value of the PSC register.</li>
<li><b>Counter Period:</b> Parameter to set the value of the ARR register.</li>
<li><b>Pulse (16 bits):</b> Parameter to mofidy the CCR register.</li>
<li><b>Mode: </b> The PWM mode 1 must be selected.</li>
</ul>

Additionally, within the code, the timer to use must be initialized following the structure below:

<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

The CCR value can be modified by introducing the following instruction:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

in which CCR1 indicates that we are accessing to the channel 1 register, new_ccr is the new to set and htimx refers to the timer x (for example, htim2 or htim3).

In the same way, to modify the register of the channel 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T10:29:49Z

Blancal:

__TOC__

To install STM32CubeIDE and to run a Hello World example, please check it here: http://wiki.robolabo.etsit.upm.es/index.php/Nucleo_Boards

<h1> GPIO read and write </h1>

<h2> Read from a GPIO</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Write to a GPIO</h2>
- High level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- Low level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Theory </h2>

<h2> Encoder Configuration in STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Theory </h2>

<h2> Main registers </h2>
<h3> Prescaler (PSC) </h3>

The prescaler is a register that divides the timer clock frequency to obtain a specific frequency.
Specifically, the frequency reduction is applied using the following formula:

f_PWM = f_CLK / (PSC + 1)

Therefore, if the frequency to set is the same as the frequency of the clock, the PSC register must be set at PSC=0.
The STM32 timers allow a prescaler value up to 65535, through 16 bits registers.

<h3> Auto Reload Register (ARR) and Capture Compare Register (CCR) </h3>
The ARR register storages the maximum value that the counter can reach before going back to zero.
Moreover, the CCR registers the value of the corresponding timer counter after which the output PWM signal goes from high to low level.
Every channel of the timer used to generate the PWM will have a different CCR register (for example, CCR1 and CCR2 for channels 1 and 2).
In this way, the value of the CCR together with the value of the ARR define the width of the pulses and, therefore, the duty cycle of the PWM signal:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
This is the register that storages the value of the counter used to generate the PWM.

<h2>PWM Configuration in STM32CubeIDE</h2>

To configure a timer as PWM, the first thing to do is to select one of the timers that could be configured as a PWM generator.
Additionally, also the channels that will be used as PWM output must be decided.

<b>Advice:</b> As different PWM outputs are needed, it is recommended to use different channels of the same timer to the extent possible.

The main timers that can be set as PWM are: TIM2, TIM3, TIM4 and TIM5, with 4 different channels each of them.

<b>Advice:</b> It is recommended to use the timer and the corresponding channels that match directly with the pins that feed the H-bridge to modulate the speed of the motor. Otherwise, the PWM output signals must be bridged with the H-bridge input signals.

Therefore, the pins that the channels of the timer are using need to be checked in the "Pinout" section of the STM32CubeIDE.

Once the channels of the timer have been activated, some parameters and the configuration of the timer must be changed.

Main parameters:
<ul>
<li><b>Clock Source:</b> Clock of the timer. The Internal clock option must be selected. Moreover, it must be checked that the frequency of the clock that is being used is the one desired. This could be checked within the clock configuration tab of the STM32CubeIDE. </li>
<li><b>Channel x:</b> Configuration for the channel x of the timer. The option “PWM Generation CHx” must be selected, in which x will be the number of the channel to configure.</li>
<li><b>Prescaler (PSC):</b> Parameter to introduce the value of the PSC register.</li>
<li><b>Counter Period:</b> Parameter to set the value of the ARR register.</li>
<li><b>Pulse (16 bits):</b> Parameter to mofidy the CCR register.</li>
<li><b>Mode: </b> The PWM mode 1 must be selected.</li>
</ul>

Additionally, within the code, the timer to use must be initialized following the structure below:

<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

The CCR value can be modified by introducing the following instruction:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

in which CCR1 indicates that we are accessing to the channel 1 register, new_ccr is the new to set and htimx refers to the timer x (for example, htim2 or htim3).

In the same way, to modify the register of the channel 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T10:29:36Z

Blancal:

__TOC__

To install STM32CubeIDE and to run a Hello World example, please check it here: http://wiki.robolabo.etsit.upm.es/index.php/Nucleo_Boards

<h1> GPIO read and write </h1>

<h2> Read from a GPIO</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Write to a GPIO</h2>
- High level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- Low level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Theory </h2>

<h2> Encoder Configuration in STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Theory </h2>

<h2> Main registers </h2>
<h3> Prescaler (PSC) </h3>

The prescaler is a register that divides the timer clock frequency to obtain a specific frequency.
Specifically, the frequency reduction is applied using the following formula:

f_PWM = f_CLK / (PSC + 1)

Therefore, if the frequency to set is the same as the frequency of the clock, the PSC register must be set at PSC=0.
The STM32 timers allow a prescaler value up to 65535, through 16 bits registers.

<h3> Auto Reload Register (ARR) and Capture Compare Register (CCR) </h3>
The ARR register storages the maximum value that the counter can reach before going back to zero.
Moreover, the CCR registers the value of the corresponding timer counter after which the output PWM signal goes from high to low level.
Every channel of the timer used to generate the PWM will have a different CCR register (for example, CCR1 and CCR2 for channels 1 and 2).
In this way, the value of the CCR together with the value of the ARR define the width of the pulses and, therefore, the duty cycle of the PWM signal:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
This is the register that storages the value of the counter used to generate the PWM.

<h2>PWM Configuration in STM32CubeIDE</h2>

To configure a timer as PWM, the first thing to do is to select one of the timers that could be configured as a PWM generator.
Additionally, also the channels that will be used as PWM output must be decided.

<b>Advice:</b> As different PWM outputs are needed, it is recommended to use different channels of the same timer to the extent possible.

The main timers that can be set as PWM are: TIM2, TIM3, TIM4 and TIM5, with 4 different channels each of them.

<b>Advice:</b> It is recommended to use the timer and the corresponding channels that match directly with the pins that feed the H-bridge to modulate the speed of the motor. Otherwise, the PWM output signals must be bridged with the H-bridge input signals.

Therefore, the pins that the channels of the timer are using need to be checked in the "Pinout" section of the STM32CubeIDE.

Once the channels of the timer have been activated, some parameters and the configuration of the timer must be changed.

Main parameters:
<ul>
<li><b>Clock Source:</b> Clock of the timer. The Internal clock option must be selected. Moreover, it must be checked that the frequency of the clock that is being used is the one desired. This could be checked within the clock configuration tab of the STM32CubeIDE. </li>
<li><b>Channel x:</b> Configuration for the channel x of the timer. The option “PWM Generation CHx” must be selected, in which x will be the number of the channel to configure.</li>
<li><b>Prescaler (PSC):</b> Parameter to introduce the value of the PSC register.</li>
<li><b>Counter Period:</b> Parameter to set the value of the ARR register.</li>
<li><b>Pulse (16 bits):</b> Parameter to mofidy the CCR register.</li>
<li><b>Mode: </b> The PWM mode 1 must be selected.</li>
</ul>

Additionally, within the code, the timer to use must be initialized following the structure below:

<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

The CCR value can be modified by introducing the following instruction:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

in which CCR1 indicates that we are accessing to the channel 1 register, new_ccr is the new to set and htimx refers to the timer x (for example, htim2 or htim3).

In the same way, to modify the register of the channel 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T10:21:47Z

Blancal:

__TOC__

<h1> GPIO read and write </h1>

<h2> Read from a GPIO</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Write to a GPIO</h2>
- High level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- Low level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Theory </h2>

<h2> Encoder Configuration in STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Theory </h2>

<h2> Main registers </h2>
<h3> Prescaler (PSC) </h3>

The prescaler is a register that divides the timer clock frequency to obtain a specific frequency.
Specifically, the frequency reduction is applied using the following formula:

f_PWM = f_CLK / (PSC + 1)

Therefore, if the frequency to set is the same as the frequency of the clock, the PSC register must be set at PSC=0.
The STM32 timers allow a prescaler value up to 65535, through 16 bits registers.

<h3> Auto Reload Register (ARR) and Capture Compare Register (CCR) </h3>
The ARR register storages the maximum value that the counter can reach before going back to zero.
Moreover, the CCR registers the value of the corresponding timer counter after which the output PWM signal goes from high to low level.
Every channel of the timer used to generate the PWM will have a different CCR register (for example, CCR1 and CCR2 for channels 1 and 2).
In this way, the value of the CCR together with the value of the ARR define the width of the pulses and, therefore, the duty cycle of the PWM signal:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
This is the register that storages the value of the counter used to generate the PWM.

<h2>PWM Configuration in STM32CubeIDE</h2>

To configure a timer as PWM, the first thing to do is to select one of the timers that could be configured as a PWM generator.
Additionally, also the channels that will be used as PWM output must be decided.

<b>Advice:</b> As different PWM outputs are needed, it is recommended to use different channels of the same timer to the extent possible.

The main timers that can be set as PWM are: TIM2, TIM3, TIM4 and TIM5, with 4 different channels each of them.

<b>Advice:</b> It is recommended to use the timer and the corresponding channels that match directly with the pins that feed the H-bridge to modulate the speed of the motor. Otherwise, the PWM output signals must be bridged with the H-bridge input signals.

Therefore, the pins that the channels of the timer are using need to be checked in the "Pinout" section of the STM32CubeIDE.

Once the channels of the timer have been activated, some parameters and the configuration of the timer must be changed.

Main parameters:
<ul>
<li><b>Clock Source:</b> Clock of the timer. The Internal clock option must be selected. Moreover, it must be checked that the frequency of the clock that is being used is the one desired. This could be checked within the clock configuration tab of the STM32CubeIDE. </li>
<li><b>Channel x:</b> Configuration for the channel x of the timer. The option “PWM Generation CHx” must be selected, in which x will be the number of the channel to configure.</li>
<li><b>Prescaler (PSC):</b> Parameter to introduce the value of the PSC register.</li>
<li><b>Counter Period:</b> Parameter to set the value of the ARR register.</li>
<li><b>Pulse (16 bits):</b> Parameter to mofidy the CCR register.</li>
<li><b>Mode: </b> The PWM mode 1 must be selected.</li>
</ul>

Additionally, within the code, the timer to use must be initialized following the structure below:

<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

The CCR value can be modified by introducing the following instruction:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

in which CCR1 indicates that we are accessing to the channel 1 register, new_ccr is the new to set and htimx refers to the timer x (for example, htim2 or htim3).

In the same way, to modify the register of the channel 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T10:12:24Z

Blancal:

__TOC__

<h1> GPIO read and write </h1>

<h2> Read from a GPIO</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Write to a GPIO</h2>
- High level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- Low level:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Theory </h2>

<h2> Encoder Configuration in STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Theory </h2>

<h2> Main registers </h2>
<h3> Prescaler (PSC) </h3>

The prescaler is a register that divides the timer clock frequency to obtain a specific frequency.
Specifically, the frequency reduction is applied using the following formula:

f_PWM = f_CLK / (PSC + 1)

Therefore, if the frequency to set is the same as the frequency of the clock, the PSC register must be set at PSC=0.
The STM32 timers allow a prescaler value up to 65535, through 16 bits registers.

<h3> Auto Reload Register (ARR) and Capture Compare Register (CCR) </h3>
The ARR register storages the maximum value that the counter can reach before going back to zero.
Moreover, the CCR registers the value of the corresponding timer counter after which the output PWM signal goes from high to low level.
Every channel of the timer used to generate the PWM will have a different CCR register (for example, CCR1 and CCR2 for channels 1 and 2).
In this way, the value of the CCR together with the value of the ARR define the width of the pulses and, therefore, the duty cycle of the PWM signal:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
This is the register that storages the value of the counter used to generate the PWM.

<h2>PWM Configuration in STM32CubeIDE</h2>

To configure a timer as PWM, the first thing to do is to select one of the timers that could be configured as a PWM generator.
Additionally, also the channels that will be used as PWM output must be decided.

<b>Advice:</b> As different PWM outputs are needed, it is recommended to use different channels of the same timer to the extent possible.

The main timers that can be set as PWM are: TIM2, TIM3, TIM4 and TIM5, with 4 different channels each of them.

<b>Advice:</b> It is recommended to use the timer and the corresponding channels that match directly with the pins that feed the H-bridge to modulate the speed of the motor. Otherwise, the PWM output signals must be bridged with the H-bridge input signals.

Therefore, the pins that the channels of the timer are using need to be checked in the "Pinout" section of the STM32CubeIDE.

Once the channels of the timer have been activated, some parameters and the configuration of the timer must be changed.

Main parameters:
<ul>
<li><b>Clock Source:</b> reloj a tomar como referencia por el timer. Debemos seleccionar la opción Internal clock. Además, debemos asegurarnos que la frecuencia del reloj usada es la deseada, en la pestaña de clock configuration.</li>
<li><b>Channel x:</b> configuración deseada para el canal x del timer. Debemos seleccionar la opción “PWM Generation CHx”, donde x será el número del canal en cuestión.</li>
<li><b>Prescaler (PSC):</b> Parámetro para configurar el registro de PSC.</li>
<li><b>Counter Period:</b> Parámetro para configurar el valor del registro ARR.</li>
<li><b>Pulse (16 bits):</b> parámetro para modificar el registro de CCR.</li>
<li><b>Mode: </b> Debemos seleccionar PWM mode 1.</li>
</ul>

Además, en nuestro código debemos activar el timer ya configurado e inicializado de la siguiente manera:
<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

Podemos modificar el valor de CCR (aceder al registro) mediante código de la siguiente manera:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

donde CCR1 indica que estamos accediendo al registro del canal 1, new_ccr es el nuevo valor entero que queremos establecer y htimx es la instancia correspondiente al timer x (por ejemplo, htim2 o htim3).

De igual manera, para modificar el registro del canal 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T09:22:47Z

Blancal:

__TOC__

<h1> Lectura y escritura de pines </h1>
<h2> Lectura</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Escritura</h2>
- A nivel alto:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- A nivel bajo:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Teoría </h2>

<h2>Configuración de encoder en STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Teoría </h2>

<h2> Principales registros </h2>
<h3> Prescaler (PSC) </h3>
El preescalado es un registro que especifica entre cuánto se debe dividir la frecuencia de referencia del reloj usado por el timer.
En concreto, la reducción de frecuencia se aplica de la siguiente manera:

f_PWM = f_CLK / (PSC + 1)

Por lo tanto, hay que tener en cuenta que si queremos mantener la misma frecuencia que la del reloj de referencia debemos fijar PSC=0.
Los timers del STM32 admiten valores de preescalado de hasta 65535, mediante registros de 16 bits.

<h3> Auto Reload Register (ARR) y Capture Compare Register (CCR) </h3>
El registro ARR almacena el valor máximo que debe alcanzar el contador antes de volver a cero.
Por otra parte, CCR registra valor del contador del timer asociado a partir del cual la señal PWM de salida pasa de nivel alto a nivel bajo.
Cada canal del timer usado para la generación de señal PWM tendrá un registro CCR diferente (por ejemplo CCR1 y CCR para canales 1 y 2).
De esta manera, el valor de CCR junto con el valor de ARR definen la anchura de los pulsos y con ello el ciclo de trabajo de la señal PWM:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
Es el registro que almacena el valor actual del contador usado para la generación PWM.

<h2>Configuración de PWM en STM32CubeIDE</h2>

Para configurar el timer como PWM primero debemos seleccionar uno de los posibles timers configurables como generador PWM.
También debemos decidir los canles que queremos usar como salidas PWM.

<b>Consejo:</b> Al usar varias salidas PWM es recomendable usar diferentes canales del mismo timer en la medida de lo posible.

Los principales timers configurables como PWM son el TIM2, TIM3, TIM4 y TIM5, con 4 canales independientes cada uno.

<b>Consejo:</b> Es recomendable usar el timer y los canales que se correspondan directamente con los pines que alimentan las entradas del Puente H para modular la velocidad del motor. En caso contrario deberemos puentear las salidas del timer PWM con las entradas del puente H.

Por lo tanto, deberemos buscar los pines asociados a los canales del timer a usar en la vista “Pinout” del entorno de desarrollo.

Una vez hemos activado los canales del timer necesarios, debemos modificar la configuración y parámetros del timer.
Los principales parámetros
<ul>
<li><b>Clock Source:</b> reloj a tomar como referencia por el timer. Debemos seleccionar la opción Internal clock. Además, debemos asegurarnos que la frecuencia del reloj usada es la deseada, en la pestaña de clock configuration.</li>
<li><b>Channel x:</b> configuración deseada para el canal x del timer. Debemos seleccionar la opción “PWM Generation CHx”, donde x será el número del canal en cuestión.</li>
<li><b>Prescaler (PSC):</b> Parámetro para configurar el registro de PSC.</li>
<li><b>Counter Period:</b> Parámetro para configurar el valor del registro ARR.</li>
<li><b>Pulse (16 bits):</b> parámetro para modificar el registro de CCR.</li>
<li><b>Mode: </b> Debemos seleccionar PWM mode 1.</li>
</ul>

Además, en nuestro código debemos activar el timer ya configurado e inicializado de la siguiente manera:
<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

Podemos modificar el valor de CCR (aceder al registro) mediante código de la siguiente manera:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

donde CCR1 indica que estamos accediendo al registro del canal 1, new_ccr es el nuevo valor entero que queremos establecer y htimx es la instancia correspondiente al timer x (por ejemplo, htim2 o htim3).

De igual manera, para modificar el registro del canal 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

<h1> Serial Port </h1>

Nucleo Boards for Control Systems

2023-02-06T09:18:37Z

Blancal:

__TOC__

<h1> Lectura y escritura de pines </h1>
<h2> Lectura</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Escritura</h2>
- A nivel alto:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- A nivel bajo:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Teoría </h2>
<img src="robolabo.png">

<h2>Configuración de encoder en STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Teoría </h2>

<h2> Principales registros </h2>
<h3> Prescaler (PSC) </h3>
El preescalado es un registro que especifica entre cuánto se debe dividir la frecuencia de referencia del reloj usado por el timer.
En concreto, la reducción de frecuencia se aplica de la siguiente manera:

f_PWM = f_CLK / (PSC + 1)

Por lo tanto, hay que tener en cuenta que si queremos mantener la misma frecuencia que la del reloj de referencia debemos fijar PSC=0.
Los timers del STM32 admiten valores de preescalado de hasta 65535, mediante registros de 16 bits.

<h3> Auto Reload Register (ARR) y Capture Compare Register (CCR) </h3>
El registro ARR almacena el valor máximo que debe alcanzar el contador antes de volver a cero.
Por otra parte, CCR registra valor del contador del timer asociado a partir del cual la señal PWM de salida pasa de nivel alto a nivel bajo.
Cada canal del timer usado para la generación de señal PWM tendrá un registro CCR diferente (por ejemplo CCR1 y CCR para canales 1 y 2).
De esta manera, el valor de CCR junto con el valor de ARR definen la anchura de los pulsos y con ello el ciclo de trabajo de la señal PWM:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
Es el registro que almacena el valor actual del contador usado para la generación PWM.

<h2>Configuración de PWM en STM32CubeIDE</h2>

Para configurar el timer como PWM primero debemos seleccionar uno de los posibles timers configurables como generador PWM.
También debemos decidir los canles que queremos usar como salidas PWM.

<b>Consejo:</b> Al usar varias salidas PWM es recomendable usar diferentes canales del mismo timer en la medida de lo posible.

Los principales timers configurables como PWM son el TIM2, TIM3, TIM4 y TIM5, con 4 canales independientes cada uno.

<b>Consejo:</b> Es recomendable usar el timer y los canales que se correspondan directamente con los pines que alimentan las entradas del Puente H para modular la velocidad del motor. En caso contrario deberemos puentear las salidas del timer PWM con las entradas del puente H.

Por lo tanto, deberemos buscar los pines asociados a los canales del timer a usar en la vista “Pinout” del entorno de desarrollo.

Una vez hemos activado los canales del timer necesarios, debemos modificar la configuración y parámetros del timer.
Los principales parámetros
<ul>
<li><b>Clock Source:</b> reloj a tomar como referencia por el timer. Debemos seleccionar la opción Internal clock. Además, debemos asegurarnos que la frecuencia del reloj usada es la deseada, en la pestaña de clock configuration.</li>
<li><b>Channel x:</b> configuración deseada para el canal x del timer. Debemos seleccionar la opción “PWM Generation CHx”, donde x será el número del canal en cuestión.</li>
<li><b>Prescaler (PSC):</b> Parámetro para configurar el registro de PSC.</li>
<li><b>Counter Period:</b> Parámetro para configurar el valor del registro ARR.</li>
<li><b>Pulse (16 bits):</b> parámetro para modificar el registro de CCR.</li>
<li><b>Mode: </b> Debemos seleccionar PWM mode 1.</li>
</ul>

Además, en nuestro código debemos activar el timer ya configurado e inicializado de la siguiente manera:
<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

Podemos modificar el valor de CCR (aceder al registro) mediante código de la siguiente manera:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

donde CCR1 indica que estamos accediendo al registro del canal 1, new_ccr es el nuevo valor entero que queremos establecer y htimx es la instancia correspondiente al timer x (por ejemplo, htim2 o htim3).

De igual manera, para modificar el registro del canal 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

Nucleo Boards for Control Systems

2023-02-06T09:16:33Z

Blancal:

Nucleo Boards for Control Systems

2023-02-06T09:14:48Z

Blancal:

__TOC__

<h1> Lectura y escritura de pines </h1>
<h2> Lectura</h2>
<pre>
HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_9);
</pre>
<h2> Escritura</h2>
- A nivel alto:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
</pre>

- A nivel bajo:
<pre>
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
</pre>

<h1> Encoder </h1>
<h2> Teoría </h2>
hohslhalsodhas

<h2>Configuración de encoder en STM32CubeIDE</h2>

<h1> PWM </h1>

<h2> Teoría </h2>

<h2> Principales registros </h2>
<h3> Prescaler (PSC) </h3>
El preescalado es un registro que especifica entre cuánto se debe dividir la frecuencia de referencia del reloj usado por el timer.
En concreto, la reducción de frecuencia se aplica de la siguiente manera:

f_PWM = f_CLK / (PSC + 1)

Por lo tanto, hay que tener en cuenta que si queremos mantener la misma frecuencia que la del reloj de referencia debemos fijar PSC=0.
Los timers del STM32 admiten valores de preescalado de hasta 65535, mediante registros de 16 bits.

<h3> Auto Reload Register (ARR) y Capture Compare Register (CCR) </h3>
El registro ARR almacena el valor máximo que debe alcanzar el contador antes de volver a cero.
Por otra parte, CCR registra valor del contador del timer asociado a partir del cual la señal PWM de salida pasa de nivel alto a nivel bajo.
Cada canal del timer usado para la generación de señal PWM tendrá un registro CCR diferente (por ejemplo CCR1 y CCR para canales 1 y 2).
De esta manera, el valor de CCR junto con el valor de ARR definen la anchura de los pulsos y con ello el ciclo de trabajo de la señal PWM:

Duty_Cycle (%) = 100 * (CCR / ARR)

<h3> CNT </h3>
Es el registro que almacena el valor actual del contador usado para la generación PWM.

<h2>Configuración de PWM en STM32CubeIDE</h2>

Para configurar el timer como PWM primero debemos seleccionar uno de los posibles timers configurables como generador PWM.
También debemos decidir los canles que queremos usar como salidas PWM.

<b>Consejo:</b> Al usar varias salidas PWM es recomendable usar diferentes canales del mismo timer en la medida de lo posible.

Los principales timers configurables como PWM son el TIM2, TIM3, TIM4 y TIM5, con 4 canales independientes cada uno.

<b>Consejo:</b> Es recomendable usar el timer y los canales que se correspondan directamente con los pines que alimentan las entradas del Puente H para modular la velocidad del motor. En caso contrario deberemos puentear las salidas del timer PWM con las entradas del puente H.

Por lo tanto, deberemos buscar los pines asociados a los canales del timer a usar en la vista “Pinout” del entorno de desarrollo.

Una vez hemos activado los canales del timer necesarios, debemos modificar la configuración y parámetros del timer.
Los principales parámetros
<ul>
<li><b>Clock Source:</b> reloj a tomar como referencia por el timer. Debemos seleccionar la opción Internal clock. Además, debemos asegurarnos que la frecuencia del reloj usada es la deseada, en la pestaña de clock configuration.</li>
<li><b>Channel x:</b> configuración deseada para el canal x del timer. Debemos seleccionar la opción “PWM Generation CHx”, donde x será el número del canal en cuestión.</li>
<li><b>Prescaler (PSC):</b> Parámetro para configurar el registro de PSC.</li>
<li><b>Counter Period:</b> Parámetro para configurar el valor del registro ARR.</li>
<li><b>Pulse (16 bits):</b> parámetro para modificar el registro de CCR.</li>
<li><b>Mode: </b> Debemos seleccionar PWM mode 1.</li>
</ul>

Además, en nuestro código debemos activar el timer ya configurado e inicializado de la siguiente manera:
<pre>
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
</pre>

Podemos modificar el valor de CCR (aceder al registro) mediante código de la siguiente manera:
<pre>
htimx.Instance->CCR1 = new_ccr;
</pre>

donde CCR1 indica que estamos accediendo al registro del canal 1, new_ccr es el nuevo valor entero que queremos establecer y htimx es la instancia correspondiente al timer x (por ejemplo, htim2 o htim3).

De igual manera, para modificar el registro del canal 2:
<pre>
htimx.Instance->CCR2 = new_ccr;
</pre>

1DOF Haptic

2018-07-23T17:14:48Z

Blancal:

__TOC__

<b> Note: </b> The electronics of the robot are based on a Arduino Due board: https://www.arduino.cc/en/Main/ArduinoBoardDue
Moreover, the motor control is done through a H-Bridge board from ST: http://www.st.com/en/ecosystems/x-nucleo-ihm04a1.html

<h1> Configuring the environment </h1>

<h2> Setting up the Arduino Software </h2>

<ul>
<li> Download the Arduino IDE 1.6.x according to your operating system from: https://www.arduino.cc/en/Main/Software . </li>
<li> Install the Arduino IDE </li>
<ul>
<li> If you have chosen to download the installer, run the installer and install the software in a path of your convenience. </li>
<li> If you have chosen to download the sources (Linux or zip on Windows), uncompress the software in a path of your convenience </li>
</ul>
<li> Open/run Arduino IDE, so it will create all the folders needed</li>

</ul>

<h2> Installing Tools and Libraries </h2>
<ul>
<li> The 1DOF haptic robot uses a Arduino DUE board, so the Arduino IDE support must be installed. Open Boards configurator: </li>
<pre>
Tools → Boards → Boards' Manager
</pre>
Install support for SAM Boards - (32-bits ARM Cortex-M3

<li> Download the DueTimer.zip library from: https://github.com/ivanseidel/DueTimer/releases </li>
<li> Install the library: </li>
<pre>
Program → Include library → Add Zip library
</pre>

<li> Select the zip file that has been downloaded </li>

<h3> Installing FTDI drivers </h3>
If you are using Linux or Mac, skip this step.
If you are using Windows, power up the robot and connect it to your computer.
Windows should ask you to install some FTDI drivers to be able to connect to the robot.

<h1> Hello World example </h1>

We have created a helloWorld example to test the communication with the robot.
Please download it from [[media:1DOFHAP-HelloWorldMotor.tgz | here ]] in your prefered destination.
Untar the file:
<pre>
tar -xvzf helloWorld.tgz
</pre>

<h2> Compiling the code </h2>
<li> Open Arduino IDE and load the .ino file in your environment: </li>
<pre>
File → Open → <HELLOWORLD_EXAMPLE>
</pre>

<li> Select the Arduino DUE board: </li>
<pre>
Tools → Board → Arduino Due
</pre>

<li> Compile the program: </li>
<pre>
Program → Verify/Compile
</pre>

<h2> Downloading the code to the robot </h2>
The Arduino Due has two usb ports. The one that is closer to the power jack is the programming port and the one used with the 1DOF Haptic Robot.

Select the correct port to download the binaries:
In Linux, typically:
<pre>
tools → Port → /dev/ttyUSBX
</pre>

In Windows, typically:
<pre>
tools → Port → COMX
</pre>

where X depends on your system and the number of peripherals on it

Upload your code to the board:
<pre>
Program → Upload
</pre>

The IDE will notify that it is <i> uploading </i> and after some seconds it will say <i> uploaded </i>.

<h2> Playing with HelloWorld </h2>

This example allows you to see the functionality of some of the functions handcoded.
Once the software has been loaded, the robot should move 1 second counterclockwise and 1 second clockwise.
After those 2 seconds it should stop.

Once the code have been loaded, you can open the serial port:
<pre>
Tools → Serial Monitor
</pre>

You should see in real time the information provided by the helloworld example, basically:
<ul>
<li> Count: The communication time, in timer ticks
<li> Pos: The position, in encoder pulses units
<li> Vel: The speed, in encoder pulses units
</ul>

<h1> Practice 2 Template (P2)</h1>

For the implementation of Practice 2 of the "Control and Robotics in Medicine" subject of the "Master on Bioengineering" of the UPM, we have created a students template.
You can download the template from [[media:1DOFHAP-P2Template.tgz | here ]]

<h2> Structure </h2>
The template has 5 different block of files:
<ul>
<li> <b> encoder.{c,h} </b>: where functions related to the measurement of the encoder are developed.
<li> <b> motor.{c,h} </b>: where functions related to the movement of the motor are developed.
<li> <b> comm.{c,h} </b>: where functions related to the serial port communication are developed.
<li> <b> controller.{c,h} </b>: where specific controllers could be developed. <b> It will not be used on P2 </b>
<li> <b> P2-Template.ino </b>: The place where the practice should be developed.
</ul>

<h2> Methods </h2>
This Section provides important information for the resolution of Practice2.
It is based on the explanation of different methods to control the robot, but it does not explain the complete set of methods.
To get and exahustive description of all methods all fies must be studied.

Given some restrictions to the Arduino software structure, some function prototypes are defined in the main file.
However, sections related to the header files refer to its implementation.

<h3> Encoder </h3>

This library is in charge of calculating the movement of the motor related to the encoder.
The functions to control the encoder are defined as follows:


<pre>
void ENCODER_Init (void)
</pre>
It configures the pinout of the encoder and launches the interrupts related to channel A and B.
<br>


<pre>
void ENCODER_StartSpeedCalculation ( long l_sampling_time )
</pre>
It configures a timer in charge of calculating the speed average of the motor.
<ul>
<li> <b> long l_sampling_time </b>: It defines the sampling period in milliseconds.
</ul>
<br>


<pre>
long ENCODER_GetCount ( void )
</pre>
It returns the actual count of the encoder, that is, the position of the motor related to its initial condition.
<ul>
<li> <b> return </b>: It returns a long value related to the pulses of the encoder, positive or negative, related to the initial position of the encoder. </li>
</ul>
<br>


<pre>
long ENCODER_GetCountInSpeedInterval ( void)
</pre>
It returns an averge speed, expressed in counts per second.

<ul>
<li> <b> return </b>: It returns a long value related to the pulses per second of the encoder, positive or negative.
</ul>

<br>
<b> IMPORTANT: The encoder available on Practice 2, is a 48 quadrature Counts Per Revolution (CPR) encoder.
This means that <i> ENCODER_GetCount (void) </i> and <i> ENCODER_GetCountInSpeedInterval (void) </i> functions return a value related to the encoder counts.
That means that for every turn on the motor axis, there are 48 values (1 pulse every 7.5 degrees).
This value must be multiplied by the reduction ratio of the motor to check the position outside the motor axis. </b>
<br>

<h3> Motor </h3>

This library is in charge of moving the motor.
The motor is moved based on a PWM which is executed at a sampling period.

The functions to control the motor are defined as follows:


<pre>
void MOTOR_Init ( void )
</pre>
It configures the pinout of the H-bridge to control the motor and inits the PWM peripheral to control it.
<br>


<pre>
void MOTOR_SetVoltage ( float f_voltage )
</pre>
It sets up a voltage to be sent to the motor. Remember the motor is controlled through a PWM, so it really sets up a PWM to controlthe H-Bridge.

<ul>
<li> <b> flot f_voltage </b>: This is the value of the voltage to be applied to the motor. It can be positive or negative, and the function limits the maximum and minimum values according to the <i> MOTOR_MAX_VOLTAGE </i> variable defined in <i> motor.h </i> </li>
</ul>
<br>

<h3> Communication </h3>

This library is in charge of managing periodic communications through the serial port.
The functions are defined as follows:


<pre>
void COMMUNICATION_Init ( int speed );
</pre>
It configures the serial port at a specific speed.
<ul>
<li> <b> int speed </b>: The speed, in bauds, to configure and open the serial port. </li>
</ul>
<br>


<pre>
void COMMUNICATION_Start ( long l_sampling_time )
</pre>
It starts a timer to handle periodically the communications. This timer calls the <i> COMMUNICATION_ROB </i> function at <i> l_sampling_time </i>

<ul>
<li> <b> long l_sampling_time </b>: It defines the sampling period in milliseconds.</li>
</ul>
<br>


<pre>
void COMMUNICATION_Stop ( void )
</pre>
It stops the timer in charge of calling <i> COMMUNICATION_ROB </i>, so communication stops.

<h3> Controller </h3>
This library is in charge of managing a periodic timer to implement the controller developed.
The functions are defined as follows:


<pre>
void CONTROLLER_Start ( long l_sampling_time )
</pre>
It starts a timer to handle periodically the communications. This timer calls the <i> CONTROLLER_ROB </i> function at <i> l_sampling_time </i>

<ul>
<li> <b> long l_sampling_time </b>: It defines the sampling period in milliseconds.</li>
</ul>
<br>

<h3> P2-Template.ino </h3>


<pre>
void COMMUNICATION_ROB ( void )
</pre>
This function should implement which is the information you want to send through the serial port, to obtain specific data and plot some graphs.
<br>


<pre>
void CONTROLLER_ROB ( void )
</pre>
This function should implement the controllers.

<b> Important </b>: It is important that the helloworld and template files are studied before starting Practice 2.
Moreover, it is recommended that before arriving to the laboratory, two functions to convert encoder counts to position (in radians) and speed (in radians/second) are already programmed, to save time and get a basic understanding of the robot electronics.

1DOF Haptic

2018-07-23T17:14:34Z

Blancal:

__TOC__

<b> Note: </b> The electronics of the robot are based on a Arduino Due board: https://www.arduino.cc/en/Main/ArduinoBoardDue
Moreover, the motor control is done through a H-Bridge board from ST: http://www.st.com/en/ecosystems/x-nucleo-ihm04a1.html

<h1> Configuring the environment </h1>

PEPEPSPSPS

<h2> Setting up the Arduino Software </h2>

<ul>
<li> Download the Arduino IDE 1.6.x according to your operating system from: https://www.arduino.cc/en/Main/Software . </li>
<li> Install the Arduino IDE </li>
<ul>
<li> If you have chosen to download the installer, run the installer and install the software in a path of your convenience. </li>
<li> If you have chosen to download the sources (Linux or zip on Windows), uncompress the software in a path of your convenience </li>
</ul>
<li> Open/run Arduino IDE, so it will create all the folders needed</li>

</ul>

<h2> Installing Tools and Libraries </h2>
<ul>
<li> The 1DOF haptic robot uses a Arduino DUE board, so the Arduino IDE support must be installed. Open Boards configurator: </li>
<pre>
Tools → Boards → Boards' Manager
</pre>
Install support for SAM Boards - (32-bits ARM Cortex-M3

<li> Download the DueTimer.zip library from: https://github.com/ivanseidel/DueTimer/releases </li>
<li> Install the library: </li>
<pre>
Program → Include library → Add Zip library
</pre>

<li> Select the zip file that has been downloaded </li>

<h3> Installing FTDI drivers </h3>
If you are using Linux or Mac, skip this step.
If you are using Windows, power up the robot and connect it to your computer.
Windows should ask you to install some FTDI drivers to be able to connect to the robot.

<h1> Hello World example </h1>

We have created a helloWorld example to test the communication with the robot.
Please download it from [[media:1DOFHAP-HelloWorldMotor.tgz | here ]] in your prefered destination.
Untar the file:
<pre>
tar -xvzf helloWorld.tgz
</pre>

<h2> Compiling the code </h2>
<li> Open Arduino IDE and load the .ino file in your environment: </li>
<pre>
File → Open → <HELLOWORLD_EXAMPLE>
</pre>

<li> Select the Arduino DUE board: </li>
<pre>
Tools → Board → Arduino Due
</pre>

<li> Compile the program: </li>
<pre>
Program → Verify/Compile
</pre>

<h2> Downloading the code to the robot </h2>
The Arduino Due has two usb ports. The one that is closer to the power jack is the programming port and the one used with the 1DOF Haptic Robot.

Select the correct port to download the binaries:
In Linux, typically:
<pre>
tools → Port → /dev/ttyUSBX
</pre>

In Windows, typically:
<pre>
tools → Port → COMX
</pre>

where X depends on your system and the number of peripherals on it

Upload your code to the board:
<pre>
Program → Upload
</pre>

The IDE will notify that it is <i> uploading </i> and after some seconds it will say <i> uploaded </i>.

<h2> Playing with HelloWorld </h2>

This example allows you to see the functionality of some of the functions handcoded.
Once the software has been loaded, the robot should move 1 second counterclockwise and 1 second clockwise.
After those 2 seconds it should stop.

Once the code have been loaded, you can open the serial port:
<pre>
Tools → Serial Monitor
</pre>

You should see in real time the information provided by the helloworld example, basically:
<ul>
<li> Count: The communication time, in timer ticks
<li> Pos: The position, in encoder pulses units
<li> Vel: The speed, in encoder pulses units
</ul>

<h1> Practice 2 Template (P2)</h1>

For the implementation of Practice 2 of the "Control and Robotics in Medicine" subject of the "Master on Bioengineering" of the UPM, we have created a students template.
You can download the template from [[media:1DOFHAP-P2Template.tgz | here ]]

<h2> Structure </h2>
The template has 5 different block of files:
<ul>
<li> <b> encoder.{c,h} </b>: where functions related to the measurement of the encoder are developed.
<li> <b> motor.{c,h} </b>: where functions related to the movement of the motor are developed.
<li> <b> comm.{c,h} </b>: where functions related to the serial port communication are developed.
<li> <b> controller.{c,h} </b>: where specific controllers could be developed. <b> It will not be used on P2 </b>
<li> <b> P2-Template.ino </b>: The place where the practice should be developed.
</ul>

<h2> Methods </h2>
This Section provides important information for the resolution of Practice2.
It is based on the explanation of different methods to control the robot, but it does not explain the complete set of methods.
To get and exahustive description of all methods all fies must be studied.

Given some restrictions to the Arduino software structure, some function prototypes are defined in the main file.
However, sections related to the header files refer to its implementation.

<h3> Encoder </h3>

This library is in charge of calculating the movement of the motor related to the encoder.
The functions to control the encoder are defined as follows:


<pre>
void ENCODER_Init (void)
</pre>
It configures the pinout of the encoder and launches the interrupts related to channel A and B.
<br>


<pre>
void ENCODER_StartSpeedCalculation ( long l_sampling_time )
</pre>
It configures a timer in charge of calculating the speed average of the motor.
<ul>
<li> <b> long l_sampling_time </b>: It defines the sampling period in milliseconds.
</ul>
<br>


<pre>
long ENCODER_GetCount ( void )
</pre>
It returns the actual count of the encoder, that is, the position of the motor related to its initial condition.
<ul>
<li> <b> return </b>: It returns a long value related to the pulses of the encoder, positive or negative, related to the initial position of the encoder. </li>
</ul>
<br>


<pre>
long ENCODER_GetCountInSpeedInterval ( void)
</pre>
It returns an averge speed, expressed in counts per second.

<ul>
<li> <b> return </b>: It returns a long value related to the pulses per second of the encoder, positive or negative.
</ul>

<br>
<b> IMPORTANT: The encoder available on Practice 2, is a 48 quadrature Counts Per Revolution (CPR) encoder.
This means that <i> ENCODER_GetCount (void) </i> and <i> ENCODER_GetCountInSpeedInterval (void) </i> functions return a value related to the encoder counts.
That means that for every turn on the motor axis, there are 48 values (1 pulse every 7.5 degrees).
This value must be multiplied by the reduction ratio of the motor to check the position outside the motor axis. </b>
<br>

<h3> Motor </h3>

This library is in charge of moving the motor.
The motor is moved based on a PWM which is executed at a sampling period.

The functions to control the motor are defined as follows:


<pre>
void MOTOR_Init ( void )
</pre>
It configures the pinout of the H-bridge to control the motor and inits the PWM peripheral to control it.
<br>


<pre>
void MOTOR_SetVoltage ( float f_voltage )
</pre>
It sets up a voltage to be sent to the motor. Remember the motor is controlled through a PWM, so it really sets up a PWM to controlthe H-Bridge.

<ul>
<li> <b> flot f_voltage </b>: This is the value of the voltage to be applied to the motor. It can be positive or negative, and the function limits the maximum and minimum values according to the <i> MOTOR_MAX_VOLTAGE </i> variable defined in <i> motor.h </i> </li>
</ul>
<br>

<h3> Communication </h3>

This library is in charge of managing periodic communications through the serial port.
The functions are defined as follows:


<pre>
void COMMUNICATION_Init ( int speed );
</pre>
It configures the serial port at a specific speed.
<ul>
<li> <b> int speed </b>: The speed, in bauds, to configure and open the serial port. </li>
</ul>
<br>


<pre>
void COMMUNICATION_Start ( long l_sampling_time )
</pre>
It starts a timer to handle periodically the communications. This timer calls the <i> COMMUNICATION_ROB </i> function at <i> l_sampling_time </i>

<ul>
<li> <b> long l_sampling_time </b>: It defines the sampling period in milliseconds.</li>
</ul>
<br>


<pre>
void COMMUNICATION_Stop ( void )
</pre>
It stops the timer in charge of calling <i> COMMUNICATION_ROB </i>, so communication stops.

<h3> Controller </h3>
This library is in charge of managing a periodic timer to implement the controller developed.
The functions are defined as follows:


<pre>
void CONTROLLER_Start ( long l_sampling_time )
</pre>
It starts a timer to handle periodically the communications. This timer calls the <i> CONTROLLER_ROB </i> function at <i> l_sampling_time </i>

<ul>
<li> <b> long l_sampling_time </b>: It defines the sampling period in milliseconds.</li>
</ul>
<br>

<h3> P2-Template.ino </h3>


<pre>
void COMMUNICATION_ROB ( void )
</pre>
This function should implement which is the information you want to send through the serial port, to obtain specific data and plot some graphs.
<br>


<pre>
void CONTROLLER_ROB ( void )
</pre>
This function should implement the controllers.

<b> Important </b>: It is important that the helloworld and template files are studied before starting Practice 2.
Moreover, it is recommended that before arriving to the laboratory, two functions to convert encoder counts to position (in radians) and speed (in radians/second) are already programmed, to save time and get a basic understanding of the robot electronics.