I first considered setting up a dedicated IP camera in each office. But then I thought, hold on, it’s 2019, I bet there is a web-based solution out there for streaming video feeds!

As it turns out, that solution is called WebRTC, and it is the web standard for real-time peer-to-peer communication. WebRTC is an asynchronous peer-to-peer architecture, and the only need for a centralized server is for exchanging the connection set up information.

Getting Started in WebRTC

Most of the available tutorials on WebRTC only show a trivial implementation of two client objects in the same browser window. After some searching, I found a great example of a basic implementation of 1-to-1 video using WebRTC and a simple Node.js server to relay messages over Websockets.

Using this example as a baseline, all I had to do is extend it to support an arbitrary number of participants. Additionally, I decided to add some CSS styling to arrange the video containers on the screen and labels to identify each participant.

To try it out for yourself, install node.js if you haven’t already, download the full source code here, unzip the file, and start the node server locally:

 npm install
 npm start

With the server running, go to https://static.dmcinfo.com/ in Chrome. You’ll need to click through the invalid SSL certificate warning, enter a display name, and allow the page to use your camera. After that, you’ll be able to open multiple windows and see yourself multiple times. Likewise, you can enter the IP address instead of localhost, and you’ll be able to establish connections between any computers on your local network.

Setting Up the Video Chat

The core functionality is all in the client-side javascript, which handles establishing and managing the connections to all the other participants. When the page is loaded, we generate a random identifier and capture a user-entered display name.

function start() {
  localUuid = createUUID();

  // check if "&displayName=xxx" is appended to URL, otherwise alert user to populate
  var urlParams = new URLSearchParams(window.location.search);
  localDisplayName = urlParams.get('displayName') || prompt('Enter your name', '');
  document.getElementById('localVideoContainer').appendChild(makeLabel(localDisplayName));

function start() {
  localUuid = createUUID();

  // check if "&displayName=xxx" is appended to URL, otherwise alert user to populate
  var urlParams = new URLSearchParams(window.location.search);
  localDisplayName = urlParams.get('displayName') || prompt('Enter your name', '');
  document.getElementById('localVideoContainer').appendChild(makeLabel(localDisplayName));

Next, we can specify the video and audio parameters (in this implementation, audio is disabled) and grab the local video stream.

// specify no audio for user media
  var constraints = {
    video: {
      width: {max: 320},
      height: {max: 240},
      frameRate: {max: 30},
    },
    audio: false,
  };

// specify no audio for user media
  var constraints = {
    video: {
      width: {max: 320},
      height: {max: 240},
      frameRate: {max: 30},
    },
    audio: false,
  };

Once we successfully have the local video stream, we can set up the connection to the WebSockets server and set up callback functions. When the connection first opens, we send out a message to anyone who might already be connected, informing them that we joined the party.

// set up local video stream
  if (navigator.mediaDevices.getUserMedia) {
    navigator.mediaDevices.getUserMedia(constraints)
      .then(stream => {
        localStream = stream;
        document.getElementById('localVideo').srcObject = stream;
      }).catch(errorHandler)

      // set up websocket and message all existing clients
      .then(() => {
        serverConnection = new WebSocket('wss://' + window.location.hostname + ':' + WS_PORT);
        serverConnection.onmessage = gotMessageFromServer;
        serverConnection.onopen = event => {
          serverConnection.send(JSON.stringify({ 'displayName': localDisplayName, 'uuid': localUuid, 'dest': 'all' }));
        }
      }).catch(errorHandler);

  } else {
    alert('Your browser does not support getUserMedia API');
  }
}

// set up local video stream
  if (navigator.mediaDevices.getUserMedia) {
    navigator.mediaDevices.getUserMedia(constraints)
      .then(stream => {
        localStream = stream;
        document.getElementById('localVideo').srcObject = stream;
      }).catch(errorHandler)

      // set up websocket and message all existing clients
      .then(() => {
        serverConnection = new WebSocket('wss://' + window.location.hostname + ':' + WS_PORT);
        serverConnection.onmessage = gotMessageFromServer;
        serverConnection.onopen = event => {
          serverConnection.send(JSON.stringify({ 'displayName': localDisplayName, 'uuid': localUuid, 'dest': 'all' }));
        }
      }).catch(errorHandler);

  } else {
    alert('Your browser does not support getUserMedia API');
  }
}

Whenever a new message is received, we check if it’s intended for us and whether it’s for setting a new peer or initiating the connection. SDP stands for Session Description Protocol.

