% -------------------------------------------------------------
% Secção sobre tretas 1
% -------------------------------------------------------------
\section{Grandezas a monitorizar} \label{sec:sit_risk_condu}

Para fazer a monitorização da condução é necessário conhecer o estado das diferentes variáveis no interior do habitáculo do AtlasCar, isto é, todo o tipo de manípulos ou botões fundamentais ao exercício da condução. Desta forma podemos contabilizar os três pedais do condutor, os indicadores luminosos (piscas e luzes) e a buzina. Outras variáveis relevantes para análise são a velocidade e os obstáculos existentes no espaço exterior do veículo.



% -------------------------------------------------------------
% Secção sobre tretas 2
% -------------------------------------------------------------
\section{Hardware e software adotados}\label{sec:hard_used}
\subsection{Controlo do AtlasCar}\label{subsec:hard_control}


No caso específico do projeto  AtlasCar, a "centralina"\ é composta por dois PLC's. O primeiro é responsável pela atuação e gestão dos diferentes módulos do carro nos modos automático e manual. O segundo, tem como tarefa o controlo da alimentação de cada sensor presente no AtlasCar, sendo possível ligar e desligar os diferentes sensores do AtlasCar fisicamente, através do uso de interruptores ou por ordem do computador.
\\
O primeiro PLC permite o controlo dos seguintes atuadores do veículo:
\begin{itemize}

\item Borboleta do carburador e volante do carro - este efetua a leitura do sinal analógico proveniente de um potenciómetro colocado no eixo de rotação de cada sistema, isto é, na borboleta do carburador e no volante do carro. Quando é necessário acelerar ou virar, o PLC tem saídas que atuam o servo-motor da borboleta do carro ou a coluna de direção. De notar que a atuação destes dois sistemas é executada de forma independente.

\item Pedal do travão, embraiagem e travão de mão - para estes módulos de hardware são enviados sinais digitais do PLC e estes atuam nos respetivos componentes. O controlo de velocidade e a chegada ao fim de curso de cada módulo, são controladas por um microcontrolador PIC, presente em cada sistema. De notar que não é recebida nenhuma mensagem no PLC com a confirmação de que  cada módulo atingiu o seu fim de curso.

\item Ignição e Sinais luminosos do carro - para ligar estes módulos no carro o PLC atua em relés que ligarão o respetivo módulo. Não existe nenhum equipamento a monitorar o estado destes sistemas caso a atuação seja externa ao PLC, como por exemplo o próprio condutor.

\end{itemize}

O Segundo PLC, serve exclusivamente para controlo da alimentação dos sensores do carro possibilitando assim uma melhor gestão da energia dispendida. É ainda possível desligar cada um dos sensores, quando assim se entender, através dos interruptores localizados na bagageira ou pelo envio de uma mensagem, através do computador.

A rede de comunicação de dados no veículo, pode ser visualizada na figura \ref{fig:rede_local}.
Podemos reparar que a maioria dos equipamentos sensoriais utilizados no carro estão conetados por protocolo Ethernet, através de um Switch (0). Sendo o caso dos dois Arduínos (2, 3), três sensores laser (4, 5, 12) e dos dois PLC's (6, 13).
O outro tipo de ligação utilizado no carro é USB, sendo feita uma ligação direta ao computador (11), mais propriamente o laser scan (8), o recetor GPS (10), o recetor do comando da Xbox (9) e o sensor inercial (1). Para o caso da câmara estéreo (7), a comunicação utilizada é Firewire.


\hspace{1cm}
\begin{figure}[h]
\begin{center}
	\includegraphics[width=0.9\textwidth]{imagens/rede_local_do_carro.eps}
\caption{Rede local utilizada no AtlasCar.}
\label{fig:rede_local}
\end{center}
\end{figure}

\subsection{Placa microchip}\label{sec:microchip}

O presente trabalho, como já referido na secção \ref{sec:sit_risk_condu}, pretende a monitorização de alguns dos atuadores do AtlasCar. Uma vez que o PLC não monitoriza os sistemas pretendidos surge a necessidade de desenvolver um sistema hardware capaz de monitorar o estado das variáveis relevantes para o trabalho.

