Mbsborges

Descobrindo a Palavra Misteriosa do Roda a Roda Jequiti

2021-02-15T13:54:00.035-03:00

Palavra Misteriosa é um quadro apresentado no SBT pelo apresentador Silvio Santos, no qual o(s) participante(s) tenta(m) descobrir a(s) palavra(s) proposta(s) com base em dicas ou apenas pela quantidade de letras que a palavra é composta.

Para descobrir as possíveis palavras que podem ser a "Palavra Misteriosa", desenvolvemos um programa utilizando a linguagem C/C++ no qual podemos inserir as letras já conhecidas e obter as possíveis palavras da língua portuguesa que são compostas por elas. O programa também pode ser usado para ajudar na resolução de palavras cruzadas.

Requisitos:

- Conhecer ao menos uma das letras que formam a palavra

- Computador com sistema operacional Windows®

Ao baixar e abrir o arquivo .zip que contém o programa, encontramos nele dois arquivos: Palavra_Misteriosa.exe (programa usado para fazer a busca das palavras com base nas letras inseridas) e wordlistPT-BR.txt (arquivo de texto com a lista de palavras da língua portuguesa).

Download

Lista de comandos - ProjectZero

2019-04-18T12:38:00.005-03:00

Controle sua residência com comodidade a partir da palma de sua mão utilizando o ProjectZero, disponibilizados a lista de comandos abaixo para possibilitar o desenvolvimento de código fonte para diversas plataformas de hardware.

*************************************************************
APP FORMATO COMANDOS:
*************************************************************

Exemplo para acionar lâmpada 1:

IP: http://10.0.0.2
GET: /msg?q=
COMANDO:L1=1
IP+GET+COMANDO
http://10.0.0.2/msg?q=L1=1

*************************************************************
APP COMANDOS LÂMPADAS:
*************************************************************

L1=1 | Ligar lâmpada 1
L1=0 | Desligar lâmpada 1
L2=1 | Ligar lâmpada 2
L2=0 | Desligar lâmpada 2
L3=1 | Ligar lâmpada 3
L3=0 | Desligar lâmpada 3
L4=1 | Ligar lâmpada 4
L4=0 | Desligar lâmpada 4
L5=1 | Ligar lâmpada 5
L5=0 | Desligar lâmpada 5
L6=1 | Ligar lâmpada 6
L6=0 | Desligar lâmpada 6
L7=1 | Ligar lâmpada 7
L7=0 | Desligar lâmpada 7
L8=1 | Ligar lâmpada 8
L8=0 | Desligar lâmpada 8
L1=1L2=1L3=1L4=1L5=1L6=1L7=1L8=1 | Ligar todas as lâmpadas
L1=0L2=0L3=0L4=0L5=0L6=0L7=0L8=0 | Desligar todas as lâmpadas

*************************************************************
APP COMANDOS TOMADAS:
*************************************************************

T1=1 | Ligar lâmpada 1
T1=0 | Desligar lâmpada 1
T2=1 | Ligar lâmpada 2
T2=0 | Desligar lâmpada 2
T3=1 | Ligar lâmpada 3
T3=0 | Desligar lâmpada 3
T4=1 | Ligar lâmpada 4
T4=0 | Desligar lâmpada 4
T5=1 | Ligar lâmpada 5
T5=0 | Desligar lâmpada 5
T6=1 | Ligar lâmpada 6
T6=0 | Desligar lâmpada 6
T7=1 | Ligar lâmpada 7
T7=0 | Desligar lâmpada 7
T8=1 | Ligar lâmpada 8
T8=0 | Desligar lâmpada 8
T1=1T2=1T3=1T4=1T5=1T6=1T7=1T8=1 | Ligar todas as tomadas
T1=0T2=0T3=0T4=0T5=0T6=0T7=0T8=0 | Desligar todas as tomadas

*************************************************************
APP COMANDOS CONTROLE:
*************************************************************

status | Status das lâmpada e tomadas
mbsborges | Buscar módulo

*************************************************************
RESPOSTAS ESPERADAS PELO APP:
*************************************************************

mbsborges | mbsborgesIsHere
status | (Status das lâmpada e tomadas)

----------------------
Status das lâmpadas:
----------------------
- Lâmpada acesa: AC+(Número da lâmpada)
- Lâmpada apagada: AP+(Número da lâmpada)
- Exemplo 01: todas as lâmpadas acesas
- status=AC1AC2AC3AC4AC5AC6AC7AC8
- Exemplo 02: todas as lâmpadas apagadas
- status=AP1AP2AP3AP4AP5AP6AP7AP8
- Exemplo 03: somente lâmpada 1 acesa
- status=AC1AP2AP3AP4AP5AP6AP7AP8

----------------------
Status das tomadas:
----------------------
- Lâmpada acesa: PL+(Número da tomada)
- Lâmpada apagada: UP+(Número da tomada)
- Exemplo 01: todas as tomadas ligadas
- status=PL1PL2PL3PL4PL5PL6PL7PL8
- Exemplo 02: todas as tomadas desligadas
- status=UP1UP2UP3UP4UP5UP6UP7UP8
- Exemplo 03: somente tomada 1 ligada
- status=PL1UP2UP3UP4UP5UP6UP7UP8