function gotMessageFromServer(message) {
  var signal = JSON.parse(message.data);
  var peerUuid = signal.uuid;

  // Ignore messages that are not for us or from ourselves
  if (peerUuid == localUuid || (signal.dest != localUuid && signal.dest != 'all')) return;

  if (signal.displayName && signal.dest == 'all') {
    // set up peer connection object for a newcomer peer
    setUpPeer(peerUuid, signal.displayName);
    serverConnection.send(JSON.stringify({ 'displayName': localDisplayName, 'uuid': localUuid, 'dest': peerUuid }));

  } else if (signal.displayName && signal.dest == localUuid) {
    // initiate call if we are the newcomer peer
    setUpPeer(peerUuid, signal.displayName, true);

  } else if (signal.sdp) {
    peerConnections[peerUuid].pc.setRemoteDescription(new RTCSessionDescription(signal.sdp)).then(function () {
      // Only create answers in response to offers
      if (signal.sdp.type == 'offer') {
        peerConnections[peerUuid].pc.createAnswer().then(description => createdDescription(description, peerUuid)).catch(errorHandler);
      }
    }).catch(errorHandler);

  } else if (signal.ice) {
    peerConnections[peerUuid].pc.addIceCandidate(new RTCIceCandidate(signal.ice)).catch(errorHandler);
  }
}

function gotMessageFromServer(message) {
  var signal = JSON.parse(message.data);
  var peerUuid = signal.uuid;

  // Ignore messages that are not for us or from ourselves
  if (peerUuid == localUuid || (signal.dest != localUuid && signal.dest != 'all')) return;

  if (signal.displayName && signal.dest == 'all') {
    // set up peer connection object for a newcomer peer
    setUpPeer(peerUuid, signal.displayName);
    serverConnection.send(JSON.stringify({ 'displayName': localDisplayName, 'uuid': localUuid, 'dest': peerUuid }));

  } else if (signal.displayName && signal.dest == localUuid) {
    // initiate call if we are the newcomer peer
    setUpPeer(peerUuid, signal.displayName, true);

  } else if (signal.sdp) {
    peerConnections[peerUuid].pc.setRemoteDescription(new RTCSessionDescription(signal.sdp)).then(function () {
      // Only create answers in response to offers
      if (signal.sdp.type == 'offer') {
        peerConnections[peerUuid].pc.createAnswer().then(description => createdDescription(description, peerUuid)).catch(errorHandler);
      }
    }).catch(errorHandler);

  } else if (signal.ice) {
    peerConnections[peerUuid].pc.addIceCandidate(new RTCIceCandidate(signal.ice)).catch(errorHandler);
  }
}

Once we have a new peer, we can add them to the peerConnections object, with the UUID as a key.

function setUpPeer(peerUuid, displayName, initCall = false) {
  peerConnections[peerUuid] = { 'displayName': displayName, 'pc': new RTCPeerConnection(peerConnectionConfig) };
  peerConnections[peerUuid].pc.onicecandidate = event => gotIceCandidate(event, peerUuid);
  peerConnections[peerUuid].pc.ontrack = event => gotRemoteStream(event, peerUuid);
  peerConnections[peerUuid].pc.oniceconnectionstatechange = event => checkPeerDisconnect(event, peerUuid);
  peerConnections[peerUuid].pc.addStream(localStream);

  if (initCall) {
    peerConnections[peerUuid].pc.createOffer().then(description => createdDescription(description, peerUuid)).catch(errorHandler);
  }
}

function setUpPeer(peerUuid, displayName, initCall = false) {
  peerConnections[peerUuid] = { 'displayName': displayName, 'pc': new RTCPeerConnection(peerConnectionConfig) };
  peerConnections[peerUuid].pc.onicecandidate = event => gotIceCandidate(event, peerUuid);
  peerConnections[peerUuid].pc.ontrack = event => gotRemoteStream(event, peerUuid);
  peerConnections[peerUuid].pc.oniceconnectionstatechange = event => checkPeerDisconnect(event, peerUuid);
  peerConnections[peerUuid].pc.addStream(localStream);

  if (initCall) {
    peerConnections[peerUuid].pc.createOffer().then(description => createdDescription(description, peerUuid)).catch(errorHandler);
  }
}

The rest is just handling the nitty-gritty details of WebRTC, which involves several messages back and forth before you can get the remote video stream. Once you have it, you can manipulate the DOM to add it to the page.

