TMS320F28379D: SYSCONFIG Input XBAR Config Should Select By GPIO Name If Available.

let Common   = system.getScript("/driverlib/Common.js");
let Pinmux   = system.getScript("/driverlib/pinmux.js");
let InputXbar_DevSpecific  = system.getScript("/driverlib/inputxbar/inputxbar_deviceSpecific.js");

let device_driverlib_peripheral = 
    system.getScript("/driverlib/device_driverlib_peripherals/" + 
        Common.getDeviceName().toLowerCase() + "_xbar.js");

/* Intro splash on GUI */
let longDescription = "The Input X-BAR is used to route signals from a GPIO to many different" +
                    " IP blocks such as the ADC(s), eCAP(s), ePWM(s), and external interrupts";

var inputXbarCount = 16
if (["F2837xD", "F2838xS", "F2807x"].includes(Common.getDeviceName()))
{
    inputXbarCount = 14
}


/* Array of Input X-bar configurables that are common across device families */
var config = [

];

var gpios = Common.getGPIOs();
var aios = Common.getAIOs();
var inputxbarGPIOOptions = InputXbar_DevSpecific.getExtraInputOptions();
for (var gpioIndex = 0; gpioIndex < gpios.length; gpioIndex++)
{
    inputxbarGPIOOptions.push({name: gpios[gpioIndex]});
}
for (var aioIndex = 0; aioIndex < aios.length; aioIndex++)
{
    inputxbarGPIOOptions.push({name: aios[aioIndex]});
}

var inputNumOptions = []
for (var inputNum of device_driverlib_peripheral.XBAR_InputNum)
{
    inputNumOptions.push({
        name: inputNum.name
    })
}

var inputxbarINPUTConfig = {
    name        : "inputxbarInput",
    displayName : "INPUT",
    description : 'The INPUT number for Input X-Bar',
    hidden      : false,
    default     : inputNumOptions[0].name,
    options     : inputNumOptions
}

var inputxbarGPIOConfig = {
    name        : "inputxbarGpio",
    displayName : "INPUT Source",
    description : 'GPIO for this Input X-Bar',
    hidden      : false,
    default     : inputxbarGPIOOptions[0].name,
    options     : inputxbarGPIOOptions
}


var inputxbarSelectedSourceConfig = {
    name        : "inputxbarSelectedSource",
    displayName : "Selected Source Of GPIO",
    description : 'Selected GPIO is connected to this signal in the application',
    hidden      : false,
    default     : "",
    getValue    : (inst) => {
        let modNames = Object.keys(system.modules).sort();
        for (var modName of modNames)
        {
            var mod = system.modules[modName]
            var pinmuxRequirementsFunc = mod.pinmuxRequirements;
            if (pinmuxRequirementsFunc)
            {
                for (var modInstance of mod.$instances)
                {
                    var pinmuxRequirements = pinmuxRequirementsFunc(modInstance);
                    //console.log(pinmuxRequirements)
                    for (var pinmuxReq of pinmuxRequirements)
                    {
                        var pinmuxReqName = pinmuxReq.name;
                        //console.log(pinmuxReqName)
                        if (pinmuxReq.resources)
                        {
                            //
                            // Normal Peripheral Other than GPIO
                            //
                            var peripheralName = modInstance[pinmuxReqName].$solution.peripheralName
                            //console.log(peripheralName)
                            for (var pinmuxReqInterface of pinmuxReq.resources)
                            {
                                var pinmuxReqInterfaceName = pinmuxReqInterface.name
                                var devicePinName = modInstance[pinmuxReqName][pinmuxReqInterfaceName].$solution.devicePinName
                                var peripheralPinName = modInstance[pinmuxReqName][pinmuxReqInterfaceName].$solution.peripheralPinName
                                //console.log(peripheralPinName)
                                //console.log(devicePinName)

                                var gpioNames = Pinmux.getGPIOFromDevicePinName(devicePinName)
                                //console.log(gpioNames)

                                if (gpioNames.includes(inst.inputxbarGpio))
                                {
                                    //console.log("Found: " + modInstance.$name + " = " + peripheralPinName)
                                    return (modInstance.$name + " = " + peripheralPinName)
                                }
                            }
                        }
                        else
                        {
                            //
                            // GPIO
                            //
                            var peripheralName = modInstance[pinmuxReqName].$solution.peripheralName
                            var devicePinName = modInstance[pinmuxReqName].$solution.devicePinName
                            var peripheralPinName = modInstance[pinmuxReqName].$solution.peripheralPinName
                            //console.log(peripheralName)
                            //console.log(peripheralPinName)
                            //console.log(devicePinName)
                            if (devicePinName)
                            {
                                //
                                // Normal GPIO, single bonded AGPIO
                                //
                                var gpioNames = Pinmux.getGPIOFromDevicePinName(devicePinName)
                                //console.log(gpioNames)
                                if (gpioNames.includes(inst.inputxbarGpio))
                                {
                                    //console.log("Found: " + modInstance.$name + " = " + peripheralPinName)
                                    return (modInstance.$name + " = " + peripheralPinName)
                                }
                            }
                            else
                            {
                                //
                                // Double bonded AGPIO and AIOs
                                //
                                if (peripheralName == inst.inputxbarGpio)
                                {
                                    //console.log("Found: " + modInstance.$name + " = " + peripheralName)
                                    return (modInstance.$name + " = " + peripheralName)
                                }
                            }
                        }
                    }
                    //console.log(pinmuxRequirementsFunc(modInstance))
                }
            }
        }
        //console.log(system)
        return "This source is not used by any module"
    }
}