Tabela de comandos do Joystick Bluetooth

2015-05-12T16:38:00.001-03:00

Botão	Mensagem	Caractere final
Ativar Bluetooth	*Ação 1
Conectar	*Ação 2
Desconectar	*Ação 3
	up	\n
	down	\n
	left	\n
	right	\n
	stop	\n
Cmd. 1	cmd1	\n
Cmd. 2	cmd2	\n
Cmd. 3	cmd3	\n
Cmd. 4	cmd4	\n
Cmd. 5	cmd5	\n
Cmd. 6	cmd6	\n
Slider	slider=*range=slider	\n
	Exibe a carga da bateria
	Envia o texto inserido	\n
	*Ação 4

· *Ação 1: solicita permissão para ativar o bluetooth

· *Ação 2: abre lista de dispositivos pareados para selecionar e efetuar a conexão

· *Ação 3: desconecta do dispositivo conectado

· *range: valor inteiro: 0 - 99 (slider esquerda) e 100 - 199 (slider direita)

- Quando o joystick está conectado, a cada 2 s (dois segundos), é enviada a string level\n, para atualizar o nível da bateria no aplicativo, ao receber a string level\n, deve ser enviada uma resposta no formato: _bat=*range=bat (0 - 100)

· *Ação 4: Após o clique é efetuada uma das seguintes ações

- Bluetooth ativo e não conectado: conecta ao último dispositivo conectado

- Bluetooth ativo e conectado: desconecta dispositivo conectado

- Bluetooth não ativo: solicita permissão para ativar o bluetooth

Código de exemplo para o Joystick Bluetooth 2.1

2015-05-12T15:26:00.000-03:00

Código fonte de exemplo para utilizar o Joystick Bluetooth com o módulo bluetooth HC-05 e com o Arduino

/* ***************************************************************************
  Joystick Bluetooth - Código de exemplo para arduino
  Autor: Marcelo Borges dos Santos
  e-mail: mbsborges@gmail.com
  blog: http://mbsborges.blogspot.com.br

  Ultima alteração: 12 de maio de 2015 às 15:08
******************************************************************************/
//Biblioteca
#include <SoftwareSerial.h>
//Pinos para a virtual serial (RX, TX)
SoftwareSerial Bluetooth(2, 3);
//Saída PWM
int dimmer = 5;
//Pino para leitura da tensão da bateria
int bateria = A0;
//String para armazenar a leitura dos dados
String readString = "";
//variável para receber os caracteres vindos da serial
byte byteRead;

void setup() {
  Bluetooth.begin(9600);
  Serial.begin(9600);
  //Pino de saída
  pinMode(dimmer, OUTPUT);
  //Mensagem de inicialização
  Serial.println("Mbsborges - Joystick Bluetooth");
  Serial.println("http://mbsborges.blogspot.com.br/");
}

void loop() {
  //Verificando se tem algum byte disponível na serial
  while (Bluetooth.available() > 0) {
    //lendo byte disponível
    byteRead = Bluetooth.read();
    //Verificando se é fim de linha
    if (byteRead == '\n') {
      Serial.println("\nOk!");
      //Imprimindo a mensagem completa
      Serial.println(readString);
      //Tratamento dos dados para a execução dos comandos recebidos
      tratamentoDados();
      //Limpando String de leitura
      readString = "";
    }
    else {
      //Covertendo os bytes recebidos em caracteres e os concatenando
      readString += char(byteRead);
      //Imprimindo caractere recebido
      Serial.print (char(byteRead));
    }
  }
}

void tratamentoDados() {
  if (readString.indexOf("level") == 0) {
    //teste com numeros randômicos
    //int randNumber = random(0, 101);
    //Coneversão da leitura da porta analógica A0 para valores dentro da escala de 0-100
    int randNumber = map(analogRead(bateria), 0, 1023, 0, 100);
    //exibição do valor a ser enviado para o aplicativo
    Serial.println(randNumber);
    //Enviando o valor para o aplicativo
    //Formato da mensagem: _bat=number=bat
    //number é um numero inteiro e varia de 0-100
    Bluetooth.print("_bat=" + String(randNumber) + "=bat");
  }
  if (readString.indexOf("slider=") == 0) {
    //Obter valor do slider
    readString = readString.substring(readString.indexOf("slider=") + 7, readString.indexOf("=slider"));
    //Imprimindo valor do slider
    Serial.println(readString);
    //Ajustando a intensidade do led de acordo com o valor lido do slider
    analogWrite(dimmer, map(readString.toInt(), 0, 100, 0, 255));
  }
  else if (readString.indexOf("up") == 0) {
    Serial.println("UP");
  }
  else if (readString.indexOf("down") == 0) {
    Serial.println("DOWN");
  }
  else if (readString.indexOf("left") == 0) {
    Serial.println("LEFT");
  }
  else if (readString.indexOf("right") == 0) {
    Serial.println("RIGHT");
  }
  else if (readString.indexOf("stop") == 0) {
    Serial.println("STOP");
  }
  else if (readString.indexOf("cmd1") == 0) {
    Serial.println("CMD1");
  }
  else if (readString.indexOf("cmd2") == 0) {
    Serial.println("CMD2");
  }
  else if (readString.indexOf("cmd3") == 0) {
    Serial.println("CMD3");
  }
  else if (readString.indexOf("cmd4") == 0) {
    Serial.println("CMD4");
  }
  else if (readString.indexOf("cmd5") == 0) {
    Serial.println("CMD5");
  }
  else if (readString.indexOf("cmd6") == 0) {
    Serial.println("CMD6");
  }
}

