September 2019 - Page 3 of 4 - Curious Inventor

Interfacing a PS2 (PlayStation 2) Controller

Intro: There are all sorts of guides that explain how to interface a PS2 controller already out there. The goal here is to consolidate the information and make it as fast as possible to get up and running. Please let us know about mistakes!

Update: Check out the arduino ps2 library that Bill Porter helped polish.

Contents:

Hardware Interface / Wiring Connections
Software Protocol
- Low Level: how individual bytes are transfered
- high level: packet descriptions / protocol
- Button Mappings for PS2 Dual Shock controller and Guitar Hero controller.
- Complete Command listing and explanations.
Example Commands necessary to read all analog (joysticks and pressures) and control motors
Recorded Command and Response between real PlayStation and Controller during first connect
MPLAB projects (c code) for PIC18f4550 to control a PS2. You’ll need a programmer (PICKIT2) and www.microchip.com ‘s free IDE, MPLAB.

Hardware Interface / Wiring Connections:

playstation ps2 wiring connections interface protocol

Wire Colors and Functionality: There are 9 wires, 6 wires are needed at a minimum to talk to the controller: (clock, data, command, power & ground, attention). To operate vibration motors, motor_power is also needed.

Brown – Data: Controller -> PlayStation. This is an open collector output and requires a pull-up resistor (1 to 10k, maybe more). (A pull-up resistor is needed because the controller can only connect this line to ground; it can’t actually put voltage on the line).
Orange – Command: PlayStation -> Controller.
Grey – Vibration Motors Power: 6-9V? With no controller connected, this meausures about 7.9V, with a controller, 7.6V, most websites say this is 9V (except playstation.txt -> 7.6V), although it will still drive the motors down around 4V, although somewhat slower. When the motors are first engaged, almost 500mA is drawn on this line, and at steady state full power, ~300mA is drawn.
Black – Ground
Red – Power: Many sites label this as 5V, and while this may be true for Play Station 1 controllers, we found several wireless brands that would only work at 3.3V. Every controller tested worked at 3.3V, and the actual voltage measured on a live Playstation talking to a controller was 3.4V. McCubbin says that any official Sony controller should work from 3-5V. Most sites say there is a 750mA fuse for both controllers and memory cards, although this may only apply to PS1’s since 4 dual shock controllers could exceed that easily.
Yellow – Attention: This line must be pulled low before each group of bytes is sent / received, and then set high again afterwards. In our testing, it wasn’t sufficient to tie this permanently low–it had to be driven down and up around each set. Digitan considers this a “Chip Select” or “Slave Select” line that is used to address different controllers on the same bus.
Blue – Clock: 500kH/z, normally high on. The communication appears to be SPI bus. We’ve gotten it to work from less than 100kHz up through 500kHz (500k bits / second, not counting delays between bytes and packets). When the guitar hero controller is connected, the clock rate is 250kHz, which is also the rate the playstation 1 uses.
White – Unknown
Green – Acknowledge: This normally high line drops low about 12us after each byte for half a clock cycle, but not after the last bit in a set. This is a open collector output and requires a pull-up resistor (1 to 10k, maybe more). playstation.txt says that the playstation will consider the controller missing if the ack signal (> 2us) doesn’t come within 100us.

Low-Level – How Bytes and Packets are Transferred:

The play station sends a byte at the same time as it receives one (full duplex) via serial communication. The following pictures show actual signals between a playstation and guitar hero controller configured in analog mode (wammy bar sends back 7-bit value (0x7f – 0x00)).

play station controller communication signals on scope

The clock is held high until a byte is to be sent. It then drops low (active low) to start 8 cylces during which data is simultaneously sent and received. When the clock edge drops low, the values on the line start to change. When the clock goes from low to high, value are actually read. Bytes are transferred LSB (least significant bit) first, so the bits on the left (earlier in time) are less significant.

playstation acknowldge, command, data, and clock

playstation attention, command, data, and clock

Scope shots showing the acknowledge and attention lines.

High-level: Packet structure, Command and Data Meanings:

Much of this section is sourced from Dowty’s consolidation and home-brew port sniffer and emulator.

Packets have a three byte header followed by an additional 2, 6 or 18 bytes of additional command and controller data (like button states, vibration motor commands, button pressures, etc.).

