PEmicro - P&E Microcomputer Systems: Over 30 years as an Industry leader in Embedded Systems Development Tools, debug probes, and production programmers
Cart New Account Login

HomeAbout usProductsSupportForumsBlogCustomer Service

by Edison Tam and Peter Truong

PEmicro offers three USB Multilink debug probes, each with different features or device support. In this video, Edison Tam offers a brief overview of our Multilinks to help users decide which Multilink would be best suited to their project.


by Johnny Ng

In addition to supporting the flash that resides in many different microcontrollers, PEmicro supports flash connected to an MCU via the SPI, I2C, and Address/Data bus interfaces. Depending on how the flash device is connected to the MCU, the programming algorithm may need to be set up to properly configure the external address, data, and bus control pins of the MCU. If you are not sure if you selected the right algorithm for your flash memory, please also read this blog post on selecting a flash algorithm.


PEmicro is now shipping the Cyclone Universal FX, which is the flagship model of PEmicro's next-generation Cyclone programmers. PEmicro's Cyclones have set the standard for powerful, versatile production programming and debug. The Cyclone Universal FX was designed to offer the very best of the Cyclone platform with a focus on enhanced security, extremely fast performance, test, and expandability.


PEmicro is pleased to announce that support has been added to its products for files using version 3 and version 4 of the ELF/DWARF format. This is in addition to existing support for ELF/DWARF version 2 and includes both debug and object information handling. Support for 64-bit objects and structures within the ELF/DWARF files has also been added. Support for these additional file formats is available today in PEmicro's debug, flash programming, and test products.

PEmicro is now shipping the Cyclone Universal, which is the first of PEmicro's next-generation Cyclone programmers. PEmicro's Cyclones have set the standard for powerful, versatile production programming and debug. The Cyclone Universal was designed as the first in a next-generation Cyclone platform with a focus on security, performance, test, and expandability.


Supported Architectures

  • Kinetis®
  • S32
  • LPCxxxx
  • ColdFire® V2/V3/V4
  • ColdFire+/V1
  • MPC5xx/8xx
  • Qorivva® (MPC5xxx, SPC5xxx)
  • DSC
  • MAC7xxx
  • S12Z
  • HC(S)12(X)
  • HCS08
  • HC08
  • RS08
  • ARM® Cortex® processors

BOSTON, MA – July 14, 2015 - Following their debut at the 2015 Freescale Technology Forum, PEmicro's soon-to-be-released Cyclone Universal and Cyclone Universal FX are now available to pre-order. Production quantitites of both new Cyclone programmers are expected to ship by Sept. 15 (subject to change). Those interested in placing a pre-order or simply reviewing the features of our next-generation production programming, test, and debug interfaces may do so at the Cyclones' PEmicro product page. These new Cyclones each support many architectures and offer impressive feature sets that may include:

  • Large internal memory: 1GB+ secure memory storage.
  • Focus on security: Internal memory protection & encryption, anti-tampering technology, tie images to specific Cyclones, programming count limits, date range limits, logging, etc.
  • Extremely fast target communications: 25mb/s+
  • Enhanced Interface: 4.3" Touch Screen, 1M touch Start Button.
  • External memory: SDHC port for external memory cards
  • Test Support: Images can run test code before programming
  • And more! Launch port, battery backed clock, provides and switches power to target, expanded architecture support, bar code scanner support, current & voltage measurement, etc.

Join Us On Facebook & Twitter

Like us on Facebook and follow us on Twitter for the latest news about the upcoming release of the Cyclone Universal & Cyclone Universal FX.

Click to pre-order, or to learn more about the Cyclone Universal & Cyclone Universal FX.

ARM and Cortex are registered trademarks of ARM Limited (or its subsidiaries).
Freescale, Qorivva, Kinetis, and ColdFire are registered trademarks of Freescale Semiconductor, Inc.

Supported Architectures

  • Kinetis®
  • S32
  • LPCxxxx
  • ColdFire® V2/V3/V4
  • ColdFire+/V1
  • MPC5xx/8xx
  • Qorivva® (MPC5xxx, SPC5xxx)
  • DSC
  • MAC7xxx
  • S12Z
  • HC(S)12(X)
  • HCS08
  • HC08
  • RS08
  • ARM® Cortex® processors

AUSTIN, TX – June 22, 2015 - PEmicro's Cyclones have set the standard for powerful, versatile production programming and debug. We have completely redesigned the Cyclone Platform with state of the art, high-speed technology. We have maintained compatibility with our existing product line while combining support for many target architectures in a single unit and focusing on outstanding security, performance, and features.

Join us at the Freescale® Technology Forum (FTF) in Austin, June 22-25. Come visit us at booth #617 for a chance to win one of two Cyclone Universal FX units, once they are released!

In addition to supporting more target architectures, these new Cyclones offer several improvements over their predecessors:

  • Large internal memory: 1GB+ secure memory storage.
  • Focus on security: Internal memory protection & encryption, anti-tampering technology, tie images to specific Cyclones, programming count limits, date range limits, logging, etc.
  • Extremely fast target communications: 25mb/s+
  • Enhanced Interface: 4.3" Touch Screen, 1M touch Start Button.
  • External memory: SDHC port for external memory cards
  • Test Support: Images can run test code before programming
  • And more! Launch port, battery backed clock, provides and switches power to target, expanded architecture support, bar code scanner support, current & voltage measurement, etc.

Join Us On Facebook & Twitter

Like us on Facebook and follow us on Twitter for the latest news about the upcoming release of the Cyclone Universal & Cyclone Universal FX.

Click to learn more about the Cyclone Universal & Cyclone Universal FX.

ARM and Cortex are registered trademarks of ARM Limited (or its subsidiaries).
Freescale, Qorivva, Kinetis, and ColdFire are registered trademarks of Freescale Semiconductor, Inc.

PEmicro has released Rev. C of it's popular, all-in-one USB Multilink Universal interface. The case color of the Rev. C interface has been updated from green to blue, however the functionality of the Multilink Universal remains the same.

P&E continues to expand on its line of all-in-one interfaces with the launch of the high-speed USB Multilink Universal FX. Like P&E's original all-in-one interface, the USB Multilink Universal, the new USB Multilink Universal FX supports a varirety of Freescale MCUs, including: Kinetis, Qorivva 55xx/56xx, ColdFire V1/ColdFire+ V1, ColdFire V2-4, HC(S)12(X), HCS08, RS08, Power Architecture PX Series, and DSC. However the new FX interface can download at speeds up to 10x faster and can provide power to the target processor, among other enhancements.

The new USB Multilink Universal FX is natively supported by recent versions of CodeWarrior®, current P&E software applications, and toolchains from many Freescale partners including Keil and Cosmic.

More information about the USB Multilink Universal FX is available on the product page at P&E's website.


    P&E presented its new USB Multilink Universal, an ALL-IN-ONE development interface, at the recent Freescale Momentum conference. The revolutionary ALL-IN-ONE interface concept was very well received by conference attendees. USB Multilink Universal is a single interface that supports Freescale’s HCS08, RS08, HC(S)12(X), Coldfire V1/+V1/V2-V4, Qorivva MPC55xx/56xx, and Kinetis ARM microcontrollers. Thus, it eliminates the need to purchase different hardware interfaces to support specific devices that belong to those MCU families.

    P&E also previewed two upcoming products: the USB Multilink Universal FX and Tracelink. The USB Multilink Universal FX is an enhanced, very high-speed version of the USB Multilink Universal. The Tracelink interface will support trace capture for 32 bit Freescale device architectures.