HomeControl: Nova arquitetura de comunicação

2014-12-20T13:54:00.000-03:00

Para tornar mais fácil a implantação a estrutura dos dispositivos foi remodelada (Toda a comunicação é feita sem fio, exceto o controlador) e agora também possui suporte a acesso fora da rede local...

Arquitetura de comunicação

Protótipo da arquitetura da rede [TCC Domótica]

2014-04-26T18:05:00.001-03:00

O arquitetura da rede é composta por um roteador, um ethernet shield, três arduinos uno, duas placas de relês, dois módulos NRF24L01 e pulsadores de um, dois e três botões. O controle dos dispositivos tanto pode ser efetuado pelo celular ou tablet com sistema operacional android quanto pelos pulsadores.

Aplicativo Android para o TCC de Domótica v0.3

2014-03-24T00:21:00.001-03:00

Novas alterações:
- Ajuste de tela de login;
- Menu remodelado;
- Funcionalidade de cenas inseridas;
- Implementado o controle de iluminação e de tomadas;
- Atualização dos ícones da tela iluminação a cada 1s; e,
- Atualização dos ícones da tela tomada a cada 1s

Aplicativo Android para o TCC de Domótica

2014-03-16T19:18:00.001-03:00

Evolução do desenvolvimento do aplicativo HomeControl....

Mbsborges - Joystick Bluetooh 2.0 [Teste 01]

2013-12-16T20:41:00.001-03:00

Teste 01: Medição do nível de bateria do dispositivo conectado

Observações:

- A atualização do nível da bateria ocorre a cada três segundos (3s)
- O número ao lado esquerdo da seta para cima indica a porcentagem do nível da bateria

Demonstração - Joystick Bluetooth v1.2

2013-12-13T03:11:00.002-03:00

Utilizando a interface do aplicativo para conectar, enviar comando e desconectar do dispositivo a ser controlado

Utilizando o aplicativo para controlar o bípede

Mbsborges - Joystick Bluetooth v1.2

2013-12-13T02:17:00.001-03:00

Aplicativo desenvolvido no APP Inventor v2 para controle de dispositivos (Robô de sumô, carrinhos, bípedes e muito mais) utilizando um celular ou tablet com sistema operacional android com suporte a comunicação por bluetooth, um módulo bluetooth (para efetuar a comunicação entre o dispositivo controlado e o controlador) e um microcontrolador (Arduino, Pic, ...).

Tela inicial

Tela do Joystick

Baixe via QR Code ou clique aqui para efetuar o download

Teste de portas analógicas do Simulino v3.0

2013-08-28T13:43:00.001-03:00

Após realizar um teste com as portas analógicas da nova versão do simulino v3.0, assim como algumas pessoas eu também encontrei o problema nas portas analógicas (elas só retornam 1023).

Na verdade o erro não é causado por um problema do simulador e sim por que a tensão não foi referenciada (na versão antiga o simulador utiliza uma fonte de alimentação em comum, por isso não era necessária a referenciação, já na nova versão utiliza-se fontes diferentes, logo é obrigatório fazer a referenciação para um correto funcionamento).
Achei estranho o fato de não haver tensão entre os pinos "5V e GND", porém segundo o autor isso ocorre devido a limitações do Proteus.

Referenciando a tensão

Falta de tensão entre os pinos 5V e GND

Motivo de não haver tensão entre os pinos 5V e GND

Mapa de Karnaugh

2013-07-20T12:25:00.003-03:00

Mapa de Karnaugh é um método de simplificação gráfico criado por Edward Veitch e aperfeiçoado pelo engenheiro de telecomunicações Maurice Karnaugh. Chamamos esse diagrama de mapa, visto este ser um mapeamento biunívoco a partir de uma tabela verdade da função que está a ser analisada.

Disponibilizamos para download o programa e o código fonte que desenvolvemos em linguagem C/C++ para a resolução do Mapa de Veitch-karnaugh com duas ou três variáveis.

Clique aqui para baixar a versão para duas variáveis ou clique aqui para baixar a versão para para três variáveis

Robô Bípede - Programa de controle v1.1.1

2013-04-08T16:24:00.006-03:00

/*

Programa de controle de robô bípede com 6 servos v. 1.1.1 Beta
Última atualização em 20 de março de 2013 às 15:14:10
Autor: Marcelo Borges dos Santos
e-mail: mbsborges@gmail.com
blog: https://mbsborges.blogspot.com

*/

//Inicio da inserção das bibliotecas
#include <Servo.h>

//Fim da inserção das bibliotecas

#define tempo 150 //Variável de controle da velocidade 