An example exchange that from a dual shock controller when first plugged in:

Controller defaults to digital mode and only transmits the on / off status of the buttons in the 4th and 5th byte. No joystick data, pressure or vibration control capabilities.

(no buttons pressed)

byte #	1	2	3	4	5
Command	0x01	0x42	0x00	0x00	0x00
Data	0xFF	0x41	0x5A	0xFF	0xFF

Explanation:

— Header: (always the first three bytes)

byte #	source / type	example value	explanation
1st byte	Command	0x01	New packets always start with 0x01 … 0x81 for memory card?
1st byte	Data	0xFF	always 0xFF
2nd byte	Command	0x42	Main command: can either poll controller or configure it. See below for command listing
2nd byte	Data	0x41	Device Mode: the high nibble (4) indicates the mode (0x4 is digital, 0x7 is analog, 0xF config / escape?), (lynxmotion calls 0xF ‘DS Native Mode’… not sure) the lower nibble (1) is how many 16 bit words follow the header, although the playstation doesn’t always wait for all these bytes
3rd byte	Command	0x00	Always 0x00
3rd byte	Data	0x5A	Always 0x5A, this value appears in several non-functional places

— Command / Mode Dependent Data (2 to 18 more bytes depending on mode):

4th byte	Command	0x00	Can be configured to control either of the motors
4th byte	Data	0xFF	Each digital (on/off) button state is mapped to one of the bits in the 4th and 5th byte
5th byte	Command	0x00	Can be configured to control either of the motors
5th byte	Data	0xFF	1, or all 1’s (0xFF) means everything is unpressed.

Digital Button State Mapping (which bits of bytes 4 & 5 goes to which button):

button	Select	L3 (jush push)	R3	Start	Up	Right	Down	Left	L2	R2	L1	R1	Triangle	O	X	Square
byte.bit	4.0	4.1	4.2	4.3	4.4	4.5	4.6	4.7	5.0	5.1	5.2	5.3	5.4	5.5	5.6	5.7

For example:

example play station clock and data signals when Up and R2 are pressed

Guitar Hero Button Mapping

button	Green	Red	Yellow	Blue	Orange	Up	Down	Select	Start	Wammy
byte.bit	5.1	5.5	5.4	5.6	5.7	4.4	4.6	4.0	4.3	byte 9: 0x7f (released) to 0x00 (pressed)

Bytes 4, 6, 7, 8 and 9 are normally 0x7F if nothing is pressed.

Command Listing / Examples:

The most comprehensive listings that we’ve found are Dowty’s and lynxmotion’s. This listing is based on information from both that has been tested.

— 0x41: Find out what buttons are included in poll responses.

The controller can be configured (through command 0x4F) to respond with more or less information about each button with each poll. Only works when the controller is already in configuration mode (0xF3)… use Command 0x43 to enter / exit configuration mode.

byte #	1	2	3	4	5	6	7	8	9
Command	0x01	0x41	0x00	0x5A	0x5A	0x5A	0x5A	0x5A	0x5A
Data	0xFF	0x41	0x5A	0xFF	0xFF	0x03	0x00	0x00	0x5A
section	header			bits corresponding to buttons in response packet

18 total bytes can be turned on or off, including the 2 digital state bytes and 16 analog bytes (pressures and joysticks).
9.cmd and 9.dat are always 0x5a.
Data is all 0x00 if controller is in digital mode (0x41)
Command data is always 0x5A, although 0x00 yields the same result.

— 0x42: Main polling command

Depending on the controller’s configuration, this command can get all the digital and analog button states, as well as control the vibration motors.

byte #	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21
Command (hex)	01	42	00	WW	YY	00	00	00	00	00	00	00	00	00	00	00	00	00	00	00	00
Data (hex)	FF	79	5A	FF	FF	7F	7F	7F	7F	00	00	00	00	00	00	00	00	00	00	00	00
section	header			digital		analog joy				button pressures (0xFF = fully pressed)
analog map						RX	RY	LX	LY	R	L	U	D	Tri	O	X	Sqr	L1	R1	L2	R2

If mode (2.data) is 41, the packet only contains 5 bytes, if mode == 0x73, 9 bytes are returned.
WW and YY are used to control the motors (which does what depends on the config).

— 0x43: Enter / Exit Config Mode, also poll all button states, joysticks and pressures

