\documentclass[12pt]{article}
\usepackage[english]{babel}
\usepackage{natbib}
\usepackage{url}
\usepackage[utf8x]{inputenc}
\usepackage{amsmath}
\usepackage{graphicx}
\usepackage{enumitem}
\graphicspath{{images/}}
\usepackage{parskip}
\usepackage{listings}
\usepackage{fancyhdr}
\usepackage[noend]{algpseudocode}
\usepackage{hyperref}
\usepackage{vmargin}
\usepackage{amssymb}
\usepackage{fancyvrb}
\usepackage[]{algorithm}
\usepackage{fancyhdr, blindtext}
\setmarginsrb{3 cm}{2.5 cm}{3 cm}{2.5 cm}{1 cm}{1.5 cm}{1 cm}{1.5 cm}

\makeatletter
\def\BState{\State\hskip-\ALG@thistlm}
\makeatother
\lstset{
basicstyle=\small\ttfamily,
columns=flexible,
breaklines=true,
breakatwhitespace=true,
}

\title{Relatório Trabalho Prático Nº2}                               % Title
\author{Paulo Ferreira}                             % Author
\date{\today}                                           % Date

\makeatletter
\let\thetitle\@title
\let\theauthor\@author
\let\thedate\@date
\makeatother



\pagestyle{fancy}
\fancyhf{}
\lhead{\fontsize{8}{12} \selectfont Trabalho Prático nº2}
\rhead{\fontsize{8}{12} \selectfont 2017/2018}
\chead{\fontsize{8}{12} \selectfont Arduíno: Sistema de controlo com recurso a tecnologias móveis}
\cfoot{\thepage}

\begin{document}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{titlepage}
    \centering
    \vspace*{0.5 cm}
    \includegraphics[scale = 0.4]{estig.jpg}\\[1.0 cm]  % University Logo
    \textsc{\LARGE Comunicações Movéis}\\[2.0 cm]    % University Name
    \textsc{\Large Engenharia Informática}\\[0.5 cm]               % Course Code
    \textsc{\large 3º Ano}\\[0.5 cm]               % Course Name
    \rule{\linewidth}{0.2 mm} \\[0.4 cm]
        { \huge \bfseries \thetitle}\\
    \rule{\linewidth}{0.2 mm} \\[1.5 cm]

    \begin{minipage}{0.4\textwidth}
        \begin{flushleft} \large
            \emph{Realizado por:} \\
            \theauthor: a34960\\
            José Couto: a34953\\
            Miguel Rodrigues: a33884

            \end{flushleft}

            \end{minipage}~
            \begin{minipage}{0.4\textwidth}
            \begin{flushright} \large
            \emph{Docente:}\\
            Rui Fernandes
        \end{flushright}
    \end{minipage}\\[2 cm]

    {\large \thedate}\\[2 cm]

    \vfill

\end{titlepage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\tableofcontents
\pagebreak

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Exercicío 1}
\subsection{Exercício 1.1.}
\subsubsection{Comentários}
\begin{enumerate}
   \item \textbf{Explicação do algoritmo:}
   \begin{enumerate}[label=(\roman*)]
     \item Inicializar duas variavéis, uma para saber o número de Leds que estão na placa, e outra para saber a posição do Pin inicial.
     \item Configurar os Pins como Output/Input com a função PinMode().
     \item Dentro de um loop, onde o contador tem valor incial do pin inicial(statingPin) e incrementa ate o seu valor for menor que o (pin inicial - o número de Leds - 1), é acendido e desligado o pin com o valor do contador, a cada iteração, tendo um delay entre.
     \item Dentro de outro loop, onde o contador tem valor incial (pin inicial - o número de Leds - 1) e diminui ate o seu valor for menor que o pin inicial(statingPin), é acendido e desligado o pin com o valor do contador, a cada iteração, tendo um delay entre.
     \item É também configurado um Pin como input, onde é lido um valor através de um potenciometro. Esse valor tem como objetivo a definição do tempo do delay.
   \end{enumerate}
\end{enumerate}