function gotRemoteStream(event, peerUuid) {
  console.log(`got remote stream, peer ${peerUuid}`);
  //assign stream to new HTML video element
  var vidElement = document.createElement('video');
  vidElement.setAttribute('autoplay', '');
  vidElement.setAttribute('muted', '');
  vidElement.srcObject = event.streams[0];

  var vidContainer = document.createElement('div');
  vidContainer.setAttribute('id', 'remoteVideo_' + peerUuid);
  vidContainer.setAttribute('class', 'videoContainer');
  vidContainer.appendChild(vidElement);
  vidContainer.appendChild(makeLabel(peerConnections[peerUuid].displayName));

  document.getElementById('videos').appendChild(vidContainer);

  updateLayout();
}


function updateLayout() {
  // update CSS grid based on number of diplayed videos
  var rowHeight = '98vh';
  var colWidth = '98vw';

  var numVideos = Object.keys(peerConnections).length + 1; // add one to include local video

  if (numVideos > 1 && numVideos <= 4) { // 2x2 grid
    rowHeight = '48vh';
    colWidth = '48vw';
  } else if (numVideos > 4) { // 3x3 grid
    rowHeight = '32vh';
    colWidth = '32vw';
  }

  document.documentElement.style.setProperty(`--rowHeight`, rowHeight);
  document.documentElement.style.setProperty(`--colWidth`, colWidth);
}

function makeLabel(label) {
  var vidLabel = document.createElement('div');
  vidLabel.appendChild(document.createTextNode(label));
  vidLabel.setAttribute('class', 'videoLabel');
  return vidLabel;
}

function gotRemoteStream(event, peerUuid) {
  console.log(`got remote stream, peer ${peerUuid}`);
  //assign stream to new HTML video element
  var vidElement = document.createElement('video');
  vidElement.setAttribute('autoplay', '');
  vidElement.setAttribute('muted', '');
  vidElement.srcObject = event.streams[0];

  var vidContainer = document.createElement('div');
  vidContainer.setAttribute('id', 'remoteVideo_' + peerUuid);
  vidContainer.setAttribute('class', 'videoContainer');
  vidContainer.appendChild(vidElement);
  vidContainer.appendChild(makeLabel(peerConnections[peerUuid].displayName));

  document.getElementById('videos').appendChild(vidContainer);

  updateLayout();
}


function updateLayout() {
  // update CSS grid based on number of diplayed videos
  var rowHeight = '98vh';
  var colWidth = '98vw';

  var numVideos = Object.keys(peerConnections).length + 1; // add one to include local video

  if (numVideos > 1 && numVideos <= 4) { // 2x2 grid
    rowHeight = '48vh';
    colWidth = '48vw';
  } else if (numVideos > 4) { // 3x3 grid
    rowHeight = '32vh';
    colWidth = '32vw';
  }

  document.documentElement.style.setProperty(`--rowHeight`, rowHeight);
  document.documentElement.style.setProperty(`--colWidth`, colWidth);
}

function makeLabel(label) {
  var vidLabel = document.createElement('div');
  vidLabel.appendChild(document.createTextNode(label));
  vidLabel.setAttribute('class', 'videoLabel');
  return vidLabel;
}

On the HTML side, all we need is a reference to the javascript and a container div for the local video. The remote video streams get appended to the same div by manipulating the DOM from the client-side javascript. Some CSS also takes care of arranging the videos in a grid based on the number of connected peers and displaying their name in the corner.

<html>

<head>
  <!-- prevent extraneous favicon requests -->
  <link rel="icon" href="data:,">

  <link rel="stylesheet" href="style.css">

  <script src="https://webrtc.github.io/adapter/adapter-latest.js"></script>
  <script src="webrtc.js"></script>
</head>

<body>

  <div id="videos" class="videos">

    <div id="localVideoContainer" class="videoContainer">
      <video id="localVideo" autoplay muted></video>
    </div>

    <!-- Remote videos get appended here -->

  </div>

  <script type="text/javascript">
    start();
  </script>

</body>

</html>

<html>

<head>
  <!-- prevent extraneous favicon requests -->
  <link rel="icon" href="data:,">

  <link rel="stylesheet" href="style.css">

  <script src="https://webrtc.github.io/adapter/adapter-latest.js"></script>
  <script src="webrtc.js"></script>
</head>

<body>

  <div id="videos" class="videos">

    <div id="localVideoContainer" class="videoContainer">
      <video id="localVideo" autoplay muted></video>
    </div>

    <!-- Remote videos get appended here -->

  </div>

  <script type="text/javascript">
    start();
  </script>

