Electrical – Shield arduino for electrical interference

arduinointerferencerelay

I have an Arduino UNO controlling two high voltage relays via a switch. It also reads out a third relay, which is controlled outside of the Arduino. My setup looks like this:

With the following representing circuit:

When I turn on the soldering station, the Arduino reads an interrupt on pin 2, where the switch is connected. This also happens when the 12V source is replaced by a car battery. The soldering station is also not grounded. Due to these facts I concluded it must be some kind of electrical interference, probably EMI. I have been looking all over the web to find a way to isolate the Arduino from the interference but I can't find a proper way.

Does anyone know how to shield the Arduino for the interference?

Thanks on forehand.

Best Answer

You can do several things to reduce the effects of interference on the pin2 input. There is no one answer of how to prevent EMI causing problems, each system is different and each system needs a different solution. But here's some general tips for you to try:

Reduce interference at the source. This is the best, but it's not always possible. You could check that the switch on the solder station isn't too worn, but you're probably not going to gain anything here. I've written it anyway, because it's a good general rule.
Reduce R1. Smaller pull-down resistors mean more current available and less susceptibility to EMI. If you were using 100k, I would definitely suggest a smaller value, but you might still see some gain from going below 10K.
Filter/debounce. The usual approach to debouncing switches, with a capacitor, can help reject brief transient EMI. It's also generally a good idea.
Sheilding. Put everything inside a metal enclosure, and connect the enclosure to ground.
Wiring. Avoid long lengths of wire, and especially avoid long lengths of wire outside the enclosure. Where long wires are unavoidable, group them together to reduce loop area. If S1 needs to be outside the box, connect it using twisted pair (or even better, shielded twisted pair). Connect the shield to the enclosure.

Related Solutions

Electronic – arduino – Choosing a relay to control outlets from Arduino

What are those "larger components"? The only larger thing is the relay, and most relays will fit on a breadboard.

enter image description here

This is how you control the relay (the coil is shown next to the diode), it assumes you can connect the 12V's ground to the Arduino's. Resistor, transistor and diode are normal, small components. This relay is just a few cm long, wide and high. It can switch 10A and 230V. If you tell us more about what you want to switch I can give you more directed advice.

edit re your shopping
The relay requires 90mA from your 5V power supply. That will add a couple of hundreds of mW in the Arduino's voltage regulator. At 12V in that would be 630mW, which is a pity. If you have 12V in it would have been better to use that for a 12V relay.

The TIP31 transistor is overkill. It's a power transistor, and they don't have very high \$H_{FE}\$ (the current gain). Next time go for a TO-92 general purpose transistor like the BC547. The BC547B variant has an \$H_{FE}\$ of minimum 200. Go for a high \$H_{FE}\$. This one is still OK at an \$H_{FE}\$ of 100, but I would take a safety factor, and calculate with 40. Then the base current has to be 90mA/40 = 2.25mA. A 1k\$\Omega\$ base resistor will give you 4.3mA, so that's OK.

Electronic – arduino – How to use the flash memory on the Copperhead WiFi Shield

I'm not entirely sure of this, without a datasheet or manual for the shield there's no way to be sure. (other than trying it out)

It seems to use SPI flash, which means that it uses the SPI protocol to transfer data.

Firstly, join the MISO/MOSI/SCK pins on the two devices. Also connect Arduino pin 10 to the ChipSelect of the device. (It is quite possible that these pins are already connected -- at least the LinkSprite site seems to say so)

Transferring data to be stored/read from external memory via SPI is explained rather well here. I'll copy the final code over:

Note that the code is for an EEPROM chip, but it ought to work here as well.

#define DATAOUT 11//MOSI
#define DATAIN  12//MISO 
#define SPICLOCK  13//sck
#define SLAVESELECT 10//ss

//opcodes
#define WREN  6
#define WRDI  4
#define RDSR  5
#define WRSR  1
#define READ  3
#define WRITE 2

byte eeprom_output_data;
byte eeprom_input_data=0;
byte clr;
int address=0;
//data buffer
char buffer [128];

void fill_buffer()
{
  for (int I=0;I<128;I++)
  {
    buffer[I]=I;
  }
}