This can poll the controller like 0x42, but if the first command byte is 1, it has the effect of entering config mode (0xF3), in which the packet response can be configured. If the current mode is 0x41, this command only needs to be 5 bytes long. Once in config / escape mode, 0x43 does not return button states anymore, but 0x42 still does (except for pressures). Also, all packets have will 6 bytes of command / data after the header.

byte #	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21
Command (hex)	01	43	00	0x01	00	00	00	00	00	00	00	00	00	00	00	00	00	00	00	00	00
Data (hex)	FF	79	5A	FF	FF	7F	7F	7F	7F	00	00	00	00	00	00	00	00	00	00	00	00
section	header			digital		analog joy				button pressures (0xFF = fully pressed)
analog map						RX	RY	LX	LY	R	L	U	D	Tri	O	X	Sqr	L1	R1	L2	R2

4.command = 0x01 enters config mode (or ‘escape’ mode at Dowty calls it)., 0x00 exits. If 0x00 and already out of config mode, it behaves just like 0x42, but without vibration motor control.

— 0x44: Switch modes between digital and analog

Only works after the controller is in config mode (0xF3).

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	44	00	0x01	0x03	00	00	00	00
Data (hex)	FF	F3	5A	00	00	00	00	00	00
section	header			config parameters

Set analog mode: 4.command = 0x01, set digital mode: 4.command = 0x00
If 5.command is 0x03, the controller is locked, otherwise the user can change from analog to digital mode using the analog button on the controller. Note that if the controller is already setup to deliver pressure values, toggling the state with the controller button will revert the controller back into not sending pressures.
Some controllers have a watch-dog timer that reverts back into digital mode if a command is not received within a second or so.

— 0x45: Get more status info

Only works after the controller is in config mode (0xF3).

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	45	00	5A	5A	5A	5A	5A	5A
Data (hex)	FF	F3	5A	03	02	01	02	01	00
section	header			config parameters

4.data = 0x03 for dual shock controller, 0x01 for guitar hero
6.data = 0x01 when LED is on, 0x00 when it’s off

— 0x46: Read an unknown constant value from controller

This command is always issued twice in a row, and appears to be retrieving a 10 byte constant of over those two calls. It is always called in a sequence of 0x46 0x46 0x47 0x4C 0x4C. Only works after the controller is in config mode (0xF3).

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	46	00	00	5A	5A	A	5A	5A
Data (hex)	FF	F3	5A	00	00	00	02	00	0A
section	header			config parameters

second pass

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	46	00	01	5A	5A	A	5A	5A
Data (hex)	FF	F3	5A	00	00	00	00	00	14
section	header			config parameters

4.command appears to get the first half of the constant when it’s 0x00, and the 2nd half when it’s 0x01.
As shown above, the constant returned for a dual shock controller is: 00 00 02 00 0A 00 00 00 00 14
A Katana wireless controller and the guitar hero controller each returned this: 00 01 02 00 0A 00 01 01 01 14

— 0x47: Read an unknown constant value from controller

It is always called in a command sequence of 0x46 0x46 0x47 0x4C 0x4C. Only works after the controller is in config mode (0xF3).

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	47	00	00	5A	5A	A	5A	5A
Data (hex)	FF	F3	5A	00	00	02	00	00	00
section	header			config parameters

Dowty thinks the first byte is probably an offset like in 0x46 and 0x4C, which would leave 5 bytes of interest.
As shown above, the constant returned for a dual shock controller is: 00 02 00 00 00
guitar hero controller and Katana wireless: 00 02 00 01 00

— 0x4C: Read an unknown constant value from controller

This command is always issued twice in a row, and appears to be retrieving a 10 byte constant of over those two calls. It is always called in a command sequence of 0x46 0x46 0x47 0x4C 0x4C. Only works after the controller is in config mode (0xF3).

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	4C	00	00	5A	5A	A	5A	5A
Data (hex)	FF	F3	5A	00	00	00	04	00	00
section	header			config parameters

second pass

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	4C	00	01	5A	5A	A	5A	5A
Data (hex)	FF	F3	5A	00	00	00	06	00	00
section	header			config parameters

