Gang programming with Cyclone programmers
A volume production solution is often based on simultaneous group programming of different target boards to meet the speed and throughput requirements. This programming scenario can integrate Cyclone programmers into a device that is connected to a panel of cards to be programmed. Programming is typically controlled and monitored from a local computer, particularly when customized dynamic data is added to the main binary image programmed into each target.
The gear programming solution from PEmicro consists of controlling many Cyclone programmers simultaneously via the Cyclone Control Suite. A mix of programming images, targets and data can be programmed into many devices at the same time, while maintaining a high level of performance, since each Cyclone itself is an independent programmer.
The Cyclone Control Suite offers several options for controlling group programming processes. The Cyclone Control Console is a scriptable command line program that makes group programming extremely easy to set up and execute. The Cyclone Control SDK is based on a dynamically linked library (DLL or SO) and enables detailed control of group programming via many tools, languages and environments on the host PC.
Cyclone can be connected to the host computer directly via USB or remotely via Ethernet.
1. Group programming (Gang Programming) with the Cyclone Control Console
The fastest way to program gears is to use the Cyclone Control Console. The Cyclone Control Console is a powerful command line application that can be used to control one or more Cyclones at the same time. Programming images can be added / removed, settings read / set, programming processes started and dynamic data programmed. The command line application displays comprehensive status messages and also returns a result code that indicates success or failure. The application can be launched from a script, console, or other application
Connect to multiple cyclones
Opening multiple Cyclones with the console is easy. Either pass a comma-separated list of cyclone names to the -cyclone = parameter (e.g. -cyclone = agnes, colossus, hal9000) or use several -cyclone parameters (e.g. -cyclone = agnes -cyclone = colossus -cyclone = hal9000). . The other operations on the command line are performed on all open Cyclones, including programming start, except for dynamic data programming (where the Cyclone to which the dynamic data is to be applied is specified as part of the parameter). Here is an example of listing images on two Cyclones:
Start the main image programming on several CyclonesThe same image can be started on several cyclones at the same time by simply specifying several cyclones in the command line. If there are different image sets on each Cyclone, using compressed image descriptions is a good way to ensure that the corresponding programming image is started. If the image set on each Cyclone is the same, the image number will match. Therefore, the image number is another way to start the same image on multiple Cyclones. In the following example the programming image "Green Image v1.0" is started on three different Cyclones at the same time. The cyclones are referenced by name (Agnes, Colossus, HAL9000) and the image is referenced by the compressed image description "GreenImagev1.0".
Provision of additional dynamic data for each programmed target
In addition to programming the data that is part of a programming image, additional data can be programmed into each target device. This "dynamic" data can be specified each time a programming image is started, so that it can be adapted target by target. Dynamic data has many use cases: customer-controlled serialization, configuration, tracking, date coding, etc. Several sets of dynamic data can be specified on the command line. Data can be provided as an array of bytes or as a null-terminated string.
The cyclone handle number must be specified as part of the dynamic data programming parameter. This allows various dynamic data to be programmed into targets associated with each Cyclone open. If only one Cyclone is started, the value 1 is used. If three cyclones were specified on the command line, they would be numbered 1, 2, and 3 on the command line in order from left to right.
The syntax for programming dynamic data as an array of bytes is:
-putdynamicdata = [cyclone number], [address], [data]
The syntax for programming dynamic data as a null-terminated string is:
-putdynamicstring = [cyclone number], [address], [string]
In the following example, we program both a unique user-generated serial number and a unique user-generated IP address string into two different destinations that are connected to two different Cyclones:
Restoring success / failure results from Python / Bash / Batch / etc.
The Cyclone Control Console not only displays success and error information as strings written in the console, but also returns a corresponding error code to the operating system on the PC. An application or different scripting languages can be used to test this error code. A zero error code indicates successful operation and a non-zero error code indicates an error.
Here is an example of a Python script that can successfully restore success / failure information from the Cyclone Control Console:
Import subprocess
import sys
P = subprocess.run ("cyclonecontrolconsole -cyclone = Agnes -launchimage = green_serial", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
print ("STDOUT print:")
print (P.stdout.decode ())
if P.returncode == 0:
print ("programmed successfully!")
otherwise:
print ("Programming failed !!! with error code" + str (P.returncode))
sys.exit (1)
Here is an example of a Windows batch file that can be used to successfully restore success / failure information from the Cyclone Control Console:
cyclonecontrolconsole -cyclone = Agnes -launchimage = green_serial
When ERRORLEVEL 1 no longer occurs
echo programmed successfully!
finished
:An error has occurred
Echo programming failed !!!!!
: done
Here is an example of a bash shell script that can successfully restore success / failure information from the Cyclone Control Console:
#! / bin / bash
cyclonecontrolconsole -cyclone = Agnes -launchimage = green_serial
errorReturn = $?
if [$ errorReturn == 0]; then
Echo 'Successfully programmed!'
otherwise
echo 'programming failed !!!!! with the error code '$ errorReturn
Exit 1
fi
2. Group programming with the Cyclone Control SDK
PEmicro's Cyclone Control SDK provides developers with a dynamically loadable shared library (DLL or SO), sample application code, and supporting documentation so that custom software applications can control Cyclone directly. Languages and environments such as C, C ++, Delphi, C #, Java, Python and Labview are supported.
Binary data information, algorithm information, programming processes and other settings are saved together in a SAP image, which is saved directly in the FLASH memory of the Cyclone. Programming processes can be started at the push of a button on the Cyclone. However, the SDK allows a PC to give the Cyclone a command to start the same programming sequence and also to provide other functions, e.g. B. the ability to add dynamics data to each card to be programmed and the ability to recover error information.
Establish a connection to several Cyclones and start a programming image
Connecting to multiple Cyclones through the SDK is very easy. Below is an example of what the code in C would look like:
Here the programming processes are started on 3 separate Cyclone units, which are connected to the host PC. This also works if all Cyclones are connected to a mixture of different ports or remotely from the PC. The program then waits for completion before continuing. Basically 3 separate devices are programmed in parallel. Many Cyclone units can be controlled in parallel from a single host PC, since the programming work is carried out on the Cyclones itself.
Provision of additional dynamic data for each programmed target
In the following example, a serial number is programmed into each of the destinations associated with the three Cyclones.
For this purpose, the code calls the routine "startDynamicDataProgram". The arguments are the cyclone handle returned by "connectToCyclone", the address to be programmed (in this case the address 0), the length of the data to be programmed and a character buffer.
Check for errors
The Cyclone Control SDK allows the user to search for errors after completing a programming command (displayed when checkCycloneExecutionStatus returns 0).
To search for errors, call the routine "getNumberOfErrors" with the Cyclone handle as the only argument. The return value of this routine is the number of errors in the specified cyclone. If this value is 0, there were no errors. By using the "getErrorCode" function with the cyclone handle and the error number (1. the number of errors), the user can call up the error code number of the error that has occurred. For more information, enter the error code and pass it to the "getDescriptionOfErrorCode" routine in the Cyclone Control SDK, which returns a detailed text description of the error.
Conclusion
With the Cyclone Control Suite from PEmicro in combination with several Cyclones, it is very easy to create a gear programming setup. Because each Cyclone is an independent programmer, a mix of programming images, targets, and data can be programmed into many devices at the same time while maintaining a high level of performance. The Cyclone Control Console makes it much easier to set up group programming, while the Cyclone Control SDK enables detailed customization of the group programming control from many tools, languages and environments.
Cyclone Programmer