char spi_transfer(volatile char data)
{
  SPDR = data;                    // Start the transmission
  while (!(SPSR & (1<<SPIF)))     // Wait the end of the transmission
  {
  };
  return SPDR;                    // return the received byte
}

void setup()
{
  Serial.begin(9600);

  pinMode(DATAOUT, OUTPUT);
  pinMode(DATAIN, INPUT);
  pinMode(SPICLOCK,OUTPUT);
  pinMode(SLAVESELECT,OUTPUT);
  digitalWrite(SLAVESELECT,HIGH); //disable device
  // SPCR = 01010000
  //interrupt disabled,spi enabled,msb 1st,master,clk low when idle,
  //sample on leading edge of clk,system clock/4 rate (fastest)
  SPCR = (1<<SPE)|(1<<MSTR);
  clr=SPSR;
  clr=SPDR;
  delay(10);
  //fill buffer with data
  fill_buffer();
  //fill eeprom w/ buffer
  digitalWrite(SLAVESELECT,LOW);
  spi_transfer(WREN); //write enable
  digitalWrite(SLAVESELECT,HIGH);
  delay(10);
  digitalWrite(SLAVESELECT,LOW);
  spi_transfer(WRITE); //write instruction
  address=0;
  spi_transfer((char)(address>>8));   //send MSByte address first
  spi_transfer((char)(address));      //send LSByte address
  //write 128 bytes
  for (int I=0;I<128;I++)
  {
    spi_transfer(buffer[I]); //write data byte
  }
  digitalWrite(SLAVESELECT,HIGH); //release chip
  //wait for eeprom to finish writing
  delay(3000);
  Serial.print('h',BYTE);
  Serial.print('i',BYTE);
  Serial.print('\n',BYTE);//debug
  delay(1000);
}

byte read_eeprom(int EEPROM_address)
{
  //READ EEPROM
  int data;
  digitalWrite(SLAVESELECT,LOW);
  spi_transfer(READ); //transmit read opcode
  spi_transfer((char)(EEPROM_address>>8));   //send MSByte address first
  spi_transfer((char)(EEPROM_address));      //send LSByte address
  data = spi_transfer(0xFF); //get data byte
  digitalWrite(SLAVESELECT,HIGH); //release chip, signal end transfer
  return data;
}

void loop()
{
  eeprom_output_data = read_eeprom(address);
  Serial.print(eeprom_output_data,DEC);
  Serial.print('\n',BYTE);
  address++;
  if (address == 128)
    address = 0;
  delay(500); //pause for readability
}

This code ought to work for the Copperhead shield as well. If not, there's this code for SPI flash (from here):

#include <SPI.h>
#include <Peggy2.h>

#define SS_PIN  16

Peggy2 frame1;
byte toDisp = 0;
byte checker = 0;

void setup()
{
    frame1.HardwareInit();
    pinMode(SS_PIN,OUTPUT); //set pin16 to output, SS pin
    SPI.setClockDivider(SPI_CLOCK_DIV2); //set the SPI clock to f/2, fastest possible
    SPI.begin();    //SPI lib function which sets ddr for SCK and MOSI pin
                    //MISO is auto input
                    //see SPI.cpp for more info

}

void loop()
{

    if(!checker){
                enableProgramming();
        programData();
        toDisp = receiveByte(0);
        checker = 1;
        frame1.WriteRow(0,toDisp);
    }
    frame1.RefreshAll(2);

}

byte receiveByte(unsigned long startAddress)
{
    //Begin High Speed Read Instruction
    //See p. 10 of SST data sheet
    digitalWrite(SS_PIN,LOW);
    SPI.transfer(0x0B); //high speed read instruction
    SPI.transfer(0x00); //next 3 transfers are address bits A32 - A0
    SPI.transfer(0x00); //So this will read the first byte on the chip
    SPI.transfer(0x00); //last address bits
    SPI.transfer(0xFF); //dummy byte is required to start sending data back to uP
    SPI.transfer(0xFF); //I'm hoping that if I transfer a bullshit byte, the flash
                        //chip will transfer it's data to me in the same time
    digitalWrite(SS_PIN,HIGH);
    //End High Speed Read Instruction   
    return SPDR;    
}

