Удалять код, который занимается из-за колеса и датчика робота, чтобы делать это одноглазым и хромым [закрывшая]

Палач, сделай твою обязанность!

Я хочу преобразовать код робота, установленного в течение курса из-за одноглазого и хромого робота. Я хочу создать образец электронный с только колесом и датчиком без модуля Блуетоот К-06.

Я продолжаю курс электроны - en-acciвn Папского Католического университета Чили с Coursera. В конце курса, мы можем строить робота с Arduino. Код где-то здесь.

Мне хотелось бы понимать код преобразовывая его немножко.

Я хочу создать образец электронный с только колесом и датчиком без модуля Блуетоот К-06. Я даю ему адрес 'w' прямо в коде, однако, buzzer делает тот же звук все время и не двигается механизм (только он выражает маленький шум), кроме того не кнопка.

Они могут помогать мне понимать это? По крайней мере, - код, который дает преподаватель, вещи для левой стороны робота.

Здесь - диаграмма блока:

diagrama de bloque

... и здесь есть другая диаграмма:

otro diagrama.

Здесь есть фотография для прототипа:

introducir la descripción de la imagen aquí

Здесь - мой код:

/* Sensor de Proximidad con Buzzer (como el de los autos!) */
/* En esta oportunidad vamos a crear un arreglo circuital que nos avisará
* con frecuencias de un determinado tono si estamos cerca o no de un obstáculo
* Hoja de datos del sensor de distancia: http://www.sharpsma.com/webfm_send/1208
*/
#include <math.h> //Librería de funciones matemáticas
#include <SoftwareSerial.h> //Librer+ia para asignar otros puertos seriales
#include <Servo.h> 
// Definimos el funccion del buzzer
void Dist_Sensor_Buzzer();
// Definimos el pin del buzzer
int sensorPin = 0; // Entrada analogica que lee al sensor de distancia ("ojo derecho")
int buzzPin = 8;
int led_pin = 13; // Pin que avisará estados
int servoderPin = 6; // Pin del servo derecho
int ang_der = 90;
int button_pin = 7;
// declarar la funccion movimiento
void movimiento(int estado);
//Variable para definir la direccion de movimiento.
/*
0 -> Reposo
1 -> Avanzar
2 -> Retroceder
3 -> Virar izquierda
4 -> Virar derecha */
/*
Definimos una variable para la entrada del sensor.
El sensor utiliza la entrada analogica 0
*/
int estado = 0; 
boolean apagar = true; // Variable para controlar encendido y apagado (condición inicial)???
boolean modoauto = false; // Variable para controlar modo de funcionamiento???
char comando = 0; // Variable para almacenar el comando recibido por bluetooth
int button_read; // Variable Botón apagado/encendido
// Mediciones del sensor
int sensorRead; // Variable que almacena el voltaje leido en el sensor de la izquierda
int dist; // Variable para la distancia medida por el sensor de la derecha
// Tolerancias de distancia. Las usaremos para decidir que hace el robot
int tolerancia_sup = 18;
int tolerancia_inf = 8;
// Variables para manejo de tiempo.
int intervalo; // Variable auxiliar (para comparar tiempos de sonido de buzzer)
unsigned long tiempo_previo = 0; // Variable para medir tiempo (inicial)
unsigned long tiempo_actual; //Variable para medir tiempo de ejecución del programa ( millis() )
// Creamos dos objetos de tipo Servo para manejar las ruedas
Servo miServo_izq; // Servo de la rueda izquierda
Servo miServo_der; // Servo de la rueda derecha
// Creamos un puerto serial por software en los pines 4 y 2.
SoftwareSerial BT1(4, 2); // RX, TX
void setup() {
    miServo_der.attach(servoderPin);
    pinMode(buzzPin, OUTPUT);
    pinMode(led_pin, OUTPUT);
    pinMode(button_pin, INPUT);
    pinMode(servoderPin, OUTPUT);
    BT1.begin(9600); //Comunicación con el módulo bluetooth
}
void loop() {
        if (BT1.available()) { //Revisa si hay información desde el bluetooth. Funciona para el encendido inicial via bluetooth (espera un retorno de línea)
        comando = {'w'};
        BT1.flush();
    }
    button_read = LOW; //Leemos al botón
    // revisar si prende, apaga o cambia modo con BT o boton.
    // Actualiza estado de operacion
    //
    if (comando == 'o' || button_read == LOW) { //Apaga/Enciende
        apagar = !apagar;
        estado = 0;
        comando = 0;
        digitalWrite(led_pin, !apagar); //Robot encendido, enciende luz
        tone(buzzPin, 2000,20);
        delay(200); //Delay para que notemos el cambio de modo
    }
    else if (comando == 'm') { //Cambio de modo auto/manual
        modoauto = !modoauto;
        estado = 0;
        comando = 0;
        tone(buzzPin, 2000,20);
        delay(200); //Delay para que notemos el cambio de modo
    }
    movimiento(estado);
    if (apagar == false) { /* Se ejecuta si el robot está encendido -> apagar = false */
        // Mide distancia y suena
        Dist_Sensor_Buzzer();
        /* ***Servos*** */
        /* Modo auto */
        if (modoauto == true) {
            // if ....
            // state = 1;
            // Valores utilizados fueron encontrados de forma empírica (acá usamos los parámetros de tolerancia)
            // Estos parámetros se pueden variar para hacer que el robot haga acciones a determinadas distancias
            // Como tenemos 3 situaciones: avanzar, viraje y retroceder y 2 sensores de distancia, tenemos 3^2 posibles
            // situaciones que pueden ocurrir (con el conector AND(&&)).
            // Comentaremos lo que hará el Robot en cada una (lo que sería más lógico).
            // Se pueden agregar más condiciones si se quiere mejorar el algoritmo de movimiento(IA)
            // Con este simple algoritmo estamos haciendo que el robot busque siempre pasar obstáculos y buscar la zona que le permita avanzar mejor y más cómodo
            /* Condiciones de viraje de Servos */
            if (dist > tolerancia_sup) {
                // avanzar
                estado = 1;
            } 
            else {
                if (dist < tolerancia_inf) {
                    //retrocede
                    estado = 2;
                }
                else {
                    /*if (dist_izq > dist_der) {
                    //dobla izq
                    estado = 3;
                    movimiento(estado);
                    delay(random(500,1000));*/ 
                    //dobla der
                    estado = 4;
                    movimiento(estado);
                    delay(random(300,1000));
                }
            }
        }
        delay(200);
    }
    /* Modo manual controlado por Bluetooth */
    else { // Modo manual
        /* Definimos las letras siguientes por gusto*/
        /* Si se cambian, no olvidar cambiarlas en la aplicación que controla al robot*/
        if (comando == 'w') {
            //avanzar
            estado = 1;
        }
        else if (comando == 'a') {
            //Virar izquierda
            estado = 3;
        }
        else if (comando == 'd') {
            //Virar derecha
            estado = 4;
        }
        else if (comando == 's') {
            //retrocede
            estado = 2;
        }
        else if (comando == 'f') {
            //Reposo
            estado = 0;
        }
    }
}
/* Funciones utilizadas */
void movimiento(int estado){
    if (estado == 0){
        ang_der = 90;
    }
    else if (estado == 1){
        ang_der = 120;
    }
    else if (estado == 2){
        ang_der = 70;
    }
    else if (estado == 3){
        ang_der = 100;
    }
    else if (estado == 4){
        ang_der = 80;
    }
    miServo_der.write(ang_der);
}
void Dist_Sensor_Buzzer() {
    sensorRead = analogRead(sensorPin); //Lectura de voltaje del sensor (lo que mide)
    // La fórmula de conversión aproximada a la curva mostrada en la hoja de datos
    // es la siguiente:
    // distancia = (3027.4/Vo)^1.2134
    // En la fórmula, Vo es el voltaje que entrega el sensor (lo que mide)
    // En este caso, la distancia medida estará en centímetros
    dist = pow(3027.4 / sensorRead, 1.2134); //Fórmula vista en ejemplo anterior
    // Ahora pensaremos en una función tal que al aproximarnos al obstáculo suene más rápido
    // tal como los sensores que utilizan algunos autos para estacionarse
    // La lógica es entonces, a menor distancia, más rápido suenan los tonos
    // La función que usaremos será f(x)= 36x - 320 . Lo explicaremos más adelante
    unsigned long tiempo_actual = millis(); //millis() mide el tiempo de ejecución del programa
    intervalo = 36 * dist - 320 ; //nuestra función f(x)
    if (intervalo <= 50) { //Condición para evitar números negativos y el siseo del buzzer en pequeñas distancias
        intervalo = 50;
    }
    if (intervalo > 2500) { //Condición para evitar largos períodos de tiempo entre sonidos
        intervalo = 2500;
    }
    /* Esta condición if tiene la siguiente lógica:
    * Mientras más cerca esté el sensor,"dist" será más pequeño y por ello "intervalo" será más pequeño también,
    * por lo tanto, se requerirá menos diferencia de tiempo(condición del if) para que el buzzer emita un sonido.
    * Esto es, mientras más cerca está el sensor del obstáculo, más veces por segundo se emitirá un sonido.
    */
    if (tiempo_actual - tiempo_previo >= intervalo) {
        tiempo_previo = tiempo_actual;
        /*
        La función "tone" toma 3 parámetros
        - Respectivamente pide: El pin de salida, la frecuencia de tono, duración de tono
        - Esta función entrega una señal que siempre tiene el mismo ciclo de trabajo
        y dado esto no cambia el volumen del buzzer
        En este caso generamos un tono de 4 kHz durante 20 milisegundos en el pin del buzzer
        */
        tone(buzzPin, 4000, 20);
        //Ahora solo queda ver en pantalla la distancia medida por el sensor:
        Serial.print("Distancia: ");
        Serial.print(dist);
        Serial.println(" cm.");
    }
}
/* Nota 1 (acerca de la función f(x) utilizada para calcular delay):
/* Elegimos esa función para que cuando la distancia sea aprox 10 cm tengamos una diferencia de tiempo
* pequeña(40 ms) entre sonidos y para grandes distancias, como 80 cm, tengamos una diferencia de tiempo
* entre sonidos de aproximadamente 2.5 s
*/
/* Nota 2 (ruido en la medición del sensor):
* A veces, según la topología del circuito, puede haber "ruido" en la medición del sensor de distancia
* en estos casos. se utilizan ciertas técnicas y configuraciones circuitales (filtro pasabajos, etc.)
* para tratar de "limpiar" la señal que nos envía el sensor. Esas técnicas no están mostradas en el
* presente código, pero deben tenerse en cuenta en el armado del circuito para resultados más precisos
*/
/* Nota 3 (fórmula de conversión a distancia):
* Al ver la curva proporcionada por el fabricante del sensor, notamos que la fórmula de conversión deja
* de ser válida para distancias pequeñas. No hay que olvidar que la fórmula presentada se trata de una aproximación
* de la curva para distancias entre 10 y 80 cm, donde la curva tiene forma de hipérbola. Los parámetros de la
* fórmula pueden cambiarse si se estima conveniente para mejorar la exactitud de los resultados obtenidos
*/
8
задан 13.03.2017, 04:38
0 ответов