var inputxbarLOCKConfig = {
    name        : "inputxbarLock",
    displayName : "INPUT Lock",
    description : 'Lock this Input X-Bar',
    hidden      : false,
    default     : false
}

config.push(inputxbarINPUTConfig);
config.push(inputxbarGPIOConfig);
//config.push(inputxbarSelectedSourceConfig);
config.push(inputxbarLOCKConfig);

function onValidate(inst, validation)
{
    var usedInsts = [];
    for (var instance_index in inst.$module.$instances)
    {
        var instance_obj = inst.$module.$instances[instance_index];
        usedInsts.push(instance_obj.inputxbarInput);
    }
    
    var duplicatesResult = Common.findDuplicates(usedInsts)
    
    if (duplicatesResult.duplicates.length != 0)
    {
        var allDuplicates = "";
        for (var duplicateNamesIndex in duplicatesResult.duplicates)
        {
            allDuplicates = allDuplicates + Common.stringOrEmpty(allDuplicates, ", ")
                            + duplicatesResult.duplicates[duplicateNamesIndex];
        }
        validation.logError(
            "This instance is already in use! Duplicates: " + allDuplicates,
            inst, "inputxbarInput");
    }
}

/*
 *  ======== filterHardware ========
 *  Control RX, TX Pin usage by the user specified dataDirection.
 *
 *  param component - hardware object describing signals and
 *                     resources they're attached to
 *
 *  returns Boolean indicating whether or not to allow the component to
 *           be assigned to an instance's $hardware config
 */
function filterHardware(component)
{
    return (Common.typeMatches(component.type, ["INPUTXBAR"]));
}

if (Common.onlyPinmux())
{
    //config = [];
}
var inputxbarModule = {
    peripheralName: "INPUTXBAR",
    displayName: "INPUTXBAR INPUT",
    maxInstances: inputXbarCount,
    defaultInstanceName: "myINPUTXBARINPUT",
    description: "Input X-bar",
    filterHardware : filterHardware,
    config: config,
    validate  :  onValidate,
    templates: {
        boardc : "/driverlib/inputxbar/inputxbar_input.board.c.xdt",
        boardh : "/driverlib/inputxbar/inputxbar_input.board.h.xdt"
    },
    //pinmuxRequirements    : Pinmux.inputxbarPinmuxRequirements
};


if (inputxbarModule.maxInstances <= 0)
{
    delete inputxbarModule.pinmuxRequirements;
}


exports = inputxbarModule;

let CONTEXT_CPU1= "CPU1";
let CONTEXT_CPU2= "CPU2";
let CONTEXT_SYSTEM = "system"
let Collateral  = system.getScript("/driverlib/sysconfig_collateral_links.js");