//Inicio da nomeção dos servos
//Quadris
Servo quadrilDireito;
Servo quadrilEsquerdo;
//joelhos
Servo joelhoDireito;
Servo joelhoEsquerdo;
//pés
Servo peDireito;
Servo peEsquerdo;
//Fim da nomeção dos servos

//Inicio do ajuste de angulação dos servos (em graus)
#define ajustePeDireito 0           // Ajuste do pé direito
#define ajustePeEsquerdo 0          // Ajuste do pé esquerdo
#define ajusteJoelhoDireito 0       // Ajuste do joelho direito
#define ajusteJoelhoEsquerdo 0      // Ajuste do joelho esquerdo
#define ajusteQuadrilDireito -5    // Ajuste do quadril direito
#define ajusteQuadrilEsquerdo 0     // Ajuste do quadril esquerdo
//Fim do ajuste de angulação dos servos

void setup() {
  //Definindo as portas de controle dos servos
  peDireito.attach(6);
  peEsquerdo.attach(11);
  joelhoDireito.attach(5);
  joelhoEsquerdo.attach(10);
  quadrilDireito.attach(3);
  quadrilEsquerdo.attach(9);
}

void loop() {

  //Movendo servos para posição inicial
  posicaoInicial();
  delay (2000);
  cumprimentar (2);
  delay(20);
  andar(4);
  delay(20);
  girarSentidoAntiHorario(4);
  delay(20);
  andar(2);
  delay(20);
  girarSentidoAntiHorario(4);
  delay(20);
  andar(4);
  delay(20);
  girarSentidoAntiHorario(8);
  delay(20);
  cumprimentar (2);
  delay(20);
}

//Funções
//Função Posição Inicial (Manda todos os servos para 90º)
void posicaoInicial() {
  peDireito.write(90 + ajustePeDireito);
  peEsquerdo.write(90 + ajustePeEsquerdo);
  quadrilDireito.write(90 + ajusteQuadrilDireito);
  quadrilEsquerdo.write(90 + ajusteQuadrilEsquerdo);
  joelhoDireito.write(90 + ajusteJoelhoDireito);
  joelhoEsquerdo.write(90 + ajusteJoelhoEsquerdo);
  delay(1000);
}

//Função Cumprimentar (Faz n cumprimentações)
void cumprimentar (int vezes) {
  int x;
  for (x = 0; x < vezes; x++) {
    //(i - incremento) / (d - decremento)
    //Movimento de ida
    int i = 90, d = 90;
    for (i = 90; i < 115; i++) {
      joelhoDireito.write(d + ajusteJoelhoDireito);
      joelhoEsquerdo.write(i + ajusteJoelhoEsquerdo);
      quadrilDireito.write(i + ajusteQuadrilDireito);
      quadrilEsquerdo.write(d + ajusteQuadrilEsquerdo);
      d--;
      delay(0.5 * tempo);
    }
    delay (2000);
    //Movimento de volta
    for (i = 115; i > 90; i--) {
      joelhoDireito.write(d + ajusteJoelhoDireito);
      joelhoEsquerdo.write(i + ajusteJoelhoEsquerdo);
      quadrilDireito.write(i + ajusteQuadrilDireito);
      quadrilEsquerdo.write(d + ajusteQuadrilEsquerdo);
      d++;
      delay(0.5 * tempo);
    }
    posicaoInicial();
    delay (50);
  }
}

//Função abaixar-se (o robô abaixa-se)
void abaixar () {
  //(i - incremento) / (d - decremento)
  int i = 90, d = 90;
  for (i = 90; i < 130; i++) {
    joelhoDireito.write(d + ajusteJoelhoDireito);
    joelhoEsquerdo.write(i + ajusteJoelhoEsquerdo);
    quadrilDireito.write(d + ajusteQuadrilDireito);
    quadrilEsquerdo.write(i + ajusteQuadrilEsquerdo);
    d--;
    delay(0.5 * tempo);
  }
}

//Função inclinar para a esquerda
void inclinarEsquerda(int sentido) {
  int i;
  //Inclinando para a esquerda
  if (sentido == 1) {
    for (i = 90; i < 110; i++) {
      peEsquerdo.write(i + ajustePeEsquerdo);
      peDireito.write(i + ajustePeDireito);
      delay(tempo);
    }
    delay (100);
    peEsquerdo.write(110 + ajustePeEsquerdo);
    peDireito.write(110 + ajustePeDireito);
    delay (100);
  }
  //Retornando para posição anterior
  if (sentido == 0) {
    for (i = 110; i > 90; i--) {
      peEsquerdo.write(i + ajustePeEsquerdo);
      peDireito.write(i + ajustePeDireito);
      delay (tempo);
    }
    delay (100);
    peDireito.write(90 + ajustePeDireito);
    peEsquerdo.write(90 + ajustePeEsquerdo);
    delay (100);
  }
}