//will perform the read instruction starting from
//startAddress and will receive numOfBytes bytes in
//succession
void receiveBytes(int numOfBytes, unsigned long startAddress)
{
    digitalWrite(SS_PIN,LOW);
    SPI.transfer(0x0B);//high speed read instruction

}

//will perform:
// 1) Chip Erase
// and loop through:
// 1) Page Program
// 2) increment Page
//until the data has finished **note this can loop and over write beginning of memory
void programData(){
    //Begin ChipErase Instruction
    //See p. 17 of SST data sheet
    digitalWrite(SS_PIN,LOW);
    SPI.transfer(0x60);//chip erase instruction
    digitalWrite(SS_PIN,HIGH);
    delay(50);//spec'd time for CE to finish
                //don't bother polling because time to program is irrelevant
    //End ChipErase Instruction

        //Begin WREN Instruction
    //See p. 18 of SST data sheet
    digitalWrite(SS_PIN,LOW);
    SPI.transfer(0x06);//write enable instruction
    digitalWrite(SS_PIN,HIGH);
    //End WREN Instruction

    digitalWrite(SS_PIN,LOW);
    SPI.transfer(0x02); //page program instruction
    SPI.transfer(0x00); //first 8 address bits
    SPI.transfer(0x00); //2nd 8 address bits
    SPI.transfer(0x00); //3rd 8 address bits
    SPI.transfer(0xAA); //10101010 is the byte I should be writing
    digitalWrite(SS_PIN,HIGH);
    delayMicroseconds(3000); //wait 3 ms for page program


    /*
    //Begin Page-Program Instruction
    //see p. 13 of SST data sheet
    byte firstAddress = 0;
    byte secondAddress = 0;
    //this loop will write to every byte in the chips memory
    //32,768 pages of 256 bytes = 8,388,608 bytes
    for(unsigned int i = 0; i < 32,768; ++i) //long variable is number of pages
    {
        digitalWrite(SS_PIN,LOW);
        ++secondAddress; //cycles from 0 to 255, counts pages
        firstAddress = i>>8; // floor(i/256)

        SPI.transfer(0x02);//Page-Program instruction byte
        SPI.transfer(firstAddress); //increments every 256 pages i.e. at page 256 this should be 1
        SPI.transfer(secondAddress); //increments every 256 bytes, i.e every page
        SPI.transfer(0x00); //beginning of a page boundary
        for(int j = 0; j < 256; ++j) //number of bytes per page
        {
            SPI.transfer(2program[(256*i) + j]);//data byte transfer            
        }
        digitalWrite(SS_PIN,HIGH);
        delayMicroseconds(2500); //2500us (2.5ms) delay for each page-program instruction to execute
    }
    //End Page-Program Instruction
    */
}

//Will prepare the chip for writing by performing:
// 1) arm the status register
// 2) Write Enable instruction
//Only needs to be performed once!
void enableProgramming(){
    //Begin EWSR & WRSR Instructions
    //See p. 20 of SST data sheet for more info
    digitalWrite(SS_PIN,LOW); //lower the SS pin
    SPI.transfer(0x50); //enable write status register instruction
    digitalWrite(SS_PIN,HIGH); //raise the SS pin
    delay(10);
    digitalWrite(SS_PIN,LOW); //lower the SS pin
    SPI.transfer(0x01); //write the status register instruction
    SPI.transfer(0x00);//value to write to register
                //xx0000xx will remove all block protection
    digitalWrite(SS_PIN,HIGH);
    //End EWSR & WRSR Instructions

    //Begin WREN Instruction
    //See p. 18 of SST data sheet
    digitalWrite(SS_PIN,LOW);
    SPI.transfer(0x06);//write enable instruction
    digitalWrite(SS_PIN,HIGH);
    //End WREN Instruction

}

Best Answer

Related Solutions

Electronic – arduino – Choosing a relay to control outlets from Arduino

Electronic – arduino – How to use the flash memory on the Copperhead WiFi Shield

Related Topic