Exercicio 4.04 Resolvido

*
* CURSO DE ROBOTICA 2020
*
* Exercicio: 4.4
* Tema: Organizar numeros
* Atividade: Carregar 5 numeros randomicos num vetor e organiza-los
* Descrição: usar a função random para gerar numeros entre 1 e 99, guardá-los num vetor de 10 posições, depois rodar o algoritmo para organizá-los
* Hardware: Montar o display
* Comandos: lcd.print(); for(); if(); random(1,99);
* Dica1: String é uma variável que armazena um conjunto de diversos valores do mesmo tipo
* Dica2: Declaração do vetor int nome_vetor[tamanho]; tipo dos dados, no caso int. Nome do vetor identifica a variável. Entre conchetes vai o tamanho do vetor
* Dica3: A cada 300ms realiza um ciclo de organização dos numeros para poder acompanhar a evolução do processo
* Dica4: A estratégia usada será a o algoritmo de ordenação por troca, descrito no livro "C completo e total", pag 502, mesmo que o bubble https://pt.wikipedia.org/wiki/Algoritmo_de_ordena%C3%A7%C3%A3o
* Dica5: Inserir um temporizador no processo para acompanhar as trocas
* Dica6: Testar primeiro elemento se é maior que o segundo, se for inverte os dois de lugar
* Dica7: Para mostrar as 10 posições use as duas linhas do display, colocando 5 valores na primeira linha e 5 na segunda linha
* Dica8: Usar uma tecla para controlar o inicio do proximo ciclo
* Dica9: Quando chegar ao final acender um led indicando o fim do algoritmo
* PLANO DE IMPLANTAÇÃO:
* 01 - Usar um botão para start e o tempo de pressionado usar na função randomSeed() para garantir a aleatoriedade
* 02 - Gerar os números Aleatórios e guardar nas posições do vetor
* 03 - Mostrar on numeros no display, colocar os 5 primeiros na primeira linha separados por " " espaço e os outros 5 na segunda linha
* 04 - Iniciar as comparações da posição 0 com a 1
* 05 - Caso o número na posição 0 seja maior que na 1, fazer a inversão usando uma variável temporária, senão testar a posição 1
* 06 - Caso uma posição anterior tenha um número maior que a posição subsequente, reiniciar o contador
* 07 - A cada inversão realizada mostrar o vetor no display e temporizar para ficar perseptível a evolução do algoritmo
* 08 - Caso o contador atinja o último valor do vetor a ordenação estará concluida, então sinalizar no led
*/
//DEFINICOES INICIAIS
#include //
#define tecla 2 //
#define led 3 //

//DECLARAcAO DE VARIAVEIS GLOBAIS
LiquidCrystal lcd(12,11,10,9,8,7);//
byte vetorRandom[10];//

//INICIALIZAÇÃO DO HARDWARE
void setup() {
lcd.begin(16,2);//
lcd.clear();//
pinMode(tecla, INPUT_PULLUP);//
pinMode(led ,OUTPUT);//
}
//FUNÇÕES COMPLEMENTARES
void mostraDispay(){
lcd.clear();//
for(byte count = 0;count <10; count ++){
lcd.print(vetorRandon[count];//
lcd.print(" ");//
}
lcd.setCursor(0,1);//
for(count = 5; count < 10; count ++){
lcd.print(vetorRandom[count];//
lcd.print(" ");//
}
delay(400);//
}
//PROGRAMA PRINCIPAL
void loop() {
while(digitalRead(tecla));//
randomSeed(millis());//
}
digitalWrite(led,LOW);//
//Carregador vetor com numero Randomico
for(i = 0 ; i < 10 ; i++);//
vetorRandom[i] = random(0,99);//
}
//Ordenação
for(i = 0 ; i < 10 ; i++){
if(vetorRandom[i] > vetorRandom[i +i]){
byte temp = vetorRandom[i];//
vetorRandom[i] = vetorRandom[i +i];//
vetorRandom[i + i] = temp;//
i = -1;//
}
mostraDisplay();//
}
digitalWrite(led ,HIGH);//
}


Resolvido 4.04 só não Comentado