exports = {
    getBoard : getBoard,
    getBoardName : getBoardName,
    getDeviceTRM: getDeviceTRM,
    getDeviceDatasheet: getDeviceDatasheet,
    findDuplicates : findDuplicates,
    peripheralCount: peripheralCount,
    typeMatches: typeMatches,
    peripheralNames: peripheralNames,
    stringOrEmpty: stringOrEmpty,
    removeNonNumber : removeNonNumber,
    gpioNameToNumber : gpioNameToNumber,
    printDebugObject : printDebugObject,
    printDebugObjectKeys : printDebugObjectKeys,
    getGPIOs : getGPIOs,
    getAIOs : getAIOs,
    peripheralListFromSysCtl : peripheralListFromSysCtl,
    getDeviceName: getDeviceName,
    getDevicePart: getDevicePart,
    getDevicePackage: getDevicePackage,
	getSDK: getSDK,
	onlyPinmux: onlyPinmux,
	CLB_isType1 : CLB_isType1,
	CLB_isType1_Type2 : CLB_isType1_Type2,
	CLB_isType2 : CLB_isType2,
    autoForce : autoForce,
    autoForceMultiple : autoForceMultiple,
    SYSCLK_getMaxMHz : SYSCLK_getMaxMHz,
	getConfigNameRecursive: getConfigNameRecursive,
    getConfigsRecursive: getConfigsRecursive,
    printConfigsInfo : printConfigsInfo,
    getCollateralFindabilityList : getCollateralFindabilityList,
	zero_to_15        : [
        { name: 0 },
        { name: 1 },
        { name: 2 },
        { name: 3 },
        { name: 4 },
        { name: 5 },
        { name: 6 },
        { name: 7 },
        { name: 8 },
        { name: 9 },
        { name: 10 },
        { name: 11 },
        { name: 12 },
        { name: 13 },
        { name: 14 },
        { name: 15 },
	],
	zero_to_16        : [
        { name: 0 },
        { name: 1 },
        { name: 2 },
        { name: 3 },
        { name: 4 },
        { name: 5 },
        { name: 6 },
        { name: 7 },
        { name: 8 },
        { name: 9 },
        { name: 10 },
        { name: 11 },
        { name: 12 },
        { name: 13 },
        { name: 14 },
        { name: 15 },
        { name: 16 },
	],

    CONTEXT_CPU1: CONTEXT_CPU1,
    CONTEXT_CPU2: CONTEXT_CPU2,
    isContextCPU1: isContextCPU1,
    isContextCPU2: isContextCPU2,
    isMultiCoreSysConfig : isMultiCoreSysConfig,
    isMultiCoreDevice : isMultiCoreDevice,
    getModuleForCore : getModuleForCore,
    getContextNames: getContextNames,
    getAllModulesForCore: getAllModulesForCore,
    getModulePaths, getModulePaths,
    getContextDisplayName: getContextDisplayName,
    getOtherContextNames: getOtherContextNames,
    isModuleOnThisContext: isModuleOnThisContext,
    isModuleOnAnyContext: isModuleOnAnyContext,
    isModuleOnOtherContext: isModuleOnOtherContext,
    getModuleForTheFirstAvailableCore : getModuleForTheFirstAvailableCore,
    removeArrayFromArray : removeArrayFromArray,
    getSYSCLK: getSYSCLK,
    getClockTree : getClockTree,
};

function getSYSCLK(cpu)
{
    var clockTree = getClockTree();
    if (clockTree){

        if (isMultiCoreDevice())
        {
            if (!cpu)
            {
                if (isContextCPU1())
                {
                    cpu = "1"
                    return clockTree["CPU" + cpu + "_SYSCLK"].in
                }
                else
                {
                    cpu = "2"
                    
                    return clockTree["CPU" + cpu + "_SYSCLK"].in
                }
            }
        }
        else
        {
            return clockTree["SYSCLK"].in
        }
    }
    else
    {
        return SYSCLK_getMaxMHz()
    }
}