Tendo em vista a aquisição das variáveis descritas na seção \ref{sec:sit_risk_condu} foi então desenvolvida uma placa para monitorizar os sinais provenientes do carro, o protótipo que pode ser visto na figura \ref{fig:placa_microchip}. Este protótipo utiliza um microcontrolador PIC18F258 da Microchip, juntamente com um conversor max232 que comunica por porta série com o computador. 
De notar que este hardware permite a comunicação com o utilizador através de uma interface gráfica. O funcionamento do protótipo e da interface gráfica em ambiente GTK pode ser visto no vídeo online \cite{pic_video}.

\begin{figure}[h]
\begin{center}
	\includegraphics[width=0.5\textwidth]{imagens/monitotiza_test.eps}
\caption{Protótipo elaborado para testes.}
\label{fig:placa_microchip}
\end{center}
\end{figure}

O sistema presente na figura \ref{fig:placa_microchip}, revelou problemas de fiabilidade, com algumas falhas na comunicação quando submetido a testes durante várias horas. Alguns destes problemas foram resolvidos. Porém a necessidade de avançar com uma solução viável para o projeto, ditou a escolha de uma plataforma mais fiável e robusta, o Arduíno\textsuperscript{\texttrademark} \cite{arduino}.

\subsection{Arduíno\textsuperscript{\texttrademark}}\label{sec:Arduino}

O Arduíno\textsuperscript{\texttrademark} é uma plataforma \textit{opensource} que utiliza microcontroladores de 8 bits da ATmega.
Esta plataforma permite a construção de projetos de controlo e monitorização de uma forma simples. A quantidade de suporte \textit{online} existente é maior que no caso do PIC, existindo bibliotecas para fazer a comunicação com hardware. O Arduíno é utilizado nos mais variados projetos de eletrónica, exemplo de um robot que recolhe bolas de ténis \cite{arduino_tenis_ball}, monitorização de um sistema para saltar a corda \cite{arduino_multi_jump} ou a monitorização de sistemas pneumáticos \cite{arduino_pump_fluid}. A estrutura do código utilizado no Arduíno, em comparação com a programação de um PIC, é mais simplista, pois as configurações de cada um dos pinos do microcontrolador é feita através das bibliotecas internas do programa Arduíno, poupando assim ao utilizador tempo na sua configuração. De referir ainda que esta plataforma de trabalho está disponível para Linux, Windows e MacOS.

\begin{figure}[h]
\begin{center}
	\includegraphics[width=0.4\textwidth]{imagens/arduino_ethernet.eps}
\caption{Arduíno Uno.}
\label{fig:arduino_ethernet}
\end{center}
\end{figure}

Como já referido, o PLC detém o controlo sobre os atuadores do carro e a monitorização de algumas variáveis, por este motivo é imperativo que todas as mensagens de estado que este envia para o computador não contenham atrasos ou valores em falta, o que não tem sido sempre o caso. Aparentemente a causa deste problema é a sobrecarga do sistema, com pedidos de comunicação.
Pelas razões referidas, tornou-se fundamental desenvolver módulos de hardware que se dediquem a uma função especifica, a solução de hardware encontrada foi o Arduíno.

\subsection{\textit{Shield} de ethernet}\label{sec:Ethernet}


Para comunicar com o Arduíno foi utilizada a comunicação \textit{TCP/IP}, visto que o ambiente no interior do AtlasCar induz algum ruído elétrico nos sinais. 
A utilização da porta USB seria problemática devido a distâncias superiores a 5 metros entre o Arduíno e a entrada usb no computador, correndo o risco de perder sinal, como se veio a comprovar com testes realizados no carro. 
%A utilização da Shield de Ethernet, inviabiliza a utilização dos pinos 4, 10, 11, 12, 13 pois são necessita destes pinos, de modo a comunicar com o arduino.


\subsection{R.O.S. - Robot Operating System}\label{sec:ros}

