Fazendo um simples barco aero RC

?

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

1. Pode ser colocado em diferentes plataformas: um barco, trenó, um pedaço de espuma ...
2. Não pega no fundo ou nas algas.

1. Um parafuso + volante para voltas ;
2. Um parafuso + seu sistema de torneamento ;
3. Dois parafusos fixos. Transformar mudando seus desejos é a maneira mais fácil. Ele usou isso.

Controle remoto

Princípio de operação

O que fazer

1. Conversor de energia 0,9 - 5 V -> 5 V para alimentar o Arduino por US $ 0,35 (o conector USB, juntamente com um pedaço da placa, pode ser quebrado por compacidade);
2. O estabilizador AMS1117-3.3 de 3.3V para alimentar o módulo de rádio, custa US $ 0,03 por unidade ;
3. Compartimento da bateria para a bateria de um dedo por US $ 0,15 ;

Enchimento do modelo RC

Componentes

1. 5 V para todos os componentes eletrônicos, exceto o módulo de rádio;
2. 3,3 V para o módulo de rádio;
3. para motores tanto quanto eles precisam (mina 4,2 V).

O programa

1. Gire para a frente;
2. Gire para trás;
3. Não torça.

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. Escreva um valor positivo, negativo ou zero em motLeft / motRight (o módulo não é importante);
2. Registre a "velocidade de rotação" em 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. Ao ligar a alimentação, lembre-se da posição inicial do joystick;
2. No ciclo, leia a posição do joystick, subtraia a posição zero e envie dados para o barco.

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 a diferença entre a velocidade real de rotação do barco (podridão) e a desejada (motRot * rotMaxSpeed);
2. Calculamos as velocidades de rotação desejadas dos parafusos motRight e motLeft;
3. Se as velocidades de rotação desejadas excederem o máximo possível, reduzimos-as enquanto mantemos a relação entre elas;
4. Chamamos setMotRight / setMotLeft já familiares para nós.

1. forwardMult - sensibilidade ao movimento do joystick para frente / trás;
2. rotMaxSpeed ​​- a velocidade de rotação desejada ao inclinar o joystick totalmente para a direita / esquerda;
3. rotMult - coeficiente do componente proporcional (quanto o desvio da velocidade de rotação atual do desejado afeta a rotação);
4. iDeltaRotMult - coeficiente do componente integral (quanto o desvio do ângulo de rotação atual do desejado afeta a rotação).

Indicação de status

1. Laptop;
2. LCD Nokia 5110

   
   

1. Microcontrolador GD32F103R8T6;
2. SDRAM Winbond W9864G6KH-6 (8 MB);
3. Memória flash Winbond W25Q256FVFG (32 MB, 100.000 ciclos de reescrita, o que é muito bom);
4. FPGA Altera MAX II EPM570T144C5N.

1. Muito fácil de usar. Há documentação simples, exemplos, vídeos no Youtube, ... Em algumas horas você pode descobrir do zero. Quase tudo o que você precisa saber sobre ele está em duas páginas: página wiki e conjunto de instruções
2. Desenvolvimento muito rápido. Um editor visual como o Visual Studio (apenas mais fácil). Joguei componentes e tudo funciona.
3. Componentes de alta qualidade. A mesma memória flash para 100k ciclos de reescrita.
4. Um depurador que pode simular uma exibição usando um PC e se comunicar com o seu MK através de uma porta COM. Permite que você desenvolva totalmente o dispositivo, depure e compre um monitor, apenas se tudo der certo.
   Embora haja um problema com ele

   . . , , .
   
5. Sensor Resistivo Você pode criar controles bastante pequenos e cutucá-los com a unha ou com qualquer caneta.

1. Preço $ 50 ainda é muito para uma tela de 4,3 ''.
2. Existem poucos componentes existentes, poucas configurações de componentes, como criar o seu próprio não é claro. Isso é parcialmente compensado pelas funções de desenhar primitivas (linhas, retângulos, círculos, ...).
3. O componente padrão do Gauge pisca quando atualizado.
4. Não (pelo menos não encontrei) transparência.
5. Requisitos de energia: 4,75-7 V e corrente média 250 mA. Quando a tensão cai, o visor começa a piscar.
6. Apenas UART. Poderia se comunicar com ele no SPI e I²C.
7. Saída GPIO apenas para um loop (sem pente de 2,54 mm), sem ADC.

1. Indicação de status. Estou interessado principalmente em:
   
   • "Velocidades de rotação" dos parafusos;
   • O valor da variável iDeltaRot é o quanto o ângulo de viragem desejado difere do desejado;
   • Velocidade de rotação do barco;
   • Ângulo de rotação do barco;
   • Frequência de recebimento de pacotes do controle remoto;
   • A frequência das chamadas para a função motTick.
   
   
2. Parâmetros de configuração, especificamente os descritos acima, forwardMult, rotMaxSpeed, rotMult, iDeltaRotMult.

1. Indicações:
   
   
   
2. Configurações dos parâmetros: primeiras 4 colunas da esquerda para a direita: forwardMult, rotMult, iDeltaRotMult, rotMaxSpeed.
   
   
   
   
   

Características

• Haste 9 g;
• Peso 115 g, das quais baterias pesam 52 g;
• A aceleração máxima é de 0,77 m / s ^ 2. Para humanos 5 km / h, se não houvesse resistência à água, o barco aceleraria em 1,8 s;
• O custo dos componentes é de cerca de US $ 15 se você usar o Arduino Nano no controle remoto e no barco (sem tela e baterias).

Conclusão