4.command appears to get the first half of the constant when it’s 0x00, and the 2nd half when it’s 0x01.
As shown above, the constant returned for a dual shock controller is: 00 00 04 00 00 00 00 06 00 00
A Katana wireless controller and the guitar hero controller each returned this: 00 00 04 00 00 00 00 07 00 00

— 0x4D: Map bytes in the 0x42 command to actuate the vibration motors

Only works after the controller is in config mode (0xF3).

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	4D	00	00	01	FF	FF	FF	FF
Data (hex)	FF	F3	5A	00	01	FF	FF	FF	FF
section	header			config parameters

0x00 maps the corresponding byte in 0x42 to control the small motor. A 0xFF in the 0x42 command will turn it on, all other values turn it off.
0x01 maps the corresponding byte in 0x42 to control the large motor. The power delivered to the large motor is then set from 0x00 to 0xFF in 0x42. 0x40 was the smallest value that would actually make the motor spin for us.
0xFF disables, and is the default value when the controller is first connected. The data bytes just report the current mapping.
Things don’t always work if more than one command byte is mapped to a motor.

— 0x4F: Add or remove analog response bytes from the main polling command (0x42)

This could set up the controller to only reply with the L1 and R1 pressures for instance. Only works after the controller is in config mode (0xF3).

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	4F	00	FF	FF	03	00	00	00
Data (hex)	FF	F3	5A	00	00	00	00	00	5A
section	header			config parameters

Each of the 18 bits in FF FF 03 correspond to a response byte, starting with the digital states, then 4 analog joysticks, then 12 pressure bytes.
By default, the pressure values are not sent back, so this is the command that is necessary to enable them.

Byte Sequence to Configure Controller for Analog Mode + Button Pressure + Vibration Control

The following sequence will setup a controller to send back all available analog values, and also map the left and right motors to command bytes 4 and 5.

— 0x42 Poll once just for fun

byte #	1	2	3	4	5
Command (hex)	01	42	00	FF	FF
Data (hex)	FF	41	5A	FF	FF
section	header			digital

— 0x43 Go into configuration mode

byte #	1	2	3	4	5
Command (hex)	01	43	00	0x01	00
Data (hex)	FF	41	5A	FF	FF
section	header			digital

— 0x44 Turn on analog mode

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	44	00	0x01	0x03	00	00	00	00
Data (hex)	FF	F3	5A	00	00	00	00	00	00
section	header			config parameters

— 0x4D Setup motor command mapping

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	4D	00	00	01	FF	FF	FF	FF
Data (hex)	FF	F3	5A	00	01	FF	FF	FF	FF
section	header			config parameters

— 0x4F Config controller to return all pressure values

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	4F	00	FF	FF	03	00	00	00
Data (hex)	FF	F3	5A	00	00	00	00	00	5A
section	header			config parameters

— 0x43 Exit config mode

byte #	1	2	3	4	5	6	7	8	9
Command (hex)	01	43	00	0x00	5A	5A	5A	5A	5A
Data (hex)	FF	F3	5A	00	00	00	00	00	00
section	header			config parameters

— 0x42 Example Poll (loop this)

byte #	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21
Command (hex)	01	42	00	WW	YY	00	00	00	00	00	00	00	00	00	00	00	00	00	00	00	00
Data (hex)	FF	79	5A	FF	FF	7F	7F	7F	7F	00	00	00	00	00	00	00	00	00	00	00	00
section	header			digital		analog joy				button pressures (0xFF = fully pressed)
analog map						RX	RY	LX	LY	R	L	U	D	Tri	O	X	Sqr	L1	R1	L2	R2

Hand-shaking (first communication) recordings between Play Station 2 and Various Controllers

This excel sheet lists both the commands and response data between a play station and various controllers when the controller is first plugged in. Includes guitar hero, dual shock, wire less katana and chinese knock-off (looks the same as the dual shock).

Both a guitar hero game and dirt-bike game (to get vibration motor control data) were used.

We used 2 PIC18f4550 to do the port sniffing, see below to download the code.

PIC18f4550 Code to Read a PlayStation 2 Dual Shock or Guitar Hero Controller

The first program will configure a controller in analog mode so that all the joysticks and button pressures can be read. It also sets up the Left pressure to controller the left vibration motor and the Right button pressure to toggle the smaller right vibration motor.

Each command and response packet is sent out a serial port at 57600 kbs.

ps2_commander_reader.zip