//Função inclinar para a direita
void inclinarDireita (int sentido) {
  int i;
  if (sentido == 1) {
    //Inclinando para a direita
    for (i = 90; i > 70; i--) {
      peDireito.write(i + ajustePeDireito);
      peEsquerdo.write(i + ajustePeEsquerdo);
      delay (tempo);
    }
    delay (100);
    peDireito.write(70 + ajustePeDireito);
    peEsquerdo.write(70 + ajustePeEsquerdo);
    delay(100);
  }
  //Retornando para posição anterior
  if (sentido == 0) {
    for (i = 70; i < 90; i++) {
      peEsquerdo.write(i + ajustePeEsquerdo);
      peDireito.write(i + ajustePeDireito);
      delay(tempo);
    }
    delay (100);
    peEsquerdo.write(90 + ajustePeEsquerdo);
    peDireito.write(90 + ajustePeDireito);
    delay(100);
  }
}

//Função Aquecimento
void aquecimento () {
  inclinarDireita(1);
  inclinarDireita(0);
  inclinarEsquerda(1);
  inclinarEsquerda(0);
  posicaoInicial();
  abaixar();
  posicaoInicial();
}

//Função Andar
void andar (int passos) {
  posicaoInicial();
  int i, x;
  for (i = 0; i < passos; i++) {
    inclinarEsquerda(1);
    if (i == 0) {
      for (x = 90; x < 110; x++) {
        quadrilDireito.write(x + ajusteQuadrilDireito);
        quadrilEsquerdo.write(x + ajusteQuadrilEsquerdo);
        joelhoDireito.write(x + ajusteJoelhoDireito);
        joelhoEsquerdo.write(x + ajusteJoelhoEsquerdo);
        delay(0.25 * tempo);
      }
    }
    else {
      for (x = 70; x < 110; x++) {
        quadrilDireito.write(x + ajusteQuadrilDireito);
        quadrilEsquerdo.write(x + ajusteQuadrilEsquerdo);
        joelhoDireito.write(x + ajusteJoelhoDireito);
        joelhoEsquerdo.write(x + ajusteJoelhoEsquerdo);
        delay(0.25 * tempo);
      }
    }
    inclinarEsquerda(0);
    inclinarDireita(1);
    for (x = 110; x > 70; x--) {
      quadrilDireito.write(x + ajusteQuadrilDireito);
      quadrilEsquerdo.write(x + ajusteQuadrilEsquerdo);
      joelhoDireito.write(x + ajusteJoelhoDireito);
      joelhoEsquerdo.write(x + ajusteJoelhoEsquerdo);
      delay(0.25 * tempo);
    }
    inclinarDireita(0);
  }
  //Retornando para a posição inicial
  inclinarEsquerda (1);
  for (i = 70; i < 90; i++) {
    quadrilDireito.write(i + ajusteQuadrilDireito);
    quadrilEsquerdo.write(i + ajusteQuadrilEsquerdo);
    joelhoDireito.write(i + ajusteJoelhoDireito);
    joelhoEsquerdo.write(i + ajusteJoelhoEsquerdo);
    delay (0.25 * tempo);
  }
  inclinarEsquerda (0);
}
//Função Girar no Sentido Anti-Horário
void girarSentidoAntiHorario(int passos) {
  //Cada passo proporciona um giro de 45º no sentido anti-horário
  int i, x;
  for (i = 0; i < passos; i++) {
    posicaoInicial();
    inclinarEsquerda(1);
    for (x = 90; x < 110; x++) {
      quadrilDireito.write(x + ajusteQuadrilDireito);
      quadrilEsquerdo.write(x + ajusteQuadrilEsquerdo);
      joelhoDireito.write(x + ajusteJoelhoDireito);
      joelhoEsquerdo.write(x + ajusteJoelhoEsquerdo);
      delay(0.25 * tempo);
    }
    inclinarEsquerda(0);
    posicaoInicial();
  }
}
//Função Girar no Sentido Horário
void girarSentidoHorario(int passos) {
  //Cada passo proporciona um giro de 45º no sentido horário
  int i, x;
  for (i = 0; i < passos; i++) {
    inclinarDireita(1);
    for (x = 90; x > 70; x--) {
      quadrilDireito.write(x + ajusteQuadrilDireito);
      quadrilEsquerdo.write(x + ajusteQuadrilEsquerdo);
      joelhoDireito.write(x + ajusteJoelhoDireito);
      joelhoEsquerdo.write(x + ajusteJoelhoEsquerdo);
      delay(0.25 * tempo);
    }
    inclinarDireita(0);
    posicaoInicial();
  }
}

//Fim

Robô Bípede - Demonstração

2013-01-12T19:27:00.001-03:00

Demonstração do robô bípede utilizando o Programa de Controle v. 0.9, que foi desenvolvido utilizando a plataforma Arduino

Robô Bípede - Programa de controle v. 1.0.1

2012-12-11T16:20:00.004-03:00

/*

Programa de controle de robô bípede com 6 servos v. 1.0.1 Beta
Última atualização em 11 de dezembro de 2012 às 15:34:03
Autor: Marcelo Borges dos Santos
e-mail: mbsborges@gmail.com
blog: http://mbsborges.blogspot.com

*/

#include <Servo.h>
#define tempo 150

//Servos
//Quadris
Servo quadrilDireito;
Servo quadrilEsquerdo;
//joelhos
Servo joelhoDireito;
Servo joelhoEsquerdo;
//pés
Servo peDireito;
Servo peEsquerdo;

