Estava analisando um código e não consegui entender o uso da função millis() nesse código. Em determinado momento ele faz changeTime - millis. No entanto, ele define changeTime como millis. Ué, millis - millis?
Obs.: Não tenho noção de programação além do arduino. Não sei se é uma pergunta ridícula.
// Projeto 4 – Semáforo interativo
int carRed = 12; // estabelece o semáforo para carros
int carYellow = 11;
int carGreen = 10;
int pedRed = 9; // estabelece o semáforo para pedestres
int pedGreen = 8;
int button = 2; // pino do botão
int crossTime = 5000; // tempo para que os pedestres atravessem
unsigned long changeTime; // tempo desde que o botão foi pressionado
void setup() {
pinMode(carRed, OUTPUT);
pinMode(carYellow, OUTPUT);
pinMode(carGreen, OUTPUT);
pinMode(pedRed, OUTPUT);
pinMode(pedGreen, OUTPUT);
pinMode(button, INPUT); // botão no pino 2
// acende a luz verde
digitalWrite(carGreen, HIGH);
digitalWrite(pedRed, HIGH);
}
void loop() {
int state = digitalRead(button);
/* verifica se o botão foi pressionado e se transcorreram 5 segundos desde a última vez que
isso ocorreu */
if (state == HIGH && (millis() - changeTime) > 5000) {
// Chama a função para alterar as luzes
changeLights();
}
}
void changeLights() {
digitalWrite(carGreen, LOW); // apaga o verde
digitalWrite(carYellow, HIGH); // acende o amarelo
delay(2000); // espera 2 segundos
digitalWrite(carYellow, LOW); // apaga o amarelo
digitalWrite(carRed, HIGH); // acende o vermelho
delay(1000); // espera 1 segundo, por segurança
digitalWrite(pedRed, LOW); // apaga o vermelho dos pedestres
digitalWrite(pedGreen, HIGH); // acende o verde dos pedestres
delay(crossTime); // espera por um intervalo de tempo predefinido
// pisca o verde dos pedestres
for (int x=0; x<10; x++) {
digitalWrite(pedGreen, HIGH);
delay(250);
digitalWrite(pedGreen, LOW);
delay(250);
}
// acende o vermelho dos pedestres
digitalWrite(pedRed, HIGH);
delay(500);
digitalWrite(carYellow, HIGH); // acende o amarelo
digitalWrite(carRed, LOW); // apaga o vermelho
delay(1000);
digitalWrite(carGreen, HIGH); // acende o verde
digitalWrite(carYellow, LOW); // apaga o amarelo
// registra o tempo desde a última alteração no semáforo
changeTime = millis();
// depois retorna para o loop principal do programa
}
Não sei se compreendi bem a pergunta. Se a confusão é apenas millis()-millis() a resposta é relativamente simples.
Penso que o maior problema é a função millis(), por isso vamos tomar como base a pagina de referência do Arduino para esta função:
Description
Returns the number of milliseconds since the Arduino board began running the current program. This number will overflow (go back to zero), after approximately 50 days.
Parameters
None
Returns
Number of milliseconds since the program started (unsigned long)
Trocando por miúdos isto, o que acontece quando é chamada a função millis() é que é devolvido o número de milissegundos que passaram desde que o programa teve início.
Sendo assim, quando faz millis()-millis(), na realidade está a fazer isto, mas como as chamadas de cada função foram feitas em tempos diferentes, na realidade isto não vai dar zero. Irá dar o tempo em milissegundo que transcorreu entre uma chamada e a outra da função.
Ok. Vamos ver se eu entendi. É como se a função millis() marcasse um horário no código, certo?
Tem como você ver, então, se a análise do meu código está adequada?
Vamos lá. Pelo que ue entendi, o changeTime = millis(), lá no final da página, marca aquele pedaço do código com um "horário". O outro "millis", que está presente na subtração, é o tempo em que o NOVO LOOP está rodando?
Posso entender dessa forma? Como um relógio que é parado sempre que a função millis é chamada?
Outra dúvida: Ele usou changeTime pro segundo millis para diferenciar do millis do loop?
Em relação à questão do changeTime a resposta é, sim.
A ideia da instrução:
if (state == HIGH && (millis() - changeTime) > 5000) {
(principalmente da parte que contem milliis()) é que se verifique que já passaram 5 segundos desde a última vez que foram alteradas as luzes. Dentro da função (quando se alteram as luzes) é "anotado o tempo" em que isso foi feito, depois esse tempo é comparado com o tempo actual (dado pela função millis()), a diferença entre os dois valores dá o tempo transcorrido.
Vê as coisas assim, a função millis indica-te o numero de milisegundos que passaram desde que alimentaste ou fizeste um reset ao ARduino.
Ou seja, a função millis retorna sempre algo diferente. O que o código faz é temporizar uma acção tendo por base o tempo passado entre duas chamadas à função millis.
Se colocares uns prints do valor da função millis em várias partes do programa acho que será mais simples de entender o que ela faz e o mecanismo em que é normalmente usada.
o changetime não estouraria? Por ser colocado nele uma variável maior do que suporta? O programa não daria erro?
Se colocares um valor maior dentro do tipo de dados, essa variável recomeça da parte menor que ela suporta.Neste caso sendo um unsigned long ira começar do zero.
Se tivesses suprimido o "unsigned" ela iria recomeçar de -2,147,483,648 pois a parte menor seria a parte negativa.
HugoPT:
Se colocares um valor maior dentro do tipo de dados, essa variável recomeça da parte menor que ela suporta.Neste caso sendo um unsigned long ira começar do zero.
Se tivesses suprimido o "unsigned" ela iria recomeçar de -2,147,483,648 pois a parte menor seria a parte negativa.
Deixa eu ver se entendi. Então depois que a variável atinge o limite ela zera novamente? Porque no caso deste programa o changeTime suportaria até o 48º dia se não me engano, fazendo as contas aqui.