function removeArrayFromArray(arrSource, arrRem)
{
    return arrSource.filter( function( el ) {
      return !arrRem.includes( el );
    } );
}


function getContextDisplayName(cntxName)
{
    return (cntxName == CONTEXT_SYSTEM? CONTEXT_CPU1: cntxName)
}

function isContextCPU1()
{
    if (system.context == CONTEXT_CPU1 || system.context == CONTEXT_SYSTEM)
    {
        return true;
    }
    return false
}

function isContextCPU2()
{
    if (system.context == CONTEXT_CPU2)
    {
        return true;
    }
    return false
}

function getOtherContextNames()
{
    var contextNames = Object.keys(system.contexts)
    return contextNames.filter(e => e !== system.context);
}

function isModuleOnThisContext(moduleName)
{
    return system.modules[moduleName]?true:false;
}

function isModuleOnAnyContext(moduleName)
{
    var cntxs = getContextNames();
    for (var cntx of cntxs){
        if (getModuleForCore(moduleName, cntx)){
            return true;
        }
    }
    return false;
}

function isModuleOnOtherContext(moduleName)
{
    var cntxs = getOtherContextNames();
    for (var cntx of cntxs){
        if (getModuleForCore(moduleName, cntx)){
            return true;
        }
    }
    return false;
}

function getContextNames()
{
    var contextNames = Object.keys(system.contexts)
    return contextNames;
}

//
// Returns true only when the multi-core is laucnhed in sysconfig
// If a multi-core device is launched in signle view it wont return true.
//
function isMultiCoreSysConfig()
{   
    return (getContextNames().length > 1);
}

function isMultiCoreDevice()
{   
    return (system.context.includes("CPU"));
}

function getAllModulesForCore(coreName)
{
    let context = system.contexts[coreName];
    let modules = context ? context.system.modules : {};

    return modules;
}

//
// Handles getting clocktree for multi-core this for multi-core
//
function getClockTree()
{
    var contextNames = getContextNames();
    var mainContext = "system"
    if (contextNames.includes("CPU1"))
    {
        mainContext = "CPU1"
    }
    let context = system.contexts[mainContext];
    let clocktree = context ? context.system.clockTree : null;

    if (system.deviceData.clockTree)
    {
        return clocktree
    }
    else
    {
        return null
    }
}

function getModuleForCore(moduleName, coreName)
{
    let context = system.contexts[coreName];
    let modules = context ? context.system.modules : {};
    let module = modules[moduleName];

    return module;
}

function getModuleForTheFirstAvailableCore(moduleName)
{
    var cntxs = getContextNames();
    for (var cntx of cntxs){
        var mod = getModuleForCore(moduleName, cntx)
        if (mod){
            return mod;
        }
    }
    return null;
}

function getModulePaths(modules)
{
    return Object.keys(modules).sort();;
}

function getBoard()
{
    return system.deviceData.board;
}


function getBoardName()
{
    if (system.deviceData.board)
    {
        return system.deviceData.board.name;
    }
    return null;
}


function getConfigNameRecursive(arrayConfigs)
{
    var configNames = [];
    for (var modConfig of arrayConfigs)
    {        
        if (modConfig.config)
        {
            configNames = configNames.concat(getConfigNameRecursive(modConfig.config))
        }
        else
        {
            var modConfigName = modConfig.name;
            configNames.push(modConfigName);
        }
    }
    return configNames;
}

function getConfigsRecursive(arrayConfigs)
{
    var configNames = [];
    for (var modConfig of arrayConfigs)
    {        
        if (modConfig.config)
        {
            configNames = configNames.concat(getConfigsRecursive(modConfig.config))
        }
        else
        {
            var modConfigName = modConfig;
            configNames.push(modConfigName);
        }
    }
    return configNames;
}

function printConfigsInfo(configByName)
{
    // for (const key in configByName) {
    //     console.log(key);
    //     console.log(configByName[key].name)
    //     console.log(configByName[key].displayName)
    //     console.log(configByName[key].default)
    //     console.log(configByName[key].options)
    // }
    console.log(JSON.stringify(configByName, null, 4));
}


function autoForceMultiple(module_names_paths)
{
    return (function (){
        return module_names_paths
    })

}