%\todo{explicar nodos e organização do ros, provavelmente com uma imagem}
 
No projeto AtlasCar é utilizada a arquitetura \textit{R.O.S.} \cite{ROS}. Esta está organizada em \textit{packages}, isto é, uma pasta principal onde podem existir vários \textit{nodes}. 
Os \textit{nodes} são instanciações de um ficheiro binário, o que permite a possibilidade de ter vários \textit{nodes} lançados pelo mesmo binário.
Este tipo de organização facilita a compreensão e organização do código.
A comunicação entre \textit{nodes} é possível através da subscrição e publicação de mensagens, os chamados \textit{topics}.
Caso seja necessário gravar informação dos \textit{topics} do sistema operativo, podemos utilizar uma ferramenta chamada \textit{rosbag}, responsável pela gravação e repetição de ficheiros do tipo \textit{.bag} que contêm a informação gravada.
Para analisar melhor as diferentes situações de risco é utilizada uma ferramenta chamada Rviz disponível em ambiente ROS, esta ferramenta permite ao utilizador visualizar as nuvens de pontos adquiridas aos obstáculos em redor do veículo, quando é feita a revisão dos dados gravados.
Os conceitos referidos têm muita importância pois serão invocados por várias ocasiões ao longo do texto.

\section{Placa de aquisição de dados}\label{sec:aquisicao_estados}

% A placa de aquisição de dados foi desenvolvida para recolher em tempo real os valores de todas as variáveis relevantes durante o exercício da condução.
 
\begin{figure}[h]
\begin{center}
	\includegraphics[width=0.5\textwidth]{imagens/ard_monit.eps}
\caption{Instalação do Arduíno \textsuperscript{\texttrademark} responsável pela monitorização da condução.}
\label{fig:arduino_monit}
\end{center}
\end{figure}


O sistema monitoriza o "pisca"\ direito e esquerdo, quatro "piscas", médios, máximos, buzina e pedais do condutor do AtlasCar em modo manual e automático (Figura \ref{fig:arduino_monit}).
Para o desenvolvimento da placa de aquisição de dados foram tidos em conta os diferentes níveis elétricos nas entradas digitais do Arduíno que funcionam a 5 volts, e os sinais do carro que provêm da bateria a 14 volts. 
Os sinais a monitorizar estavam junto à coluna de direção do carro.
Depois de identificados, foram acoplados a um cabo que os transporta até ao Arduíno colocado debaixo do banco lateral esquerdo do condutor. 
O esquema elétrico da placa está presente no capítulo \ref{ch:esq_eletricos}, ou para uma melhor compreensão, a figura \ref{fig:Esq_in_out_monit} contém representadas as portas utilizadas pelo Arduíno.
A alimentação do Arduíno é efetuada por uma fonte de tensão contínua instalada na bagageira, que fornece 12 V.

\subsection{Instalação de sensores de força nos pedais}\label{sec:pedais}

Nos pedais do condutor foram instalados sensores de força resistivos (Figura \ref{fig:pedais_atlas}), que permitem medir a força aplicada pelos pés do condutor. Este tipo de sensor funciona com uma tensão aplicada de 5 V no sensor que irá variar à entrada do microcontrolador consoante a força aplicada ao sensor. 
A escolha destes sensores deve-se ao seu baixo custo e volume ocupados depois de instalados, quando comparados a um equipamento especializado \cite{adas_pedal_calhau}, que utiliza uma célula de carga (Figura \ref{fig:pedal_concorencia}).
Os valores de tensão provenientes destes sensores são proporcionais à força aplicada nestes.
A mensagem de estados dos diferentes atuadores do habitáculo do AtlasCar pode ser vista na tabela \ref{tab:msg_arduino_monitoring}.

\begin{figure}[h!]
      \centering
      \includegraphics[width=0.6\textwidth]{imagens/fsr.eps}
      \caption{Sensor instalado em cada pedal do AtlasCar. (Sensitronics)}
  \label{fig:pedais_atlas}
\end{figure}
  