New! Follow us on Twitter at!  

This video provides a brief comparison of the features of two popular P&E hardware interfaces, the USB BDM Multilink and the Cyclone PRO. This overview is intended to help users determine which interface is best suited for their project. More information about each interface can be found on the USB-ML-12 and Cyclone PRO product pages.


P&E is pleased to announce that 64-bit Windows support has arrived, including support for Windows 7. P&E software has been upgraded to work under Windows 7 (and other Windows 64-bit operating systems) by using the latest version of our drivers - P&E Hardware Interface Drivers 10. There is no need to worry about P&E software compatibility if you're migrating to a Windows 64-bit OS at home or in the office. 

P&E is committed to ensuring a smooth transition to these newer operating sytems for our customers. Customers who have purchased P&E software within the last 12 months can contact us for a free ugprade. Customers who have purchased software between 12 and 24 months ago are eligible to upgrade by purchasing the latest version of the software at a 50% discount from the full price.

Unfortunately, due to OS and hardware driver limitations, P&E legacy products such as USB-ML-12 Rev. A, USB-ML-CF Rev A, the BDM Lightning Card and also parallel port versions of our programmers are not supported under Windows 7 and 64-bit systems. However, we are committed to supporting these products under 32-bit operating systems such as Windows 98/2000/XP/Vista by continuing to offer Version 9 of our P&E Hardware Interface Drivers. These can be downloaded from the Documentation and Downloads section of P&E's website, or directly at the following link:


We're pleased to announce the release of our latest device drivers. This update includes support for Microsoft Windows XP, Vista, and Windows 7 Operating Systems for both 32-bit and 64-bit architectures, as well as some minor bug fixes.

To get started using the drivers:

  1.     Download P&E Hardware Interface Drivers 10
  2.     Run the file drivers_10_install.exe. If you have an older version of our drivers installed, the setup will automatically perform the update.

NOTE: The latest drivers no longer include support for Windows 98 and ME, but P&E will continue to make our older drivers available. Support for PCI devices (e.g., BDM Lightning) and Parallel port devices has been removed for Windows Vista and later, as well as all 64-bit operating systems.

P&E drivers allow P&E applications to communicate with P&E hardware via the parallel port, PCI bus, Ethernet, Serial, and USB.

This video gives a demonstration of how to load a programming image onto a CompactFlash card in the expansion port of P&E's Cyclone products. CompactFlash activation is a powerful feature that lets users expand the memory and versatility of their Cyclone:



PEmicro’s Cyclone PRO/MAX Stand Alone Programmers offer an impressive array of capabilities such as in-circuit flash programming, stand-alone programming, and as much as 7MB internal non-volatile memory for storing programming images. And now this memory space can be expanded via optional software which enables the Cyclones’ CompactFlash interface. The expanded storage feature simplifies management of Stand-Alone Programming images. This Expert’s Corner explains how to take advantage of the CompactFlash card feature to facilitate the Stand-Alone Programming process.


  1.    Introduction – Stand Alone Programming
  2.    Setup – Image Creation
  3.    Using CompactFlash – Inserting a CompactFlash Card
  4.    Using CompactFlash – Storing an Image into CompactFlash
  5.    Using CompactFlash – Selecting an Image on the LCD screen
  6.    Limitations
  7.    Security
  8.    Conclusion

1. Introduction – Stand Alone Programming

One of the key features of the Cyclone PRO/MAX Stand-Alone Programmers is the ability to store all necessary programming information - binary data, algorithm information, and programming settings – in the Cyclone’s internal memory, in a format known as the Stand-Alone Programming (SAP) Image. This allows programming operations to be initiated by pushing a single button.

There are currently two methods that can be used to load a SAP image onto a Cyclone. If only a single image is necessary for production, that image can be stored directly on the Cyclone using the “Cyclone Image Creation Utility”.If several images are necessary for production, the “Cyclone Image Creation Utility” can first be used to create all the SAP images, and then the “Cyclone Image Manager” can be used to load all the images simultaneously into the cyclone.

These methods are useful for updating small SAP images stored internally, or when the unit is easily accessible from a host PC. However, the procedure becomes a bit more involved if the Cyclone unit is not easily accessible. If the unit is at a different manufacturing plant, for example, or overseas, the user would have to obtain the Cyclone, update the images, and then send it back to its original location. However, with the addition of CompactFlash support this process becomes a matter of simply removing a CompactFlash card with one set of images and plugging in another with the new set, thereby reducing the need for an additional PC and engineering support. This makes it very easy to reconfigure images in the field.

In addition, activation of the Cyclone’s CompactFlash capability provides support for images which are larger than the internal memory storage space. A firmware image of 16 MB intended for programming into a hybrid engine controller, for example, can now easily be stored on a CompactFlash card.

The following sections demonstrate how to use the CompactFlash feature. We will create a SAP image example and then store it on a CompactFlash card in a Cyclone MAX, Rev. B.

Back to top

2. Setup – Image Creation

First we create a SAP image using the “Cyclone Image Creation Utility” and save the SAP image on the PC.Then we transfer the image onto the Cyclone’s CompactFlash card. In the screenshot below, the “Cyclone Image Creation Utility” is configured for Freescale Power Architecture 5534 with a typical programming sequence:

Additional settings for the SAP image may need to be configured depending on the architecture. For the Power Architecture there are three other settings to configure, which are as follows:

   1. BDM Shift Frequency: 5, which corresponds to a communication frequency of 2.2 MHz. This clock cannot typically exceed a 1/6th of the processor bus frequency.
   2. Reset Delay: 0. The reset delay section allows the user to set a delay before attempting communication. It is generally used if a reset driver exists on the target board which further asserts reset for a longer delay. In this example we will use a reset delay of zero.
   3. Image Description: Field_Upgrade_Hybrid_3.49. The field for “Image Description” is used for naming each image that is created.


After verifying that the programming settings are correct, use the “Store Image to Disk” button to save the image on the PC. Then load the image into the CompactFlash card by using the “Cyclone Image Manager Utility”.

In this example, the SAP image is saved on the Desktop:



Back to top

3. Using CompactFlash – Inserting a CompactFlash Card

Insert the CompactFlash card into the “Flash Expansion Port” on the Cyclone Max Rev. B. It is not necessary to power off the Cyclone Max Rev. B before inserting the CompactFlash Card.

Upon insertion of a blank CompactFlash card the Cyclone prompts the user to format the card for use with the Cyclone device. The user should use only a PEmicro branded CompactFlash card to guarantee proper operation.


Back to top

4. Using CompactFlash – Storing an Image into CompactFlash

If the Cyclone’s CompactFlash capabilities have been activated, the “Cyclone Image Manager” will display a section that can be used to manage images stored on the CompactFlash. The new Cyclone Image Manager software is sold separately and must be registered before use. Below is a screenshot which shows the “Browse & Add Images to CompactFlash” section activated:

In this example, the Cyclone MAX, Rev. B is named “Persepolis” and has an IP address of “” with two SAP images already stored in its internal memory.

The section labeled “Browse & Add Images to Internal Memory” has been updated so that SAP images stored in internal memory will be displayed with a prefix of “IN#:” The prefixes are automatically added after a SAP image is stored. The functionality of the buttons, “Remove All”, “Remove”, and “Add”, remain the same as before. “Remove All” will remove all the images from the internal memory. “Remove” and “Add” are used to configure a list of images to be stored in the Cyclone MAX, Rev. B internal memory. A screenshot of this section appears below:



To store a SAP image on the CompactFlash, click on the “Add” button under the second section, “Browse & Add Images to CompactFlash”.

In this example, the SAP image “Field_Upgrade_Hybrid_349.SAP” created in Section 2 is selected. After selecting the correct SAP image, click open. The SAP image should now be listed in the “Browse & Add Images to CompactFlash” section. Shown below is a screenshot of “Browse & Add Images to CompactFlash” before committing changes. The prefix “EX#” is added before the file name to designate it as CompactFlash external memory.


After verifying that the correct SAP image has been added to the list, click on “Commit Changes” to store the image into the CompactFlash card. Shown below is a screenshot of “Browse & Add Images to CompactFlash” after committing changes. Note that the image is now listed on the left.

Several SAP images can also be added at the same time. In the screenshot below, two extra SAP Images have been added to the CompactFlash card.


Now that the SAP images have been added to the Cyclone’s CompactFlash card, we can use LCD screen and interface buttons on the Cyclone MAX, Rev. B to select which image to use for stand-alone programming. The next section discusses the steps needed for selecting a SAP image.

If you wish you may watch this brief video demonstrating how to load a programming image onto the CompactFlash.

Back to top

5. Using CompactFlash – Selecting an Image on the LCD screen

After storing the SAP images into the internal memory and CompactFlash, the status window displayed on the Cyclone MAX, Rev. B appears as below:

To change the selected SAP image press the “Menu/Select” button, which brings up the main menu:

Then press the “Menu/Select” button again when “Select SAP Image” is highlighted.

This will bring up a list of available SAP images. As mentioned previously, the prefix “IN#:” indicates that an Image is stored in internal memory and the prefix “EX#:” identifies that an Image that is stored in CompactFlash. Scroll until the desired image is highlighted and then press “Select”.

Once the SAP image is selected, its name will be displayed in the status window:

Back to top

6. Limitations

The CompactFlash feature is currently available on the Cyclone MAX, Rev. B and Cyclone PRO, Rev. C. Only PEmicro branded CompactFlash cards are guaranteed to work with the these Cyclones.

The largest currently supported CompactFlash card memory size is 128 megabytes. The largest number of distinct SAP images that can be stored on one CompactFlash card is 248.

Back to top

7. Security

For added data security, information can only be written to the CompactFlash through the Cyclone MAX, Rev. B and Cyclone PRO, Rev. C, and datasets cannot be extracted from the CompactFlash once they have been written.

Back to top

8. Conclusion

With the new CompactFlash card feature, PEmicro’s Cyclone PRO and Cyclone MAX Stand-Alone Programmers are no longer constrained by a limit of eight SAP images in the internal memory. Furthermore, updating a SAP image at an off-site production facility or on the field is now as easy as sending a CompactFlash with the new SAP Image. Archiving each new version of an image becomes easier by storing each new image on a separate CompactFlash Card.

Back to top

Juan See is a Design Engineer at P&E Microcomputers.  He can be reached at jsee (at)

© 2009 P&E Microcomputer Systems

P&E engineer Edison Tam demonstrates how to program Freescale's QE128 with P&E's Cyclone PRO stand-alone automated programmer, and gives an overview of the development and production capabilities of the Cyclone PRO. To learn more, please visit the Cyclone PRO product page:


Watertown, MA - P&E Microcomputer Systems has expanded its line of UNIT Library Interface Routines by adding a new version that supports Freescale's RS08 microcontroller family. P&E's UNIT Libraries allow the user to create custom Windows applications that can fully control an RS08 processor using either P&E's Cyclone PRO (Rev. C) or USB-ML-12 (Rev. C)  interfaces. It also supports P&E's DEMO9RS08LA8, DEMO9RS08LE4, and DEMO9RS08KB12 development boards, available through Freescale.

The UNIT libraries are frequently used to build custom production line testers. The libraries allow applications to peek and poke memory, peripherals, and other resources of the processor by using P&E interfaces to access the debug port. With these abilities, the application can perform tests of the target hardware, calculate target calibration data, or simply control the target using debug mode. 

More information about P&E's UNIT Interface Library Routines for the RS08 can be found at P&E's website.


P&E has updated its Cyclone PRO Image Creation Utility to provide a way for users to set a custom trim frequency for HCS08, RS08, and CFV1 devices that have an internal reference clock. To use this feature, the user must first select a programming algorithm, because not all devices have the same maximum and minimum internal reference clock frequencies.

Once the programming algorithm has been selected, the utility will determine the allowed frequency range from which the user can choose. The user also has the option of enabling or disabling this feature. When it is enabled, the user can input a desired frequency. If the user does not enable this feature and input a frequency, or if this feature is disabled, the utility will simply select the default trim frequency as specified in the device reference manual.

Please note that this feature is only effective if the "PT ; Program Trim" command is included in the programming sequence. This custom trim feature in the updated Cyclone PRO Image Creation Utility is similar to the one available in CodeWarrior for Microcontrollers (RS08/HC(S)08/ColdFire V1).

To download the latest updates, please visit our Cyclone PRO product page.



Did you know that P&E offers full chip simulation for all 8-bit Freescale devices? This powerful tool allows you to jump start device evaluation and firmware development because you can start writing code without having access to the actual device. All aspects of 8-bit devices from the CPU to the external I/O can be analyzed in a full-chip simulator.

Because of the importance that external I/O plays in development of any embedded system, P&E's full chip simulator gives the user access to all onboard modules via a combination of input/output GUIs and commands. The user can simulate sending and receiving data to and from modules such as SCI, SPI, IIC, ADC and PGA. At the same time the user can also simulate analog inputs on bi-directional I/O ports, which can be used to trigger keyboard interrupt events if the KBI module is properly configured. Availability of  the modules mentioned above depends the actual device.

Currently, all P&E full chip simulators are available through fully licensed and evaluation versions of Freescale Codewarrior IDE. However, P&E plans to release a stand-alone product which will include simulation for 8-bit Freescale devices.

Below is a code snippet that can be used to perform an SCI transmission. Once the transmission takes place, it can be observed in the SCI output buffer window:


       mov   #$00,SCI1BDH       ; Baud Rate = 9600
       mov   #$1A,SCI1BDL       ; Baud Rate = 9600
       mov   #$40,SCI1C1         ; Enable the SCI peripheral
       mov   #$08,SCI1C2         ; Enable the SCI transmitter


       brclr 7,SCI1S1,HERE       ; wait until xmitter is ready.
       sta   SCI1D                   ; Xmit it our serial port

To display the output of the SCI module in a separate window, use the SCDO command.

For a complete list of supported modules and instructions, please refer to the Debugger_HC08.pdf file, which can be found in the [Codewarrior Installation Directory]HelpPDF folder on your PC.


PEmicro’s PROG programming software will sometimes prompt the user to enter a “Base Address”. In this article, we discuss what the base address is and why it exists.

On most 8-bit and 16-bit processors, the internal flash/eeprom is located at fixed address locations. If this is the case, the associated programming algorithm will NOT prompt the user for a base address, since the address is fixed and already known.

On 32-bit processors and any systems using external flash, the address of the flash may be configured to reside anywhere within the processor’s address space. The developer will decide on an appropriate memory map early in the design process.