function autoForce(module_name, module_path)
{
    return (function (){
        return [{
            name      : module_name,
            moduleName: module_path,
            hidden    : false
        }]
    })

}

function findDuplicates(arrayToCheck)
{
    const count = arrayToCheck =>
      arrayToCheck.reduce((a, b) => ({ ...a,
        [b]: (a[b] || 0) + 1
      }), {})

    const duplicates = dict =>
      Object.keys(dict).filter((a) => dict[a] > 1)

    return {count: count(arrayToCheck), duplicates: duplicates(count(arrayToCheck))};
}

function onlyPinmux()
{
	return false;
}

function getSDK()
{
	var sdk = system.getScript("/.metadata/sdk.json");

    return sdk;
}

function getDeviceName()
{
	var deviceName = system.deviceData.device;
	return deviceName
}

function getDevicePart()
{
    var devicePart = system.deviceData.part;
    return devicePart
}

function getDevicePackage()
{
    var devicePackage = system.deviceData.package;
    return devicePackage
}

function stringOrEmpty(stringToCheck, stringToAdd)
{
    if (stringToCheck != "")
    {
        return stringToAdd;
    }
    return "";
}

function printDebugObject(obj)
{
	if (obj == null)
	{
		console.log("Object is null");
		return;
	}
    var keys = Object.keys(obj);
    for (var key in keys)
	{
    	console.log(keys[key] + " : " + obj[keys[key]]);
    }
}

function printDebugObjectKeys(obj)
{
    if (obj == null)
    {
        console.log("Object is null");
        return;
    }
    var keys = Object.keys(obj);
    console.log("Keys:")
    for (var key in keys)
    {
        console.log(keys[key]);
    }
}

function removeNonNumber(stringToCheck)
{
	var numberOnly = "";
    if (stringToCheck != "")
    {
    	for (var i = 0; i < stringToCheck.length; i++)
    	{
    		if ("0123456789".includes(stringToCheck[i]))
    		{
    			numberOnly += stringToCheck[i];
    		}
    	}
        return numberOnly;
    }
    return "";
}

//As soon a number is detected and then more characters are detected, exit.
//Good for usecases like GPIO180_X2, the 2 is not added to the numbers
function gpioNameToNumber(stringToCheck)
{
	var numberOnly = "";
	var numbersDetected = false;
    if (stringToCheck != "")
    {
    	for (var i = 0; i < stringToCheck.length; i++)
    	{
    		if ("0123456789".includes(stringToCheck[i]))
    		{
    			numberOnly += stringToCheck[i];
    			numbersDetected = true;
    		}
    		else
    		{
    			if (numbersDetected)
        		{
        			return numberOnly;
        		}
    		}
    	}
        return numberOnly;
    }
    return "";
}

function getGPIOs()
{
	var allGpioNames = [];
	let gpio = system.deviceData.interfaces.GPIO;
	if (gpio != null)
	{
		for (var i = 0; i < gpio.peripherals.length; i++)
		{
			var gpioperiph = gpio.peripherals[i];
			allGpioNames.push(gpioperiph.name);
		}
	}
	return allGpioNames
}

function getAIOs()
{
	var allAioNames = [];
	let aio = system.deviceData.interfaces.AIO;
	if (aio != null)
	{
		for (var i = 0; i < aio.peripherals.length; i++)
		{
			var aioperiph = aio.peripherals[i];
			allAioNames.push(aioperiph.name);
		}
	}
	return allAioNames;
}

function peripheralListFromSysCtl(peripheralName, sysctl)
{
    var peripherals = []
    sysctl.SysCtl_PeripheralPCLOCKCR.forEach((element, index) => {
        var split_by_underscore = element.name.split("_")
        var peripheralInst = split_by_underscore[split_by_underscore.length - 1];
        if (peripheralInst.startsWith(peripheralName))
        {
            peripherals.push(peripheralInst)
        }
    });
    return peripherals
}