void setup() {
  //Definindo as portas de controle dos servos
  peDireito.attach(6);
  peEsquerdo.attach(11);
  joelhoDireito.attach(5);
  joelhoEsquerdo.attach(10);
  quadrilDireito.attach(3);
  quadrilEsquerdo.attach(9);
}

void loop() {
  //Movendo servos para posição inicial
  posicaoInicial();
  delay (2000);
  cumprimentar (2);
  delay(20);
  andar(4);
  delay(20);
  girarSentidoAntiHorario(4);
  delay(20);
  andar(2);
  delay(20);
  girarSentidoAntiHorario(4);
  delay(20);
  andar(4);
  delay(20);
  girarSentidoAntiHorario(8);
  delay(20);
  cumprimentar (2);
  delay(20);
}

//Funções
//Função Posição Inicial (Manda todos os servos para 90º)
void posicaoInicial() {
  peDireito.write(90);
  peEsquerdo.write(90);
  quadrilDireito.write(90);
  quadrilEsquerdo.write(90);
  joelhoDireito.write(90);
  joelhoEsquerdo.write(90);
  delay(1000);
}

//Função Cumprimentar (Faz n cumprimentações)
void cumprimentar (int vezes) {
  int x;
  for (x = 0; x < vezes; x++) {
    //(i - incremento) / (d - decremento)
    //Movimento de ida
    int i = 90, d = 90;
    for (i = 90; i < 115; i++) {
      joelhoDireito.write(d);
      joelhoEsquerdo.write(i);
      quadrilDireito.write(i);
      quadrilEsquerdo.write(d);
      d--;
      delay(0.5 * tempo);
    }
    delay (2000);
    //Movimento de volta
    for (i = 115; i > 90; i--) {
      joelhoDireito.write(d);
      joelhoEsquerdo.write(i);
      quadrilDireito.write(i);
      quadrilEsquerdo.write(d);
      d++;
      delay(0.5 * tempo);
    }
    posicaoInicial();
    delay (50);
  }
}

//Função abaixar-se (o robô abaixa-se)
void abaixar () {
  //(i - incremento) / (d - decremento)
  int i = 90, d = 90;
  for (i = 90; i < 130; i++) {
    joelhoDireito.write(d);
    joelhoEsquerdo.write(i);
    quadrilDireito.write(d);
    quadrilEsquerdo.write(i);
    d--;
    delay(0.5 * tempo);
  }
}

//Função inclinar para a esquerda
void inclinarEsquerda(int sentido) {
  int i;
  //Inclinando para a esquerda
  if (sentido == 1) {
    for (i = 90; i < 110; i++) {
      peEsquerdo.write(i);
      peDireito.write(i);
      delay(tempo);
    }
    delay (100);
    peEsquerdo.write(110);
    peDireito.write(110);
    delay (100);
  }
  //Retornando para posição anterior
  if (sentido == 0) {
    for (i = 110; i > 90; i--) {
      peEsquerdo.write(i);
      peDireito.write(i);
      delay (tempo);
    }
    delay (100);
    peDireito.write(90);
    peEsquerdo.write(90);
    delay (100);
  }
}

//Função inclinar para a direita
void inclinarDireita (int sentido) {
  int i;
  if (sentido == 1) {
    //Inclinando para a direita
    for (i = 90; i > 70; i--) {
      peDireito.write(i);
      peEsquerdo.write(i);
      delay (tempo);
    }
    delay (100);
    peDireito.write(70);
    peEsquerdo.write(70);
    delay(100);
  }
  //Retornando para posição anterior
  if (sentido == 0) {
    for (i = 70; i < 90; i++) {
      peEsquerdo.write(i);
      peDireito.write(i);
      delay(tempo);
    }
    delay (100);
    peEsquerdo.write(90);
    peDireito.write(90);
    delay(100);
  }
}

//Função Aquecimento
void aquecimento () {
  inclinarDireita(1);
  inclinarDireita(0);
  inclinarEsquerda(1);
  inclinarEsquerda(0);
  posicaoInicial();
  abaixar();
  posicaoInicial();
}