\begin{figure}[h!]
      \centering
      \includegraphics[width=0.6\textwidth]{imagens/calhau.eps}
      \caption{Sistema baseado numa célula de carga para medição da força aplicada no pedal. }
  \label{fig:pedal_concorencia}
\end{figure}



%\begin{figure}[h!]
%\begin{minipage}[b]{0.5\linewidth}
%\centering
%\subfigure[Cenário urbano típico]
%{
%  \includegraphics[width=6.5cm]{imagens/calhau.eps}
%  \label{subfig:voxel_example}
%}
%\\
%\subfigure[cenas]
%{
%  \includegraphics[width=6.5cm]{imagens/calhau.eps}
%  \label{subfig:voxel_0.1}
%}
%\end{minipage}
%
%\begin{minipage}[b]{0.5\linewidth}
%\centering
%\subfigure[\textit{Voxel} de 0.3 (m).]
%{
%  \includegraphics[width=6.5cm]{imagens/calhau.eps}
%  \label{subfig:voxel_0.3}
%}
%\\
%\subfigure[\textit{Voxel} de 0.5 (m).]
%{
%  \includegraphics[width=6.5cm]{imagens/calhau.eps}
%  \label{subfig:voxel_0.5}
%}
%\end{minipage}
%\caption{Exemplo de aplicação de vários tamanhos de \textit{voxel grid}.}
%\label{fig:voxel}
%\end{figure}




\subsection{Programação do Arduíno da monitorização}\label{sec:prog_ard_monito}
O Arduíno da monitorização utiliza 7 entradas digitais e os pinos utilizados estão ilustrados na figura \ref{fig:Esq_in_out_monit}. É também ilustrada a utilização de três entradas analógicas, que correspondem a cada sensor instalado nos pedais do veículo.

\begin{figure}[h]
\begin{center}
	\includegraphics[width=0.95\textwidth]{imagens/arduino_monitoriza.eps}
\caption{Esquema das portas utilizadas pelo Arduíno responsável pela monitorização.}
\label{fig:Esq_in_out_monit}
\end{center}
\end{figure}

Na figura \ref{fig:prog_arduino_monitoriza} pode-se visualizar o esquema com a organização do código do programa implementado no Arduíno. Quando este liga, são configuradas as portas digitais e as analógicas que receberem os diferentes sinais assim como o protocolo Ethernet usado para comunicar com o equipamento.



\begin{figure}[h]
\begin{center}
	\includegraphics[width=0.7\textwidth]{imagens/diagrama_arduino_monitoriza.eps}
\caption{Diagrama do código utilizado para programar o Arduíno responsável pela monitorização.}
\label{fig:prog_arduino_monitoriza}
\end{center}
\end{figure}

Depois da configuração inicial, o módulo hardware entra num ciclo onde verifica se existe um cliente conectado por cabo ethernet e caso seja verdadeiro, envia uma mensagem com os campos descritos na tabela \ref{tab:msg_arduino_monitoring}, contendo o estado de todas as variáveis monitorizadas.

%\subsection{Mensagem de estados do carro}\label{sec:pedais_fsr}


\begin{table}[h!]
\centering
    \begin{tabular}{  c  c }
    \hline \hline
     \textbf{Endereço de IP do Arduíno}  &  10.0.0.30\\  \hline     
     \hline
     \textbf{Estrutura da mensagem}  & \textbf{Descrição das variáveis} \\ \hline
      '0x02' & início de mensagem \\ \hline
      00000000 & estado das variáveis \\ \hline
      T000 & valor do sensor do acelerador \\ \hline
      C000 & valor do sensor da embraiagem \\ \hline
      B000 & valor do sensor do travão \\ \hline
      '0x03' & fim da mensagem \\
  \hline \hline
 \end{tabular}
\caption{Formato da mensagem enviada com o estado do habitáculo do AtlasCar}
\label{tab:msg_arduino_monitoring}
\end{table}



\section{Placa de medição da velocidade}\label{sec:velocity}