function peripheralCount(peripheralType)
{
	let peripherals = system.deviceData.peripherals
	let numberOfPeripherals = Object.keys(peripherals).length;
	var count = 0;

	//console.log(numberOfPeripherals);

	for (var peripheral in peripherals) {

	  	try
	  	{
	  		var interfaces = peripherals[peripheral]["interfaces"];
	  		for (var interfaceType in interfaces)
	  		{
	  			if (peripheralType == interfaceType)
	  			{
	  				peripheralNames = interfaces[interfaceType].peripherals;
	  				//console.log(peripheralNames);
	  				count = peripheralNames.length;
					//console.log(count);
	  				return count;
	  			}
			}
		}
		catch(err) {

		}
	}
	if (count == 0)
	{
		return -1;
	}
    return (count);
}


function peripheralNames(peripheralType)
{
	let peripherals = system.deviceData.peripherals
    //console.log(peripherals);
	let numberOfPeripherals = Object.keys(peripherals).length;
	var names = [];

	//console.log(numberOfPeripherals);

	for (var peripheral in peripherals) {

	  	try
	  	{
	  		var interfaces = peripherals[peripheral]["interfaces"];
            //console.log(interfaces);
	  		for (var interfaceType in interfaces)
	  		{
	  			if (peripheralType == interfaceType)
	  			{
	  				names = interfaces[interfaceType].peripherals;
	  				//console.log(names);
	  				return names;
	  			}
			}
		}
		catch(err) {

		}
	}
    //console.log(names);
    return (names);
}


function CLB_isType1() {
    return ["F28004x"].includes(getDeviceName());
}

function CLB_isType2() {
    return ["F28002x", "F2838x", "F28003x"].includes(getDeviceName());
}

function CLB_isType1_Type2(){
    return (CLB_isType1() | CLB_isType2());
}

function SYSCLK_getMaxMHz()
{
    var sysclk_max = {
        F2807x      : 120,
        F2837xS     : 200,
        F2837xD     : 200,
        F2838x      : 200,
        F28004x     : 100,
        F28002x     : 100,
        F28003x     : 120,
        F280013x    : 120,
        F280015x    : 120,
        F28P65x     : 200
    }
    return sysclk_max[getDeviceName()];
}



/*
 *  ======== typeMatches ========
 *  Check that HW signal type matches a specified array of types
 *
 *  Example: within a module's filterHardware(component) method:
 *      for (sig in component.signals) {
 *          let type = component.signals[sig].type;
 *          if (Common.typeMatches(type, ["PWM", "DOUT"])) {
 *              :
 *          }
 *      }
 *
 *  type      - a string or array of strings that are valid signal types
 *  nameArray - array of signal name types that must match one of the signal
 *              types named by type
 *
 *  Returns true iff nameArray contains at least one type name that's
 *          specified the type parameter.
 */
function typeMatches(type, nameArray)
{
    let options = {};

    if (type instanceof Array || typeof type == "object") {
        for (var i = 0; i < type.length; i++) {
            options[type[i]] = 1;
        }
    }
    else if (typeof type == "string" || type instanceof String) {
        options[type] = 1;
    }

    for (var i = 0; i < nameArray.length; i++) {
        let name = nameArray[i];
        if (name in options) {
            return (true);
        }
    }

    return (false);
}

function getDeviceTRM()
{
    var deviceTRMLinks = {
        "F2807x":   "https://www.ti.com/lit/spruhm9",
        "F2837xS":  "https://www.ti.com/lit/spruhx5",
        "F2837xD":  "https://www.ti.com/lit/spruhm8",
        "F28004x":  "https://www.ti.com/lit/sprui33",
        "F2838x":   "https://www.ti.com/lit/spruii0",
        "F28002x":  "https://www.ti.com/lit/spruin7",
        "F28003x":  "https://www.ti.com/lit/spruiw9",
        "F280013x": "https://www.ti.com/lit/spruix1",
        "F280015x": "https://www.ti.com/lit/spruiy4"
    }

    var deviceTRMLink = deviceTRMLinks[getDeviceName()];
    if (deviceTRMLink)
    {
        return deviceTRMLink
    }
    else
    {
        return ""
    }
}