//Função Andar
void andar (int passos) {
  posicaoInicial();
  int i, x;
  for (i = 0; i < passos; i++) {
    inclinarEsquerda(1);
    if (i == 0) {
      for (x = 90; x < 110; x++) {
        quadrilDireito.write(x);
        quadrilEsquerdo.write(x);
        joelhoDireito.write(x);
        joelhoEsquerdo.write(x);
        delay(0.25 * tempo);
      }
    }
    else {
      for (x = 70; x < 110; x++) {
        quadrilDireito.write(x);
        quadrilEsquerdo.write(x);
        joelhoDireito.write(x);
        joelhoEsquerdo.write(x);
        delay(0.25 * tempo);
      }
    }
    inclinarEsquerda(0);
    inclinarDireita(1);
    for (x = 110; x > 70; x--) {
      quadrilDireito.write(x);
      quadrilEsquerdo.write(x);
      joelhoDireito.write(x);
      joelhoEsquerdo.write(x);
      delay(0.25 * tempo);
    }
    inclinarDireita(0);
  }
  //Retornando para a posição inicial
  inclinarEsquerda (1);
  for (i = 70; i < 90; i++) {
    quadrilDireito.write(i);
    quadrilEsquerdo.write(i);
    joelhoDireito.write(i);
    joelhoEsquerdo.write(i);
    delay (0.25 * tempo);
  }
  inclinarEsquerda (0);
}
//Função Girar no Sentido Anti-Horário
void girarSentidoAntiHorario(int passos) {
  //Cada passo proporciona um giro de 45º no sentido anti-horário
  int i, x;
  for (i = 0; i < passos; i++) {
    posicaoInicial();
    inclinarEsquerda(1);
    for (x = 90; x < 110; x++) {
      quadrilDireito.write(x);
      quadrilEsquerdo.write(x);
      joelhoDireito.write(x);
      joelhoEsquerdo.write(x);
      delay(0.25 * tempo);
    }
    inclinarEsquerda(0);
    posicaoInicial();
  }
}
//Função Girar no Sentido Horário
void girarSentidoHorario(int passos) {
  //Cada passo proporciona um giro de 45º no sentido horário
  int i, x;
  for (i = 0; i < passos; i++) {
    inclinarDireita(1);
    for (x = 90; x > 70; x--) {
      quadrilDireito.write(x);
      quadrilEsquerdo.write(x);
      joelhoDireito.write(x);
      joelhoEsquerdo.write(x);
      delay(0.25 * tempo);
    }
    inclinarDireita(0);
    posicaoInicial();
  }
}

//Fim

Robô Bípede - Programa de controle v. 0.9

2012-12-04T12:49:00.006-03:00

/*

Programa de controle de robô bípede com 6 servos v. 0.9 Beta
Última atualização em 02 de dezembro de 2012 às 00:24:43
Autor: Marcelo Borges dos Santos
e-mail: mbsborges@gmail.com
blog: http://mbsborges.blogspot.com

*/

#include <Servo.h>
#define tempo 150

//Servos
//Quadris
Servo quadrilDireito;
Servo quadrilEsquerdo;
//joelhos
Servo joelhoDireito;
Servo joelhoEsquerdo;
//pés
Servo peDireito;
Servo peEsquerdo;

void setup() {
  //Definindo as portas de controle dos servos
  peDireito.attach(6);
  peEsquerdo.attach(11);
  joelhoDireito.attach(5);
  joelhoEsquerdo.attach(10);
  quadrilDireito.attach(3);
  quadrilEsquerdo.attach(9);
}

void loop() {
  //Movendo servos para posição inicial
  posicaoInicial();
  delay (5000);
  aquecimento();
  delay (20);
  cumprimentar (3);
  delay(20);
  andar(4);
}

//Funções
//Função Posição Inicial (Manda todos os servos para 90º)
void posicaoInicial() {
  peDireito.write(90);
  peEsquerdo.write(90);
  quadrilDireito.write(90);
  quadrilEsquerdo.write(90);
  joelhoDireito.write(90);
  joelhoEsquerdo.write(90);
  delay(1000);
}

//Função Cumprimentar (Faz n cumprimentações)
void cumprimentar (int vezes) {
  int x;
  for (x = 0; x < vezes; x++) {
    //(i - incremento) / (d - decremento)
    //Movimento de ida
    int i = 90, d = 90;
    for (i = 90; i < 115; i++) {
      joelhoDireito.write(d);
      joelhoEsquerdo.write(i);
      quadrilDireito.write(i);
      quadrilEsquerdo.write(d);
      d--;
      delay(0.5 * tempo);
    }
    delay (2000);
    //Movimento de volta
    for (i = 115; i > 90; i--) {
      joelhoDireito.write(d);
      joelhoEsquerdo.write(i);
      quadrilDireito.write(i);
      quadrilEsquerdo.write(d);
      d++;
      delay(0.5 * tempo);
    }
    posicaoInicial();
    delay (50);
  }
}

//Função abaixar-se (o robô abaixa-se)
void abaixar () {
  //(i - incremento) / (d - decremento)
  int i = 90, d = 90;
  for (i = 90; i < 130; i++) {
    joelhoDireito.write(d);
    joelhoEsquerdo.write(i);
    quadrilDireito.write(d);
    quadrilEsquerdo.write(i);
    d--;
    delay(0.5 * tempo);
  }
}

//Função inclinar para a esquerda
void inclinarEsquerda(int sentido) {
  int i;
  //Inclinando para a esquerda
  if (sentido == 1) {
    for (i = 90; i < 110; i++) {
      peEsquerdo.write(i);
      peDireito.write(i);
      delay(tempo);
    }
    delay (100);
    peEsquerdo.write(110);
    peDireito.write(110);
    delay (100);
  }
  //Retornando para posição anterior
  if (sentido == 0) {
    for (i = 110; i > 90; i--) {
      peEsquerdo.write(i);
      peDireito.write(i);
      delay (tempo);
    }
    delay (100);
    peDireito.write(90);
    peEsquerdo.write(90);
    delay (100);
  }
}

