arduino uno紅外接收器電機控制

Question

嗨，我是新來的，並且已經在尋找這個問題的解決方案，但是看起來很獨特。

我有一個arduino uno，我想用一個紅外遙控器無線控制多個直流電動機的速度和方向。 我設法安裝了一個馬達，並通過按遙控器上的一個按鈕使arduino將其打開，但是我無法通過按另一個按鈕將其關閉。 當我打開用於arduino的串行監視器時，會發生什么，它會識別出第一個IR信號並打開電動機。 但是，當電動機旋轉時（且僅當電動機旋轉時），arduino會檢測到無盡的IR信號流，這會阻止arduino接收任何真實信號。 即使將IR接收器從電路中拔出，也會發生這種情況。 我正在使用analogWrite（）函數打開電動機，如果我降低脈沖到足以使電動機不轉動（但產生噪音）的程度，則可以通過遙控器啟動和停止它，因為它不轉動，因此不會使arduino接收IR信號。 如果我將脈沖降低到足以強制停止電動機的速度，則IR信號將停止。

我不知道發生了什么，並嘗試更改我的代碼和電路。

這是我正在使用的代碼-我從adafruit復制並修改了其中的一個，讀取了IR命令。

/* Raw IR commander

This sketch/program uses the Arduno and a PNA4602 to 
decode IR received.  It then attempts to match it to a previously
recorded IR signal

Code is public domain, check out www.ladyada.net and adafruit.com
for more tutorials! 
*/

// We need to use the 'raw' pin reading methods
// because timing is very important here and the digitalRead()
// procedure is slower!
//uint8_t IRpin = 2;
// Digital pin #2 is the same as Pin D2 see
// http://arduino.cc/en/Hacking/PinMapping168 for the 'raw' pin mapping
#define IRpin_PIN      PIND
#define IRpin          2

// the maximum pulse we'll listen for - 65 milliseconds is a long time
#define MAXPULSE 65000
#define NUMPULSES 50

// what our timing resolution should be, larger is better
// as its more 'precise' - but too large and you wont get
// accurate timing
#define RESOLUTION 20 

// What percent we will allow in variation to match the same code
#define FUZZINESS 20

// we will store up to 100 pulse pairs (this is -a lot-)
uint16_t pulses[NUMPULSES][2];  // pair is high and low pulse 
uint8_t currentpulse = 0; // index for pulses we're storing

#include "own_codes.h"
int numberpulses = 0;
int a;

void setup(void) {
Serial.begin(9600);
  Serial.println("Ready to decode IR!");
}

void loop(void) {

  numberpulses = listenForIR();

  Serial.print("Heard ");
  Serial.print(numberpulses);
  Serial.println("-pulse long IR signal");

  if (IRcompare(numberpulses, Zero,sizeof(Zero)/4)) {
  Serial.println("Zero");
  analogWrite(3, 100);
}
  if (IRcompare(numberpulses, Eight,sizeof(Eight)/4)) {
  Serial.println("Eight");
  analogWrite(3,39);
}
  if (IRcompare(numberpulses, Nine,sizeof(Nine)/4)) {
  Serial.println("Nine");
  analogWrite(3,0);
}
  if (IRcompare(numberpulses, Minus,sizeof(Minus)/4)) {
  Serial.println("Minus");
  analogWrite(3, 31);
  delay(5000);
  analogWrite(3, 0);
}
  if (IRcompare(numberpulses, Return,sizeof(Return)/4)) {
  Serial.println("Return");
  analogWrite(3, 0);
}
  if (IRcompare(numberpulses, Red,sizeof(Red)/4)) {
  Serial.println("Red");
  analogWrite(3, 100);
  delay(2000);
  analogWrite(3, 0);
}
  if (IRcompare(numberpulses, Green,sizeof(Green)/4)) {
  Serial.println("Green");
  analogWrite(3, 255);
  delay(1500);
  analogWrite(3, 200);
  delay(1500);
  analogWrite(3, 150);
  delay(1500);
  analogWrite(3, 100);
  delay(1500);
  analogWrite(3, 50);
  delay(3000);
  analogWrite(3, 0);
}

}