For these situations where the flash can be relocated, the PROG software will always move the flash so that it begins at address 0.  However, the developer may not have an object file that matches this new memory mapping. To account for this, the “Base Address” (specified by the user) is subtracted from all addresses in the object file prior to programming.

Below is an example of how the developer’s memory map may differ from the one in PROG. Although the external flash is located at different addresses, it refers to the same physical memory. Here, the user would specify a base address of FFC00000.

The base address should always be the starting address of flash in the developer’s memory map, and not the “first” address where data exists (although in most cases they are the same!)

Today's tip concerns P&E's Cyclone automated programmers. With the release of the Cyclone Automated Control Package, users have been inquiring if there is a way to automate the creation of stand-alone images. Fortunately, with the standard Cyclone PRO/MAX installations, users already have command-line executables that can accomplish this task.

For each architecture there is a corresponding CSAPXXXX.EXE application that can be used to create a stand-alone image file. For example, to create an image for the Coldfire V2/V3/V4 devices, the user would use CSAPBDMCFZ.EXE. For this blog, we will demonstrate how to create a stand-alone image for a 9S08QE128 device by using CSAPHCS08Z.EXE.

Begin by creating a stand-alone configuration file. You can create a configuration file by configuring the programming sequence in the Cyclone Image Creation Utility and then saving it thorugh File ->Save Cyclone Configuration. You can also create a configuration file by using a text editor, typing in the commands, and saving it as a .CFG file. A typical configuration file might use the following sequence:

CM  C:pemicrocyclone_proAlgorithmsHCS089S08QE128.S8P
SS   C: esthcs089S08QE128.S19
EM  ;Erase Module
BM  ;Blank Check Module
PT  ;Program Trim
PM  ;Program Module
VM  ;Verify Module
VC  ;Verify Checksum

In this example, we will save the .CFG file as "9S08QE128.CFG" in c:. With the configuration file created, we can now create a stand-alone image or .SAP file by using the command prompt. In the command prompt, we can invoke the configuration script file as follows:

c:pemicrocyclone_procsaphcs08z.exe "c:9S08QE128.cfg" imagefile "" imagecontent "9S08QE128_1_26_2009"

The first parameter, "c:9S08QE128.cfg", specifies the location of the input configuration file.

The second parameter, imagefile  "", specifies the name and output location of the .SAP file.

The last parameter, imagecontent "9S08QE128_1_26_2009", specifies the image description.

You can use the '?' character option to cause the utility to wait and display the result of the configuration in the CSAP window. You can also use the '!' character option to cause the utility to wat and display the result only if the file failed to generate.

After invoking the configuration script in the command prompt, the file is generated in the C: directory. The file can now be loaded into the Cyclone PRO/MAX by using the Cyclone Automated Control Package or the Cyclone Manage Images Utility.










P&E's Cyclone PRO makes it very simple to program both the Flash and EEPROM on your HC(S)12(X) device.  There is a unique algorithm for each device and the type of memory, so the first step is to determine the correct algorithm for your setup.  A list of all of our algorithms is located here.  If you need help indentifying the correct algorithm, please refer to our previous post, Choosing The Right Programming Algorithm.

The following is a demonstration of how to program the 9S12DP256B microcontroller with P&E's Cyclone PRO,  first in Interactive and then in Stand-Alone mode. 

The 9S12DP256B has 4KB of EEPROM and 256KB (4 blocks of 64KB) Flash, so the algorithm files that you are need are:

Freescale_9S12DP256B_1x16x2k_4k_EEPROM.12P - Internal EEPROM algortihm

Freescale_9S12DP256B_1x16x128k_256k_Linear_16k_page.12P - Internal Flash algorithm

You can place your code for EEPROM and Flash in seperate S-Record files or combine it into one.  The P&E programming software will ignore any addresses in the S-Record that are out of memory range.  Note that Freescale's Codewarrior Develoopment Kit automatically outputs an S-Record file and PHY file that contain both the Flash and EEPROM code.  You can load the PHY file directly with either algorithm for programming.


When using the Cyclone PRO in Interactive Mode, open up the CyclonePro_PROG12Z Flash programming software and connect to the target board. 

1. Load Freescale_9S12DP256B_1x16x2k_4k_EEPROM.12P with the "CM" command.
2. Specify S-record that you want to program with the "SS" command. 
3. Erase the EEPROM with the "EM" command.
4. Program the EEPROM with the "PM" command
5. Verify the EEPROM with the "VM" command       
6. Load Freescale_9S12DP256B_1x16x128k_256k_Linear_16k_page.12P with the "CM" command
7. Erase the Flash with the "EM" command.
8. Program the Flash with the "PM" command
9. Verify the Flash with the "VM" command       



If you're using the Cyclone in Stand-Alone mode you'll need to configure the following programming sequence in the Cyclone PRO Image Creation Utility.  If you don't have this utility, you can download the software here

CM Freescale_9S12DP256B_1x16x2k_4k_EEPROM.12P
CM Freescale_9S12DP256B_1x16x128k_256k_Linear_16k_page.12P

Did you know that the Freescale Codewarrior IDE includes an option that allows you to program flash with more flexibility? This option is called “Expert Mode."

Expert Mode provides a set of general interface functions which are used to control the erasing, verifying, programming and viewing of modules to be programmed and provides the flexibility of choosing your own flash programming algorithm and program/erase ranges in your module within the IDE.

To access this feature, follow these steps:

  1. Start the Freescale CodeWarrior IDE
  2. Create your project or use an existing one.
  3. Make sure the connection type is set to “P&E Multilink/Cyclone Pro” and your target is connected.
  4. Start the Debug session and interface with the target.
  5. Inside the real-time debugger, navigate to “MultilinkCyclonePro” ==> “Start Expert Mode Programmer…” and select this option.

This will allow you to access features that are normally available to you in P&E's PROG flash programming software. This option is available in CodeWarrior 6.2 for the HCS08 and RS08 architecture and allows the Cyclone PRO to be used for interactive programming.

To find full documentation of our software for your device, please visit:

and select the specific PROG that you are using.

Cyclone ACP, Rev. C PEmicro’s product line of Cyclone stand-alone programmers provides a fast, robust, and automated solution for production-scale programming of microprocessors. However, production facilities may desire an even higher level of automation than the single-button touch capability that is offered by the Cyclone. PEmicro offers several means of automating control, including a command-line executable, UDP/Serial communications, or the .DLL included in PEmicro's new Cyclone Automated Control Software Package. In this article, we discuss automated control using the automated control package and the unprecedented level of power and flexibility that it offers.

1.) Introduction – Controlling a Cyclone through the PC

PEmicro’s new Cyclone Automated Control Package provides the developer with a dynamic link library (DLL) and supporting documentation to allow custom software applications to directly control the Cyclone.

By storing the binary data information, algorithm information, and settings directly into the FLASH memory of the Cyclone, programming operations can be initiated by the simple push of a button. However, the DLL enables us to use the PC to issue a command to the Cyclone to start the same programming sequence!

The use of a PC to control the Cyclone enhances the functionality of the stand-alone programming operations, but also introduces new capabilities that were not available previously. In the following sections, we explore the features of the Cyclone Automated Control Package and present practical examples of how to use it in your own production line.

2.) Setup – Image Creation

The first step is always to create the actual stand-alone images that will be stored onto the Cyclone. These images contain the algorithm needed to program FLASH / EEPROM, the actual binary data to be programmed, the sequence of programming operations, and many user-specified Cyclone settings. PEmicro’s “Cyclone Image Creation Utility” allows the user to properly configure the stand-alone images.