//Função inclinar para a direita
void inclinarDireita (int sentido) {
  int i;
  if (sentido == 1) {
    //Inclinando para a direita
    for (i = 90; i > 70; i--) {
      peDireito.write(i);
      peEsquerdo.write(i);
      delay (tempo);
    }
    delay (100);
    peDireito.write(70);
    peEsquerdo.write(70);
    delay(100);
  }
  //Retornando para posição anterior
  if (sentido == 0) {
    for (i = 70; i < 90; i++) {
      peEsquerdo.write(i);
      peDireito.write(i);
      delay(tempo);
    }
    delay (100);
    peEsquerdo.write(90);
    peDireito.write(90);
    delay(100);
  }
}

//Função Aquecimento
void aquecimento () {
  inclinarDireita(1);
  inclinarDireita(0);
  inclinarEsquerda(1);
  inclinarEsquerda(0);
  posicaoInicial();
  abaixar();
  posicaoInicial();
}

//Função Andar
void andar (int passos) {
  posicaoInicial();
  int i, x;
  for (i = 0; i < passos; i++) {
    inclinarEsquerda(1);
    for (x = 90; x < 110; x++) {
      quadrilDireito.write(x);
      quadrilEsquerdo.write(x);
      joelhoDireito.write(x);
      joelhoEsquerdo.write(x);
      delay(0.25 * tempo);
    }
    inclinarEsquerda(0);
    inclinarDireita(1);
    for (x = 110; x > 70; x--) {
      quadrilDireito.write(x);
      quadrilEsquerdo.write(x);
      joelhoDireito.write(x);
      joelhoEsquerdo.write(x);
      delay(0.25 * tempo);
    }
    inclinarDireita(0);
  }
  inclinarEsquerda (1);
  for (i = 70; i < 90; i++) {
    quadrilDireito.write(i);
    quadrilEsquerdo.write(i);
    joelhoDireito.write(i);
    joelhoEsquerdo.write(i);
    delay (0.25 * tempo);
  }
  inclinarEsquerda (0);
}

//Fim

Robô Bípede - Programa de controle

2012-12-01T19:32:00.004-03:00

O programa de controle do bípede com 6 servos está em fase de finalização, no momento está na versão 0.8 Beta e a data de lançamento da versão 1.0 está prevista para o dia 4 de dezembro

Upload da versão 0.8 para o bípede

Robô Bípede - Programa de Pré-Montagem

2012-11-25T02:25:00.005-03:00


/*
Programa de pré-montagem do bípede
Data: 15/11/2012 às 10:34:57
Programa de controle do robô bípede com 6 servos

*/

#include <Servo.h>

//Servos
//Quadris
Servo quadrilDireito;
Servo quadrilEsquerdo;
//joelhos
Servo joelhoDireito;
Servo joelhoEsquerdo;
//pés
Servo peDireito;
Servo peEsquerdo;

void setup() {
  //Definindo as portas de controle dos servos
  peDireito.attach(6);
  peEsquerdo.attach(11);
  joelhoDireito.attach(5);
  joelhoEsquerdo.attach(10);
  quadrilDireito.attach(3);
  quadrilEsquerdo.attach(9);
}

void loop() {
  //Movendo servos para posição inicial
  posicaoInicial();
  delay (3000);

}

//Função Posição Inicial (Move o eixo de todos os servos para 90º)
void posicaoInicial() {
  peDireito.write(90);
  peEsquerdo.write(90);
  quadrilDireito.write(90);
  quadrilEsquerdo.write(90);
  joelhoDireito.write(90);
  joelhoEsquerdo.write(90);
  delay(2000);
}
//Fim

Robô Bípede - Chassi

2012-10-20T18:30:00.001-03:00

Robô bípede é um pequeno robô que possui duas pernas. Este modelo utiliza seis servo-motores para locomoção e poderá ser controlado de forma autônoma ou manual.

Simulino UNO [Simulador de Arduino UNO]

2012-09-03T16:05:00.005-03:00

O Simulador possui aparência e funcionalidade muito similar à placa original, foi desenvolvido pelo Blog Embarcado utilizando o software Proteus e é baseado no Arduino UNO R3.

Simulino UNO

Clique aqui para fazer o download do Simulino UNO

Alterando o idioma da IDE do Arduino 1.01

2012-08-27T15:52:00.001-03:00

O idioma padrão da interface do Arduino é o inglês, porém é possível personalizar a interface trocando o idioma padrão para português ou outro idioma de sua preferência.

Como soldar componentes eletrônicos

2012-07-27T14:39:00.002-03:00

Aprenda com este vídeo tutorial do Tecmundo a efetuar soldas com qualidade e rapidez.

Lutas do Minotauro no CBRA 2011

2012-04-13T22:29:00.003-03:00

Minotauro x Verme

Lista de reprodução com alguns dos vídeos do Campeonato Baiano de Robôs Autônomos (CBRA 2011).

Adaptando fonte ATX para bancada

2012-03-14T15:36:00.001-03:00

Uma fonte de alimentação de qualidade é um item indispensável numa bancada de eletrônica, porém, seu preço é relativamente alto, principalmente as que possuem proteção contra curto-circuito e sobrecarga.
Uma alternativa eficiente e de baixo custo é adaptar uma fonte ATX, pois, ela possui proteção contra curto-circuito e pode fornecer altos níveis de corrente. Abaixo disponibilizamos um modelo e o link para baixar o tutorial completo de como adaptar sua Fonte ATX.

Clique aqui para fazer o download do tutorial