\begin{algorithm}[H]
\caption{Algoritmo Exercicio 1}\label{euclid}
\begin{algorithmic}[1]
\State $nLeds \gets \textit{Número de leds}$
\State $startingPin \gets \textit{Pin Inicial}$
\Function{setup}{}
\For {$count=startingPin$ to $startingPin + nLeds -1$}
\State $pinMode(count, OUTPUT); \gets \textit{Configura o Pin como Output}$
\State $pinMode(A0, INPUT); \gets \textit{Configura o Pin como Input}$
\EndFor
\EndFunction
\Function{loop}{}
\State $timeDelay = analogRead(A0); \gets \textit{Usa a variavel para ler o valor do potenciómetro}$
\For {$count=startingPin$ to $startingPin + nLeds - 1$}
\State $digitalWrite(count, HIGH); \gets\textit{Acende o Led}$
\State $delay(timeDelay);\gets\textit{Aguarda}$
\State $digitalWrite(count, LOW);\gets\textit{Apaga o Led}$
\State $delay(timeDelay);\gets\textit{Aguarda}$
\EndFor
\For {$count=startingPin + nLeds - 1$ to $startingPin$}
\State \textit{Faz a mesma coisa que loop anterior}
\EndFor
\EndFunction
\end{algorithmic}
\end{algorithm}
\subsubsection{Simulações}
\begin{itemize}
\item \href{https://www.dropbox.com/s/1ps53s1t02gwlvq/cm_exercico_1.3gp?dl=0}{Video link}

\item \href{https://www.dropbox.com/s/i1yv1gd18skfp32/out-1.ogv?dl=0}{Simulador online Video link}
\end{itemize}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newpage
\subsection{Comentários e Simulações (Exercício 2)}
\subsubsection{Comentários}
\begin{enumerate}
   \item \textbf{Explicação do algoritmo:}
   \begin{enumerate}[label=(\roman*)]
     \item Inicializar duas variavéis, uma para saber o número de Leds que estão na placa, e outra para saber a posição do Pin inicial.
     \item Configurar os Pins como Output/Input com a função PinMode().
     \item Dentro de um loop, onde o contador tem valor incial do pin inicial(statingPin) e incrementa ate o seu valor for menor que o (pin inicial - o número de Leds - 1), se a cada determinada iteração o valor do contador for par é acendido e desligado o pin com o valor do contador(neste caso, somente os pares), a cada iteração, tendo um delay entre, caso contrário, se for impar, são acendidos todos os leds com o valor do contador, que é impar.
     \item Dentro de outro loop, onde o contador tem valor incial (pin inicial - o número de Leds - 1) e diminui ate o seu valor for menor que o pin inicial(statingPin), se a cada determinada iteração o valor do contador for par é acendido e desligado o pin com o valor do contador(neste caso, somente os pares), a cada iteração, tendo um delay entre, caso contrário, se for impar, são acendidos todos os leds com o valor do contador, que é impar.
     \item É configurado um Pin como input, onde é lido um valor através de um potenciometro. Esse valor tem como objetivo a definição do tempo do delay.
     \item É também configurado um Pin como input, que servirá para regular a intensidade da luz dos leds na posições impares, sendo o seu valor lido através de outro potenciometro.
   \end{enumerate}
\end{enumerate}

\begin{algorithm}[H]
\caption{Algoritmo Exercicio 2}\label{euclid}
\begin{algorithmic}[1]
\State $nLeds \gets \textit{Número de leds}$
\State $startingPin \gets \textit{Pin Inicial}$
\State $counter = 0 \gets \textit{Inicializa o contador a 0}$
\Function{setup}{}
\For {$count=startingPin$ to $startingPin + nLeds -1$}
\State $pinMode(count, OUTPUT); \gets \textit{Configura o Pin como Output}$
\State $pinMode(A0, INPUT); \gets \textit{Configura o Pin como Input}$
\EndFor
\EndFunction
\Function{loop}{}
\State $counter++; \gets \textit{Incremeta o valor do contador cada vez que o efeito knight rider acontece}$
\State $value = analogRead(A5); \gets \textit{Valor do potenciómetro, para regular a intensidade}$
\State $timeDelay = analogRead(A0); \gets \textit{Valor do potenciómetro, para regular o delay}$
\State $value = map(value, 0, 1023, 0, 255); \gets \textit{Enquadra os valores lidos, no range pretendido}$
\For {$count=startingPin$ to $startingPin + nLeds - 1$}
\If {count é par}
\State $digitalWrite(count, HIGH); \gets\textit{Acende o Led}$
\State $delay(timeDelay);\gets\textit{Aguarda}$
\State $digitalWrite(count, LOW);\gets\textit{Apaga o Led}$
\State $delay(timeDelay);\gets\textit{Aguarda}$
\Else
\State $analogWrite(x, value); \gets\textit{Acende o Led, intensidade regulada por uma variável}$
\EndIf

\EndFor
\For {$count=startingPin + nLeds - 3$ to $startingPin$}
\If {count é par}
\State \textit{Faz o efeito knight rider, acima explicado}
\EndIf
\EndFor
\EndFunction
\end{algorithmic}
\end{algorithm}
\subsubsection{Simulações}
\begin{itemize}
\item \href{https://www.dropbox.com/s/ux20u8d2sju5h8p/cm_exercico_2.3gp?dl=0}{Video link}
\end{itemize}



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newpage
\section{Conclusões}
Com este trabalho ganhou-se conhecimento sobre programação em arduino, desde o uso de funções do arduino, a leitura de dados digitais.
Sendo agora possivél fazer trabalho mais complexos, com matéria relacionada com programação em arduino.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%55
\newpage
\section{Source Code}
\subsection{Exercício 1}

\begin{lstlisting}
int nLeds = 4;
int startingPin = 8;
void setup() {
    Serial.begin(9600);
    for (int count=startingPin; count <=  startingPin + nLeds -1 ;count++) {
        pinMode(count, OUTPUT);
        pinMode(A0, INPUT);
      }
}

void loop() {
    int time_delay = analogRead(A0);

    for (int count=startingPin; count< startingPin + nLeds - 1 ; count++)
    {
        digitalWrite(count, HIGH);
        delay(time_delay);
        digitalWrite(count, LOW);
        delay(time_delay);
    }

    for (int count=startingPin + nLeds - 1 ;count > startingPin ; count--)
    {
        digitalWrite(count, HIGH);
        delay(time_delay);
        digitalWrite(count, LOW);
        delay(time_delay);
    }
    Serial.println(time_delay);
}

\end{lstlisting}

\newpage
\subsection{Exercício 2}
\begin{lstlisting}
int startPin = 2;
int numLeds = 5;
int counter = 0;

void setup() {

  Serial.begin(9600);
  for(x = startPin; x <= startPin + numLeds - 1; x++){
    pinMode(x, OUTPUT);
    pinMode(A0, INPUT);
    pinMode(A5, INPUT);
  }
}
void loop() {
  counter++;
  int time_delay = analogRead(A0);
  int value = analogRead(A5);
  value = map(value, 0, 1023, 0, 255);

    for(int x = startPin; x <= startPin + numLeds - 1; x++){
        if(x%2 == 0){
          digitalWrite(x, HIGH);
          delay(time_delay);
          digitalWrite(x, LOW);
          delay(time_delay);
        }
        if(x%2 != 0){
          analogWrite(x, value);
        }

     }
    for(int x = startPin + numLeds - 3; x > startPin; x--){
          if(x%2==0){
            digitalWrite(x, HIGH);
            delay(time_delay);
            digitalWrite(x, LOW);
            delay(time_delay);
          }
    }
    Serial.println(counter);
}
\end{lstlisting}
\newpage
\subsection{Exercício 3}
\begin{lstlisting}
int values[2];
int add, substration, substration_inversed, multiplication;
float division, division_inversed;
int time_delay = 2000;

void setup() {
  Serial.begin(9600);
}
void loop() {
  Serial.println("Insira o primeiro valor:")
  while(Serial.available()==0) {}
  values[0]= Serial.parseInt();
  Serial.println("Insira o segundo valor:")
  while(Serial.available()==0) {}
  values[1] = Serial.parseInt();

  add = values[0]+ values[1];
  substration = values[0]- values[1];
  substration_inversed = values[1] - values[0];
  multiplication = values[0]* values[1];
  division = (float)values[0]/ values[1];
  division_inversed = (float)values[1] / values[0];

  Serial.print("a + b = ");
  Serial.println(add);
  delay(time_delay);
  Serial.print("a - b = ");
  Serial.println(substration);
  delay(time_delay);
  Serial.print("b - a = ");
  Serial.println(substration_inversed);
  delay(time_delay);
  Serial.print("a * b = ");
  Serial.println(multiplication);
  delay(time_delay);
  Serial.print("a / b = ");
  Serial.println(division);
  delay(time_delay);
  Serial.print("b / a = ");
  Serial.println(division_inversed);
}
\end{lstlisting}
\newpage
\subsection{Exercício 4}
\begin{lstlisting}
#define BETWEEN(value, min, max) (value < max && value > min)
int numLeds = 5;
int startPin = 2;
int x;
int time_delay = 500;

void setup() {
    Serial.begin(9600);
    for(x = startPin; x < startPin + numLeds; x++){
      pinMode(x, OUTPUT);
    }
}
void loop() {
    Serial.println("Insira um valor inteiro:");
    while(Serial.available() == 0) {}
    int value = Serial.parseInt();
    Serial.println("O numero em binario: ");
    if(BETWEEN(value, 0, 32)){
        for(x = startPin; x < startPin + numLeds; x++){
                int state = bitRead(value, x - startPin);
                digitalWrite(x, state);
                Serial.print(state);
        }
    }
    else{
        Serial.println("O numero inserido e invalido:");
        for(int i = 0; i < 3; i++){
            for(x = startPin; x < startPin + numLeds; x++){
                digitalWrite(x, HIGH);
            }
            delay(time_delay);
            for(x = startPin; x < startPin + numLeds; x++){
                digitalWrite(x, LOW);
            }
            delay(time_delay);
        }
    }
}
\end{lstlisting}
\newpage
\subsection{Exercício 5}
\begin{lstlisting}
int pinInput = A0;
float division, division_inv;
float first_value, second_value;
float value;
float add, sub, sub_inv, mult;
int neg_value = 0, pos_value = 0;

boolean first_read = true;

void setup() {
  Serial.begin(9600);
  pinMode (pinInput , INPUT);
  pinMode(2,OUTPUT);
  pinMode(3,OUTPUT);
}

void loop() {
  int time_delay = 0;

  if(first_read == true)
  {
    value = analogRead(pinInput);
    Serial.print("Valor do primeiro valor= ");
    Serial.println(value);
    first_value = value;
    delay(2000);
    first_read = false;
  }

  else
  {
    Serial.print("Primeiro numero = ");
    Serial.println(x);
  }

  value = analogRead(pinInput);
  Serial.print("Segundo numero = ");
  Serial.println(valor);
  second_value = value;

  add = first_value + second_value;
  sub = first_value - second_value;
  sub_inv = second_value - first_value;
  mult = first_value * second_value;
  division = (float)first_value / second_value;
  division_inv = (float)second_value / first_value;

  Serial.print("\nSoma = ");
  Serial.println(add);

  Serial.print("\nSubtracao= ");
  Serial.println(sub);

  Serial.print("\nSubtracao inversa= ");
  Serial.println(sub_inv);

  Serial.print("\nMultiplicacao = ");
  Serial.println(mult);

  Serial.print("\nDivisao = ");
  Serial.println(division);

  Serial.print("\nDivisao inversa = ");
  Serial.println(division_inv);

  if(add < 0 || sub < 0 || sub_inv < 0 || mult < 0 || division < 0 || division_inv < 0){
    digitalWrite(2, HIGH);
    delay(1000);
    digitalWrite(2, LOW);
    neg_value = 1;
  }

  if(add > 2000 || sub > 2000 || sub_inv > 2000 || mult > 2000 || division > 2000 || division_inv > 2000){
     digitalWrite(3, HIGH);
     delay(1000);
     digitalWrite(3, LOW);
     pos_value = 1;
   }

  if(neg_value == 1 || pos_value == 1){
    time_delay = 1000;
  }
  else if (neg_value == 1 && pos_value == 1)
  {
    time_delay = 0;
  }
  else if (first_read == true)
  {
    time_delay = 0;
  }
  else{
    time_delay = 2000;
  }

  first_value = second_value;

  delay(time_delay)
  Serial.println("--------");

}
\end{lstlisting}


\end{document}