</body>

</html>

We can also take care of peer connections that have dropped off by removing the video element from the DOM.

function checkPeerDisconnect(event, peerUuid) {
  var state = peerConnections[peerUuid].pc.iceConnectionState;
  console.log(`connection with peer ${peerUuid} ${state}`);
  if (state === "failed" || state === "closed" || state === "disconnected") {
    delete peerConnections[peerUuid];
    document.getElementById('videos').removeChild(document.getElementById('remoteVideo_' + peerUuid));
    updateLayout();
  }
}

function checkPeerDisconnect(event, peerUuid) {
  var state = peerConnections[peerUuid].pc.iceConnectionState;
  console.log(`connection with peer ${peerUuid} ${state}`);
  if (state === "failed" || state === "closed" || state === "disconnected") {
    delete peerConnections[peerUuid];
    document.getElementById('videos').removeChild(document.getElementById('remoteVideo_' + peerUuid));
    updateLayout();
  }
}

For the node.js server, all we need to do is serve the client-side files, and then set up a WebSocket server that re-broadcasts any messages that it receives.

// Create a server for the client html page
const handleRequest = function (request, response) {
  // Render the single client html file for any request the HTTP server receives
  console.log('request received: ' + request.url);

 if (request.url === '/webrtc.js') {
    response.writeHead(200, { 'Content-Type': 'application/javascript' });
    response.end(fs.readFileSync('client/webrtc.js'));
  } else if (request.url === '/style.css') {
    response.writeHead(200, { 'Content-Type': 'text/css' });
    response.end(fs.readFileSync('client/style.css'));
  } else {
    response.writeHead(200, { 'Content-Type': 'text/html' });
    response.end(fs.readFileSync('client/index.html'));
  }
};

const httpsServer = https.createServer(serverConfig, handleRequest);
httpsServer.listen(HTTPS_PORT);

// ----------------------------------------------------------------------------------------

// Create a server for handling websocket calls
const wss = new WebSocketServer({ server: httpsServer });

wss.on('connection', function (ws) {
  ws.on('message', function (message) {
    // Broadcast any received message to all clients
    console.log('received: %s', message);
    wss.broadcast(message);
  });

  ws.on('error', () => ws.terminate());
});

wss.broadcast = function (data) {
  this.clients.forEach(function (client) {
    if (client.readyState === WebSocket.OPEN) {
      client.send(data);
    }
  });
};

// Create a server for the client html page
const handleRequest = function (request, response) {
  // Render the single client html file for any request the HTTP server receives
  console.log('request received: ' + request.url);

 if (request.url === '/webrtc.js') {
    response.writeHead(200, { 'Content-Type': 'application/javascript' });
    response.end(fs.readFileSync('client/webrtc.js'));
  } else if (request.url === '/style.css') {
    response.writeHead(200, { 'Content-Type': 'text/css' });
    response.end(fs.readFileSync('client/style.css'));
  } else {
    response.writeHead(200, { 'Content-Type': 'text/html' });
    response.end(fs.readFileSync('client/index.html'));
  }
};

const httpsServer = https.createServer(serverConfig, handleRequest);
httpsServer.listen(HTTPS_PORT);

// ----------------------------------------------------------------------------------------

// Create a server for handling websocket calls
const wss = new WebSocketServer({ server: httpsServer });

wss.on('connection', function (ws) {
  ws.on('message', function (message) {
    // Broadcast any received message to all clients
    console.log('received: %s', message);
    wss.broadcast(message);
  });

  ws.on('error', () => ws.terminate());
});

wss.broadcast = function (data) {
  this.clients.forEach(function (client) {
    if (client.readyState === WebSocket.OPEN) {
      client.send(data);
    }
  });
};

WebRTC requires TLS, so it does need a certificate, and you can optionally add a redirect from HTTP to HTTPS. The server can be run locally or easily deployed as a Windows service using node-windows. 

Caveats

The main downside with this implementation is that it creates a mesh network, with each participant sending a separately encoded video stream to every single other participant. If you add more than a handful of participants, you’ll notice that you’ll start maxing out your CPU and performance will degrade. For larger groups, you’ll want to look into using a centralized server to forward each client’s video feed to all its peers. This article does a nice job of laying out the options.

The post Multi User Video Chat With WebRTC appeared first on DMC, Inc..

