Ein einfaches RC Aero Boot bauen

?

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

1. Es kann auf verschiedene Plattformen gestellt werden: ein Boot, einen Schlitten, ein Stück Schaum ...
2. Es fängt sich nicht am Boden oder an Algen.

1. Eine Schraube + Lenkrad für Kurven ;
2. Eine Schraube + das Drehsystem ;
3. Zwei feste Schrauben. Das Drehen durch Ändern ihres Verlangens ist der einfachste Weg. Er hat es benutzt.

Fernbedienung

Funktionsprinzip

Was tun?

1. Stromrichter 0,9 - 5 V -> 5 V für die Stromversorgung von Arduino für 0,35 USD (USB-Anschluss kann zusammen mit einem Teil der Platine aus Gründen der Kompaktheit abgebrochen werden);
2. Der 3,3-V-Stabilisator AMS1117-3.3 für die Stromversorgung des Funkmoduls kostet 0,03 USD pro Einheit .
3. Batteriefach für Ein-Finger-Batterie für 0,15 USD ;

RC-Modellfüllung

Komponenten

1. 5 V für die gesamte Elektronik außer dem Funkmodul;
2. 3,3 V für das Funkmodul;
3. für Motoren so viel wie sie brauchen (meine 4,2 V).

Das Programm

1. Vorwärts drehen;
2. Dreh dich zurück;
3. Nicht verdrehen.

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. Schreiben Sie einen positiven, negativen oder Nullwert in motLeft / motRight (das Modul ist nicht wichtig);
2. Notieren Sie die "Drehzahl" in 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. Denken Sie beim Einschalten an die Ausgangsposition des Joysticks.
2. Lesen Sie im Zyklus die Position des Joysticks ab, subtrahieren Sie die Nullposition davon und senden Sie Daten an das Boot.

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. Proportional;
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. Wir berechnen die Differenz zwischen der tatsächlichen Rotationsgeschwindigkeit des Bootes (rot) und der gewünschten (motRot * rotMaxSpeed);
2. Wir berechnen die gewünschten Drehzahlen der Schrauben motRight und motLeft.
3. Wenn die gewünschten Drehzahlen das maximal mögliche überschreiten, reduzieren wir sie unter Beibehaltung des Verhältnisses zwischen ihnen.
4. Wir nennen setMotRight / setMotLeft, das uns bereits bekannt ist.

1. forwardMult - Empfindlichkeit für die Bewegung des Joysticks vorwärts / rückwärts;
2. rotMaxSpeed ​​- die gewünschte Drehzahl, wenn der Joystick ganz nach rechts / links gekippt wird;
3. rotMult - Koeffizient der proportionalen Komponente (wie stark beeinflusst die Abweichung der aktuellen Drehzahl von der gewünschten die Drehung);
4. iDeltaRotMult - Koeffizient der Integralkomponente (wie stark sich die Abweichung des aktuellen Drehwinkels vom gewünschten auf die Drehung auswirkt).

Statusanzeige

1. Laptop;
2. LCD Nokia 5110

   
   

1. Mikrocontroller GD32F103R8T6;
2. SDRAM Winbond W9864G6KH-6 (8 MB);
3. Winbond W25Q256FVFG Flash-Speicher (32 MB, 100.000 Umschreibzyklen, was sehr gut ist);
4. FPGA Altera MAX II EPM570T144C5N.

1. Sehr einfach zu bedienen. Es gibt einfache Dokumentationen, Beispiele, Videos auf Youtube, ... In ein paar Stunden können Sie es von Grund auf neu herausfinden. Fast alles, was Sie über ihn wissen müssen, befindet sich auf zwei Seiten: Wiki-Seite und Befehlssatz
2. Sehr schnelle Entwicklung. Ein visueller Editor wie Visual Studio (nur einfacher). Ich warf Komponenten und alles funktioniert.
3. Hochwertige Komponenten. Der gleiche Flash-Speicher für 100.000 Umschreibungszyklen.
4. Ein Debugger, der eine Anzeige mit einem PC simulieren und über einen COM-Port mit Ihrem MK kommunizieren kann. Ermöglicht es Ihnen, das Gerät vollständig zu entwickeln, zu debuggen und ein Display zu kaufen, nur wenn alles funktioniert.
   Obwohl es ein Problem mit ihm gibt

   . . , , .
   
5. Widerstandssensor Sie können relativ kleine Steuerelemente erstellen und diese mit Ihrem Fingernagel oder einem beliebigen Stift stechen.

1. Preis 50 US-Dollar sind immer noch viel für ein 4,3-Zoll-Display.
2. Es gibt nur wenige vorhandene Komponenten, nur wenige Komponenteneinstellungen. Wie Sie eigene Komponenten erstellen, ist nicht klar. Dies wird teilweise durch die Funktionen zum Zeichnen von Grundelementen (Linien, Rechtecke, Kreise, ...) ausgeglichen.
3. Die Standard-Messgerätekomponente flackert beim Upgrade.
4. Nein (zumindest habe ich keine Transparenz gefunden).
5. Leistungsbedarf: 4,75-7 V und durchschnittlicher Strom 250 mA. Wenn die Spannung abfällt, beginnt die Anzeige zu blinken.
6. Nur UART. Könnte mit ihm über SPI und I²C kommunizieren.
7. GPIO-Ausgang nur für eine Schleife (kein Kamm 2,54 mm), kein ADC.

1. Statusanzeige. Ich interessiere mich hauptsächlich für:
   
   • "Drehzahlen" der Schrauben;
   • Der Wert der Variablen iDeltaRot gibt an, um wie viel sich der gewünschte Drehwinkel vom gewünschten unterscheidet.
   • Bootsdrehzahl;
   • Drehwinkel des Bootes;
   • Häufigkeit des Empfangs von Paketen von der Fernbedienung;
   • Die Häufigkeit der Aufrufe der motTick-Funktion.
   
   
2. Einstellen von Parametern, nämlich der oben beschriebenen, forwardMult, rotMaxSpeed, rotMult, iDeltaRotMult.

1. Indikationen:
   
   
   
2. Parametereinstellungen: Erste 4 Spalten von links nach rechts: forwardMult, rotMult, iDeltaRotMult, rotMaxSpeed.
   
   
   
   
   

Eigenschaften

• Stab 9 g;
• Gewicht 115 g, davon wiegen Batterien 52 g;
• Die maximale Beschleunigung beträgt 0,77 m / s ^ 2. Für Menschen mit 5 km / h würde das Boot in 1,8 s beschleunigen, wenn es keinen Wasserwiderstand gäbe.
• Die Kosten für Komponenten betragen ca. 15 USD, wenn Sie den Arduino Nano sowohl in der Fernbedienung als auch im Boot verwenden (ohne Display und Batterien).

Fazit