The second program can operate in two modes:

Continous SPI to Serial: Every SPI byte is sent out the serial port at 57600. Since the play station communicates at 512kbs, the code uses a circular buffer to capture SPI bytes until the playstation pauses between packets, at which time it sends out the data via serial.
Bulk Capture and Dump: Caputer about 650 bytes of data into buffers, then dump the entire batch out through serial. We used this code to capture the initial communication between a Play Station and controller when they first connect. There are probably about 100 cleaner ways to do this, but the PICs we had on hand only had one SPI port, so two PICs were used at the same time to capture both the command and data lines. One PIC would send back it’s recordings immediately, and the other would wait for a few seconds, during which time a switch was flipped to connect the PC’s serial to the 2nd PIC.

ps2_listener.zip

Connection Schematic:

note: avoid connecting the PIC’s SPI clock to a play station’s clock when the PIC is configured as a SPI master.

schematic ps2 to PIC18f4550

Making New Components and Modules (Footprints) in KiCad

NOTE: This tutorial was written in 1847, and kicad has changed a lot since then!

Intro:

This won’t go into every detail, but it will cover the unintuitive aspects of creating new components, including how the libraries work.

About the Libraries:

Unlike Eagle, where there is one type of library that contains both the schematic symbol and the footprint variations, in KiCad, .lib files contain schematic symbols and .mod files contain footprints, or “modules.” Cvpcb is used to map footprints to symbols.

Both of these libraries can contain from one to many parts.

LibEdit: Making New Schematic Components:

To create a new component, first launch LibEdit.

The most common approach is to modify a component from another library, and then save it in your own custom library.

First, open a source library. Here we choose the microchip library:

Then, load a component that you are going to modify, the 18F2550 PIC.

Let’s change the chip’s name by modifying its properties.

Select the “Fields” tab and click “Value/Chip Name”.

We’re going to call the new chip “magic_smoker”.

You now have a couple different choices for where to save this newly named part:

Save it in the current library: First save it in “ram,” and then to the hard disk. Saving in “ram” lets you update the symbol in the current schematic so you can see if the graphics fit within other components, for instance. If you don’t like the changes, just re-load the part from the source library as before since it hasn’t been changed on disk. Save to “disk” to permanently store the changes within the microchip library.
Save it to a New library: Clicking the new library button will open a dialog that lets you name a new library and save this part to it. Be aware that this new library and its part will not be loaded unless you update eeschema’s preferences to load that new library!!
Export the symbol: Export is the same as creating a new library, except that the default save location will be in your project directory, not the general KiCad library directory. Exporting simply creates a new library that happens to only have the one new part.

Creating a New Library in which to Save the New Chip:

Let’s take the 2nd option, and store the chip in a new custom library that will hold all of our custom schematic symbols.

We save the library as “curious_inventor_symbols.lib” inside the default KiCad library directory.

Two notes:
–The “current library” in LibEdit is still set to microchip.lib, not our new library. So if you were going to make more changes, be sure to switch to your new library before saving anything!
–We now need to update the preferences in Eeschema to load the new library, otherwise it won’t be able to load the chip. We do this next.

Close LibEdit, return to Eeschema and open the preferences.

Add the new library, and then be sure to save the configuration in the main .pro (project) file.

The manual does a good job of explaining how to make new parts. Our only advice is to avoid using the hidden power pins on new parts, and just keep everything visible and connected with wires. It can be especially confusing when you have multiple power levels.

Many of the same ideas apply to making new modules, but the library situation is slightly more confusing.

All about modules (footprints) and their libraries:

What files do I need to send someone else so they can load my schematic and board?

With schematics, they need to have the .lib files that contain the symbols, and those library files need to be loaded in the Eeschema preferences. On the other hand, with boards (.brd files), modules (footprints) can be stored inside the .brd file. You can send someone a .brd file and nothing else, and they would be able to look at and edit the board. However, when you want to load components from a netlist, the module libraries (.mod files) need to be present and loaded in the Pcbnew preferences just as with schematics. Also, it is necessary to load the .mod files in the preferences of Pcbnew in order for those modules to show up in Cvpcb.

If someone sends you a .brd file with modules you’d like to use in another board, you can open the module editor, load a module from the current board, and save or export it into another module library. You can also export all the modules in a .brd file at once via: Pcbnew–>File–>Archive Footprints–>Create footprint archive, which will create a new .mod file with all the board’s modules.