Fortunately, the Siemens S7-1200 series PLCs are quite easy to disassemble, and I was able to replace the damaged components and restore it to a proper working condition. I definitely wouldn’t trust this refurbished PLC to run a critical system, but for testing code in our lab, it should be just fine. I would also recommend reaching out to the manufacturer if you are running into issues with a production PLC, keeping in mind that any warranty may be voided if you attempt to fix it yourself.

Opening the Enclosure

Using a small flat blade screwdriver to push in the side tabs, it’s easy to pull the enclosure apart and separate the power conditioning PCB from the main board.

Surveying The Damage

I immediately noticed the burn marks coming from the positive voltage supply pin, but everything else looked okay, and there was no visible damage on the main board.

The first component in the circuit is a fuse, designed to limit the damage from precisely this type of mishap. Using a multimeter to check for continuity showed that it was in fact blown, as one would expect. I went ahead and jumpered it out with a wire wrap connection.

Now What?

Unfortunately, the fix wasn’t going to be that easy. Measuring the resistance across the voltage supply terminals, I found there was now a short circuit. After checking all the components that go across the voltage bus, I found that the culprit was a small Zener diode.

Its purpose is to suppress spikes in the supply voltage, but unsurprisingly, applying 120 VAC far exceeded its maximum power dissipation rating and caused it to short out. Simply desoldering the offending diode from one of its pads fixed the short, and after reassembling the PCBs and applying power, I was surprised that the PLC powered up and was fully functional. Clearly, the protection circuitry had done its job.

Patching Everything Up

Even though I now had a working PLC, leaving it as-is would mean that it would most likely not survive a second jolt of high voltage, so I went ahead and replaced the fuse and Zener diode to make it almost as good as new at a cost of less than $2.

After that, it’s easy to snap everything back together, power it up, and watch the blinkenlights turn on!

Conclusion

I hope you enjoyed this sneak peek under the hood of a device that we work with on a daily basis. It was nice to see that Siemens designs their PLCs to be pretty robust and easy to disassemble, unlike the typical consumer electronics devices you tend to see these days. Share your own stories of hacking PLC hardware in the comments section below!

Learn more about DMC’s Siemens S7 PLC programming expertise and embedded design expertise. 

The post How To Disassemble and Fix a Fried S7-1200 PLC appeared first on DMC, Inc..

• Set up your Raspberry Pi with the latest version of Raspbian by burning the image to an SD card.
• Connect the camera and power on the Pi. Connect to your Wi-Fi or wired network, and open a terminal session, either via SSH or directly on the Pi.
• (Optional) Set up a static IP address. This will let you find your server in the same place every time. If you’re feeling fancy, you can even set up a DNS server to resolve a URL (e.g. myraspitimelapse.local) to this IP address.
• Install libav, which contains avconv. This is the tool we will use to create a video from the captured stills:

sudo apt-get install libav-tools

sudo apt-get install libav-tools

• Install lighttpd. This will let you view your time-lapse video via a web browser:

sudo apt-get install lighttpd

sudo apt-get install lighttpd

• Create a basic web page containing the time-lapse video and save it in the directory where lighttpd will know to serve it. The most straightforward way is to use the built-in text editor nano:

sudo nano /var/www/html/index.html

sudo nano /var/www/html/index.html

• Then copy in the following HTML, which tells the browser to automatically play the video on loop (the muted attribute is required for some browsers to autoplay):

<!DOCTYPE html>
<html>
<head>
    <title>My Timelapse</title>
</head>
<body>

    <video autoplay loop muted>
        <source src="timelapse.mp4" type="video/mpt support the video tag.
    </video>

</body>
</html>

<!DOCTYPE html>
<html>
<head>
    <title>My Timelapse</title>
</head>
<body>

    <video autoplay loop muted>
        <source src="timelapse.mp4" type="video/mpt support the video tag.
    </video>

</body>
</html>

• To create the video, we’ll use a simple shell script. Open a new file using nano as before:

   sudo nano /home/pi/timelapse/timelapse.sh

  and paste in the following script, which saves a new still photo and generates a video file from all the existing stills every time it runs. It takes an input argument that specifies the number of seconds for the video duration.
• Next, change the file permissions so that the script can be executed:

   sudo chmod +x /home/pi/timelapse/timelapse.sh

  You should now be able to run your script as:

   /home/pi/timelapse/timelapse.sh 5

  and see the timelapse.mp4 file get created in the directory. Enter the Pi’s IP address into your browser, and you should be able to play the 5-second long video. For now, it won’t be too exciting, since it will just be a single frame.
