archive-gh-me/Espruino
1
0
Fork 0
mirror of https://github.com/espruino/Espruino.git synced 2025-12-08 19:06:15 +00:00
Code Issues Projects Releases Wiki Activity
Espruino/scripts/build_platform_config.py
Gordon Williams 138452fb65 Merging Dickens-specific changes into master
2023-09-27 14:57:47 +01:00

552 lines
22 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/env python
# This file is part of Espruino, a JavaScript interpreter for Microcontrollers
#
# Copyright (C) 2013 Gordon Williams <gw@pur3.co.uk>
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# ----------------------------------------------------------------------------------------
# Reads board information from boards/BOARDNAME.py and uses it to generate a header file
# which describes the available peripherals on the board
# ----------------------------------------------------------------------------------------
import subprocess;
import re;
import json;
import sys;
import os;
import importlib;
import common;
scriptdir = os.path.dirname(os.path.realpath(__file__))
# added os.path.normpath to get a correct reckognition of the subsequent path
# by Ubuntu 14.04 LTS
basedir = os.path.normpath(scriptdir+"/../")
# added leading / as a consequence of use of os.path.normpath
sys.path.append(basedir+"/scripts");
sys.path.append(basedir+"/boards");
import pinutils;
# -----------------------------------------------------------------------------------------
# Now scan AF file
print("Script location "+scriptdir)
if len(sys.argv)!=3:
print("ERROR, USAGE: build_platform_config.py BOARD_NAME HEADERFILENAME")
exit(1)
boardname = sys.argv[1]
headerFilename = sys.argv[2]
print("HEADER_FILENAME "+headerFilename)
print("BOARD "+boardname)
# import the board def
board = importlib.import_module(boardname)
pins = board.get_pins()
# -----------------------------------------------------------------------------------------
#allow to override board name so we can build for same board from multiple board files
if "boardname" in board.info:
boardname = board.info["boardname"]
print("BOARDNAME "+boardname)
LINUX = board.chip["family"]=="LINUX"
EMSCRIPTEN = board.chip["family"]=="EMSCRIPTEN"
if not "default_console" in board.info:
board.info["default_console"] = "EV_SERIAL1"
has_bootloader = False
if "bootloader" in board.info and board.info["bootloader"]!=0:
has_bootloader = True
variables=board.info["variables"]
# variables from board-file can bw overwritten. Be careful with this option.
# usually the definition in board file are already the maximum, and adding some more will corrupt firmware
if 'VARIABLES' in os.environ:
variables=int(os.environ['VARIABLES'])
if variables==0: var_size = 16
elif variables<1023: var_size = 12 # the 'packed bits mean anything under 1023 vars gets into 12 byte JsVars
else: var_size = 16
var_cache_size = var_size*variables
flash_needed = var_cache_size + 4 # for magic number
print("Variables = "+str(variables))
print("JsVar size = "+str(var_size))
print("VarCache size = "+str(var_cache_size))
flash_page_size = 1024
if LINUX:
flash_saved_code_pages = board.chip['flash']*1024 / flash_page_size
total_flash = flash_page_size*flash_saved_code_pages
else: # NOT LINUX
# 100xB and 103xB are mid-density, so have 1k page sizes
if board.chip["part"][:7]=="STM32F1" and board.chip["part"][10]=="B": board.chip["subfamily"]="MD";
if board.chip["family"]=="STM32F1":
flash_page_size = 1024 if "subfamily" in board.chip and board.chip["subfamily"]=="MD" else 2048
if board.chip["family"]=="STM32F2":
flash_page_size = 128*1024
if board.chip["family"]=="STM32F3":
flash_page_size = 2*1024
if board.chip["family"]=="STM32F4":
flash_page_size = 128*1024
if board.chip["family"]=="NRF51":
flash_page_size = 1024
if board.chip["family"]=="NRF52":
flash_page_size = 4*1024
if board.chip["family"]=="EFM32GG":
flash_page_size = 4*1024
if board.chip["family"]=="STM32L4":
flash_page_size = 128*1024
flash_saved_code_pages = round((flash_needed+flash_page_size-1)/flash_page_size + 0.5) #Needs to be a full page, so we're rounding up
# F4 has different page sizes in different places
total_flash = board.chip["flash"]*1024
flash_saved_code2_pages = 0
if "saved_code" in board.chip:
flash_saved_code_start = board.chip["saved_code"]["address"]
flash_page_size = board.chip["saved_code"]["page_size"]
flash_saved_code_pages = board.chip["saved_code"]["pages"]
flash_available_for_code = board.chip["saved_code"]["flash_available"]*1024
if "address2" in board.chip["saved_code"]:
flash_saved_code2_start = board.chip["saved_code"]["address2"]
flash_saved_code2_pages = board.chip["saved_code"]["pages2"]
else:
flash_saved_code_start = "(FLASH_START + FLASH_TOTAL - FLASH_SAVED_CODE_LENGTH)"
flash_available_for_code = total_flash - (flash_saved_code_pages*flash_page_size)
if has_bootloader: flash_available_for_code -= common.get_bootloader_size(board)
print("Flash page size = "+str(flash_page_size))
print("Flash pages = "+str(flash_saved_code_pages))
print("Total flash = "+str(total_flash))
print("Flash available for code = "+str(flash_available_for_code))
# -----------------------------------------------------------------------------------------
headerFile = open(headerFilename, 'w')
def codeOut(s): headerFile.write(s+"\n");
# -----------------------------------------------------------------------------------------
def die(err):
print("ERROR: "+err)
sys.exit(1)
def toPinDef(pin):
for p in pins:
if p["name"]=="P"+pin:
return str(pins.index(p))+"/* "+pin+" */";
die("Pin named '"+pin+"' not found");
def codeOutDevice(device):
if device in board.devices:
codeOut("#define "+device+"_PININDEX "+toPinDef(board.devices[device]["pin"]))
if device[0:3]=="BTN":
codeOut("#define "+device+"_ONSTATE "+("0" if "inverted" in board.devices[device] else "1"))
if "pinstate" in board.devices[device]:
codeOut("#define "+device+"_PINSTATE JSHPINSTATE_GPIO_"+board.devices[device]["pinstate"]);
if device[0:3]=="LED":
codeOut("#define "+device+"_ONSTATE "+("0" if "inverted" in board.devices[device] else "1"))
if "no_bootloader" in board.devices[device]:
codeOut("#define "+device+"_NO_BOOTLOADER 1 // don't use this in the bootloader");
def codeOutDevicePin(device, pin, definition_name):
if device in board.devices:
codeOut("#define "+definition_name+" "+toPinDef(board.devices[device][pin]))
def codeOutDevicePins(device, definition_name):
for entry in board.devices[device]:
if entry.startswith("pin_") or entry=="pin":
codeOut("#define "+definition_name+"_"+entry.upper()+" "+toPinDef(board.devices[device][entry]))
# -----------------------------------------------------------------------------------------
codeOut("""
// Automatically generated header file for """+boardname+"""
// Generated by scripts/build_platform_config.py
#ifndef _PLATFORM_CONFIG_H
#define _PLATFORM_CONFIG_H
""");
codeOut("#define PC_BOARD_ID \""+boardname+"\"")
codeOut("#define PC_BOARD_CHIP \""+board.chip["part"]+"\"")
codeOut("#define PC_BOARD_CHIP_FAMILY \""+board.chip["family"]+"\"")
codeOut("")
# Linker vars used for:
linker_end_var = "_end"; # End of RAM (eg top of stack)
linker_etext_var = "_etext"; # End of text (function) section
# External interrupt count
exti_count = 16
if board.chip["family"]=="LINUX":
board.chip["class"]="LINUX"
elif board.chip["family"]=="EMSCRIPTEN":
board.chip["class"]="EMSCRIPTEN"
elif board.chip["family"]=="STM32F1":
board.chip["class"]="STM32"
codeOut('#include "stm32f10x.h"')
elif board.chip["family"]=="STM32F2":
board.chip["class"]="STM32"
codeOut('#include "stm32f2xx.h"')
codeOut("#define STM32API2 // hint to jshardware that the API is a lot different")
elif board.chip["family"]=="STM32F3":
board.chip["class"]="STM32"
codeOut('#include "stm32f30x.h"')
codeOut("#define STM32API2 // hint to jshardware that the API is a lot different")
codeOut("#define USB_INT_DEFAULT") # hack
elif board.chip["family"]=="STM32F4":
board.chip["class"]="STM32"
codeOut('#include "stm32f4xx.h"')
codeOut('#include "stm32f4xx_conf.h"')
codeOut("#define STM32API2 // hint to jshardware that the API is a lot different")
elif board.chip["family"]=="STM32L4":
board.chip["class"]="STM32_LL"
codeOut('#include "stm32l4xx_ll_bus.h"')
codeOut('#include "stm32l4xx_ll_rcc.h"')
codeOut('#include "stm32l4xx_ll_adc.h"')
elif board.chip["family"]=="NRF51":
board.chip["class"]="NRF51"
linker_etext_var = "__etext";
linker_end_var = "end";
exti_count = 4
codeOut('#include "nrf.h"')
elif board.chip["family"]=="NRF52":
board.chip["class"]="NRF52"
linker_etext_var = "__etext";
linker_end_var = "end";
exti_count = 8
codeOut('#include "nrf.h"')
elif board.chip["family"]=="EFM32GG":
board.chip["class"]="EFM32"
linker_etext_var = "__etext";
codeOut('#include "em_device.h"')
elif board.chip["family"]=="LPC1768":
board.chip["class"]="MBED"
elif board.chip["family"]=="AVR":
board.chip["class"]="AVR"
elif board.chip["family"]=="ESP8266":
board.chip["class"]="ESP8266"
elif board.chip["family"]=="ESP32":
board.chip["class"]="ESP32"
exti_count = 40
elif board.chip["family"]=="SAMD":
board.chip["class"]="SAMD"
codeOut('#include "targetlibs/samd/include/due_sam3x.init.h"')
elif board.chip["family"]=="EMBED":
board.chip["class"]="EMBED"
else:
die('Unknown chip family '+board.chip["family"])
codeOut("#define LINKER_END_VAR "+linker_end_var);
codeOut("#define LINKER_ETEXT_VAR "+linker_etext_var);
if board.chip["class"]=="MBED":
codeOut("""
#pragma diag_suppress 1295 // deprecated decl
#pragma diag_suppress 188 // enumerated type mixed with another type
#pragma diag_suppress 111 // statement is unreachable
#pragma diag_suppress 68 // integer conversion resulted in a change of sign
""");
codeOut("""
// SYSTICK is the counter that counts up and that we use as the real-time clock
// The smaller this is, the longer we spend in interrupts, but also the more we can sleep!
#define SYSTICK_RANGE 0x1000000 // the Maximum (it is a 24 bit counter) - on Olimexino this is about 0.6 sec
#define SYSTICKS_BEFORE_USB_DISCONNECT 2
#define DEFAULT_BUSY_PIN_INDICATOR (Pin)-1 // no indicator
#define DEFAULT_SLEEP_PIN_INDICATOR (Pin)-1 // no indicator
""");
util_timer = pinutils.get_device_util_timer(board)
if util_timer!=False:
codeOut(util_timer['defines']);
codeOut("");
# ------------------------------------------------------------------------------------- Chip Specifics
codeOut("#define RAM_TOTAL ("+str(board.chip['ram'])+"*1024)")
codeOut("#define FLASH_TOTAL ("+str(board.chip['flash'])+"*1024)")
codeOut("");
if variables==0:
codeOut('#define RESIZABLE_JSVARS // Allocate variables in blocks using malloc - slow, and linux-only')
else:
codeOut("#define JSVAR_CACHE_SIZE "+str(variables)+" // Number of JavaScript variables in RAM")
if LINUX:
codeOut("#define JSVAR_MALLOC 1")
if LINUX:
codeOut("#define FLASH_START "+hex(0x10000000))
codeOut("#define FLASH_PAGE_SIZE "+str(flash_page_size))
else:
codeOut("#define FLASH_AVAILABLE_FOR_CODE "+str(int(flash_available_for_code)))
if board.chip["class"]=="EFM32":
codeOut("// FLASH_PAGE_SIZE defined in em_device.h");
else:
codeOut("#define FLASH_PAGE_SIZE "+str(flash_page_size))
if board.chip["family"]=="ESP8266":
codeOut("#define FLASH_START "+hex(0x0))
elif board.chip["family"]=="NRF52" or board.chip["family"]=="NRF51":
codeOut("#define FLASH_START "+hex(0x0))
elif board.chip["class"]=="EFM32":
codeOut("#define FLASH_START FLASH_BASE // FLASH_BASE defined in em_device.h")
else:
codeOut("#define FLASH_START "+hex(0x08000000))
if has_bootloader:
codeOut("#define BOOTLOADER_SIZE "+str(common.get_bootloader_size(board)))
codeOut("#define ESPRUINO_BINARY_ADDRESS "+hex(common.get_espruino_binary_address(board)))
codeOut("")
codeOut("#define FLASH_SAVED_CODE_START "+str(flash_saved_code_start))
codeOut("#define FLASH_SAVED_CODE_LENGTH "+str(int(flash_page_size*flash_saved_code_pages)))
if flash_saved_code2_pages:
codeOut("// Extra flash pages in external flash")
codeOut("#define FLASH_SAVED_CODE2_START "+str(flash_saved_code2_start))
codeOut("#define FLASH_SAVED_CODE2_LENGTH "+str(int(flash_page_size*flash_saved_code2_pages)))
codeOut("");
codeOut("#define CLOCK_SPEED_MHZ "+str(board.chip["speed"]))
codeOut("#define USART_COUNT "+str(board.chip["usart"]))
if "spi" in board.chip:
codeOut("#define SPI_COUNT "+str(board.chip["spi"]))
codeOut("#define I2C_COUNT "+str(board.chip["i2c"]))
codeOut("#define ADC_COUNT "+str(board.chip["adc"]))
codeOut("#define DAC_COUNT "+str(board.chip["dac"]))
codeOut("#define EXTI_COUNT "+str(exti_count))
codeOut("");
codeOut("#define DEFAULT_CONSOLE_DEVICE "+board.info["default_console"]);
if "default_console_tx" in board.info:
codeOut("#define DEFAULT_CONSOLE_TX_PIN "+toPinDef(board.info["default_console_tx"]))
if "default_console_rx" in board.info:
codeOut("#define DEFAULT_CONSOLE_RX_PIN "+toPinDef(board.info["default_console_rx"]))
if "default_console_baudrate" in board.info:
codeOut("#define DEFAULT_CONSOLE_BAUDRATE "+board.info["default_console_baudrate"])
codeOut("");
xoff_thresh = 6 # how full (out of 8) is buffer when we sent the XOFF flow control char to say 'stop'
xon_thresh = 3 # how full (out of 8) is buffer when we sent the XON flow control char to say 'go'
if LINUX:
bufferSizeIO = 256
bufferSizeTX = 256
bufferSizeTimer = 16
elif EMSCRIPTEN:
bufferSizeIO = 256
bufferSizeTX = 256
bufferSizeTimer = 16
else:
# IO buffer - for received chars, setWatch, etc
bufferSizeIO = 64
if board.chip["ram"]>=20: bufferSizeIO = 128
if board.chip["ram"]>=96: bufferSizeIO = 256
# NRF52 needs this as Bluetooth traffic is funnelled through the buffer
if board.chip["family"]=="NRF52":
bufferSizeIO = 256
# we often use increased MTUs and even with a big buffer these mean we need to leave
# a lot of space when we send XOFF (due to delay in response from sender)
xoff_thresh = 3
xon_thresh = 2
# TX buffer - for print/write/etc
bufferSizeTX = 32
if board.chip["ram"]>=20: bufferSizeTX = 128
if board.chip["ram"]>=128: bufferSizeTX = 256
bufferSizeTimer = 4 if board.chip["ram"]<20 else 16
if 'util_timer_tasks' in board.info:
bufferSizeTimer = board.info['util_timer_tasks']
if 'io_buffer_size' in board.info:
bufferSizeIO = board.info['io_buffer_size']
codeOut("#define IOBUFFERMASK "+str(bufferSizeIO-1)+" // (max 65535) amount of items in event buffer - events take 5 bytes each")
codeOut("#define TXBUFFERMASK "+str(bufferSizeTX-1)+" // (max 255) amount of items in the transmit buffer - 2 bytes each")
codeOut("#define UTILTIMERTASK_TASKS ("+str(bufferSizeTimer)+") // Must be power of 2 - and max 256")
codeOut("");
codeOut("// When to send the message that the IO buffer is getting full")
codeOut("#define IOBUFFER_XOFF ((TXBUFFERMASK)*"+str(xoff_thresh)+"/8)")
codeOut("// When to send the message that we can start receiving again")
codeOut("#define IOBUFFER_XON ((TXBUFFERMASK)*"+str(xon_thresh)+"/8)")
codeOut("");
usedPinChecks = ["false"];
ledChecks = ["false"];
btnChecks = ["false"];
for device in pinutils.SIMPLE_DEVICES:
if device in board.devices:
codeOutDevice(device)
check = "(PIN)==" + toPinDef(board.devices[device]["pin"])
if device[:3]=="LED": ledChecks.append(check)
if device[:3]=="BTN": btnChecks.append(check)
# usedPinChecks.append(check)
# Actually we don't care about marking used pins for LEDs/Buttons
if "USB" in board.devices:
if "pin_disc" in board.devices["USB"]: codeOutDevicePin("USB", "pin_disc", "USB_DISCONNECT_PIN")
if "pin_vsense" in board.devices["USB"]: codeOutDevicePin("USB", "pin_vsense", "USB_VSENSE_PIN")
if "LCD" in board.devices:
codeOut("#define LCD_CONTROLLER_"+board.devices["LCD"]["controller"].upper())
if "width" in board.devices["LCD"]:
codeOut("#define LCD_WIDTH "+str(board.devices["LCD"]["width"]))
if "height" in board.devices["LCD"]:
codeOut("#define LCD_HEIGHT "+str(board.devices["LCD"]["height"]))
if "bpp" in board.devices["LCD"]:
codeOut("#define LCD_BPP "+str(board.devices["LCD"]["bpp"]))
if "bitrate" in board.devices["LCD"]:
codeOut("#define LCD_SPI_BITRATE "+str(board.devices["LCD"]["bitrate"]))
if "pin_bl" in board.devices["LCD"]:
codeOutDevicePin("LCD", "pin_bl", "LCD_BL")
if "pin_en" in board.devices["LCD"]:
codeOutDevicePin("LCD", "pin_en", "LCD_EN")
if board.devices["LCD"]["controller"]=="fsmc":
for i in range(0,16):
codeOutDevicePin("LCD", "pin_d"+str(i), "LCD_FSMC_D"+str(i))
codeOutDevicePin("LCD", "pin_rd", "LCD_FSMC_RD")
codeOutDevicePin("LCD", "pin_wr", "LCD_FSMC_WR")
codeOutDevicePin("LCD", "pin_cs", "LCD_FSMC_CS")
if "pin_rs" in board.devices["LCD"]:
codeOutDevicePin("LCD", "pin_rs", "LCD_FSMC_RS")
if "pin_reset" in board.devices["LCD"]:
codeOutDevicePin("LCD", "pin_reset", "LCD_RESET")
if board.devices["LCD"]["controller"]=="ssd1306" or board.devices["LCD"]["controller"]=="st7567" or board.devices["LCD"]["controller"]=="st7789v" or board.devices["LCD"]["controller"]=="st7735" or board.devices["LCD"]["controller"]=="gc9a01":
codeOutDevicePin("LCD", "pin_mosi", "LCD_SPI_MOSI")
codeOutDevicePin("LCD", "pin_sck", "LCD_SPI_SCK")
codeOutDevicePin("LCD", "pin_cs", "LCD_SPI_CS")
codeOutDevicePin("LCD", "pin_dc", "LCD_SPI_DC")
codeOutDevicePin("LCD", "pin_rst", "LCD_SPI_RST")
if board.devices["LCD"]["controller"]=="LPM013M126":
codeOutDevicePin("LCD", "pin_mosi", "LCD_SPI_MOSI")
codeOutDevicePin("LCD", "pin_sck", "LCD_SPI_SCK")
codeOutDevicePin("LCD", "pin_cs", "LCD_SPI_CS")
codeOutDevicePin("LCD", "pin_disp", "LCD_DISP")
codeOutDevicePin("LCD", "pin_extcomin", "LCD_EXTCOMIN")
if "pin_miso" in board.devices["LCD"]:
codeOutDevicePin("LCD", "pin_miso", "LCD_SPI_MISO")
if "pin_tearing" in board.devices["LCD"]:
codeOutDevicePin("LCD", "pin_tearing", "LCD_TEARING")
if board.devices["LCD"]["controller"]=="st7789_8bit":
codeOutDevicePins("LCD","LCD");
if "SD" in board.devices:
if not "pin_d3" in board.devices["SD"]: # NOT SDIO - normal SD
if "pin_cs" in board.devices["SD"]: codeOutDevicePin("SD", "pin_cs", "SD_CS_PIN")
if "pin_di" in board.devices["SD"]: codeOutDevicePin("SD", "pin_di", "SD_DI_PIN")
if "pin_do" in board.devices["SD"]: codeOutDevicePin("SD", "pin_do", "SD_DO_PIN")
if "pin_clk" in board.devices["SD"]:
codeOutDevicePin("SD", "pin_clk", "SD_CLK_PIN")
sdClkPin = pinutils.findpin(pins, "P"+board.devices["SD"]["pin_clk"], False)
spiNum = 0
for func in sdClkPin["functions"]:
if func[:3]=="SPI": spiNum = int(func[3])
if spiNum==0: die("No SPI peripheral found for SD card's CLK pin")
codeOut("#define SD_SPI EV_SPI"+str(spiNum))
if "IR" in board.devices:
codeOutDevicePin("IR", "pin_anode", "IR_ANODE_PIN")
codeOutDevicePin("IR", "pin_cathode", "IR_CATHODE_PIN")
if "CAPSENSE" in board.devices:
codeOutDevicePin("CAPSENSE", "pin_rx", "CAPSENSE_RX_PIN")
codeOutDevicePin("CAPSENSE", "pin_tx", "CAPSENSE_TX_PIN")
if "VIBRATE" in board.devices:
codeOutDevicePins("VIBRATE", "VIBRATE")
if "SPEAKER" in board.devices:
codeOutDevicePins("SPEAKER", "SPEAKER")
if "HEARTRATE" in board.devices:
codeOutDevicePins("HEARTRATE", "HEARTRATE")
if "addr" in board.devices["HEARTRATE"]:
codeOut("#define HEARTRATE_ADDR "+str(board.devices["HEARTRATE"]["addr"]))
codeOut("#define HEARTRATE_DEVICE_"+board.devices["HEARTRATE"]["device"].upper()+" 1")
if "BAT" in board.devices:
codeOutDevicePins("BAT", "BAT")
if "GPS" in board.devices:
if "pin_en" in board.devices["GPS"]: codeOutDevicePin("GPS", "pin_en", "GPS_PIN_EN")
codeOutDevicePins("GPS", "GPS")
if "ACCEL" in board.devices:
codeOut("#define ACCEL_DEVICE \""+board.devices["ACCEL"]["device"].upper()+"\"")
codeOut("#define ACCEL_DEVICE_"+board.devices["ACCEL"]["device"].upper()+" 1")
codeOut("#define ACCEL_ADDR "+str(board.devices["ACCEL"]["addr"]))
codeOutDevicePins("ACCEL", "ACCEL")
if "MAG" in board.devices:
codeOut("#define MAG_DEVICE \""+board.devices["MAG"]["device"].upper()+"\"")
codeOut("#define MAG_DEVICE_"+board.devices["MAG"]["device"].upper()+" 1")
if "addr" in board.devices["MAG"]:
codeOut("#define MAG_ADDR "+str(board.devices["MAG"]["addr"]))
codeOutDevicePins("MAG", "MAG")
if "TEMP" in board.devices:
if "addr" in board.devices["TEMP"]:
codeOut("#define TEMP_ADDR "+str(board.devices["TEMP"]["addr"]))
codeOutDevicePins("TEMP", "TEMP")
if "PRESSURE" in board.devices:
codeOut("#define PRESSURE_DEVICE \""+board.devices["PRESSURE"]["device"].upper()+"\"")
codeOut("#define PRESSURE_DEVICE_"+board.devices["PRESSURE"]["device"].upper()+" 1")
codeOut("#define PRESSURE_ADDR "+str(board.devices["PRESSURE"]["addr"]))
codeOutDevicePins("PRESSURE", "PRESSURE")
if "TOUCH" in board.devices:
codeOut("#define TOUCH_DEVICE \""+board.devices["TOUCH"]["device"].upper()+"\"")
codeOut("#define TOUCH_ADDR "+str(board.devices["TOUCH"]["addr"]))
codeOutDevicePins("TOUCH", "TOUCH")
if "SPIFLASH" in board.devices:
codeOut("#define SPIFLASH_PAGESIZE 4096")
codeOut("#define SPIFLASH_LENGTH "+str(board.devices["SPIFLASH"]["size"]))
codeOut("#define SPIFLASH_BASE "+str(board.devices["SPIFLASH"]["memmap_base"])+"UL")
codeOutDevicePins("SPIFLASH", "SPIFLASH")
for device in pinutils.OTHER_DEVICES:
if device in board.devices:
for entry in board.devices[device]:
if entry[:3]=="pin": usedPinChecks.append("(PIN)==" + toPinDef(board.devices[device][entry])+"/* "+device+" */")
# Specific hacks for nucleo boards
if "NUCLEO_A" in board.devices:
for n,pin in enumerate(board.devices["NUCLEO_A"]):
codeOut("#define NUCLEO_A"+str(n)+" "+toPinDef(pin))
if "NUCLEO_D" in board.devices:
for n,pin in enumerate(board.devices["NUCLEO_D"]):
codeOut("#define NUCLEO_D"+str(n)+" "+toPinDef(pin))
if "ESP8266" in board.devices:
for entry in board.devices["ESP8266"]:
if entry[0:4]=="pin_":
codeOut("#define ESP8266_"+str(entry[4:].upper())+" "+toPinDef(board.devices["ESP8266"][entry]))
codeOut("")
codeOut("// definition to avoid compilation when Pin/platform config is not defined")
codeOut("#define IS_PIN_USED_INTERNALLY(PIN) (("+")||(".join(usedPinChecks)+"))")
codeOut("#define IS_PIN_A_LED(PIN) (("+")||(".join(ledChecks)+"))")
codeOut("#ifndef IS_PIN_A_BUTTON")
codeOut("#define IS_PIN_A_BUTTON(PIN) (("+")||(".join(btnChecks)+"))")
codeOut("#endif")
codeOut("""
#endif // _PLATFORM_CONFIG_H
""");
Reference in New Issue View Git Blame Copy Permalink