Oi Monica, Estava corrigindo o exercício e encontrei uns erros de sintaxe
1 - Nessa linha lcd.print(vetorRandon[count]; //faltou fechar os parenteses e a variável esta escrita errada
2 - for(count = 5; count < 10; count ++){ //se a variável não foi declarada no global, pode e deve ser declarada no for
3 - lcd.print(vetorRandom[count]; //faltou fechar o parenteses
4 -while(digitalRead(tecla));/// faltou abrir a chave
5 - for(i = 0 ; i < 10 ; i++); //faltou abrir a chave e declarar a variável

Não olhei a semantica

/* CURSO DE ROBOTICA 2020
*
* Exercicio: 4.4
* Tema: Organizar numeros
* Atividade: Carregar 5 numeros randomicos num vetor e organiza-los
* Descrição: usar a função random para gerar numeros entre 1 e 99, guardá-los num vetor de 10 posições, depois rodar o algoritmo para organizá-los
* Hardware: Montar o display
* Comandos: lcd.print(); for(); if(); random(1,99);
* Dica1: String é uma variável que armazena um conjunto de diversos valores do mesmo tipo
* Dica2: Declaração do vetor int nome_vetor[tamanho]; tipo dos dados, no caso int. Nome do vetor identifica a variável. Entre conchetes vai o tamanho do vetor
* Dica3: A cada 300ms realiza um ciclo de organização dos numeros para poder acompanhar a evolução do processo
* Dica4: A estratégia usada será a o algoritmo de ordenação por troca, descrito no livro "C completo e total", pag 502, mesmo que o bubble https://pt.wikipedia.org/wiki/Algoritmo_de_ordena%C3%A7%C3%A3o
* Dica5: Inserir um temporizador no processo para acompanhar as trocas
* Dica6: Testar primeiro elemento se é maior que o segundo, se for inverte os dois de lugar
* Dica7: Para mostrar as 10 posições use as duas linhas do display, colocando 5 valores na primeira linha e 5 na segunda linha
* Dica8: Usar uma tecla para controlar o inicio do proximo ciclo
* Dica9: Quando chegar ao final acender um led indicando o fim do algoritmo
* PLANO DE IMPLANTAÇÃO:
* 01 - Usar um botão para start e o tempo de pressionado usar na função randomSeed() para garantir a aleatoriedade
* 02 - Gerar os números Aleatórios e guardar nas posições do vetor
* 03 - Mostrar on numeros no display, colocar os 5 primeiros na primeira linha separados por " " espaço e os outros 5 na segunda linha
* 04 - Iniciar as comparações da posição 0 com a 1
* 05 - Caso o número na posição 0 seja maior que na 1, fazer a inversão usando uma variável temporária, senão testar a posição 1
* 06 - Caso uma posição anterior tenha um número maior que a posição subsequente, reiniciar o contador
* 07 - A cada inversão realizada mostrar o vetor no display e temporizar para ficar perseptível a evolução do algoritmo
* 08 - Caso o contador atinja o último valor do vetor a ordenação estará concluida, então sinalizar no led
*/
//DEFINICOES INICIAIS
#include   //Carrega a biblioteca com as funções do display
#define tecla 2 //Define que o 2 vai ser chamado de tecla.
#define led 3 //Define que o 3 vai ser chamado de led.

//DECLARAcAO DE VARIAVEIS GLOBAIS
LiquidCrystal lcd(12,11,10,9,8,7);//Setup conforme as ligações realizadas RS-EN-D4-D5-D6-D7
byte vetorRandom[10];// Variavel vetorRandom
byte count //
byte temp //
//INICIALIZAÇÃO DO HARDWARE
void setup() {
lcd.begin(16,2);//Aqui vai iniciar o display que esta configurado como 16 colunas e 2 linhas
lcd.clear();//Aqui vai limpar o display e pocisionar o cursor na primeira linha e primeira coluna
pinMode(tecla, INPUT_PULLUP);//Programado tecla como Entrada PULL UP
pinMode(led ,OUTPUT); //Programado led como saida
}
//FUNÇÕES COMPLEMENTARES
void mostraDispay(){
lcd.clear();//Aqui vai limpar o display e pocisionar o cursor na primeira linha e primeira coluna
for(byte count = 0;count <10; count ++){
lcd.print(vetorRandon[count];//
lcd.print(" ");//Aqui é o espaço para separar os valores
}
lcd.setCursor(0,1);//
for(count = 5; count < 10; count ++){
lcd.print(vetorRandom[count]);//
lcd.print(" ");//Aqui é o espaço para separar os valores
}
delay(400);//tempo
}
//PROGRAMA PRINCIPAL
void loop() {
while(digitalRead(tecla));//
randomSeed(millis());//
}
digitalWrite(led,LOW);//deliga o led
//Carregador vetor com numero Randomico
for(i = 0 ; i < 10 ; i++){
vetorRandom[i] = random(0,99);//
}
//Ordenação
for(i = 0 ; i < 10 ; i++){
if(vetorRandom[i] > vetorRandom[i +i]){
byte temp = vetorRandom[i];//
vetorRandom[i] = vetorRandom[i +i];//
vetorRandom[i + i] = temp;//
i = -1;//
}
mostraDisplay();//
digitalWrite(led ,HIGH);//liga o led
}

incompleto

Eita, tem bastante erro de sintaxe para arrumar.

/* CURSO DE ROBOTICA 2020
*
* Exercicio: 4.4
* Tema: Organizar numeros
* Atividade: Carregar 5 numeros randomicos num vetor e organiza-los
* Descrição: usar a função random para gerar numeros entre 1 e 99, guardá-los num vetor de 10 posições, depois rodar o algoritmo para organizá-los
* Hardware: Montar o display
* Comandos: lcd.print(); for(); if(); random(1,99);
* Dica1: String é uma variável que armazena um conjunto de diversos valores do mesmo tipo
* Dica2: Declaração do vetor int nome_vetor[tamanho]; tipo dos dados, no caso int. Nome do vetor identifica a variável. Entre conchetes vai o tamanho do vetor
* Dica3: A cada 300ms realiza um ciclo de organização dos numeros para poder acompanhar a evolução do processo
* Dica4: A estratégia usada será a o algoritmo de ordenação por troca, descrito no livro "C completo e total", pag 502, mesmo que o bubble https://pt.wikipedia.org/wiki/Algoritmo_de_ordena%C3%A7%C3%A3o
* Dica5: Inserir um temporizador no processo para acompanhar as trocas
* Dica6: Testar primeiro elemento se é maior que o segundo, se for inverte os dois de lugar
* Dica7: Para mostrar as 10 posições use as duas linhas do display, colocando 5 valores na primeira linha e 5 na segunda linha
* Dica8: Usar uma tecla para controlar o inicio do proximo ciclo
* Dica9: Quando chegar ao final acender um led indicando o fim do algoritmo
* PLANO DE IMPLANTAÇÃO:
* 01 - Usar um botão para start e o tempo de pressionado usar na função randomSeed() para garantir a aleatoriedade
* 02 - Gerar os números Aleatórios e guardar nas posições do vetor
* 03 - Mostrar on numeros no display, colocar os 5 primeiros na primeira linha separados por " " espaço e os outros 5 na segunda linha
* 04 - Iniciar as comparações da posição 0 com a 1
* 05 - Caso o número na posição 0 seja maior que na 1, fazer a inversão usando uma variável temporária, senão testar a posição 1
* 06 - Caso uma posição anterior tenha um número maior que a posição subsequente, reiniciar o contador
* 07 - A cada inversão realizada mostrar o vetor no display e temporizar para ficar perseptível a evolução do algoritmo
* 08 - Caso o contador atinja o último valor do vetor a ordenação estará concluida, então sinalizar no led
*/
//DEFINICOES INICIAIS
#include //Carrega a biblioteca com as funções do display
#define tecla 2 //Define que o 2 vai ser chamado de tecla.
#define led 3 //Define que o 3 vai ser chamado de led.

//DECLARAcAO DE VARIAVEIS GLOBAIS
LiquidCrystal lcd(12,11,10,9,8,7);//Setup conforme as ligações realizadas RS-EN-D4-D5-D6-D7
byte vetorRando[10];// Variavel vetorRandom
byte count ;//Variavel byte count
byte temp ;//Variavel byte tempo
byte i ;//Variavel byte i
//INICIALIZAÇÃO DO HARDWARE
void setup() {
lcd.begin(16,2);//Aqui vai iniciar o display que esta configurado como 16 colunas e 2 linhas
lcd.clear();//Aqui vai limpar o display e pocisionar o cursor na primeira linha e primeira coluna
pinMode(tecla, INPUT_PULLUP);//Programado tecla como Entrada PULL UP
pinMode(led ,OUTPUT); //Programado led como saida
}
//FUNÇÕES COMPLEMENTARES//////////////////////////////////////////////////////////////////////////////
void mostraDisplay(){
lcd.clear();//Aqui vai limpar o display e pocisionar o cursor na primeira linha e primeira coluna
for(byte count = 0;count <10; count ++){
lcd.print(vetorRandom[count]);//
lcd.print(" ");//Aqui é o espaço para separar os valores
}
lcd.setCursor(0,1);//
for(count = 5; count < 10; count ++){
lcd.print(vetorRandom[count]);//
lcd.print(" ");//Aqui é o espaço para separar os valores
}
delay(400);//tempo
}

//PROGRAMA PRINCIPAL/////////////////////////////////////////////////////////////////////////////////
void loop() {
while(digitalRead(tecla));//
randomSeed(millis());//
digitalWrite(led,LOW);//deliga o led
//Carregador vetor com numero Randomico
for(i = 0 ; i < 10 ; i++){
vetorRandom[i] = random(0,99);//
}
//Ordenação
for(i = 0 ; i < 10 ; i++){
if(vetorRandom[i] > vetorRandom[i + i]){
byte temp = vetorRandom[i];//
vetorRandom[i] = vetorRandom[i + i];//
vetorRandom[i + i] = temp;//
i = -1;//
}
mostraDisplay();//
digitalWrite(led ,HIGH);//liga o led
}
}
INcompleto !!

/* CURSO DE ROBOTICA 2020
*
* Exercicio: 4.4
* Tema: Organizar numeros
* Atividade: Carregar 5 numeros randomicos num vetor e organiza-los
* Descrição: usar a função random para gerar numeros entre 1 e 99, guardá-los num vetor de 10 posições, depois rodar o algoritmo para organizá-los
* Hardware: Montar o display
* Comandos: lcd.print(); for(); if(); random(1,99);
* Dica1: String é uma variável que armazena um conjunto de diversos valores do mesmo tipo
* Dica2: Declaração do vetor int nome_vetor[tamanho]; tipo dos dados, no caso int. Nome do vetor identifica a variável. Entre conchetes vai o tamanho do vetor
* Dica3: A cada 300ms realiza um ciclo de organização dos numeros para poder acompanhar a evolução do processo
* Dica4: A estratégia usada será a o algoritmo de ordenação por troca, descrito no livro "C completo e total", pag 502, mesmo que o bubble https://pt.wikipedia.org/wiki/Algoritmo_de_ordena%C3%A7%C3%A3o
* Dica5: Inserir um temporizador no processo para acompanhar as trocas
* Dica6: Testar primeiro elemento se é maior que o segundo, se for inverte os dois de lugar
* Dica7: Para mostrar as 10 posições use as duas linhas do display, colocando 5 valores na primeira linha e 5 na segunda linha
* Dica8: Usar uma tecla para controlar o inicio do proximo ciclo
* Dica9: Quando chegar ao final acender um led indicando o fim do algoritmo
* PLANO DE IMPLANTAÇÃO:
* 01 - Usar um botão para start e o tempo de pressionado usar na função randomSeed() para garantir a aleatoriedade
* 02 - Gerar os números Aleatórios e guardar nas posições do vetor
* 03 - Mostrar on numeros no display, colocar os 5 primeiros na primeira linha separados por " " espaço e os outros 5 na segunda linha
* 04 - Iniciar as comparações da posição 0 com a 1
* 05 - Caso o número na posição 0 seja maior que na 1, fazer a inversão usando uma variável temporária, senão testar a posição 1
* 06 - Caso uma posição anterior tenha um número maior que a posição subsequente, reiniciar o contador
* 07 - A cada inversão realizada mostrar o vetor no display e temporizar para ficar perseptível a evolução do algoritmo
* 08 - Caso o contador atinja o último valor do vetor a ordenação estará concluida, então sinalizar no led
*/
//DEFINICOES INICIAIS
#include //Carrega a biblioteca com as funções do display
#define tecla 2 //Define que o 2 vai ser chamado de tecla.
#define led 3 //Define que o 3 vai ser chamado de led.

//DECLARAcAO DE VARIAVEIS GLOBAIS
LiquidCrystal lcd(12,11,10,9,8,7);//Setup conforme as ligações realizadas RS-EN-D4-D5-D6-D7
byte vetorRandom[10];// Variavel vetorRandom
byte count ;//Variavel byte count
byte temp ;//Variavel byte tempo
byte i ;//Variavel byte i
//INICIALIZAÇÃO DO HARDWARE
void setup() {
lcd.begin(16,2);//Aqui vai iniciar o display que esta configurado como 16 colunas e 2 linhas
lcd.clear();//Aqui vai limpar o display e pocisionar o cursor na primeira linha e primeira coluna
pinMode(tecla, INPUT_PULLUP);//Programado tecla como Entrada PULL UP
pinMode(led ,OUTPUT); //Programado led como saida
}
//FUNÇÕES COMPLEMENTARES//////////////////////////////////////////////////////////////////////////////
void mostraDisplay(){
lcd.clear();//Aqui vai limpar o display e pocisionar o cursor na primeira linha e primeira coluna
for(byte count = 0;count <10; count ++){
lcd.print(vetorRandom[count]);//
lcd.print(" ");//Aqui é o espaço para separar os valores
}
lcd.setCursor(0,1);//
for(count = 5; count < 10; count ++){
lcd.print(vetorRandom[count]);//
lcd.print(" ");//Aqui é o espaço para separar os valores
}
delay(400);//tempo
}

//PROGRAMA PRINCIPAL/////////////////////////////////////////////////////////////////////////////////
void loop() {
while(digitalRead(tecla));//
randomSeed(millis());//
digitalWrite(led,LOW);//deliga o led
//Carregador vetor com numero Randomico
for(i = 0 ; i < 10 ; i++){
vetorRandom[i] = random(0,99);//
}
//Ordenação
for(i = 0 ; i < 10 ; i++){
if(vetorRandom[i] > vetorRandom[i + i]){
byte temp = vetorRandom[i];//
vetorRandom[i] = vetorRandom[i + i];//
vetorRandom[i + i] = temp;//
i = -1;//
}
mostraDisplay();//
digitalWrite(led ,HIGH);//liga o led
}
}
Completo so falta comentar

Salveee
Então, há alguns problems com seu programa

1º - Na sua função Mostra Display , o seu primeiro for está indo de i=0 a i<10, porém de veria ser até i<5 pois queremos apenas os 5 primeiros números na primeira linha, os outros 5 são na segunda linha

2º - No seu programa principal, quando vc faz a ordenação, vc está comprando e trocando o vetorRandom[i] com o vetorRandom[i+i], porém deve ser entre vetorRandom[i] e vetorRandom[i+1] pois estamos comparando a posição atual com a próxima

3º - Faltou os comentários

Aguardo o retorno corrigido

/* CURSO DE ROBOTICA 2020
*
* Exercicio: 4.4
* Tema: Organizar numeros
* Atividade: Carregar 5 numeros randomicos num vetor e organiza-los
* Descrição: usar a função random para gerar numeros entre 1 e 99, guardá-los num vetor de 10 posições, depois rodar o algoritmo para organizá-los
* Hardware: Montar o display
* Comandos: lcd.print(); for(); if(); random(1,99);
* Dica1: String é uma variável que armazena um conjunto de diversos valores do mesmo tipo
* Dica2: Declaração do vetor int nome_vetor[tamanho]; tipo dos dados, no caso int. Nome do vetor identifica a variável. Entre conchetes vai o tamanho do vetor
* Dica3: A cada 300ms realiza um ciclo de organização dos numeros para poder acompanhar a evolução do processo
* Dica4: A estratégia usada será a o algoritmo de ordenação por troca, descrito no livro "C completo e total", pag 502, mesmo que o bubble https://pt.wikipedia.org/wiki/Algoritmo_de_ordena%C3%A7%C3%A3o
* Dica5: Inserir um temporizador no processo para acompanhar as trocas
* Dica6: Testar primeiro elemento se é maior que o segundo, se for inverte os dois de lugar
* Dica7: Para mostrar as 10 posições use as duas linhas do display, colocando 5 valores na primeira linha e 5 na segunda linha
* Dica8: Usar uma tecla para controlar o inicio do proximo ciclo
* Dica9: Quando chegar ao final acender um led indicando o fim do algoritmo
* PLANO DE IMPLANTAÇÃO:
* 01 - Usar um botão para start e o tempo de pressionado usar na função randomSeed() para garantir a aleatoriedade
* 02 - Gerar os números Aleatórios e guardar nas posições do vetor
* 03 - Mostrar on numeros no display, colocar os 5 primeiros na primeira linha separados por " " espaço e os outros 5 na segunda linha
* 04 - Iniciar as comparações da posição 0 com a 1
* 05 - Caso o número na posição 0 seja maior que na 1, fazer a inversão usando uma variável temporária, senão testar a posição 1
* 06 - Caso uma posição anterior tenha um número maior que a posição subsequente, reiniciar o contador
* 07 - A cada inversão realizada mostrar o vetor no display e temporizar para ficar perseptível a evolução do algoritmo
* 08 - Caso o contador atinja o último valor do vetor a ordenação estará concluida, então sinalizar no led
*/
//DEFINICOES INICIAIS
#include //Carrega a biblioteca com as funções do display
#define tecla 2 //Define que o 2 vai ser chamado de tecla.
#define led 3 //Define que o 3 vai ser chamado de led.

//DECLARAcAO DE VARIAVEIS GLOBAIS
LiquidCrystal lcd(12,11,10,9,8,7);//Setup conforme as ligações realizadas RS-EN-D4-D5-D6-D7
byte vetorRandom[10];// Variavel vetorRandom
byte count ;//Variavel byte count
byte temp ;//Variavel byte tempo
byte i ;//Variavel byte i
//INICIALIZAÇÃO DO HARDWARE
void setup() {
lcd.begin(16,2);//Aqui vai iniciar o display que esta configurado como 16 colunas e 2 linhas
lcd.clear();//Aqui vai limpar o display e pocisionar o cursor na primeira linha e primeira coluna
pinMode(tecla, INPUT_PULLUP);//Programado tecla como Entrada PULL UP
pinMode(led ,OUTPUT); //Programado led como saida
}
//FUNÇÕES COMPLEMENTARES//////////////////////////////////////////////////////////////////////////////
void mostraDisplay(){ //vou começar nessa função, usou dois for, pode ser dai um conta de 0 a 4 e outro de 5 a 9, se o primeiro contar até 10 para depois trocar a linha vai dar ruim.
lcd.clear();//Aqui vai limpar o display e pocisionar o cursor na primeira linha e primeira coluna
for(byte count = 0;count <10; count ++){
lcd.print(vetorRandom[count]);//
lcd.print(" ");//Aqui é o espaço para separar os valores
}
lcd.setCursor(0,1);// //poderia resolver com único for() dai poe um if dentro dele , se for igual a 5 roda esse comado colocando o cursor na segunda linha, ou deixa com 2 for() mas a contagem precisa ser correta
for(count = 5; count < 10; count ++){
lcd.print(vetorRandom[count]);//
lcd.print(" ");//Aqui é o espaço para separar os valores
}
delay(400);//tempo
}

//PROGRAMA PRINCIPAL/////////////////////////////////////////////////////////////////////////////////
void loop() {
while(digitalRead(tecla));//
randomSeed(millis());// legal, muito bom para mudar os resultados
digitalWrite(led,LOW);//deliga o led
//Carregador vetor com numero Randomico
for(i = 0 ; i < 10 ; i++){
vetorRandom[i] = random(0,99);//
}
//Ordenação //antes desse for() coloca um while com uma variavel de controle, vai parar quando acabar
for(i = 0 ; i < 10 ; i++){
if(vetorRandom[i] > vetorRandom[i + i]){
byte temp = vetorRandom[i];//
vetorRandom[i] = vetorRandom[i + i];//
vetorRandom[i + i] = temp;//
i = -1;//
} //se houver troca no for(), a variavel dw controle é reiniciada, indicando que não acabou
mostraDisplay();//
digitalWrite(led ,HIGH);//liga o led esse led acende só quando acabar, deve ficar fora do segundo while
} se houver alguma troca reinicia a a variavel de controle
}

Monica, vou te ajudar dando as dicas no seu programa, segue com a fonte em vermelho.
Uma dica é que use mais os debugs para acompanhar o funcionamento do programa

/* CURSO DE ROBOTICA 2020
*
* Exercicio: 4.4
* Tema: Organizar numeros
* Atividade: Carregar 5 numeros randomicos num vetor e organiza-los
* Descrição: usar a função random para gerar numeros entre 1 e 99, guardá-los num vetor de 10 posições, depois rodar o algoritmo para organizá-los
* Hardware: Montar o display
* Comandos: lcd.print(); for(); if(); random(1,99);
* Dica1: String é uma variável que armazena um conjunto de diversos valores do mesmo tipo
* Dica2: Declaração do vetor int nome_vetor[tamanho]; tipo dos dados, no caso int. Nome do vetor identifica a variável. Entre conchetes vai o tamanho do vetor
* Dica3: A cada 300ms realiza um ciclo de organização dos numeros para poder acompanhar a evolução do processo
* Dica4: A estratégia usada será a o algoritmo de ordenação por troca, descrito no livro "C completo e total", pag 502, mesmo que o bubble https://pt.wikipedia.org/wiki/Algoritmo_de_ordena%C3%A7%C3%A3o
* Dica5: Inserir um temporizador no processo para acompanhar as trocas
* Dica6: Testar primeiro elemento se é maior que o segundo, se for inverte os dois de lugar
* Dica7: Para mostrar as 10 posições use as duas linhas do display, colocando 5 valores na primeira linha e 5 na segunda linha
* Dica8: Usar uma tecla para controlar o inicio do proximo ciclo
* Dica9: Quando chegar ao final acender um led indicando o fim do algoritmo
* PLANO DE IMPLANTAÇÃO:
* 01 - Usar um botão para start e o tempo de pressionado usar na função randomSeed() para garantir a aleatoriedade
* 02 - Gerar os números Aleatórios e guardar nas posições do vetor
* 03 - Mostrar on numeros no display, colocar os 5 primeiros na primeira linha separados por " " espaço e os outros 5 na segunda linha
* 04 - Iniciar as comparações da posição 0 com a 1
* 05 - Caso o número na posição 0 seja maior que na 1, fazer a inversão usando uma variável temporária, senão testar a posição 1
* 06 - Caso uma posição anterior tenha um número maior que a posição subsequente, reiniciar o contador
* 07 - A cada inversão realizada mostrar o vetor no display e temporizar para ficar perseptível a evolução do algoritmo
* 08 - Caso o contador atinja o último valor do vetor a ordenação estará concluida, então sinalizar no led
*/
//DEFINICOES INICIAIS
#include //Carrega a biblioteca com as funções do display
#define tecla 2 //Define que o 2 vai ser chamado de tecla.
#define led 3 //Define que o 3 vai ser chamado de led.

//DECLARAcAO DE VARIAVEIS GLOBAIS
LiquidCrystal lcd(12,11,10,9,8,7);//Setup conforme as ligações realizadas RS-EN-D4-D5-D6-D7
byte vetorRandom[10];// Variavel vetorRandom
byte count ;//Variavel byte count
byte temp ;//Variavel byte tempo
byte i ;//Variavel byte i


//INICIALIZAÇÃO DO HARDWARE
void setup() {
lcd.begin(16,2);//Aqui vai iniciar o display que esta configurado como 16 colunas e 2 linhas
lcd.clear();//Aqui vai limpar o display e pocisionar o cursor na primeira linha e primeira coluna
pinMode(tecla, INPUT_PULLUP);//Programado tecla como Entrada PULL UP
pinMode(led ,OUTPUT); //Programado led como saida
}


//FUNÇÕES COMPLEMENTARES//////////////////////////////////////////////////////////////////////////////
void mostraDisplay(){ //
lcd.clear();//Aqui vai limpar o display e pocisionar o cursor na primeira linha e primeira coluna
for(byte count = 0;count <10; count ++){
lcd.print(vetorRandom[count]);//
lcd.print(" ");//Aqui é o espaço para separar os valores
}
lcd.setCursor(0,1);//
for(count = 5; count < 10; count ++){
lcd.print(vetorRandom[count]);//
lcd.print(" ");//Aqui é o espaço para separar os valores
}
delay(400);//tempo
}

//PROGRAMA PRINCIPAL/////////////////////////////////////////////////////////////////////////////////
void loop() {
while(digitalRead(tecla)){;//
randomSeed(millis());//
}
digitalWrite(led,LOW);//deliga o led

for(i = 0 ; i < 10 ; i++){
vetorRandom[i] = random(0,99);//
}
//Ordenação
for(i = 0 ; i < 10 ; i++){
if(vetorRandom[i] > vetorRandom[i + i]){
byte temp = vetorRandom[i];//
vetorRandom[i] = vetorRandom[i + i];//
vetorRandom[i + i] = temp;//
i = -1;//
}
}
mostraDisplay();//
digitalWrite(led ,HIGH);//liga o led
}

Monica, não da para ver os numeros nem a ordenação. Use o mostra display() durante a geração dos numeros no vetor, depois coloque no algoritmo de ordenação para ver ele funcionando.
Ao termino do programa use um delay para segurar durante o reinicio, não apague o display após concluido. Pode usar mensagens extras enquanto aguarda o teclado, ou até mesmo ficar mostrando o resultado anterior.