use of net.sourceforge.usbdm.peripheralDatabase.DevicePeripherals in project usbdm-eclipse-plugins by podonoghue.
the class CreatePeripheralDatabase method createExpandedSvdFilesFromList.
/**
* Produces expanded (single file per target) SVD files (based on deviceList.xml)
*
* @param sourceFolderPath Should contain "DeviceList.xml" file
* @param destinationFolderPath Where to write expanded files to
*
* @throws Exception
*/
static void createExpandedSvdFilesFromList(Path sourceFolderPath, Path destinationFolderPath, boolean optimise) throws Exception {
FileFilter fileFilter = new FileFilter(firstFileToProcess, firstFileToReject);
if (Files.exists(destinationFolderPath)) {
System.err.flush();
System.err.println("Destination already exists " + destinationFolderPath);
return;
}
// Set optimisations
ModeControl.setExtractComplexStructures(optimise);
ModeControl.setExtractDerivedPeripherals(optimise);
ModeControl.setExtractSimpleRegisterArrays(optimise);
ModeControl.setMapFreescalePeriperalCommonNames(optimise);
ModeControl.setGenerateFreescaleRegisterMacros(optimise);
ModeControl.setRegenerateAddressBlocks(optimise);
// ModeControl.setExtractCommonPrefix(optimise);
destinationFolderPath.toFile().mkdir();
DeviceFileList deviceFileList = new DeviceFileList(sourceFolderPath.resolve(DEVICE_LIST_FILENAME));
ArrayList<DeviceSvdInfo> list = deviceFileList.getArrayList();
for (DeviceSvdInfo pair : list) {
if (fileFilter.skipFile(pair.deviceName)) {
continue;
}
System.err.println("Processing File : \"" + pair.svdName + "\"");
try {
// Read device description
DevicePeripherals devicePeripherals = new DevicePeripherals(sourceFolderPath.resolve(pair.svdName + ".svd.xml"));
// Optimise peripheral database
devicePeripherals.optimise();
devicePeripherals.setName(pair.deviceName);
// Create SVD file
Path svdFilePath = destinationFolderPath.resolve(devicePeripherals.getName() + ".svd.xml");
System.err.println("Creating : \"" + svdFilePath + "\"");
devicePeripherals.writeSVD(svdFilePath);
} catch (Exception e) {
e.printStackTrace();
}
}
}
use of net.sourceforge.usbdm.peripheralDatabase.DevicePeripherals in project usbdm-eclipse-plugins by podonoghue.
the class CreatePeripheralDatabase method createReducedDeviceList.
/**
* Creates a minimal set of device SVD files by looking for equivalent devices.
* A separate XML file is created that maps a device to a SVD file (deviceList.xml).
* Note: The target directory will end up with expanded SVD files!
* Note: Source directory may contain reduced SVD files.
*
* @param sourceFolderPath Directory containing SVD files to process (all files ending in ".svd.xml").
* @param destinationFolderPath Where to write destination files.
*
* @throws Exception
*/
public static void createReducedDeviceList(Path sourceFolderPath, Path destinationFolderPath) throws Exception {
FileFilter fileFilter = new FileFilter(firstFileToProcess, firstFileToReject);
if (Files.exists(destinationFolderPath)) {
System.err.flush();
System.err.println("Destination already exists " + destinationFolderPath);
return;
}
ArrayList<DevicePeripherals> deviceList = new ArrayList<DevicePeripherals>();
// Set optimizations
ModeControl.setExtractComplexStructures(false);
ModeControl.setExtractDerivedPeripherals(false);
ModeControl.setExtractSimpleRegisterArrays(false);
ModeControl.setMapFreescalePeriperalCommonNames(false);
ModeControl.setGenerateFreescaleRegisterMacros(false);
ModeControl.setRegenerateAddressBlocks(false);
ModeControl.setExpandDerivedPeripherals(true);
ModeControl.setExpandDerivedRegisters(false);
int maxDevices = 500;
Files.createDirectory(destinationFolderPath);
DirectoryStream<Path> sourceFolderStream = Files.newDirectoryStream(sourceFolderPath);
//
for (Path svdSourceFile : sourceFolderStream) {
// Create database of all devices
if (Files.isRegularFile(svdSourceFile)) {
String fileName = svdSourceFile.getFileName().toString();
if (fileFilter.skipFile(fileName)) {
continue;
}
if (fileName.endsWith(".svd.xml")) {
// System.err.println("Processing File : \""+svdSourceFile.getName()+"\"");
try {
// Read device description
DevicePeripherals device = new DevicePeripherals(svdSourceFile);
// Don't optimise as we want flat files for editing/checking
// device.optimise();
boolean foundEquivalent = false;
for (DevicePeripherals searchPeripheral : deviceList) {
if (searchPeripheral.equivalentStructure(device)) {
searchPeripheral.addEquivalentDevice(device.getName());
foundEquivalent = true;
}
}
if (!foundEquivalent) {
deviceList.add(device);
System.err.println("New " + device.getName());
} else {
System.err.println("Equivalent " + device.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
if (maxDevices-- < 0) {
break;
}
}
}
System.err.println();
// Copy devices to target directory (expanded!)
// Produce sorted list of device->svd file
// List of copied devices to check for mapping clashes
ArrayList<Pair> devicePairList = new ArrayList<Pair>();
for (DevicePeripherals device : deviceList) {
String deviceName = device.getName();
// Add reference to self
for (String equivalentDevice : device.getEquivalentDevices()) {
// Add references from other devices
devicePairList.add(new Pair(equivalentDevice, deviceName));
}
device.writeSVD(destinationFolderPath.resolve(deviceName + ".svd.xml"));
}
sortDeviceNames(devicePairList);
// Create deviceList.xml
File deviceListFile = destinationFolderPath.resolve(DEVICE_LIST_FILENAME).toFile();
PrintWriter writer = null;
try {
writer = new PrintWriter(deviceListFile);
writer.print(xmlPreamble);
writer.print(openDeviceList);
for (Pair pair : devicePairList) {
writer.print(String.format(deviceEntry, "<device name=\"" + pair.deviceName + "\">", pair.fileName));
}
writer.print(closeDeviceList);
writer.print(xmlPostamble);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (writer != null) {
writer.close();
}
}
Files.copy(MAIN_FOLDER.getParent().resolve(CMSIS_SCHEMA_FILENAME), destinationFolderPath.resolve(CMSIS_SCHEMA_FILENAME), StandardCopyOption.REPLACE_EXISTING);
Files.copy(MAIN_FOLDER.getParent().resolve(DEVICE_LIST_SCHEMA_FILENAME), destinationFolderPath.resolve(DEVICE_LIST_SCHEMA_FILENAME), StandardCopyOption.REPLACE_EXISTING);
}
use of net.sourceforge.usbdm.peripheralDatabase.DevicePeripherals in project usbdm-eclipse-plugins by podonoghue.
the class CreatePeripheralDatabase method createHeaderFiles.
/*
* *************************************************************************************************************************************
* *************************************************************************************************************************************
*/
/**
* Produces multiple header files from multiple device SVD files
* Optimisations may be applied to the SVD file before creating the header file.
* Header file name is based on device name in SVD file - not the source file name
*
* sourceFolderPath/*.svd.xml +-> destinationPath/*.h
*
* @param sourceFolderPath - Folder containing SVD files (must have .svd.xml extension, otherwise ignored)
* @param destinationFolderPath - Folder to write created header file to
* @param removeFolder - Delete destination folder
* @throws Exception
*/
public static void createHeaderFiles(Path sourceFolderPath, Path destinationFolderPath, boolean removeFolder) throws Exception {
FileFilter fileFilter = new FileFilter(firstFileToProcess, firstFileToReject);
if (Files.exists(destinationFolderPath)) {
if (!removeFolder) {
System.err.println("Destination already exists " + destinationFolderPath.toString());
} else {
System.err.println("Destination already exists - deleting " + destinationFolderPath.toString());
removeDirectoryTree(destinationFolderPath);
}
}
if (!Files.exists(destinationFolderPath)) {
Files.createDirectory(destinationFolderPath);
}
DirectoryStream<Path> sourceFolderStream = Files.newDirectoryStream(sourceFolderPath);
int deviceCount = 5000;
for (Path svdSourceFile : sourceFolderStream) {
if (deviceCount-- == 0) {
break;
}
if (Files.isRegularFile(svdSourceFile)) {
String fileName = svdSourceFile.getFileName().toString();
if (fileFilter.skipFile(fileName)) {
continue;
}
if (fileName.endsWith(".svd.xml")) {
System.err.println("Processing File : \"" + fileName + "\"");
// Read device description
DevicePeripherals devicePeripherals = new DevicePeripherals(svdSourceFile);
// Optimise peripheral database
devicePeripherals.optimise();
devicePeripherals.sortPeripherals();
// Create header file
Path headerFilePath = destinationFolderPath.resolve(devicePeripherals.getName().toString() + ".h");
System.err.println("Creating : \"" + headerFilePath + "\"");
devicePeripherals.writeHeaderFile(headerFilePath);
}
}
}
}
use of net.sourceforge.usbdm.peripheralDatabase.DevicePeripherals in project usbdm-eclipse-plugins by podonoghue.
the class CreatePeripheralDatabase method createHeaderFilesFromList.
/**
* Produces a set of header files from SVD files (based on deviceList.xml)
* Each header file represent a device family with similar peripherals
*
* @param sourceFolderPath Should contain "DeviceList.xml" file
* @param destinationFolderPath Where to write header files to
* @param removeFolder Destination folder will be deleted (otherwise files just overwrite/accumulate)
*
* @throws Exception
*/
static void createHeaderFilesFromList(Path sourceFolderPath, Path destinationFolderPath, boolean removeFolder) throws Exception {
FileFilter fileFilter = new FileFilter(firstFileToProcess, firstFileToReject);
if (Files.exists(destinationFolderPath)) {
if (!removeFolder) {
System.err.println("Destination already exists " + destinationFolderPath);
} else {
System.err.println("Destination already exists - deleting " + destinationFolderPath);
removeDirectoryTree(destinationFolderPath);
}
}
// Set options
ModeControl.setFreescaleFieldNames(true);
ModeControl.setMapFreescalePeriperalCommonNames(true);
ModeControl.setGenerateFreescaleRegisterMacros(false);
ModeControl.setUseShiftsInFieldMacros(true);
// Don't optimise
ModeControl.setExtractComplexStructures(false);
ModeControl.setExtractDerivedPeripherals(false);
ModeControl.setExtractSimpleRegisterArrays(false);
ModeControl.setRegenerateAddressBlocks(false);
destinationFolderPath.toFile().mkdir();
DeviceFileList deviceFileList = new DeviceFileList(sourceFolderPath.resolve(DEVICE_LIST_FILENAME));
// Get full list of devices
ArrayList<DeviceSvdInfo> list = deviceFileList.getArrayList();
// Map of already copied files to prevent multiple copying
HashSet<String> copiedFiles = new HashSet<String>();
for (int index = 0; index < list.size(); index++) {
DeviceSvdInfo pair = list.get(index);
if (fileFilter.skipFile(pair.deviceName)) {
continue;
}
System.err.println("Processing File : \"" + pair.deviceName + "\"");
try {
// Don't produce the same file!
if (copiedFiles.contains(pair.svdName)) {
continue;
}
copiedFiles.add(pair.svdName);
// Read device description
DevicePeripherals devicePeripherals = new DevicePeripherals(sourceFolderPath.resolve(pair.svdName + ".svd.xml"));
devicePeripherals.sortPeripherals();
devicePeripherals.setName(pair.svdName);
devicePeripherals.addEquivalentDevice(pair.deviceName);
for (int index2 = index + 1; index2 < list.size(); index2++) {
if (pair.svdName.equalsIgnoreCase(list.get(index2).svdName)) {
devicePeripherals.addEquivalentDevice(list.get(index2).deviceName);
}
}
// Create header file
Path headerFilePath = destinationFolderPath.resolve(devicePeripherals.getName() + ".h");
System.err.println("Creating : \"" + headerFilePath + "\"");
devicePeripherals.writeHeaderFile(headerFilePath);
} catch (Exception e) {
e.printStackTrace();
}
}
}
use of net.sourceforge.usbdm.peripheralDatabase.DevicePeripherals in project usbdm-eclipse-plugins by podonoghue.
the class TestVectorTable method testVectorTable.
static void testVectorTable(String device) throws Exception {
// Get description of all peripherals for device
DevicePeripheralsFactory factory = new DevicePeripheralsFactory();
DevicePeripherals devicePeripherals = factory.getDevicePeripherals(device);
if (devicePeripherals == null) {
// Return empty model
System.err.println("Failed");
return;
}
VectorTable vt = devicePeripherals.getVectorTable();
String cVectorTable = vt.getCVectorTableEntries();
System.err.print(cVectorTable);
}
Aggregations