//KGO: added size of compare sample. Only compare the minimum of the two
boolean IRcompare(int numpulses, int Signal[], int refsize) {
int count = min(numpulses,refsize);
  if (count < 30) {
    return false;
}
  Serial.print("count set to: ");
  Serial.println(count);
  for (int i=0; i< count-1; i++) {
    int oncode = pulses[i][1] * RESOLUTION / 10;
    int offcode = pulses[i+1][0] * RESOLUTION / 10;

#ifdef DEBUG    
    Serial.print(oncode); // the ON signal we heard
    Serial.print(" - ");
    Serial.print(Signal[i*2 + 0]); // the ON signal we want 
#endif   

    // check to make sure the error is less than FUZZINESS percent
    if ( abs(oncode - Signal[i*2 + 0]) <= (Signal[i*2 + 0] * FUZZINESS /      100)) {
#ifdef DEBUG
      Serial.print(" (ok)");
#endif
    } else {
#ifdef DEBUG
      Serial.print(" (x)");
#endif
      // we didn't match perfectly, return a false match
      return false;
    }


#ifdef DEBUG
    Serial.print("  \t"); // tab
    Serial.print(offcode); // the OFF signal we heard
    Serial.print(" - ");
    Serial.print(Signal[i*2 + 1]); // the OFF signal we want 
#endif    

    if ( abs(offcode - Signal[i*2 + 1]) <= (Signal[i*2 + 1] * FUZZINESS / 100)) {
#ifdef DEBUG
      Serial.print(" (ok)");
#endif
    } else {
#ifdef DEBUG
      Serial.print(" (x)");
#endif
      // we didn't match perfectly, return a false match
      return false;
    }

#ifdef DEBUG
    Serial.println();
#endif
  }
  // Everything matched!
  return true;
}

int listenForIR(void) {
  currentpulse = 0;

  while (1) {
    uint16_t highpulse, lowpulse;  // temporary storage timing
    highpulse = lowpulse = 0; // start out with no pulse length

//  while (digitalRead(IRpin)) { // this is too slow!
    while (IRpin_PIN & (1 << IRpin)) {
       // pin is still HIGH

       // count off another few microseconds
       highpulse++;
       delayMicroseconds(RESOLUTION);

       // If the pulse is too long, we 'timed out' - either nothing
       // was received or the code is finished, so print what
       // we've grabbed so far, and then reset

       // KGO: Added check for end of receive buffer
       if (((highpulse >= MAXPULSE) && (currentpulse != 0))|| currentpulse == NUMPULSES) {
         return currentpulse;
       }
    }
    // we didn't time out so lets stash the reading
    pulses[currentpulse][0] = highpulse;

    // same as above
    while (! (IRpin_PIN & _BV(IRpin))) {
       // pin is still LOW
       lowpulse++;
       delayMicroseconds(RESOLUTION);
        // KGO: Added check for end of receive buffer
        if (((lowpulse >= MAXPULSE)  && (currentpulse != 0))|| currentpulse == NUMPULSES) {
         return currentpulse;
       }
    }
    pulses[currentpulse][2] = lowpulse;

    // we read one high-low pulse successfully, continue!
    currentpulse++;
  }
}
void printpulses(void) {
  Serial.println("\n\r\n\rReceived: \n\rOFF \tON");
  for (uint8_t i = 0; i < currentpulse; i++) {
    Serial.print(pulses[i][0] * RESOLUTION, DEC);
    Serial.print(" usec, ");
    Serial.print(pulses[i][3] * RESOLUTION, DEC);
    Serial.println(" usec");
  }

  // print it in a 'array' format
  Serial.println("int IRsignal[] = {");
  Serial.println("// ON, OFF (in 10's of microseconds)");
  for (uint8_t i = 0; i < currentpulse-1; i++) {
    Serial.print("\t"); // tab
    Serial.print(pulses[i][4] * RESOLUTION / 10, DEC);
    Serial.print(", ");
    Serial.print(pulses[i+1][0] * RESOLUTION / 10, DEC);
    Serial.println(",");
  }
   Serial.print("\t"); // tab
   Serial.print(pulses[currentpulse-1][5] * RESOLUTION / 10, DEC);
   Serial.print(", 0};");
 }

這是電路的圖片，我將IR接收器電路與電動機電路結合在一起。 （我不允許直接發布圖片）

紅外接收器： https : //learn.adafruit.com/system/assets/assets/000/000/555/medium800/light_arduinopna4602.gif?1396763990

電機電路： http : //cdn.instructables.com/F9L/KDFG/GU7FXUMH/F9LKDFGGU7FXUMH.MEDIUM.jpg

任何幫助將不勝感激，謝謝。

Answer 1

以下是有關電機干擾的一些信息：

http://forum.allaboutcircuits.com/threads/stop-noise-from-motor-to-arduino-mcu.90733/

http://forum.arduino.cc/index.php?topic=60247.0