The Module (Footprint) Editor:

When you make a new component, it asks you for the reference. The reference is the name of the footprint.

<-Back

Designing PCBs in Kicad and PcbNew: Making Gerbers (files needed by the manufacturer)

NOTE: This tutorial was written in 1847, and kicad has changed a lot since then!

Making Gerbers (files needed by the manufacturer):

making gerber with plot from the file menu

For a 2 layer board, you would commonly want files that represent the metal on the top and bottom (component and copper, respectively), top and bottom solder mask (the green stuff), the top silk screen, the board outline (edges), and a drill file (click “Create Drill File” in addition to “Plot”).

<-Back Next->

Designing PCBs in Kicad and PcbNew: Adding Copper Fills/Zones

NOTE: This tutorial was written in 1847, and kicad has changed a lot since then!

Adding Copper Fills / Zones:

In KiCad, filling an area with copper does not create any connections, so the first step is to finish drawing all the traces as normal.

Use the highlight tool to highlight the net for which you will be creating a zone(GND in our case).

Select the zone tool and click somewhere to start the outline (this will bring up the zone dialog).

Select the NET, layer and pad options, which is how the zone will connect to pads that are part of the net. If you choose “include pads,” the copper fill will completely connect to the pad, which will make it very hard to solder as a large amount of heat will be drawn away. The “thermal” connection option makes several fingers that connect the pad to the fill area, thus reducing the thermal connection so it’s easier to bring the pad up to temperature during soldering.

Also, the zones are filled with individual trace lines, so choosing a grid that’s big will create large gaps, and choosing a grid that’s too small will create extremely large files. The KiCad author recommends .01″

Draw the Zone:

Adding Cutouts:

Right click with the zone tool on an existing zone outline.

Filling the Zone:

Just right click in the boundary and select fill.

<-Back Next->

Designing PCBs in Kicad and PcbNew: Changing Parts

NOTE: This tutorial was written in 1847, and kicad has changed a lot since then!

Changing Parts:

If you want to delete, add or functionally change a component, it’s best to change the schematic and repeat the entire process again:

Make changes in eeschema, re-annotating the components if necessary (putting numbers in for R?, C?, etc.)
Save netlist in eeschema (schematic editor)
Run Cvpcb and assign a footprints / modules to the new components
Read the netlist again in Pcbnew (backup the .brd first!)

If you’re just changing the footprint of a module, for instance, going from a 1/4W resistor to a larger 1/2W, you can make the changes just in Pcbnew (explained below).

Deleting, Adding or Making other Major Changes:

As just stated above, make the changes in the schematic using eeschema. We’ll add a 2-pin header for power, and replace the pot with a fixed resistor.

adding a 2 pin connector in kicad / eeschema 2 new parts in kicad

Add the 2-pin connector, wire it up, delete the pot and re-wire a resistor in its place.

generating a netlist in kicad

Again, save the netlist, and then open Cvpcb.

cvpcb kicad

The new netlist should have two blanks in it now. Assign the module SIL-2 to the CONN_2 connector and another R4 to the resistor. Save the netlist again.

read netlist in pcbnew

Open Pcbnew and click the “Read netlist” button.

click the read net list button to load components

If you just click “Read Current Netlist” in the dialog without changing any options, it adds the two new components, but doesn’t delete the old ones and their stale tracks.

click the read net list button to load new components

Selecting “Change” and “Delete” under “Exchange Module” and “Bad Tracks Deletion” gets rid of some of the bad traces, but still doesn’t delete module RV1. Had RV1 been labeled R4 before, it would have indeed deleted the module and replaced it with the new R4.

But since RV1 has a different name, the only way to get rid of it is to manually delete it or select “Remove Extra Footprints” under “options.” We can’t select that option, however, because that would delete any modules that are not in the netlist (or the .cmp file), which includes our screw holes.

555 timer circuit

Changing Just a Module, and Not the Circuit:

This can be done solely in Pcbnew without going back into Cvpcb or Eeschema.

You can either swap out a module for a different one from the library, or actually edit the silk screen and pin layout.

First, right click on a component and edit the footprint.

Then click “Change Module”.

Type in “R5” or Browse to find a new module, then click “Change Module”.