A medição da velocidade do AtlasCar era feita inicialmente pelo PLC através de um contador de alta velocidade interno.
Os contadores de alta velocidade, tal como o nome indica contam pulsos de um \textit{encoder} a uma taxa muito superior ao ciclo do programa principal. O seu funcionamento pretende que os três canais do \textit{encoder} sejam conetados às entradas do contador que incrementa uma unidade à contagem por cada vez que este recebe um pulso.
O sistema de cálculo da velocidade do carro conta os pulsos de um \textit{encoder} incremental \cite{encoder} com resolução de 50 pulsos por volta; este sistema já estava implementado fisicamente no carro, como pode ser visto na figura \ref{fig:encoder_velocity}. 
Como referido na subsecção \ref{sec:Arduino}, a passagem da leitura da velocidade para um Arduíno impôs a necessidade de encontrar um contador de alta velocidade compatível com o Arduíno Uno.
Essa escolha recaiu num contador de quadratura \textit{HCTL-2022} devido ao limitado número de portas disponíveis no Arduíno, bem como a existência de uma biblioteca para comunicar com este contador que, embora fosse para o modelo Arduíno Mega, mostrou ser fácil de alterar \cite{HCTL2022}.

\begin{figure}[h]
\begin{center}
	\includegraphics[width=0.5\textwidth]{imagens/roda_encoder.eps}
\caption{Suporte para encoder acoplado à roda lateral traseira do AtlasCar.}
\label{fig:encoder_velocity}
\end{center}
\end{figure}


As caraterísticas deste contador são apresentadas na tabela \ref{tab:HCTL_2022}.


\begin{table}[h!]
\centering
    \begin{tabular}{ c  c }
      \hline \hline
      \multicolumn{2}{c}{\textbf{Caraterísticas}} 
      \\ \hline \hline
      Pinos & 20\\ \hline
      Nº de Bits&  32 \\ \hline
      Tipo de contador & Up / Down e contagem\\ \hline
      Número de eixos & 1 \\ \hline
      Modo de contagem & 4x \\ \hline
      Frequência de operação & 2 a 33 MHz      \\
  \hline \hline
 \end{tabular}
\caption{Caraterísticas do contador de quadratura \textit{HCTL-2022}.}
\label{tab:HCTL_2022}
\end{table}

O facto de trabalhar a 32 bits permite uma representação de grandes números, e evita a necessidade de encontrar um dispositivo externo para armazenar os valores da contagem. 
Porém, a leitura do valor do contador é feita através da concatenação de 4 bytes consecutivos. Para fazer a leitura dos valores basta alternar entre as diferentes combinações dos pinos SEL1 e SEL2, encarregados da seleção do buffer a ser lido (Tabela \ref{tab:SEL1_SEL2}).


\begin{table}[h!]
\centering
\begin{tabular}{cccccc}
\cline{3-6} 
& & \multicolumn{4}{c}{\textbf{Seleção do Buffer}} \\ \cline{1-6} \hline \hline
\multicolumn{1}{ c }{ \textbf{SEL 1}} & \multicolumn{1}{c}{\textbf{SEL 2}} & \textbf{1º byte} & \textbf{2º byte} & \textbf{3º byte} & \textbf{4º byte} \\ \hline \hline
\multicolumn{1}{ c }{ 0} & \multicolumn{1}{c}{1} & D4 &  -  & -   & - \\ \hline
\multicolumn{1}{ c }{ 1} & \multicolumn{1}{c}{1} &  -  & D3 & -   & -\\ \hline
\multicolumn{1}{ c }{ 0} & \multicolumn{1}{c}{0} &  -  &  -  & D2 & -\\ \hline
\multicolumn{1}{ c }{ 1} & \multicolumn{1}{c}{0} &  -  &  -  &  -  & D1  \\
 \hline \hline
\end{tabular}
\caption{Tabela com a sequência de seleção utilizada para leitura individual de cada buffer}
\label{tab:SEL1_SEL2}
\end{table}