function getDeviceDatasheet()
{
    var deviceDSLinks = {
        "F2807x":   "https://www.ti.com/lit/gpn/tms320f28075",
        "F2837xS":  "https://www.ti.com/lit/gpn/tms320f28377s",
        "F2837xD":  "https://www.ti.com/lit/gpn/tms320f28379d",
        "F28004x":  "https://www.ti.com/lit/gpn/tms320f280049",
        "F2838x":   "https://www.ti.com/lit/gpn/tms320f28388d",
        "F28002x":  "https://www.ti.com/lit/gpn/tms320f280025c",
        "F28003x":  "https://www.ti.com/lit/gpn/tms320f280039c",
        "F280013x": "https://www.ti.com/lit/gpn/tms320f2800137",
        "F280015x": "https://www.ti.com/lit/gpn/tms320f2800157"
    }

    var deviceDSLink = deviceDSLinks[getDeviceName()];
    if (deviceDSLink)
    {
        return deviceDSLink
    }
    else
    {
        return ""
    }
}

function getCollateralFindabilityList(peripheral)
{
    var res = "";
    //*********************************************************************
    // GETTING STARTED WITH SYSCONFIG
    //*********************************************************************
    res += "**"
    res += "Sysconfig Resources"
    res += "**\n"
    res += "*   [C2000 SysConfig - Step by Step Guide on How to use C2000 SysConfig](https://www.ti.com/lit/spracx3)\n"
    res += "*   [C2000 SysConfig - Speed Up Development With C2000 Real-Time MCUs Using SysConfig](https://www.ti.com/lit/spry341)\n"
    res += "\n"

    var deviceGPN = getDeviceName();
    var cdata = Collateral.getCollateralData();
    // console.log(cdata[peripheral]);
    for (var i=0; i < cdata[peripheral].length; i++)
    {
        //*********************************************************************
        // CATEGORY TITLE
        //*********************************************************************
        var category_dict = cdata[peripheral][i];
        // console.log(category_dict['category_displayName'])

        // first check if the category is used by this device at all (not filtered out from this device)
        var category_used = false;
        for (var j=0; j < category_dict['content'].length; j++)
        {
            var content_dict = category_dict['content'][j]
            if (    ('devices' in content_dict && content_dict['devices'].includes(deviceGPN)) ||
                    !('devices' in content_dict)
            )
            {
                category_used = true;

                // break out of loop on the first occurrence of a collateral that is used for this device
                break;
            }
        }

        // now if it was used, go ahead and add the category title
        if (category_used)
        {
            res += "\n# **" +
                    category_dict['category_displayName'] +
                    "**\n"
        }

        //*********************************************************************
        // COLLATERAL LINKS WITHIN CATEGORY
        //*********************************************************************
        // add each content item that applies
        for (var j=0; j < category_dict['content'].length; j++)
        {
            var content_dict = category_dict['content'][j]
            if (    ('devices' in content_dict && content_dict['devices'].includes(deviceGPN)) ||
                    !('devices' in content_dict)
            )
            {
                // italicize if this is an App Note
                if ( 'appNote' in content_dict )
                {
                    res += "*   *[" +
                            content_dict['name'] +
                            "](" +
                            content_dict['url'] +
                            ")*"
                }
                // don't italicize if not an app note
                else
                {
                    res += "*   [" +
                            content_dict['name'] +
                            "](" +
                            content_dict['url'] +
                            ")"
                }

                // add a (Video) tag if this is a video
                if ('video' in content_dict)
                {
                    res += " (Video)"
                }

                // now add a newline to finish up the normal bullet
                res += "\n"

                //*********************************************************************
                // EXTRA TEXT FOR THIS COLLATERAL LINK
                //*********************************************************************
                // add the "Extra Text" as a sub-bullet if it exits
                if ('description' in content_dict)
                {
                    res += "    *   " +
                            content_dict['description'] +
                            "\n"
                }
            }
        }

    }

    //*********************************************************************
    // DEVICE TRM
    //*********************************************************************
    // finally, add the device TRM to the bottom of the list
    // res += "---\n"
    res += "\n# ***"
    res += "["+deviceGPN+" Technical Reference Manual](" + getDeviceTRM() + ")"
    res += "***\n"


    return res
}