A new, longer resistor footprint should be in place. Although the netlist didn’t change, another file also used to keep track of modules has: the .cmp file. Next time you run Cvpcb, it will already show a new R5 module mapped to R4. The naming convention is extremely confusing here–R4 is a component label, and R5 is actually a foot print name.

By clicking “Edit Module” in the above Module Properties dialog, you could open up the module editor and actually change the shape and pin arrangement of the footprint. The resulting module would be saved in the .brd file, and not a library (I think).

<-Back Next->

designing PCBs in Kicad and PcbNew: Undo and Adding Screw Holes

NOTE: This tutorial was written in 1847, and kicad has changed a lot since then!

UnDo… not yet, but there is an UnDelete:

undelete in kicad's pcbnew

It’s pretty easy to accidentally delete an entire track, so this is actually very helpful. Unfortunately, there is no general purpose undo that I know about.

Adding Screw Holes:

One of the quirks of KiCad is that you can’t just drill a hole, you need to make a one-pad component that has the right sized hole for your screw. The module called “1PIN” is the right size for a 4-40 screw.

adding new modules inside pcbnew

Click the “Add Modules” button.

type in the module name for 1PIN

Type in 1PIN and click OK or click “List All” to browse by library.

place the screw hole and repeat for the other 3 corners

Place the screw hole and repeat for the other 3 corners.

<-Back Next->

designing PCBs in Kicad and PcbNew: Drawing Traces

NOTE: This tutorial was written in 1847, and kicad has changed a lot since then!

Drawing Traces:

Selecting and switching between layers:

picking the copper layer in kicad

Pick either the copper or component layer to draw traces on (unless you’re making a board with more than 2 layers). The copper layer is traditionally the “bottom,” whereas the component layer is the “top,” or the side with the components.

Pressing the “v” key switches between these two layers. So if you start out on the wrong layer, press Esc, and then “v” and start again. “v” also creates a via if you’re in the middle of drawing a traces.

Drawing Traces:

select the trace tool click to set bend points when drawing traces in kicad

Select the pads and trace tool to begin drawing traces. Click a pad to begin, and then click to make bend points and double click to end a trace.

Clicking at B fixes node A, and also sets the slope of segment AB. Hitting backspace undoes node points one at a time.

If you get an error along the lines of “near track end” or “too close to via,” some part of the trace you’re trying to draw is intersecting with another trace from a different net. Or the clearance is not being maintained.

Deleting tracks:

deleting tracks in kicad

To delete tracks, first make sure the trace and pad tool is selected select the trace tool , then hover over a trace and hit “backspace” to delete one segment or “delete” to remove a complete track between two pads.

Vias:

press v to make a via in kicad

Press the “v” key to make a via during a draw operation, and also to switch layers when not drawing.

Changing Track Widths:

changing track sizes in kicad

Most pcb manufactures won’t go smaller than .007 (7 mils) inches trace width and clearance without charging extra. It’s a good idea to make power and ground traces as think as possible.

7 mil trace in kicad track clearance markings while drawing changing track width

To change an existing track’s width, first change the overall program’s track width using the dialog as before or the pull-down menu, and then right click on the trace. Via sizes are changed the same way.

Notice that I did not use the “Select Track Width” in the first level of the right-click menu. That applies to the global setting, and will not change a track that you just clicked on. If you right-click and lock some traces, you can use this global setting to change a large group of traces without affecting the power traces, for instance.

Don’t delete, just redraw:

redo traces by drawing somewhere else

If you re-draw a trace somewhere else, KiCad automatically deletes the connection that you replaced, so there’s no need to first delete it.

Changing Track /Trace Layers:

As far as I know, the only way to change a trace’s layer is to re-draw it.

Dragging Traces:

Just right click on a trace or node and select Drag Segment, Drag Node or Drag Segment keeping Slopes, which keeps the angle the same on the two adjoining trace.

Highlighting Nets:

highlighting nets

It can be helpful to highlight all the traces and pads that should be connected together (a net).

<-Back Next->

Designing PCBs in Kicad and PcbNew: Drawing the Board Outline

NOTE: This tutorial was written in 1847, and kicad has changed a lot since then!

Drawing the Board Outline:

drawing a board outline with the polyline tool