%\begin{table}[h!]
%\centering
%\begin{tabular}{cc|c|c|c|c|}
%\cline{3-6}
%& & \multicolumn{4}{c|}{\textbf{Seleção do Buffer}} \\ \cline{1-6}
%\multicolumn{1}{| c |}{ \textbf{SEL 1}} & \multicolumn{1}{|c|}{\textbf{SEL 2}} & \textbf{1º byte} & \textbf{2º byte} & \textbf{3º byte} & \textbf{4º byte} \\ \hline
%\multicolumn{1}{| c |}{ 0} & \multicolumn{1}{c|}{1} & D4 &    &    &  \\ \hline
%\multicolumn{1}{| c |}{ 1} & \multicolumn{1}{c|}{1} &    & D3 &    & \\ \hline
%\multicolumn{1}{| c |}{ 0} & \multicolumn{1}{c|}{0} &    &    & D2 & \\ \hline
%\multicolumn{1}{| c |}{ 1} & \multicolumn{1}{c|}{0} &    &    &    & D1  \\
% \hline
%\end{tabular}
%\caption{Tabela com a sequência de seleção utilizada para leitura indivídual de cada buffer}
%\label{tab:SEL1_SEL2}
%\end{table}

Sendo um contador de quadratura com modo de contagem de 4 vezes, isso implica que a cada quarto de pulso da resolução efetiva do \textit{encoder} o contador incremente uma unidade à contagem.
Sabendo que o contador lê os pulsos do canal A e B como ilustrado na figura \ref{fig:signal_enc}, desta forma é incrementada uma unidade a cada transição entre os seguintes estados:

	\begin{itemize}
	\item Canal A positivo e B igual a zero (1);
	\item Canais A e B com sinal positivo (2); 
	\item Canal A zero e B positivo (3);
	\item Canais A e B com sinal igual a zero (4).
	\end{itemize} 
\begin{figure}[h]

\begin{center}
	\includegraphics[width=0.5\textwidth]{imagens/Sinais_encoder.eps}
\caption{Ilustração dos pulsos que o \textit{encoder} envia pelos três canais.}
\label{fig:signal_enc}
\end{center}
\end{figure}


\subsection{Programação do Arduíno da velocidade}\label{sec:prog_ard_velo}

O programa usado para calcular a velocidade do carro está ilustrado na figura \ref{fig:prog_arduino_velocidade}.
Quando o Arduíno é iniciado os seguintes comandos são executados:

\begin{itemize}
\item As portas utilizadas por este são definidas, como digitais.
\item São incluídas as bibliotecas de comunicação do protocolo Ethernet que irá comunicar com a shield ethernet e a biblioteca que comunica com o contador de quadratura.
\item Definida uma variável cuja função é garantir que o valor de velocidade enviado para o computador não é repetido.
\item Por fim é associado a um \textit{interrupt} com um tempo de ciclo de 100 \begin{math} milisegundos \end{math}, uma função que lê os valores da contagem do \textit{HCTL-2022}. 
\end{itemize}

Depois da iniciação do Arduíno é então começado o loop principal, onde o Arduíno espera que um cliente se conecte via Ethernet.
Quando este estiver conetado, o Arduíno envia a informação para o computador. 
De salientar que o interrupt implementado, está associado a uma função que a cada ciclo de 100 \textit{ms}, executa as seguintes operações:
\begin{itemize}
		\item Leitura do valor da contagem;
		\item Tempo interno do microcontrolador;
		\item Define a variável count=1.
\end{itemize}
 
O cálculo da velocidade é feito caso a variável count seja verdadeira, desta forma o cálculo da velocidade implementado no Arduíno tem por base as equações descritas na subsecção \ref{sec:calc_velocity}.

\begin{figure}[h]
\begin{center}
	\includegraphics[width=0.7\textwidth]{imagens/diagrama_arduino_velocity.eps}
\caption{Diagrama explicativo do código utilizado na programação do Arduíno responsável pela medição da velocidade.}
\label{fig:prog_arduino_velocidade} s
\end{center}
\end{figure}


\subsection{Cálculo da velocidade}\label{sec:calc_velocity}
\hspace{1cm}

