Me llamo Miguel, y desde siempre he tenido la ilusion de montar un pequeño robot humanoide, pero que no estuviera limitado por el tipico mando con unas pocas funciones.
El modelo elegido a sido el HIWONDER H3P, ya que en el kit trae:
placa de control 24 servos + modulo de expansion + Arduino NANO + multiples sensores + todo lo necesario para montar el robot.
Antes de montar la estructura, estoy probando la electronica y me he encontrado con un problema.
Al grabar el .INO en la NANO me lo hace correctamente, pero una vez instalado en la placa, no manda ninguna señal para el movimiento de los servos.
El mando IR si que envia las señales, y asi se aprecia en los led de la placa.
El programa que he cargado, es uno de los que mandan con el KIT.
Os agradeceria vuestra ayuda, ya que estoy batante perdido.
En un segundo POST, os mandare fotos y el codigo.
Muchas gracias.
#include <SoftwareSerial.h>
#include <LobotServoController.h> /*Archivo de cabezal de desarrollo secundario de la placa de control de Rudd*/
#include <IRremote.h>
#include "Code.h"
#define STAND 0 //Atención
//const int RECV_PIN = 10; //Pin receptor infrarrojo en el No. 10 IO
//Número de grupo de acciones y vídeo de interpretación hay una discrepancia, por favor tome el código como el estándar, también puede modificar el número de acuerdo con la situación real
#define RECV_PIN 8 //Pin receptor infrarrojo en la E/S No. 8
#define txPin 10
#define rxPin 11
IRrecv irrecv(RECV_PIN); //Instancia de la clase de receptor remoto infrarrojo
decode_results results; //Clase de resultados de decodificación infrarroja con instancias
SoftwareSerial MySerial(rxPin, txPin);
LobotServoController Controller(MySerial); //Clases de desarrollo secundarias con instancias
bool ledON = true; //Logotipo de luz LED, verdadero cuando se enciende, apagado falso
void ledFlash() {
static uint32_t Timer; //Definir temporizador de variable estática, para la sincronización
if (Timer > millis()) //Timer devuelve cuando es mayor que milis (el número total de milisegundos que se ejecutará), //Timer es menor que el número total de milisegundos que se ejecutan para continuar ejecutando la siguiente instrucción
return;
if (ledON) { //Si la señal de luz es verdadera, la 13a E/S es alta y la luz LED se enciende en la placa
digitalWrite(13, HIGH); //No. 13 IO es alta y la luz LED se enciende en la placa
ledON = false; //Lit identificado como falso
Timer = millis() + 20; //Temporizador - Número total de milisegundos actualmente en ejecución, 20 después de 20 milisegundos
} else {
digitalWrite(13, LOW); //Coloque el no. 13 IO es bajo y el LED está apagado en la placa
}
}
//Esta función se basa en el valor clave de infrarrojo para obtener el número correspondiente del valor de clave, si no el número, devuelve -1
int getValue(uint32_t value) {
int Num;
switch (value) {
case R_ONE:
Num = 1;
break;
case R_TWO:
Num = 2;
break;
case R_THREE:
Num = 3;
break;
case R_FOUR:
Num = 4;
break;
case R_FIVE:
Num = 14;//由于5 6La acción de roll-over puede romper la cabeza del robot, así que cambia la acción para14 15.
break;
case R_SIX:
Num = 15;
break;
case R_SEVEN:
Num = 7;
break;
case R_EIGHT:
Num = 8;
break;
case R_NINE:
Num = 9;
break;
case R_ZERO:
Num = 0;
break;
default: Num = -1;
break;
}
return Num;
}
void IR_Remote() { //Implementación lógica del control remoto por infrarrojos
static uint32_t Timer = 0; //Temporizador de variable estática, para temporización
static uint32_t lastRes; //El último valor clave
static uint8_t count; //Variables estáticas para contar
if (Timer > millis()) //Timer devuelve cuando es mayor que milis (el número total de milisegundos que se ejecutará), //Timer es menor que el número total de milisegundos que se ejecutan para continuar ejecutando la siguiente instrucción
return;
if (irrecv.decode(&results)) {
ledON = true;
switch (results.value) {
case R_CH_D: //Si se pulsa el botón rojo CH del mando a distancia
Controller.stopActionGroup(); //Detener la ejecución del grupo de acción
irrecv.resume();
return; //Salga de esta instrucción switch
}
int actionNum; //Número de grupo de acción de ensayo
if (results.value == 0xFFFFFFFF)
actionNum = getValue(lastRes); //Obtenga el número correspondiente con la última clave válida
else { //La señal de lectura no es un logotipo de retención continua, entonces una nueva clave
lastRes = results.value; //Guarde el valor clave de la nueva clave
actionNum = getValue(lastRes); //Obtenga números clave con un nuevo valor clave
if (actionNum >= 0) //Si es mayor que 0, la clave es un número en 0-9
Controller.stopActionGroup(); //A continuación, detenga el grupo de acciones que se está ejecutando actualmente
}
if (actionNum >= 0) { //Si es mayor que 0, la clave es un número
Controller.runActionGroup(actionNum, 1); //Ejecutar grupo de acciones con actionNum especificando el número 1 de tiempo
//Serial.println(actionNum);
}
count = 0; //Recuento de ceros
irrecv.resume(); //Recibir a continuación
} else { //Sin pulsación de tecla
if (count++ > 2) { //Si el valor de recuento es mayor que 100, significa que no se ha recibido ninguna señal infrarroja durante mucho tiempo, y el recuento es 1
lastRes = 0; //Super tiempo no se presiona, el último botón presionado para borrar, contar cero
count = 0; //Recuento de ceros
}
}
Timer = millis() + 80; //Después de agregar 80 ms al número total de milisegundos de ejecución, 80ms Timer se ejecuta de nuevo
}
void setup() {
Serial.begin(9600); //Inicializar 0 serie, la velocidad de puerto es 9600
MySerial.begin(9600); //Serial inicial, velocidad de puerto de 9600
pinMode(13, OUTPUT); //Ajuste el puerto de E/S led 13 en la placa como salida
delay(500); //Retardo 500ms esperando la placa de control del timón lista
irrecv.enableIRIn(); //Activar receptor remoto ditérmico
results.decode_type = NEC;//Designar el protocolo de decodificación infrarroja como el protocolo NEC
Controller.runActionGroup(STAND, 1); //Ejecute el grupo de acciones 0, de vuelta a la posición inicial
delay(2000); //Retrasar 2000ms, asegurarse de que el grupo de acción 0 está terminado
Controller.stopActionGroup(); //Detener las ejecuciones del grupo de acción, garantizar la detención
}
void loop() {
// put your main code here, to run repeatedly:
Controller.receiveHandle(); //Controladores de recepción para sacar datos de la memoria caché de recepción
IR_Remote(); //Procesamiento de recepción infrarroja, implementación lógica de ejecución
ledFlash(); //Flash Led, para ejecutar indicaciones de estado
}
]
El foro tieneNormas, y hay algunas que no has satisfecho. Las imágenes deben verse, y para ello consulta el apéndiceComplementario: Cómo visualizar una imagen adjuntaque esta al final de las normas que explica cómo hacerlo .
Sugerencia para tu problema: observa si IRremote y LobotServoController usan el mismo Timer o si es el caso de SoftwareSerial.
Que te parece que quiere decir que una imagen se vea?
En el post 2 no veo una imagen, solo veo un archivo de imagen adjunto.
Si lo descargo lo veré en mi PC y lo que te pedí es que se vea en el post, para hacerlo debes seguir el link que te puse donde esta explicado y que obviamente no has leído.
Moderador: Decidí editarlo porque no podemos llevar 6 post con cosas como éstas que no contribuyen a tu problema. Eso que hice es como debe verse una imagen adjunta. Espero que para la próxima vez en que debas mostrar una imagen, uses el Preview que te permite ver si lo realizado es correcto o no antes de enviar el Post.
Volviendo a tu problema.
Tu tienes un kit. Nosotros no. Tienes librerías que yo desconozco como lo es LobotServoController.h
Asi que una de dos: o subes la librería como adjunta o bien nos pones un enlace que permita saber como esta escrita.
/******************************************************
/******************************************************
* FileName: LobotServoController.h
* Company: Le Fansol
* Date: 2016/07/02 16:53
* Description: LobotDefinición macro, clase, etc. de la biblioteca de desarrollo secundario de la placa de control del timón
*****************************************************/
#ifndef LOBOTSERVOCONTROLLER_H
#define LOBOTSERVOCONTROLLER_H
#include <Arduino.h>
#include <SoftwareSerial.h>
//Enviar parte de la instrucción
#define FRAME_HEADER 0x55 //Cabeza de marco
#define CMD_SERVO_MOVE 0x03 //Comando móvil Rudd
#define CMD_ACTION_GROUP_RUN 0x06 //Ejecutar instrucciones de grupo de acción
#define CMD_ACTION_GROUP_STOP 0x07 //Instrucciones de ejecución del grupo de acción Detención
#define CMD_ACTION_GROUP_SPEED 0x0B //Establecer instrucciones de velocidad de ejecución del grupo de acción
#define CMD_GET_BATTERY_VOLTAGE 0x0F //Obtenga instrucciones de voltaje de la batería
//接收部分的指令
#define BATTERY_VOLTAGE 0x0F //Tensión de la batería
#define ACTION_GROUP_RUNNING 0x06 //Se ejecuta el grupo de acción
#define ACTION_GROUP_STOPPED 0x07 //Grupo de acción detenido
#define ACTION_GROUP_COMPLETE 0x08 //Grupo de acción completado
struct LobotServo { //Rudd ID y estructura de posición
uint8_t ID; //Rudd ID
uint16_t Position; //Datos de Rudd
};
class LobotServoController {
public:
LobotServoController(SoftwareSerial &A);
LobotServoController(HardwareSerial &A);
void moveServo(uint8_t servoID, uint16_t Position, uint16_t Time);
void moveServos(LobotServo servos[], uint8_t Num, uint16_t Time);
void moveServos(uint8_t Num,uint16_t Time, ...);
void runActionGroup(uint8_t NumOfAction, uint16_t Times);
void stopActionGroup(void);
void setActionGroupSpeed(uint8_t NumOfAction, uint16_t Speed);
void setAllActionGroupSpeed(uint16_t Speed);
uint16_t getBatteryVolt(void);
uint16_t getBatteryVolt(uint32_t timeout);
bool waitForStop(uint32_t timeout);
void sendCMDGetBatteryVolt(void);
bool isRunning(void);
void receiveHandle(void);
public:
uint8_t numOfActinGroupRunning; //Número de serie del grupo de acciones en ejecución
uint16_t actionGroupRunTimes; //Número de ejecuciones de grupos de acciones
private:
bool isUseHardwareSerial;
bool isGetBatteryVolt;
uint16_t batteryVoltage; //Tensión de la batería de la placa de control
bool isRunning_; //¿Se está ejecutando un grupo de acciones?
Stream *SerialX;
};
#endif
Si te sirve de ayuda, he de decirte que cuando pulso los botones del mando, la placa indica con el encendido de un led, que le esta llegando una señal.
El problema es que la placa no envia señal a los servos.
Adjuntalo como un zip y que no supere 2MB o no podras hacerlo. Debe ser .zip no .rar ni otro compresor.
No subas videos como adjuntos pq superarían los 2MB aún comprimidos.