First select the edges layer, and then draw an outline using the line tool. Double click to finish the poly-line.

Tip: Drawing set lengths and measuring:

measure by hitting space bar to zero the relative position readout.

Hit space bar at the start of a line to zero out the relative coordinates at the bottom of the screen. The coordinates will then measure from that point.

<-Back Next->

Designing PCBs in Kicad and PcbNew:

NOTE: This tutorial was written in 1847, and kicad has changed a lot since then!

Arrange Components:

Grid First!

adjust the grid size in kicad

You’ll probably want to adjust the grid size before moving anything. The pull down contains the user grid size as well as several sizes listed in mils (thousandths of an inch).

Group Move:

move a group of components by selecting

When you first read a net-list, all the components will come in on top of each other.

Start off by moving the whole pile of components by drawing a selection rectangle around them and then click in the middle of the sheet.

Auto Un-Piling

turn on auto-move mode right click and select move all to unpile the components

Pcbnew will automatically unpile the components. First, enable the automatic mover by clicking the “Mode Module” button in the top toolbar. Then right click and select “Move All Modules”. Pcbnew also has an “auto placer,” which is different in that it tries to minimize the length of the connections between the modules (the ratsnest). You can fix components to prevent them from being moved by either command.

General Moving and Rotating–use keyboard shortcuts:

move components by pressing m or r

Continue moving components around by hovering the mouse pointer over them, and then pressing “m” or “r” to move or rotate.

Rats Nest (show rubber bands where all connections should be):

show the rats nest

<-Back Next->

Going from Schematic to PCB Layout in KiCad (using Cvpcb)

NOTE: This tutorial was written in 1847, and kicad has changed a lot since then!

This section will explain the process of going from the schematic to pcb layout in KiCad. The process is a little bit more involved than in Eagle, and requires 4 steps:

First, make sure all components are annotated (numbered).
Generate a netlist that contains all the components and their connections.
Use cvpcb to assign pcb footprints to all the components (not necessary if new components have not been added.)
Load the netlist in pcbnew.

Netlist Generation:

generating a netlist in kicad

Assuming your schematic is already annotated (numbered), click the “Netlist Generation” button.

generating a netlist in kicad

Just click the “Netlist” button unless you want to generate one for a different layout program or circuit simulator.

Assigning PCB Footprints to Components using Cvpcb:

run cvpcb in kicad

Now run Cvpcb.

cvpcb in kicad filtered component list in cvpcb

Click the filter button to only show capacitor footprints.

assigning a module or footprint to a component

Double click on the footprint (module) to assign it to the schematic component.

Inspecting Footprints:

previewing modules in kicad's cvpcb

We’d like to use a cylindrical upright electrolytic cap for C2, but clicking the preview button reveals that none of the choices in the filtered list look right.

After clicking “display footprints list documentation”, we can look through all of the built-in footprints and pick a better choice. Turn off the filtered list and choose C1V8.

Continue mapping the components, and then click Save to store the mappings in the netlist.

But wait, if it’s saving with the same name (.net) that was used when eeschema made a netlist, won’t it overwrite the original file?

When either eeschema or cvpcb saves a netlist, it doesn’t overwrite a pre-existing netlist, but rather adds or changes info inside one.

before and after cvpcb saves a netlist

The above picture shows the netlist (.net) file before and after cvpcb maps the modules. There are “noname” placeholders that get filled in by footprints after cvpcb runs.

Loading components in Pcbnew:

run pcbnew to begin making the pcb layout

Now that modules have been assigned to the components, run Pcbnew to begin designing the circuit board.

read netlist in pcbnew

First, click the “read netlist” button.

click the read net list button to load components

Click the read netlist button to load components.

You’ll do this same procedure when you make changes to the schematic:

annotate
write netlist (from eeschema)
run cvpcb (if new components were added)
read netlist (from pcbnew)

It’s a little tedious, that’s how the system works (to the best of my knowledge–add a comment if wrong!)

Some of the options when reading in a netlist can be dangerous. I’d recommend backing up your .brd layout file before reading from any netlists, as there’s no undo in pcbnew yet.

Say, for instance, you’ve added screw holes that aren’t in your schematic or netlist. If you check “Remove Extra Footprints” it will delete those screw holes when you read in the new list.

components loaded into pcbnew from netlist all on top of each other

<-Back Next->