Above is a screenshot of the dialog in the Cyclone Image Creation Utility which allows the user to configure the stand-alone image. The field on the right shows the programming steps and also the order in which these steps execute.

1.)    First, we select the appropriate algorithm for our processor. In this example, we are using the Freescale HC9S08GB60.

2.)    Next, we specify the target object file that represents the binary data to be programmed into the processor’s FLASH memory. Here, we are using a Motorola S-record file.

3.)    Once the algorithm and the target object file are specified, we are ready to begin programming. Typically, the procedure is to erase the device to make sure it’s blank, program the target, and verify that the contents were written correctly.

In addition to the programming sequence, there are also settings for the Cyclone that we can configure. In the above screenshot, we are using the Cyclone PRO’s power relays to provide the appropriate voltage to power up our processor. This way, we do not need a separate power supply for our target board, simplifying our production line.

Finally, we specify the Image Description so that we can easily identify the image later on. By using the “Store Image to Disk” option, we are able to save this image and its configuration as a .SAP file for future use.

3.) Using the DLL – Simple Example


The above code example shows the most basic operation that is supported by the Cyclone Automated Control Package. Below are the steps we have taken:

Step 1: Contact the desired Cyclone by specifying its IP address. The handle of the Cyclone is returned, and is used to identify the Cyclone in all subsequent function calls.

Step 2: Send a command to the Cyclone to begin the programming operations specified in image #1. These operations were specified during the image creation process.

Step 3: Wait for the Cyclone to complete the programming operations before proceeding.

Step 4: Check to see if any errors occurred during programming and provide a message to the user.

Step 5: Terminate the current session with the Cyclone.

4.) Using the DLL – More Advanced Operations

Programming a serial number



Note: The following are placeholder functions used to simplify the example, and are not provided by the automated control package:




The above example code is an event handler written for a visual MFC application, which is executed each time a button is pressed by the user. Here, we again instruct the Cyclone to perform the stand-alone programming operations of the image stored on the Cyclone. Afterwards, we program a dynamic 2-byte serial number into address 0x100 of the target processor. The serial number is then incremented and written back to a file for later use.

Although there are many different ways to program a serial number without needing to use the automated control package at all, this code example can easily be modified to program dynamic data that is not sequential. For example, if we wish to program the current date or a lot number, using the automated control package and writing your own custom application is by far the easiest and most automated way to accomplish this task.


Automatically update image stored on the Cyclone



This is a very simple example of how to ensure that the image stored on a Cyclone is always up to date. A comparison is performed between the image which currently resides on the Cyclone and an image file at a specified location on the host PC. If there is a mismatch, then we update the image. Afterwards, we proceed with the normal programming operations as seen in the previous examples.

5.) Can I Control Multiple Cyclones?

 Up until now, we have discussed some uses of the Cyclone Automated Control Package with a single Cyclone unit. Since the host PC only sends minimal control information to control each Cyclone, a single PC is actually capable of controlling many Cyclone units simultaneously.


Here, we begin programming operations on 3 separate Cyclone units and wait for their completion before proceeding. In essence, we are programming 3 separate devices in parallel. This can be easily extended to 10, 100, or even 1000 Cyclone units controlled in parallel from a single host PC!

6.) More Examples

Here are a few more real world examples:

·         Quality Control : automatically record statistics on the number of devices that fail during programming.

·         You’re a developer and just completed the firmware development for a brand new product. Now you need to get your production facility up to speed, but they are halfway across the country. Streamline this process by writing a simple application that will add a new image to the Cyclone. Send this along with the new stand-alone image SAP file and you’re done.

·         You use multiple Cyclone units for programming your devices in parallel. Each Cyclone has 4 different images, one for each of your 4 different products. Write an application that allows the user to automatically select the correct image for the current production run.

7.) Conclusion

 Whether you are performing small production runs in-house or programming a large number of chips in a high-volume facility, PEmicro’s Cyclone product family provides a powerful, yet affordable, solution. With the advanced parallel programming, image management, and error tracking features provided by PEmicro’s new Cyclone Automated Control Package, you now have the power to completely automate your production programming process like never before.

For more information, see also:

Did you ever wonder how to power cycle your device to force it into Background Debug Mode? Are you trying to eliminate an external power supply from your manufacturing setup? You can accomplish either task by using a Cyclone PRO. Using the Cyclone PRO's internal power generation mechanism, you can control power for any HC08/HCS08/RS08/HC(S)12 device.

In fact, controlling the power through a Cyclone PRO is crucial for HCS08/RS08 device applications which may not have a dedicated RESET pin. This is because power cycling the device is necessary in order to fully automate the FLASH programming procedure.

To configure a Cyclone PRO to provide power to pin 6 of the BDM header, set power jumpers 2, 3 and 4 on the side of the Cyclone unit. To provide power to pin 15 of the 16-pin MON08 header, set power jumpers 1, 2 and 3. Once the power jumpers are set, select "Provide Power to Target" from the Connection Assistant and/or Cyclone Image Creation Utility and the Cyclone PRO will take care of the rest. You can choose between 5V, 3V and 2V levels.

The Cyclone PRO is also able to toggle power for most high-power/high-voltage devices. The internal electromechanical relays can handle power supplies with a maximum switched current of 1A and a maximum switched voltage of up to 30VDC. In order to automate power cycling with an external power supply, insert it into the Cyclone's "Target Power In" jack. Use the power cord that's included in the Cyclone PRO kit to connect the output of the Cyclone's "Target Power Out" jack to the power input of your board. Then be sure to set power jumper 5 on the side of the Cyclone unit, leaving jumpers 1, 2, 3 and 4 un-populated.

To learn more about Cylcone power management options, please download our Cyclone PRO User's Manual.

P&E offers an easy and reliable way to control a Cyclone PRO via the built-in RS232 protocol. If you would like to follow along with our example, please pre-program your Cyclone PRO with a stand-alone image and configure your RS232 host device to operate at an 115200 baud rate, 8 data bits, no parity and 1 stop bit mode. You are now ready to enjoy the flexibility of controlling your Cyclone PRO by sending it a pre-defined set of byte strings. These commands cover full range of Cyclone PRO functionality, beginning with Executing All Commands of an Image (Same as Pressing the "Start" button) and ending with Dynamically Programming Data to Target.

In order to ensure that a given command reaches the Cyclone PRO without getting corrupted, each command is concluded by a CRC8 byte. Below is the command structure that should be followed every time the RS232 command is sent: [LENGTH] [COMMAND TYPE] [COMMAND ID] [PARAMETERS] [CRC8]. The user should calculate CRC8 and append it to all commands that are sent from a host system to a Cyclone PRO.

Let's go through a step-by-step example of CRC8 calculation for Execute All command:

The command consists of 4 bytes that include the CRC of $88: $03 $18 $11 $88.

Given an array of pre-calculated CRC values of:

const    crc8tab : array[0..255] of WORD = (

the following function should be executed with the initial CRC variable initialized to 0.

procedure ArrayCRC8(const a: array of byte; const len : byte; var crc: byte);
  i : byte;
     for i := 0 to (len-1) do
         crc := crc8tab[crc xor a[i]];

The first byte in the command representing its length should be omitted from CRC calculation.

Step 1: 0 xor $18 = $18. Retrieve CRC value from 24th location in our lookup table

                                 crc8tab[$18] = $48

Step 2: $48 xor $11 = $59. Retrieve CRC value from 89th location in our lookup table

                                    crc8tab[$59] = $88

Append the calculated CRC8 value of $88 to the end of your command to validate the correctness of the transmission.






Did you know you can safeguard data while erasing your Flash/EEPROM module during programming? PEmicro has added a “preserve range” function that can be used in a programming algorithm to preserve memory ranges. The function looks at the range to be preserved, saves it, and restores it after the Flash/EEPROM has been erased. The user can easily preserve code segments stored in flash with a couple of modifications to the header of the programming algorithm.

A flash programming algorithm is a text file which describes how a particular flash block is to be programmed. The algorithm contains a configuration section as well as some s-record data which implements the programming process. User's commonly will modify the configuration section to change the behavior of the programming algorithm, such as to add ranges of data to preserve.

Flash algorithms describe flash blocks as having either a fixed address (common for internal flash on a microcontroller) or a variable address (common for flash chips external to a microprocessor). Algorithms which do not have a fixed address for the flash will prompt the user for the base address of the flash at the time of programming. In either case, the algorithm can be used to specify ranges of flash to preserve relative to the start of the flash block.

For an algorithm with a fixed address for the flash block, the following line will indicate the flash block location:

NO_BASE_ADDRESS=NNNNNNNN/     ; NNNNNNNN is a Hexadecimal value indicating the start of flash

Do not modify the NO_BASE_ADDRESS line! You are simply going to add some lines after it which indicate that you wish to preserve certain ranges relative to the base address. The configuration line(s) you should add directly after the NO_BASE_ADDRESS line should have the following format (very strictly formatted - no spaces allowed and include all forward slashes):

PRESERVE_RANGE=SSSSSSSS/EEEEEEEE/     ; SSSSSSSS is the starting offset, EEEEEEEE is ending offset

Adding this line would preserve the following memory range : NNNNNNNN+SSSSSSSS to NNNNNNNN+EEEEEEEE.


If there was an algorithm which was designed to program a flash block with address range $4000-$FFFF, you would see the following configuration in the flash algorithm:

NO_BASE_ADDRESS=00004000/         ;Fixed at $4000
ADDR_RANGE=00000000/0000BFFF/00/FFFFFFC0/FFFFFE00/     ; $4000-$FFFF


Do not modify these lines! If you wanted to preserve a certain memory range, you would specify it after the line with the NO_BASE_ADDRESS command (which sets the base address) and before the lines with ADDR_RANGE. If you wanted to preserve the memory from address $F000-$F001, you would add the bolded line as follows:

NO_BASE_ADDRESS=00004000/         ;Fixed at $4000
PRESERVE_RANGE=0000B000/0000B001/ ; Preserve $0000F000-$0000F001
ADDR_RANGE=00000000/0000BFFF/00/FFFFFFC0/FFFFFE00/ ; $4000-$FFFF

Note that the preserve_range command requires the offset from the base address of your memory. If you add $4000 to $B000 and $B001, you have $F000 and $F001.

In addition, this functionality does not limit the user to preserving only 1 range or one address. The function can be called several times in the algorithm if several ranges and/or addresses need to be preserved, or if the Flash/EEPROM is segmented into several fields or extended into pages.


For the flash block above (from $4000 to $FFFF), if the user wished to preserve addresses $5001, $5006 and ranges $CCAA-$CCBB and $D123-$DFFF, the following segment would be added to the algorithm:

NO_BASE_ADDRESS=00004000/         ;Fixed at $4000
PRESERVE_RANGE=00001001/00001001/ ; 5001-4000
PRESERVE_RANGE=00001006/00001006/ ; 5006-4000
PRESERVE_RANGE=00008CAA/00008CBB/ ; CCAA-4000/CCBB-4000
PRESERVE_RANGE=00009123/00009FFF/ ; D123-4000/DFFF-4000
ADDR_RANGE=00000000/0000BFFF/00/FFFFFFC0/FFFFFE00/ ; $4000-$FFFF


It is also possible to preserve several different segments across different pages of Flash/EEPROM. The user should know how to access each page of memory logically in the software. Let's look at the HCS08 AC128. The paged Flash memory can be accessed with the following ranges. This will typcially be described in the configuration section of the programming algorithm.

$08000-$0BFFF --> Page 0
$18000-$1BFFF --> Page 1
$28000-$2BFFF --> Page 2 
$38000-$3BFFF --> Page 3 

If the user wanted to preserve memory on page 0 from $08000-$08005 and on page 3 from $38000-$38005, he would add the following commands :

NO_BASE_ADDRESS=000020F0/         ;Fixed at $20F0
PRESERVE_RANGE=00005F10/00005F15/ ; Preserve $08000-$08005
PRESERVE_RANGE=00035F10/00035F15/ ; Preserve $38000-$38005
ADDR_RANGE=00000000/0000DF0F/00/FFFFFFC0/FFFFFE00/ ; $20F0-$FFFF

Note again that the offset $20F0 is added to the parameters of the command to calculate the correct paged memory ranges to preserve. Add $20F0 to $5F10 to get $08000 and add $20F0 to $35F10 to get $38000.  

The PROG software will report a checksum error and warn that the algorithm has been modified. This error can be ignored. If you wish to remove the warning, please use our command-line ADDCRC utility to update the checksum.

The Blank Check command will now fail because of the preserved data. Also note that the Verify Module command will ignore the addresses that are preserved when comparing memory against an S-record.

Any information which follows a semicolon (;) on a configuration line is a comment.

PEmicro can provide more a detailed specification of flash algorithm construction upon request.

For time-sensitive HCS08/RS08 applications the developer often needs to trim the internal reference clock in order to generate a desired bus frequency. P&E's HCS08 and RS08 Flash Programmers provide a command called “Program Trim” that allows developers to program a pre-calculated value to the non-volatile flash locations that are reserved for storing ICSTRM and ICSSC registers. These can then be loaded at run-time.

Here’s a demonstration of how the “Program Trim” command can be used to generate a bus frequency of 8 MHz on a 9S08QE128 microcontroller. For the 9S08QE128, the “Program Trim” command will generate a value that will trim the Internal Reference Clock to 31.25 KHz with an accuracy of up to +/- 0.2%. The command will then program the generated value to 0xFFAE and 0xFFAF. We will be working with an assembly file that configures the Internal Clock Source module and toggle Port A every 20 CPU cycles.

Configuration source file:

ROMSTART equ $2080
SOPT1           equ $1802
ICSC2            equ $0039
ICSTRM         equ $003A
ICSSC            equ $003B
PTAD            equ $0000
PTADD           equ $0001


     lda SOPT1
     and #$7F
     sta SOPT1    ; Disable watchdog
     lda $FFAF
     sta ICSTRM   ; Load TRIM bits from Flash and store it into ICSTRM
     lda ICSSC    
     and #$FE
     ora $FFAE    ; Load FTRIM bit from flash and store it into ICSSC   
     sta ICSSC   
     lda ICSC2
     and #$3F    ; Set BDIV to Divide DCOOUT by 1
     sta ICSC2    ; FLL factor= 512, therefore 31.25Khz*512/1=16 MHz=DCOOUT
                      ; 16MHz/2=8MHz=Bus Frequency                   
     mov #$ff,PTADD  ; Set all PTAD pins as outputs
     mov #$ff,PTAD    ; Set all PTA outputs as high
   Bra Loop

     mov #$00,PTAD ; 4 cycles
     mov #$ff,PTAD ; 4 cycles
     jmp loop ; 4 cycles
     Org $FFFE
     dw  Main ;Reset Vector


After saving the above source file section as "9S08QE128_Example.asm" and assembling it, we can use PROGHCS08 to program the generated 9S08QE128_Example.s19 file into flash. The programming sequence outlined below will program our generated .S19 and the pre-calculated trim value.

CM  ; Choose module 9S08QE128.S8P
SS    ; Specify our object file 9S08QE128_Example.S19
EM  ; Erase module
BM  ; Blank check module
PM  ; Program module
VM ; Verify module
PT  ; Program Trim Value

On a power-on reset, our 9S08QE128 target will disable the watchdog, load trim values from flash and store them into their corresponding ICS registers, set the bus frequency divider to 1, and toggle PTA pins every 20 cycles. With a bus frequency of 8MHz, if we were to put a scope on any of the PTA pins, we would expect to observe a signal with a 400 KHz frequency +/-0.2% accuracy.

P&E's Cyclone programmers are sophisticated and flexible tools designed for in-circuit flash programming.  Field service updates, an important part of a field system, often occur in places where there is no access to a PC or power outlet.  However, P&E's Cyclones are lightweight, compact programmers that have been designed to operate in stand-alone mode – i.e. they can be loaded with a programming image, detached from the PC, and then be controlled via the LCD menu and control buttons. This makes it simple to update the firmware of a field system, for example. In the field, the Cyclone unit may be powered by using a Cyclone_PowerPack, which is a lightweight and compact lithium ion battery.  The combination of the Cyclone programmer and the battery pack creates a fully operational field programming setup that is lightweight, compact, and extremely portable. 

All that is required for a field update is to connect the battery-powered, pre-programmed Cyclone to the target. Flash programming occurs directly from the Cyclone image to the target by a simple touch of the Start button. Once initiated, programming launches and the on-board LCD displays the current state of the programming process. The final result, which is displayed on the LCD screen and with highly visible LEDs, clearly indicates a successful programming result.

Did you know that P&E provides simulation for nearly the whole array of Freescale 8-bit microcontrollers (RS08/HCS08/HC08)? Simulation is  inexpensive and fast, and allows for a highly detailed look at the functionality of the simulated device. P&E Simulations include trace capabilities and are cycle-accurate (cycle accuracy allows for a low level, cycle-by-cycle analysis of the timing and general functionality of your code). Furthermore, simulation allows the seamless loading of code to the entire memory array of the processor, without the cumbersome flash burning that accompanies hardware development -- and byte by byte modification of the memory is allowed at any time.

     In addition to initial development, simulation can serve as a highly effective means of product evaluation. Evaluation of various devices via simulators can be relatively painless and inexpensive when compared to evaluating those same devices using actual hardware. In addition, our simulations are often published before the silicon is widely available, so simulation is also an excellent tool to help you stay on the cutting edge.

     Currently, P&E Simulations are available within the Codewarrior toolsuite. However, P&E will soon be releasing the Simulation Toolkit, which will include all simulations in one convenient package. Stay tuned to the P&E Newsflash for more updates on the release of this product.

When it comes to production programming, a lot of times one or more serial numbers are required.

P&E has developed a utility called SERIALIZE, which allows the generation of a .SER serial number description file. This graphical utility sets up a serial number which will increment according to the parameters set by the user.

For P&E interactive programmers (PROGx software), the .SER files are stored on the PC and updated every time a serial number is programmed to the target.

For Cyclone stand-alone operations, a similar mechanism has been implemented, except that the serial number structure is stored in the Cyclone's non-volatile internal FLASH memory. The .SER file is used to obtain the initial serial number. Below we'll describe how a user can take advantage of this feature in stand alone operations.

Assuming that a user only needs one serial number for his product, the following sequence of operations can be specified when he creates the SAP image:

CM Corresponding programming algorithm for his product

SS Corresponding object file for his product





CS Corresponding .SER file for his product created using the Serialize utility


After storing the image on the Cyclone, a user can simply press the "START" button and watch the target be programmed with the serial number specified in the .SER file. Another press of the "START" button will program the target with the next serial number.

Multiple memory modules and multiple serial numbers can co-exist in one SAP image. The following are example scripts of two programming algorithms and three serial numbers:

CM Programming algorithm 1

SS Object file 1





CS .SER file 1


CM Programming algorithm 2

SS Object file 2





CS .SER file 2


CS .SER file 3


Once the SAP image is stored in a Cyclone, pressing the "START" button will automatically carry out all the operations listed above in sequence. Memory module 1 will contain the serial number specified in the first .SER file. Memory module 2 will contain the serial number specified in the second .SER file, and the serial number specified by the third .SER file. Another press of the "START" button will automatically program the next serial numbers in the target.

This serialize mechanism may even be used when a user wants to program some static data to different locations without using the "PB" or "PW" commands - the user can simply create a .SER file with all constants.

Please refer to this post for more information on the Serialization utility.


develP&E offers a set of In-Circuit Debuggers that are packed with powerful scripting features. Whether you are stepping through a couple of lines of assembly code or debugging a C-level source, P&E's toolset can help you get the job done. P&E's In-Circuit Debuggers are designed with repeatable test and debugging procedures in mind. Therefore, the user can completely automate software tests by creating a macro script and saving the outcome in a log file. As a result, the user can avoid hours of repeatedly setting up software and firmware tests.

Here's a small demonstration of how the built in macro commands can be used to create and perform a repeatable firmware test on a 9S08AW60 processor. We'll be working with a simple assembly loop that's designed to toggle Port A every 20 CPU cycles. Please note that while the example below will be based on ICDHCS08 debugger, the same set of macro commands is present in all P&E debuggers. For a complete set of built-in macro features, please refer to the ICD COMMANDS section in the corresponding ICDxx.hlp file.

Source under test:

RAMSTART equ $70


     mov #$ff,$01 ; ptadd
     mov #$ff,$00 ; ptad
     lda #$ff
     mov #$00,$00 ; 4 cycles
     mov #$ff,$00 ; 4 cycles
     jmp loop ; 4 cycles

The macro outlined below will load our loop_example.s19 and .map files. At the same time it will set the program counter, set the breakpoints, and initialize variables. As the code executes, it will also capture the contents of the desired registers as well as the contents of all on-screen windows. All information will in turn be stored in a log file for later comparison and analysis:

LF test_output.log  ; creates log file
HLOAD loop_example.s19  ; load an .s19 with a map file
PC Main  ; set program counter to point to the beginning of the
; code
VAR $00  ; add a variable to a variable window
VAR $01  ; add a variable to a variable window
GOTIL Loop  ; run through initialization part of the code to the loop
DUMP $00 $01  ; dump the contents of registers $00 to $01 into the log
; file
BR Loop  ; set a breakpoint at the beginning of the loop
GO ; run the code until it hits a breakpoint
SNAPSHOT ; captures the current data in all open windows and stores
; them in a log file.
LF ; close log file

To execute the above macro, enter “macro” in the command line (located on the bottom of the ICD status window). Browse to the location where your macro is saved and open the file. Please note that any built-in commands can also be executed individually. This gives the user the opportunity to perform a step-by-step test of the macro prior to starting the automated debugging procedure.

Boston , MA— P&E Microcomputer Systems continues its commitment to programming automation and efficiency by announcing the release of an Automated Control Software Development Kit (SDK) for the Cyclone family of products.

The SDK features a dynamic link library (DLL) and supporting documentation which allow the user to create custom software applications that directly control P&E’s Cyclone PRO and MAX units. It also enables users to control multiple Cyclones with a single PC, modify stored images, manage multiple images, and program non-sequential dynamic data such as serial numbers.

The Cyclone Automated Control SDK is available in Professional and Enterprise versions to suit both small and large production scales. A Basic version with limited features is available for download at no cost.

More information is available on the P&E website on this link.

Boston, MA - P&E Microcomputer Systems now offers a rechargeable Power Pack for use with the Cyclone PRO and Cyclone MAX stand-alone programmers. When powered by a lithium ion long-runtime battery, a Cyclone unit is the perfect solution for field firmware updates that require portable, stand-alone programming. The Cyclone and PowerPack are lightweight, compact, and extremely portable.

Boston, MA - P&E Microcomputer Systems announces the release of the DEMOJM development board, available through Freescale. The DEMOJM is a low-cost development system that supports Freescale MC9S08JM60 and MCF51JM128 64LQFP microcontrollers. It consists of a DEMOJM Base Board, a DC9S08JM60 Daughter Card and a DC51JM128 Daughter Card. P&E’s Embedded Multilink circuitry on the DEMOJM board allows the processor connected to the DEMOJM to be powered, debugged, and programmed via USB from a PC.

Boston, MA - P&E Microcomputer Systems announces the release of the DEMOQE128 development board, a low-cost development system designed for demonstrating, evaluating, and debugging the Freescale MC9S08QE128 and MCF51QE128 microcontrollers. P&E’s Multilink circuitry is embedded onto the DEMOQE128 board so that it can be powered, programmed, and debugged via USB from the PC. An optional BDM port is provided to allow use of an external BDM interface such as P&E’s Cyclone PRO automated programmer or USB Multilink.

P&E has developed Linux-supported versions of many of our UNIT Library Interface Routines. For several years, P&E Microcomputer Systems has offered the UNIT SDK in order to allow users of P&E's hardware to create custom applications for testing and other designs. With the addition of Linux support for many of the UNIT products, P&E continues to expand the range of users who can take advantage of these powerful tools.

UNIT Library Interface Routines for Linux are available for:

  • HCS08
  • HC(S)12
  • 683xx
  • ColdFire
  • PowerPC
  • Power PC Nexus

For more information on UNIT software for Linux or Windows, please visit P&E's website.

Boston, Massachusetts - P&E has released a suite of development tools for Freescale's 68RS08 family of microcontrollers. With this launch, P&E now offers products to take an RS08 project from development to production, including the DEVRS08KA2 low-cost development board and P&E's popular Cyclone PRO.

In addition to the DEVRS08KA2 development board, P&E has also launched the ICDRS08 In-Circuit Debugger, PROG08 Flash/EEPROM Programmer, WinIDERS08 Development Envirionment, and a package which combines the USB-ML-12E USB Multilink BDM Interface with the RS08 debugger, programmer, and IDE. The package also includes an RS08 simulator and register files.

The RS08 family of microcontrollers are reduced-core versions of the S08 architecture, designed with a focus on very small and highly portable embedded devices.

Boston, Massachusetts— P&E Microcomputer Systems announced the availability of two new USB Multilink interface cables. The first is the USB-ML-PPCNEXUS, a JTAG/BDM interface for Freescale MPC55xx devices. The second is the USB-ML-16/32, a BDM interface for Freescale 68HC16/683xx devices. Both new interfaces connect from the USB port of a Windows-based PC to the target. P&E offers these new USB Multilink interfaces individually, or packaged with software (debugger, programmer, IDE) as part of a development kit.

Boston, Massachusetts - P&E Microcomputer Systems has expanded its offering of 68HC908 development kits, with the addition of five new kits. Each new kit features a development board with one of Freescale's 68HC908EY16, -GR8, -GZ60, -SR12, or -QY4 processors, and a standard MON08 header. The kits also include a USB-to-target MON08 interface (USB-ML-MON08) and P&E's PKG08SZ software package.

P&E also announced plans to offer development boards and kits featuring the -AP64, -GT16, -KX8, -MR8, -QC16 in the near future.

PEmicro. proudly annouces the release of a wide range of development boards and kits for the M68HC908. PEmicro is now offering affordably priced development boards for the M68HC908AB32, -GP32, -GZ16, -JL8, -MR32, and -QY4. These boards are available individually or as a set of all six. In addition, PEmicro is bundling the boards with the MON08 Multilink, USB-ML-MON08, or Cyclone PRO interfaces, providing the user with powerful yet inexpensive development solutions right out of the box.

The development boards feature:

  • Resident MC68HC908 Processor (AB32, GP32, GZ16, JL8, MR32, and QY4)
  • MON08 Debug header to allow debug and programming from the Cyclone Pro, MON08 Multilink, or USB MON08 Multilink
  • Full access to all processor pins, including port pins needed for Monitor Mode entry shortly after reset (wire wrap headers included)
  • PEmicro's asm/debug/programming software available at no-cost for download
  • Clock source may be from a PEmicro interface cable, on-board crystal (except QY4), or available to be driven by the user
  • Power may be provided by a PEmicro interface cable or by the user
  • Small size perfect for embedding into prototyping areas
  • Schematic enclosed
  • Board dimensions: 2.3" x 2.125"

PEmicro also offers the boards as part of development kits, which include one of the following MON08 interfaces:

  • MON08 Multilink - parallel-port-to-target MON08 interface
  • USB-ML-MON08 - USB-port-to-target MON08 interface
  • Cyclone PRO - includes USB, ethernet, & serial MON08/BDM communications, also functions as standalone programmer. PEmicro recommends the Cyclone PRO interface for development or production programming.

search in blog posts

ARM (28)  
Atmel (13)  
ColdFire Processors (46)
Corporate News (20)
Cyclone Stand Alone Programmer (66)
Cypress (11)
Development Boards (9)
Drivers (3)
DSC (11)  
Expert's Corner (6)
GDB Server (11)
GNU (3)  
H8 Microcontrollers (5)
HCS08/RS08/HC08 Micrcontrollers (41)
HCS12Z (3)  
In-Circuit Debugging (61)
In-Circuit Flash Programming (90)
In-Circuit Test (34)
Interface Library Routines (3)
Kinetis (23)
Kinetis ARM (6)
L-Series (1)
LPCxxxx (14)
M16C Microcontrollers (4)
Maxim (11)  
MC(9)S12(X) Microcontrollers (32)
Nordic Semiconductor (5)
NXP (15)  
OpenSDA (6)
OSBDM (1)  
P&E Newsletter (1)
Power Architecture Processors (32)
Production Programming (9)
Qorivva (15)
R8C Microcontrollers (5)
Renesas (5)
RL78 (3)  
RX (2)  
S12Z (14)  
S32 (8)  
SPI Memory (2)
STM32 (5)  
STMicroelectronics (10)
SWD (8)  
Texas Instruments (12)
Toshiba (12)
Trace (1)  
Tracelink (1)
USB Multilink Hardware Interfaces (26)
USB Multilink Universal (20)
USB Multilink Universal FX (18)
Video Demonstrations (3)
Windows 8 (2)

© 2017 P&E Microcomputer Systems Inc.
Website Terms of Use and Sales Agreement