Faire un simple bateau aérodynamique RC

Pourquoi bateau aérien?

1. Simple;
2. Bon marché;
3. ;
4. , -.

1. Il peut être posé sur différentes plateformes: un bateau, un traîneau, un morceau de polystyrène ...
2. Il n'attrape pas le fond ni les algues.

1. Une vis + volant pour les virages ;
2. Une vis + son système de tournage ;
3. Deux vis fixes. Tourner en changeant leurs envies est le moyen le plus simple. Il l'a utilisé.

Télécommande

Principe de fonctionnement

Que faire

1. Convertisseur de puissance 0,9 - 5 V -> 5 V pour alimenter Arduino pour 0,35 $ (le connecteur USB, avec un morceau de la carte, peut être rompu pour plus de compacité);
2. Stabilisateur 3,3 V AMS1117-3,3 pour alimenter le module radio, ils coûtent 0,03 $ par unité ;
3. Compartiment à piles pour une pile à un doigt pour 0,15 $ ;

Remplissage du modèle RC

Composants

1. 5 V pour tous les appareils électroniques sauf le module radio;
2. 3,3 V pour le module radio;
3. pour les moteurs autant qu'ils en ont besoin (le mien 4,2 V).

Le programme

1. Tournez en avant;
2. Retournez;
3. Ne tordez pas.

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. Écrivez une valeur positive, négative ou nulle dans motLeft / motRight (le module n'est pas important);
2. Enregistrez la "vitesse de rotation" dans 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. Lors de la mise sous tension, rappelez-vous la position initiale du joystick;
2. Au cours du cycle, lisez la position du joystick, soustrayez-en la position zéro et envoyez des données au bateau.

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. Proportionnelle;
2. Intégrale.

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. Nous calculons la différence entre la vitesse réelle de rotation du bateau (pourriture) et celle souhaitée (motRot * rotMaxSpeed);
2. Nous calculons les vitesses de rotation souhaitées des vis motRight et motLeft;
3. Si les vitesses de rotation souhaitées dépassent le maximum possible, on les réduit tout en conservant le rapport entre elles;
4. Nous appelons setMotRight / setMotLeft que nous connaissons déjà.

1. forwardMult - sensibilité au mouvement du joystick vers l'avant / vers l'arrière;
2. rotMaxSpeed ​​- la vitesse de rotation souhaitée lors de l'inclinaison complète du joystick vers la droite / gauche;
3. rotMult - coefficient de la composante proportionnelle (dans quelle mesure l'écart de la vitesse de rotation actuelle par rapport à la vitesse souhaitée affecte la rotation);
4. iDeltaRotMult - coefficient de la composante intégrale (dans quelle mesure l'écart de l'angle de rotation actuel par rapport à l'angle souhaité affecte la rotation).

Indication d'état

1. Ordinateur portable;
2. LCD Nokia 5110

   
   

1. Microcontrôleur GD32F103R8T6;
2. SDRAM Winbond W9864G6KH-6 (8 Mo);
3. Mémoire flash Winbond W25Q256FVFG (32 Mo, 100 000 cycles de réécriture, ce qui est très bon);
4. FPGA Altera MAX II EPM570T144C5N.

1. Très simple d'utilisation. Il y a une documentation simple, des exemples, des vidéos sur Youtube, ... En quelques heures, vous pouvez le comprendre à partir de zéro. Presque tout ce que vous devez savoir sur lui se trouve sur deux pages: page wiki et jeu d'instructions
2. Développement très rapide. Un éditeur visuel comme Visual Studio (seulement plus facile). J'ai jeté des composants et tout fonctionne.
3. Composants de haute qualité. La même mémoire flash pour 100 000 cycles de réécriture.
4. Un débogueur qui peut simuler un affichage à l'aide d'un PC et communiquer avec votre MK via un port COM. Vous permet de développer complètement l'appareil, de déboguer et d'acheter un écran, uniquement si tout fonctionne.
   Bien qu'il y ait un problème avec lui

   . . , , .
   
5. Capteur résistif Vous pouvez créer des commandes assez petites et les pousser avec votre ongle ou n'importe quel stylet.

1. Prix 50 $, c'est encore beaucoup pour un écran de 4,3 pouces.
2. Il y a peu de composants existants, peu de paramètres de composants, comment créer le vôtre n'est pas clair. Ceci est partiellement compensé par les fonctions de dessin des primitives (lignes, rectangles, cercles, ...).
3. Le composant Gauge standard scintille lors de la mise à niveau.
4. Non (du moins je n'ai pas trouvé) de transparence.
5. Exigences d'alimentation: 4.75-7 V et courant moyen 250 mA. Lorsque la tension baisse, l'affichage commence à clignoter.
6. UART uniquement. Pourrait communiquer avec lui sur SPI et I²C.
7. Sortie GPIO uniquement pour une boucle (pas de peigne 2,54 mm), pas d'ADC.

1. Indication d'état. Je suis principalement intéressé par:
   
   • "Vitesses de rotation" des vis;
   • La valeur de la variable iDeltaRot est la différence entre l'angle de braquage souhaité et l'angle souhaité;
   • Vitesse de rotation du bateau;
   • Angle de rotation du bateau;
   • Fréquence de réception des paquets de la télécommande;
   • La fréquence des appels à la fonction motTick.
   
   
2. Définition des paramètres, à savoir ceux décrits ci-dessus forwardMult, rotMaxSpeed, rotMult, iDeltaRotMult.

1. Indications:
   
   
   
2. Réglages des paramètres: 4 premières colonnes de gauche à droite: forwardMult, rotMult, iDeltaRotMult, rotMaxSpeed.
   
   
   
   
   

CARACTÉRISTIQUES

• Baguette 9 g;
• Poids 115 g, dont les batteries pèsent 52 g;
• L'accélération maximale est de 0,77 m / s ^ 2. Pour l'homme à 5 km / h, s'il n'y avait pas de résistance à l'eau, le bateau accélérerait en 1,8 s;
• Le coût des composants est d'environ 15 $ si vous utilisez l'Arduino Nano à la fois dans la télécommande et dans le bateau (sans écran ni piles).

Conclusion