Hacer un simple aerobote RC

¿Por qué barco aéreo?

1. Simple;
2. Barato
3. ;
4. , -.

1. Se puede colocar en diferentes plataformas: un bote, trineo, un pedazo de espuma ...
2. No se atrapa en el fondo ni en las algas.

1. Un tornillo + volante para giros ;
2. Un tornillo + su sistema de giro ;
3. Dos tornillos fijos. Girar cambiando sus antojos es la forma más fácil. El lo usó.

Control remoto

Principio de operación

Que hacer

1. Convertidor de potencia 0.9 - 5 V -> 5 V para alimentar Arduino por $ 0.35 (el conector USB, junto con un pedazo de la placa, se puede cortar para ser compacto);
2. El estabilizador 3.3V AMS1117-3.3 para alimentar el módulo de radio, cuestan $ 0.03 por unidad ;
3. Compartimento de la batería para la batería de un dedo por $ 0.15 ;

Llenado modelo RC

Componentes

1. 5 V para todos los componentes electrónicos excepto el módulo de radio;
2. 3,3 V para el módulo de radio;
3. para motores tanto como lo necesiten (mina 4.2 V).

El programa

1. Girar hacia adelante;
2. Girar hacia atrás;
3. No lo tuerzas.

inline void motLeftStop(){
  PORTD &= ~(1 << MOT_LEFT_PLUS);
  PORTD &= ~(1 << MOT_LEFT_MINUS);
}

inline void motLeftForward(){    
  PORTD |= 1 << MOT_LEFT_PLUS;
  PORTD &= ~(1 << MOT_LEFT_MINUS);
}

inline void motLeftBackward(){
  PORTD &= ~(1 << MOT_LEFT_PLUS);
  PORTD |= 1 << MOT_LEFT_MINUS;
}

inline void motRightStop(){
  PORTD &= ~(1 << MOT_RIGHT_PLUS);
  PORTD &= ~(1 << MOT_RIGHT_MINUS);
}

inline void motRightForward(){
  PORTD |= 1 << MOT_RIGHT_PLUS;
  PORTD &= ~(1 << MOT_RIGHT_MINUS);
}

inline void motRightBackward(){
  PORTD &= ~(1 << MOT_RIGHT_PLUS);
  PORTD |= 1 << MOT_RIGHT_MINUS;
}

int8_t motLeft = 0, motRight = 0; // -127..+127

ISR(TIMER2_OVF_vect)
{
  if(motLeft > 0)
    motLeftForward();
  else if(motLeft < 0)
    motLeftBackward();
  if(motRight > 0)
    motRightForward();
  else if(motRight < 0)
    motRightBackward();
}

ISR(TIMER2_COMPA_vect)
{
  motLeftStop();
}

ISR(TIMER2_COMPB_vect)
{
  motRightStop();
}

1. Escriba un valor positivo, negativo o cero en motLeft / motRight (el módulo no es importante);
2. Registre la "velocidad de rotación" en OCR2A / OCR2B.

void setMotLeft(int8_t v){ // -127..+127
  if(abs(v) < 5) v = 0;
  motLeft = v;  
  OCR2A = abs(v) * 2;
}

void setMotRight(int8_t v){ // -127..+127
  if(abs(v) < 5) v = 0;
  motRight = v;
  OCR2B = abs(v) * 2;
}

if(abs(v) < 5) v = 0;

void motInit(){
  DDRD |= (1 << MOT_LEFT_PLUS) | (1 << MOT_LEFT_MINUS) | (1 << MOT_RIGHT_PLUS) | (1 << MOT_RIGHT_MINUS);
  //TCCR2B |= (1 << CS22)|(1 << CS21)|(1 << CS20); // set up timer with prescaler = 1024.   16 
  //TCCR2B |= (1 << CS22)|(0 << CS21)|(0 << CS20); // set up timer with prescaler = 64.   1 
  TCCR2B |= (0 << CS22)|(1 << CS21)|(0 << CS20); // set up timer with prescaler = 8.  128 
  //TCCR2B |= (0 << CS22)|(0 << CS21)|(1 << CS20); // set up timer with prescaler = 1.  16 
  TIMSK2 |= (1 << TOIE2)|(1 << OCIE2A)|(1 << OCIE2B); // enable overflow interrupt
  TCCR2A &= ~(3); // set WGM20 = 0, WGM21 = 0
  TCCR2B &= ~(1 << 3); // set WGM22 = 0
  setMotLeft(0);
  setMotRight(0);
  sei();
}

1. Cuando encienda la alimentación, recuerde la posición inicial del joystick;
2. En el ciclo, lea la posición del joystick, reste la posición cero y envíe datos a la embarcación.

struct ControlStatus{
  int16_t x,y;
}  controlStatus;

    uint8_t packet[MAX_BUFF]; 
    memset(packet, 0, MAX_BUFF);    
    controlStatus.x = (int16_t)analogRead(1) - x0;
    controlStatus.y = (int16_t)analogRead(0) - y0;
    memcpy(packet, &controlStatus, sizeof(controlStatus));
    Mirf.send(packet);
    while(Mirf.isSending()){;};

  while (Mirf.dataReady()) { 
    uint8_t data[MAX_BUFF];
    Mirf.getData(data);
    memcpy(&controlStatus, data, sizeof(controlStatus));
    setMotRot(-controlStatus.x);
    setMotForward(controlStatus.y); 
  }