• Finally, set up the cron job that will trigger shell script. Open the cron table file:

   crontab -e

  Add the following line to the end of the file:

   0 * * * * /home/pi/timelapse/timelapse.sh 30 > /home/pi/timelapse/timelapse.log

  This runs the shell script once per minute, and the input argument of 30 means that the video will be 30 seconds long. The > symbol redirects any errors to the specified log file. You can, of course, use other time intervals as well, and this handy website helps explain the syntax, which can be a little confusing.
• And that’s it! You can change all the parameters as needed, and you can even try making some tweaks to the script. For example, maybe you want the time-lapse video to show each frame for a set amount of time rather than keeping a fixed duration for the whole video, in which case you can get rid of the input argument and simply set the framerate to a constant.

Learn more about DMC’s embedded design expertise. 

The post How To Make a Simple Time-lapse IP Web Camera Using a Raspberry Pi appeared first on DMC, Inc..

One of the most popular series of PLCs from the 1990s to mid-2000s is the Allen-Bradly SLC 500 series: SLC 5/01, SLC 5/02, SLC 5/03, SLC 5/04, and SLC 5/05. This blog post summarizes the different ways that you can connect to these PLCs and some of the pitfalls to look out for.

Checking Your Settings

If you have access to the original PLC program (typically a .RSS file) and a copy of the RSLogix 500 programming software (contact your A-B distributor if you need one), you can open the project and check the communication settings by double-clicking on Channel Configuration under the controller section of the project tree:

Channel Configuration in RSLogix 500

However, as is often the case with legacy systems, if you don't have the program handy, you can usually figure out how to connect by method of elimination and a bit of luck.

Finding the Right Cables

SLC 500 Connectivity Comparison

As you can see, each model features a slightly different set of physical ports and protocols. The two most common ways to connect are DH-485 and DF1. The SLC 5/01, 5/02, and 5/03 use DH-485 via their RS485 8-pin RJ45 jack (which is the same physical connector as Ethernet, but it won't work if you plug it directly into your computer!).

Additionally, the 5/03, 5/04, and 5/05 have an RS232 DB9 port that MAY be configured for DH-485, but it will be set to DF1 by default and can also be configured for ASCII and Modbus RTU. You'll notice the 5/05 also has an RJ45 port, but this is for Ethernet, NOT DH-485.

DF1
All you need is a regular female-to-female null modem crossover DB9 serial cable, and a USB to RS232 adapter if your computer does not have a serial port. The official A-B cable is 1747-CP3.

DH-485
This protocol requires a special USB converter, the 1747-UIC, which you can order from A-B or find a number of 3rd party versions online. In addition, you will need the female-to-female null modem crossover DB9 serial cable or a straight-through RJ45 ethernet cable, depending on which port you want to connect to. Make sure you also set the selector switch to RS232 or RS 485.

There is one potential pitfall: the default baud rate for DH485 is 19200, and this is what you will find most of the time. However, it is possible to configure it in the PLC settings to be 1200, 2400, or 9600 baud at as well.

The 1747-UIC adapter only supports 19200 baud out of the box. If you have an original A-B unit, it is possible to change to the baud rate to 9600 by following the steps in this Rockwell knowledgebase document (requires creating a free account and logging in).

Setting Up Drivers in RSLinx

You will need to set up the connection in the RSLinx software. It comes installed as part of RSLogix 500, or you can download RSLinx Classic Lite for free from Rockwell. 

Once you plug in your cable and Windows installs any necessary drivers, it should show up in Device Manager as a COM port. Open RSLinx and go to Communications -> Configure Drivers.

DF1
From the drop-down, select RS-232 DF1 devices and click Add New. Select the right COM port and click Auto-Configure. The driver should be able to figure out the correct settings.

DH-485
From the drop-down, select DH485 UIC devices and click Add New. Select the right COM port and click OK.

If everything worked, your PLC should show up, and you should be able to open RSLogix, go online, and upload and download programs.

Summary of Allen-Bradley PLC Cables and Protocols

Relevant Links

Here is a link to the SLC 500 user manual.

Here is a walkthrough on connecting to an AB PLC-5.

Here are some general tips on working with legacy hardware. 

Learn more about DMC's Allen-Bradley PLC programming expertise or Contact Us to get started on a solution today.

The post How to Connect to an Allen-Bradley SLC 500 PLC appeared first on DMC, Inc..