sparkfun FreeSoC2 Document technique
FreeSoC2 Hookup Guide V14
Introduction
Note: This guide is for the latest version of the FreeSoC2, V14. If You have an older version (the version
number can be found on the back of the PCB), please refer to this tutorial.
The FreeSoc2 is SparkFun’s PSoC5LP development board features a full onboard debugger, support for 5V and
3.3V IO voltages, and a CY8C5888AXI-LP096 processor with 256kB of flash, 64kB of SRAM and 2kB of
EEPROM. The onboard oscillator can drive the processor at up to 80MHz, and the Cortex-M3 core provides
superior performance.
The real power of the PSoC5LP isn’t in the processor, however. Wrapped around the processor is a rich analog
and digital programmable fabric, which can be configured to provide many functions that would otherwise need to
be realized in code (lowering system performance) or external circuitry (adding cost and board size). In addition,
FreeSoC2 Development Board - PSoC5LP
DEV-13714
the highly flexible fabric means that most any function can be routed to most any pin, which makes this a
wonderful tool for development and allows board layout errors to be solved, at least temporarily, pretty easily.
Conceptually, this fabric is similar to an FPGA or CPLD.
Covered in This Tutorial
We’re going to discuss two different ways to tap the power of the PSoC. We’ve ported the Arduino core to the
PSoC5LP, so you can write code for the board in the standard Arduino IDE. The board duplicates the functionality
of an Arduino Uno R3’s various hardware peripherals on the pins, so many examples, libraries, and shields will
work out of the box.
The drawback of using the Arduino IDE, however, is that it lacks any means of configuring the programmable
fabric (at the moment, at least). To get the most out of the device, you’ll need to use the PSoC Creator IDE, which
is free of charge with no code limits from Cypress Semiconductor. Sadly, the PSoC Creator software is Windows-
only at this time. If you want to see that change, consider piping up on the Cypress forums!
In this tutorial, we’re going to go over the detailed specifications and layout of the board, how to add support for
the board to the Arduino IDE, and how to get started with a simple blink project on the PSoC Creator IDE.
Required Materials
We’re going to keep it simple; the FreeSoC2 has an onboard LED and user-accessible pushbutton. We’ll use
those for our lessons. That means you’ll only need the FreeSoC2 board and a micro-B USB cable. You may,
however, find it useful to have a second USB cable, as that will allow you to connect to both the debugger and the
target at the same time.
Suggested Reading
If you’re unfamiliar with the Arduino IDE, but want to learn, check out our tutorial on installing the Arduino IDE.
As with any development platform, it’s always wise to read the datasheet. Check out the datasheet for the
PSoC5LP CY8C58LP before continuing.
Hardware Overview
There’s a lot going on on this board: two processors, two USB ports, a ton of headers, and all sorts of configurable
options.
We’ll take a hardware tour, one element at a time, starting with the debugging and connection elements on the left.
1. 5.5mm x 2.1mm center positive barrel jack – This fits all of SparkFun’s standard “wall wart” type power
supplies. While the regulators on the FreeSoC2 can handle input voltages up to 12V, it’s best to keep the
input voltage as close to 5V as possible.
2. “Target” USB Port – Provides USB connectivity to the target processor (the CY8C5888). When uploading
code via the Arduino IDE, you’ll connect to this port.
3. “Debugger” USB Port – Connects to the debugger IC. Connecting to this port also creates a USB serial port
that can be used to get and send data from and to a UART on the target processor.
4. 2.5mm JST PH series connector footprint – Our through hole 2-pin JST PH connector fits here, allowing you
to power the board with any of our standard lithium ion polymer batteries.
5. Debugger reset button – Resets the debugger. You will probably never need to use this.
6. Debugger user button – Can be used to provide input to the debugger IC; currently unused.
7. IO voltage selection switches – These switches allow you to select the voltage of the I/O signals, either 3.3V
or 5V, on the target processor. The PSoC5LP has four I/O voltage quadrants; the bottom switch allows you
to select the voltage of the quadrant providing the Arduino header signals, and the top switch controls all the
others.
8. Debugger IC JTAG/SWD header – This 2x5 0.050" pitch header can be used to program and debug the
debugger itself. It’s intended to support a connection to the MiniProg3 programmer/debugger from Cypress.
You’ll probably never need to use it.
9. Target IC JTAG/SWD header – Similar in nature to the header for the debugger; the signals on these pins
also come from the debugger IC.
10. Debugger IC – The debug IC is also a PSoC5LP- in this case, CY8C5868LTI-LP039. The firmware it comes
preloaded with (referred to as “KitProg”) is freely available for download and modification; the part is
bootloadable to replace the firmware or update it as new firmware becomes available.
11. Debugger IC IO header – There are a number of signals available on this header; they are not used by
default but you may implement additional debugging features on the debugger IC that do use them.
12. Debugger IC user LED – Will be lit if the debugger can’t detect a host, and will flash during data transfer
(i.e., programming or debugging).
13. I C isolation jumpers – These normally open solder jumpers allow you to connect the I C lines on the target
board with the debugger. Using Cypress’s KitProg debugging software, you can snoop the I C data traffic
2 2
2
from the target IC. Normally, these are open, disabling this capability. Close them with solder blobs to
connect the debugger to the target’s I C bus.
14. Battery Supply Diode Bypass – If you populate the 2.5mm JST connector and run the FreeSoC2 off of a
LiPo battery, you may find the ~0.5V drop across the diode which ORs the battery supply into the main
supply rail. This jumper may be closed with a blob of solder to bypass that diode.
Caution: if you close this jumper but fail to open the “BATT ISOLATE” jumper (item 15), plugging the
board into USB power may cause damage to your battery or even a fire as the 5V USB supply shorts
to the LiPo battery output.
15. Battery Isolate jumper – Whenever you close the “D BYPASS” jumper (item 14), this jumper must be
opened, to avoid risk of damage to the battery or fire.
The right half of the board contains the target IC (a CY8C5888AXI-LP096) and the associated headers.
1. Arduino Uno R3-type headers – For the most part, these headers are completely compatible with the Uno
R3 board. The only exception is the VREF pin, normally located between the I C pins and the ground above
D13, is no-connect for this board.
2. Target user LED – Tied to port 6, pin 7, which corresponds to D13 on the Arduino mapped headers.
3. ADC reference bypass capacitor jumpers – These jumpers allow you to add a 100nF capacitor to three of
the PSoC part’s pins, to provide a bypass for ADC voltage references to increase the reference’s accuracy.
4. High-frequency crystal footprint – if you need better accuracy than can be achieved by the onboard
oscillator, you may add a standard HC/49 crystal here.
5. Low-frequency crystal fooprint – if you want to implement an RTC, you may add a 32.768kHz clock crystal
here.
6. Target IC reset button – This button resets only the target IC.
7. Target IC user button – This button can be mapped to any purpose within the application; the button pulls
down to ground and is not tied to any other header.
8. Additional IO headers – These 2x6 headers are all additional I/O, and their voltage level (along with the
voltage present on the VDDIO pins of those headers) is controlled by the top VDDIO set switch on the left
end of the board and can be set to either 3.3V or 5V.
9. SIO pins – These six pins are special in that they can be connected to a signal voltage that is higher than
their nominal I/O voltage. They can, of course, be used normally as well. This allows these pins to be 5V
tolerant when the rest of the IO pins are running at 3.3V.
Using the Arduino IDE
2
2
Adding Support for the FreeSoC2 to the Arduino IDE
Important: please make sure you have Arduino.cc IDE version 1.6.4 or later before attempting to use the
FreeSoC2 within the IDE!
Currently, the only way to add the FreeSoC2 support to the Arduino IDE is to download the files directly and
manually install them. Instructions on how to do so are below. The first step is to use the Board Manager to add
support for the ARM processor core.
Adding ARM processor support
Unlike “true” Arduino boards like the Uno or Leonardo, the PSoC5LP uses an ARM Cortex-M3 processor core.
Late model boards, such as the Due and the Zero, also use ARM processors, so the Arduino team have added the
ARM-GCC toolset to the officially supported toolchain. That’s good for us, because it means we don’t have to do
much work (at least, on the toolchain) to add support for the PSoC.
All you need to do is open the Arduino IDE, and launch the board manager (see image below).
One of the by-default available options is “Arduino SAM Boards”; these are boards using the ARM Cortex
processor (specifically, the Atmega SAM parts). Simply click in that box to highlight it, and click “Install”.
Once the install is complete, you’ll see a new subgroup in the boards menu for the Arduino ARM boards. Now, it’s
time to add support for the PSoC.
Adding Support for PSoC Boards
Manually adding support
To add support manually, you’ll need to download the files from the GitHub repository.
DOWNLOAD THE SUPPORT FILES AS A ZIP
Once you’ve got your copy downloaded, all you need to do is copy the “Hardware” directory into either your
sketchbook (you can find your sketchbook path in the preferences window, in Arduino) or into the main install
directory for the Arduino IDE. Either way, if there’s an existing “Hardware” directory. The files should just install
alongside the existing files.
The other files in the folder are the PSoC Creator IDE project files for the implementation of the Arduino hardware
and core software. Once you’re comfortable with using the FreeSoC2 in the Arduino IDE, you may wish to open
this up as a first step towards using the full features of the part.
If there isn’t a “Hardware” directory in the sketchbook, that’s fine. Just drag the “Hardware” directory from the zip
archive into the sketchbook.
Restart the Arduino IDE, and you should see the boards in the “Boards” menu.
Programming the FreeSoC2 Board With an Arduino Bootloader
If you’ve purchased an early version of the FreeSoC2 (V11 or earlier; look on the back of the board, under the
power connector for the version number), or if you’ve previously used the PSoC Creator software to develop on
your FreeSoC2 board, you’ll find that it will not respond to the bootloading commands of the Arduino IDE.
You’ll need a Windows computer (at the moment; we’re working on a Mac/Linux solution for the near future) to
program the part with the bootloader hex file.
DOWNLOAD THE PSOC PROGRAMMER SOFTWARE
Once you’ve installed the software, follow these instructions:
1. Plug the board into your computer, and connecting via the “Debugger” port (item 3 on the left-half hardware
tour picture). Do not connect to the “Target” port at this time.
2. The drivers for the KitBridge programmer/debugger (onboard the FreeSoC2) have already been installed as
part of the Programmer installation. If Windows fails to detect them automatically, they can be found in the
Programmer installation directory. If you have Windows 8 you may want to check out this tutorial about
installing unsigned drivers.
3. Launch the Programmer. You’ll see this window:
4. Load the “Bootloader.hex” file, located in the support package you downloaded above
(“Hardware/SparkFun/psoc”).
5. Click the “KitProg” entry to select the board for programming. If there is no “KitProg” entry in the menu,
check to make sure the driver has finished installing. If you aren’t able to select the KitProg, check to make
sure there isn’t another copy of Programmer (or PSoC Creator, perhaps) running in another window.
6. Select “On” for both “Verification” and “AutoDetection”.
7. Click the “Program” button to load the bootloader onto the board.
8. Connect the “Target” USB port on the board. The driver can be found in the support package you
downloaded above (“Hardware/SparkFun/psoc”).
If all has gone well, you’ll have a new com port (named “Cypress USB UART”), and, if you open the serial monitor
in the Arduino IDE and send “H” and “L”, you should see the LED on the board toggle.
Writing Code in Arduino
Differences Between FreeSoC2 and Other Arduino Boards
The core support for the PSoC is made to closely resemble the Arduino Uno R3, and by and large, code which
runs on the Uno R3 will work on the FreeSoC2 with little or no change. Here are some of the differences to be
aware of:
1. The hardware serial port on pins 0 and 1 is Serial1 , rather than Serial , as on the Arduino Leonardo.
Serial prints to the computer, via the USB port.
2. The AREF pin is not connected on the FreeSoC2.
3. random() returns a 24-bit value instead of a 32-bit value.
4. Some of the more advanced string manipulation is, as yet, unimplemented.
5. Pin numbers should be defined as long rather than int .
We’ve ported the most core libraries to the FreeSoC: SPI, Wire (I C), and Servo, and we’ve created a driver library
for the WS281x programmable RGB LEDs. Other native Arduino libraries may or may not work. Here’s a list of
libraries we’ve verified with the FreeSoC2 in Arduino:
Our APDS-9960 Gesture Sensor library
Our MicroOLED Breakout library
Extra Serial Port
As mentioned above, all Serial commands go through the USB connection the target maintains with the PC.
This is awkward, though, because it means that text sent immediately after reset will often be missed in the time
between the code beginning to run and the user opening the terminal window.
There’s an option for the FreeSoC2, however: when the Debugger USB port is connected to the PC, it will
enumerate as, among other things, another serial port. That port can be used to send and receive data from the
Arduino application via the Serial1 interface. We’ll demonstrate that below.
Example
This example will show you how to access pins not in the normal Arduino range, as well as using the serial ports.
Remember to select the “PSoC Dev Board” in the boards menu!
2
/******************************************************************************
Example.ino
Simple example demonstrating the use of Serial ports and extra pins on the
FreeSoC2 board within the Arduino IDE.
14 May 2015
Developed/Tested with:
FreeSoC2
Arduino.cc IDE 1.6.4
This code is beerware; if you see me (or any other SparkFun employee) at the
local, and you've found our code helpful, please buy us a round!
Distributed as-is; no warranty is given.
******************************************************************************/
// Note the use of long here instead of int! This is important.
const long LEDPin = 13; // As on most Arduino compatible boards, there's an LED
// tied to pin 13. pinMode() works the same with the
// FreeSoC2 as it does normally.
const long buttonPin = P1_D2; // Pins can also be referred to by port number
// and pin number. These numbers are given on the board
// as P<port>.<pin>. P1_D2 is connected to the user
// button on one side ang ground on the other.
void setup()
{
// pinMode() functions are unchanged.
pinMode(LEDPin, OUTPUT);
// The onboard user button needs to be a pullup-enabled input.
pinMode(buttonPin, INPUT_PULLUP);
Serial.begin(9600); // This is the same as it is on the Arduino Leonardo.
// It represents the logical serial port connection to
// the PC.
Serial1.begin(9600); // Again, same as the Leonardo. This port is the physical
// IO pins (0 and 1) on the headers. It can be accessed
// via the KitProg serial port which is available when
// the Debugger port is connected.
}
void loop()
{
// digitalRead() is unchanged.
int pinDown = digitalRead(buttonPin);
// Check for button pressed...
if (pinDown == LOW)
{
Serial1.println("KitProg! Button pressed!");
Serial.println("USB! Button pressed!");
digitalWrite(LEDPin, HIGH);
}
else
{
{
digitalWrite(LEDPin, LOW);
}
delay(250);
}
Getting Started with PSoC Creator
If you want to move beyond the basics, you’ll need to install Cypress’s PSoC Creator IDE. It’s free, with no code
size limitations, although Cypress does ask that you register before downloading.
It is, sadly, Windows only.
We’ll go through a very simple project here, just a step more involved than a normal “blink” example.
Connecting the Board
For programming and debugging within PSoC Creator, you’ll need to connect the board via the “Debugger” USB
port. The driver should have been installed as a part of the Creator install process. If not, you can find them in the
Creator installation directory. If you find driver installation problematic under Windows 8, we have a tutorial to help
with that.
There’s no need to connect the “Target” port, unless you are actually creating a project that uses USB, which is
beyond the scope of this tutorial.
Creating a Project
This is what you’ll see when you launch Creator. To start a new project, you can either click the “Create New
Project…” link on the Start Page, the “New” button in the menu bar, or open the “File” menu and choose
“Project…” in the “New” submenu.
Ce manuel convient aux modèles suivants
1
Table des matières
Autres manuels sparkfun Carte mère
sparkfun
sparkfun Simon Says Manuel utilisateur
sparkfun
sparkfun DEV-16138 Document technique
sparkfun
sparkfun Qwiic Shield for Teensy Document technique
sparkfun
sparkfun Power Delivery Board - USB-C (Qwiic) Document technique
sparkfun
sparkfun Qwiic MP3 Trigger Document technique
sparkfun
sparkfun DEV-14044 Document technique
sparkfun
sparkfun ProtoShield Manuel utilisateur
sparkfun
sparkfun Qwiic Shield for Thing Plus Document technique
sparkfun
sparkfun RV-8803 Document technique
sparkfun
sparkfun Qwiic Quad Relay Document technique
sparkfun
sparkfun BeagleBone Black Proto Cape Document technique
sparkfun
sparkfun nRF52832 Document technique
sparkfun
sparkfun ESP8266 Document technique
sparkfun
sparkfun MAG3110 Document technique
sparkfun
sparkfun gator:bit v2 Document technique
sparkfun
sparkfun Qwiic 12-Bit ADC Document technique
sparkfun
sparkfun Pi Servo Hat Document technique
sparkfun
sparkfun ZOE-M8Q Manuel utilisateur
sparkfun
sparkfun MPR121 Document technique
sparkfun
sparkfun PRT-13144 Document technique
Manuels Carte mère populaires d'autres marques
Telit Wireless Solutions
Telit Wireless Solutions SL869-3DR Manuel utilisateur
Gigabyte
Gigabyte GA-9IVDT Manuel utilisateur
Texas Instruments
Texas Instruments ADS8372EVM Manuel utilisateur
Commell
Commell MS-C73 Manuel utilisateur
IBT Technologies
IBT Technologies MB860 Manuel utilisateur
Nvidia
Nvidia TEGRA DG-04927-001_V01 Manuel utilisateur