A velocidade é calculada com base na seguinte expressão:
\begin{equation}
v= \frac{\bigtriangleup s}{\bigtriangleup t} \   \left[ m/s \right]
\end{equation}

A distância percorrida ($\bigtriangleup s$) é calculada: 

\begin{equation}
\bigtriangleup s= \pi \times D \times \frac{P}{4} \times \frac{1}{N_{\text{Resolução do \textit{encoder}}}}  \  \left[ m \right]
\end{equation}

\hspace{1cm}

Onde \begin{math} P \end{math} é o número de pulsos lidos pelo contador desde a última vez, de notar que está dividido por 4 unidades pois o modo de contagem incrementa um valor por cada quarto de pulso efetivo do \textit{encoder}; D o diâmetro da roda, 0,52 m e N corresponde à resolução do \textit{encoder}, 50 pulsos.

A variação do tempo $\bigtriangleup t$ é calculada pela diferença dos dois instantes:
\begin{equation}
\bigtriangleup t= t_f - t_i \  \left[ s \right]
\end{equation}

De modo a facilitar o entendimento matemático, T =  $\bigtriangleup t$.




%\clearpage


%\begin{equation}
%\mathrm{Tempo\ Actual}=ct \left[s\right]
%\end{equation}
% 
% \begin{equation}
% \mathrm{Tempo\ Actual}=ct \left[s\right]
% \end{equation}
% 
% \begin{equation}
% \mathrm{Tempo\ anterior}=lt \left[s\right]
% \end{equation} 
% 
% Diferença de tempos em segundos:
% \begin{equation}
% Dt = \frac{ct-lt}{1000}
% \end{equation}
% 
% 
% Calculo do número de pulsos entre as duas contagens:
% \begin{equation}
% Dp = \frac{cp-lp}{4}
% \end{equation}
% 
% \begin{equation}
% PPS = \frac{Dp}{Dt}
% \end{equation}
% 
% \begin{equation}
% VPS = \frac{PPS}{50}
% \end{equation}
% 
% \begin{equation}
%  Velocidade = VPS \times \pi \times D
% \end{equation}

Desta forma a velocidade do carro é dada pela seguinte equação: 
\begin{equation}
v= \frac{\pi \times D \times P }{4 \times 50 \times T } \   \left[ m/s \right]
\label{eq:cenas}
\end{equation}

A resolução minima que o sistema detêm é calculada pela equação \ref{eq:cenas}, onde após substituição dos valores de $P=1$ pulso, $D=0.58$m e $T=0.1$s, temos que:

\begin{equation} v= \frac{\pi \times 0.58 \times 1 }{4 \times 50 \times 0.1 } =0.0911 \   \left[ m/s \right] = 0.0328   \left[ Km/h \right]
\end{equation}

Para estimar a incerteza no cálculo da velocidade foi utilizada a expressão da propagação de erro:

 \begin{equation}
 	(\bigtriangleup v)^2 =	\sum \bigg(  \bigtriangleup x_i \times \frac{\partial v}{\partial x_i}  \bigg)^2   
 \end{equation}
 
 
 \begin{equation}
 	\|\bigtriangleup v\|^2 =  \bigg( \bigtriangleup T \times  \frac{-D \times \pi \times P}{200 \times T }  \bigg)^2  + \bigg( \bigtriangleup D \times \frac{P \times \pi}{200 \times T}  \bigg)^2 +  \bigg( \bigtriangleup P \times  \frac{D \times \pi}{200 \times T }  \bigg)^2   .
 	\label{eq:error}
 \end{equation}

O erro da leitura do tempo é igual à menor unidade de medida temporal do Arduíno, uma vez que este trabalha a 16 MHz a menor unidade de tempo é dada pela seguinte expressão:

\begin{equation}
	\bigtriangleup T =\frac{1}{16000000}=0.000000062\ [s].
\end{equation} 

O erro na medição do diâmetro da roda, corresponde a:

\begin{equation}
	\bigtriangleup D= 0.001\ [m].