void setMotRot(int16_t v){
  if(abs(v)<10) v = 0;
  motRot = (int32_t)v;
}
void setMotForward(int16_t v){
  if(abs(v)<10) v = 0;
  motForward = (int32_t)v;
}

1. Proporcional;
2. Integral

int32_t iDeltaRot = 0;
void motTick(){
  int32_t rot = getRotAvg(); //     
  int32_t deltaRot = rot - motRot * rotMaxSpeed / 512;
  iDeltaRot += deltaRot;
  int32_t motRight = (int32_t)motForward * forwardMult - deltaRot * rotMult - iDeltaRot * iDeltaRotMult, 
          motLeft  = (int32_t)motForward * forwardMult + deltaRot * rotMult + iDeltaRot * iDeltaRotMult;  

  int32_t motMax = max(abs(motRight), abs(motLeft));
  if(motMax > 127){
    motRight = (int32_t)motRight * 127 / motMax;
    motLeft  = (int32_t)motLeft  * 127 / motMax;
  }
  
  setMotRight(motRight);
  setMotLeft(motLeft);
}

1. Calculamos la diferencia entre la velocidad de rotación real de la embarcación (podredumbre) y la deseada (motRot * rotMaxSpeed);
2. Calculamos las velocidades de rotación deseadas de los tornillos motRight y motLeft;
3. Si las velocidades de rotación deseadas exceden el máximo posible, las reducimos mientras mantenemos la relación entre ellas;
4. Llamamos a setMotRight / setMotLeft que ya nos es familiar.

1. forwardMult: sensibilidad al movimiento del joystick hacia adelante / hacia atrás;
2. rotMaxSpeed: la velocidad de rotación deseada al inclinar el joystick completamente hacia la derecha / izquierda;
3. rotMult: coeficiente del componente proporcional (cuánto afecta la desviación de la velocidad de rotación actual a la deseada);
4. iDeltaRotMult - coeficiente del componente integral (cuánto afecta la desviación del ángulo de giro actual del deseado a la rotación).

Indicación de estado

1. Computadora portátil;
2. LCD Nokia 5110

   
   

1. Microcontrolador GD32F103R8T6;
2. SDRAM Winbond W9864G6KH-6 (8 MB);
3. Memoria flash Winbond W25Q256FVFG (32 MB, 100,000 ciclos de reescritura, lo cual es muy bueno);
4. FPGA Altera MAX II EPM570T144C5N.

1. Muy facil de usar. Hay documentación simple, ejemplos, videos en Youtube, ... En un par de horas puedes resolverlo desde cero. Casi todo lo que necesita saber sobre él está en dos páginas: página wiki y conjunto de instrucciones
2. Muy rápido desarrollo. Un editor visual como Visual Studio (solo que más fácil). Tiré componentes y todo funciona.
3. Componentes de alta calidad. La misma memoria flash para 100k ciclos de reescritura.
4. Un depurador que puede simular una pantalla usando una PC y comunicarse con su MK a través de un puerto COM. Le permite desarrollar completamente el dispositivo, depurar y comprar una pantalla, solo si todo funciona.
   Aunque hay un problema con él

   . . , , .
   
5. Sensor resistivo Puede crear controles bastante pequeños y pincharlos con la uña o cualquier lápiz.

1. Precio $ 50 sigue siendo mucho para una pantalla de 4.3 ''.
2. Hay pocos componentes existentes, pocas configuraciones de componentes, no está claro cómo crear los suyos propios. Esto está parcialmente compensado por las funciones de dibujar primitivas (líneas, rectángulos, círculos, ...).
3. El componente Gauge estándar parpadea cuando se actualiza.
4. No (al menos no encontré) transparencia.
5. Requisitos de energía: 4.75-7 V y corriente promedio de 250 mA. Cuando cae el voltaje, la pantalla comienza a parpadear.
6. UART solamente. Podría comunicarse con él por SPI y I²C.
7. Salida GPIO solo para el cable (sin peine 2,54 mm), sin ADC.

1. Indicación de estado. Estoy principalmente interesado en:
   
   • "Velocidades de rotación" de los tornillos;
   • El valor de la variable iDeltaRot es cuánto difiere el ángulo de giro deseado del deseado;
   • Velocidad de rotación del barco;
   • Ángulo de rotación del bote;
   • Frecuencia de recepción de paquetes desde el control remoto;
   • La frecuencia de las llamadas a la función motTick.
   
   
2. Parámetros de configuración, a saber, los descritos anteriormente forwardMult, rotMaxSpeed, rotMult, iDeltaRotMult.

1. Indicaciones:
   
   
   
2. Configuración de parámetros: primeras 4 columnas de izquierda a derecha: forwardMult, rotMult, iDeltaRotMult, rotMaxSpeed.
   
   
   
   
   

Caracteristicas

• Varilla 9 g;
• Peso 115 g, de los cuales las baterías pesan 52 g;
• La aceleración máxima es 0.77 m / s ^ 2. Para humanos a 5 km / h, si no hubiera resistencia al agua, el bote aceleraría en 1.8 s;
• El costo de los componentes es de aproximadamente $ 15 si usa el Arduino Nano tanto en el control remoto como en el bote (sin pantalla y baterías).

Conclusión