\label{eq:D}
\end{equation}  

O erro da leitura dos pulsos é dado pela expressão: 

\begin{equation}
	\bigtriangleup P= \frac{1}{200}=0.005\ pulsos.
\label{eq:d_n}
\end{equation} 

Após substituição dos valores na equação \ref{eq:error}, tem-se:


 \begin{equation}
 	\|\bigtriangleup v\|^2 =  \bigg( -6.9 \times 10^{-9}   \bigg)^2  + \bigg( 1.6 \times 10^{-4} \bigg)^2 +  \bigg( 4.4 \times 10^{-6} \bigg)^2   
 	%\label{eq:error}
 \end{equation}


Sendo que o valor do erro do cálculo da velocidade de:
\begin{equation}
 \bigtriangleup v =  1.57 \times 10^{-4} \ [m/s].
 	%\label{eq:error}
 \end{equation}

%Podemos ver que \begin{math} \bigtriangleup N \end{math} é muito superior ao valor de \begin{math}\bigtriangleup T \end{math}, podendo assim considerar unicamente para efeitos de cálculo a primeira parcela da equação \ref{eq:error}. 
%Substituindo o valor de \begin{math} \bigtriangleup N \end{math} na fórmula \ref{eq:d_n} temos que:
%
%\begin{equation}
% 	\bigtriangleup v =\sqrt{ \bigg( \bigtriangleup N \times \frac{1}{T}  \bigg)^2 } = 0.005 \times \frac{1}{0.1} = 0.05
% 	\label{eq:error_f}
% \end{equation}


A configuração física do Arduíno da velocidade implementado no AtlasCar tem por base a informação presente, no esquema elétrico no capítulo \ref{ch:esq_eletricos}. Na figura \ref{fig:esqu_in_out_velocity} é mostrada a configuração das portas utilizadas pelo Arduíno para que este possa comunicar com o \textit{HCTL-2022}. A leitura do valor da contagem é feito pelos pinos D1 a D9. Os pinos OE e RST são responsáveis pela permissão de leitura do contador e pelo \textit{reset} da contagem, respetivamente.

\begin{figure}[H]
\begin{center}
	\includegraphics[width=0.60\textwidth]{imagens/arduino_counter.eps}
\caption{Esquema das portas utilizadas pelo Arduíno responsável pela medição da velocidade.}
\label{fig:esqu_in_out_velocity}
\end{center}
\end{figure}



\subsection{Mensagem de velocidade do carro}\label{sec:msg_velocity}
A mensagem enviada para o módulo de \textit{ROS}, contém todas as variáveis que o Arduíno utiliza para calcular a velocidade, enviando assim o número absoluto de pulsos desde que o carro foi ligado, os pulsos por segundo, as rotações por segundo e por fim a velocidade em m/s do veículo. 
A mensagem enviada tem a estrutura presente na tabela \ref{tab:msg_arduino_velocity}.

\begin{figure}[H]
        \centering
      \includegraphics[width=0.5\textwidth]{imagens/arduino_velocity.eps}
      \caption{Arduíno, shield ethernet e contador de pulsos \textit{HCTL-2022}.}
  \label{fig:arduino_velocity}
\end{figure}

\begin{table}[h!]
\centering
    \begin{tabular}{  c  c }
    \hline \hline
    \textbf{Endereço de IP do Arduíno}  &  10.0.0.31\\  \hline     
    \hline  
    \textbf{Estrutura da mensagem}  & \textbf{Descrição das variáveis} \\ \hline 
    '0x02' & início de mensagem \\ \hline
    " C 0" & número de pulsos total desde que o carro foi ligado \\ \hline
    " P 0.00" & pulsos por segundo \\ \hline
    " R 0.00" & rotações da roda por segundo \\ \hline
    " S 0.0000" & velocidade em metros por segundo\\ \hline
    '0x03' & fim de mensagem\\
  \hline \hline
 \end{tabular}
\caption{Formato da mensagem enviada com a velocidade do carro}
\label{tab:msg_arduino_velocity}
\end{table}







