static void menuabout(control m)
{
char s[256], s2[256];
PrintVersionString(s2, 256);
snprintf(s, 256, "%s\n%s %s %s",
s2,
"Copyright (C)", R_YEAR,
"The R Foundation for Statistical Computing");
askok(s);
/* show(RConsole); */
}
int main()
{
UART_CFG_Type uart_config;
UART_FIFO_CFG_Type uart_fifo_config;
TIM_TIMERCFG_Type timer_config;
TIM_MATCHCFG_Type timer_match;
OS_TID uart_task_id = 0;
OS_TID activity_task_id = 0;
uint32_t reset_flags = 0;
reset_flags = LPC_SYSCON->SYSRSTSTAT;
SEQ_Initialize();
PROTO_Reset();
PROTO_SetHandlers(g_protocol_handlers);
SYSCON_AHBPeriphClockCmd(SYSCON_AHBPeriph_GPIO, ENABLE);
// Reset pin
IOCON_SetPinFunc(IOCON_PIO0_0, PIO0_0_FUN_RESET);
// Status LED pin
ACTIVITY_SET_PIN();
GPIO_SetDir(ACTIVITY_PORT, ACTIVITY_PIN, 1);
GPIO_ResetBits(ACTIVITY_PORT, ACTIVITY_PIN);
// Timer activity LED pin
TIMER_ACTIVITY_SET_PIN();
GPIO_SetDir(TIMER_ACTIVITY_PORT, TIMER_ACTIVITY_PIN, 1);
GPIO_ResetBits(TIMER_ACTIVITY_PORT, TIMER_ACTIVITY_PIN);
// RGB control
RED_SET_PIN();
GREEN_SET_PIN();
BLUE_SET_PIN();
GPIO_SetDir(RED_PORT, RED_PIN, 1);
GPIO_SetDir(GREEN_PORT, GREEN_PIN, 1);
GPIO_SetDir(BLUE_PORT, BLUE_PIN, 1);
GPIO_ResetBits(RED_PORT, RED_PIN);
GPIO_ResetBits(GREEN_PORT, GREEN_PIN);
GPIO_ResetBits(BLUE_PORT, BLUE_PIN);
timer_config.PrescaleOption = TIM_PRESCALE_TICKVAL;
timer_config.PrescaleValue = 1;
TIM_Init(LPC_TMR32B0, TIM_TIMER_MODE, &timer_config);
timer_match.MatchChannel = 0;
timer_match.IntOnMatch = ENABLE;
timer_match.StopOnMatch = DISABLE;
timer_match.ResetOnMatch = ENABLE;
timer_match.ExtMatchOutputType = 0;
timer_match.MatchValue = SystemCoreClock / (TICKS_PER_SECOND * 256);
TIM_ConfigMatch(LPC_TMR32B0, &timer_match);
TIM_Cmd(LPC_TMR32B0, ENABLE);
NVIC_EnableIRQ(TIMER_32_0_IRQn);
// UART
IOCON_SetPinFunc(IOCON_PIO1_6, PIO1_6_FUN_RXD); /* UART RXD - PIO1_6 */
IOCON_SetPinFunc(IOCON_PIO1_7, PIO1_7_FUN_TXD); /* UART RXD - PIO1_7 */
uart_config.Baud_rate = 115200;
uart_config.Databits = UART_DATABIT_8;
uart_config.Parity = UART_PARITY_NONE;
uart_config.Stopbits = UART_STOPBIT_1;
UART_Init(LPC_UART, &uart_config);
uart_fifo_config.FIFO_Level = UART_FIFO_TRGLEV0;
uart_fifo_config.FIFO_ResetRxBuf = ENABLE;
uart_fifo_config.FIFO_ResetTxBuf = ENABLE;
UART_FIFOConfig(LPC_UART, &uart_fifo_config);
UART_TxCmd(LPC_UART, ENABLE);
// SPI
CL632_Init();
// Select page 0 and no paging access
CL632_SpiWriteByte(0x00, 0x00);
CL632_SpiWriteByte(0x00, 0x00);
// LCD
// LCD backlite control
LCD_BACKLITE_SET_PIN();
GPIO_SetDir(LCD_BACKLITE_PORT, LCD_BACKLITE_PIN, 1);
GPIO_ResetBits(LCD_BACKLITE_PORT, LCD_BACKLITE_PIN);
// LCD Data bus
LCD_DATA_SET_PINS();
GPIO_SetDir(LCD_DATA_PORT, LCD_DATA_BUS, 1);
GPIO_ResetBits(LCD_DATA_PORT, LCD_DATA_BUS);
LCD_RS_SET_PIN();
GPIO_SetDir(LCD_RS_PORT, LCD_RS_PIN, 1);
GPIO_ResetBits(LCD_RS_PORT, LCD_RS_PIN);
LCD_RW_SET_PIN();
GPIO_SetDir(LCD_RW_PORT, LCD_RW_PIN, 1);
GPIO_ResetBits(LCD_RW_PORT, LCD_RW_PIN);
LCD_E_SET_PIN();
GPIO_SetDir(LCD_E_PORT, LCD_E_PIN, 1);
GPIO_ResetBits(LCD_E_PORT, LCD_E_PIN);
KS0066_PowerUpDelay();
KS0066_FunctionSet();
KS0066_WaitForIdle();
KS0066_DisplayOnOffControl(KS0066_DISPCTL_DISPLAY_ON);
KS0066_WaitForIdle();
KS0066_ClearDisplay();
KS0066_WaitForIdle();
CoInitOS();
GPIO_SetBits(ACTIVITY_PORT, ACTIVITY_PIN);
uart_task_id = CoCreateTask(uartTask, NULL, UART_TASK_PRIORITY,
GetStackTop(uartTaskStack), GetStackSize(uartTaskStack));
activity_task_id = CoCreateTask(activityTask, NULL, ACTIVITY_TASK_PRIORITY,
GetStackTop(activityTaskStack), GetStackSize(activityTaskStack));
if (uart_task_id == E_CREATE_FAIL || activity_task_id == E_CREATE_FAIL) {
UART_PrintString("INIT ERROR");
UART_PrintString(kNewLine);
}
if (reset_flags & 0x01)
UART_PrintString("RST:PU");
else if (reset_flags & 0x02)
UART_PrintString("RST:RST");
else if (reset_flags & 0x04)
UART_PrintString("RST:WDT");
else if (reset_flags & 0x08)
UART_PrintString("RST:BOD");
else if (reset_flags & 0x10)
UART_PrintString("RST:SOFT");
else
UART_PrintString("RST");
UART_PrintString(kNewLine);
PrintVersionString(UART_WriteChar);
UART_PrintString(kNewLine);
func_printf_nofloat(UART_WriteChar, "COOS:%d\r\n", CoGetOSVersion());
KS0066_WriteString("V:" __DATE__ " " __TIME__, KS0066_WRAP_FLAG);
CoStartOS();
//while (1) {
//}
return 0;
}
void HandleInputChar(char c)
{
int i;
int result;
result = PROTO_HandleInputCharacter(c);
if (result == RESULT_ERROR) {
UART_PrintString(kErrorResponse);
}
else if( result == RESULT_ACCEPT ) {
const ProtocolHandler *handler = PROTO_GetCurrentHandler();
if (handler) {
switch (handler->id) {
case PROTO_ID_DEFAULT:
UART_PrintString(kOkResponse);
UART_PrintString(kNewLine);
break;
case PROTO_ID_SYS:
if (PROTO_SYS_GetCommand() == PROTO_SYS_COMMAND_RESET) {
UART_PrintString(kOkResponse);
while(UART_CheckBusy(LPC_UART) != RESET);
NVIC_SystemReset();
}
else if (PROTO_SYS_GetCommand() == PROTO_SYS_COMMAND_VERSION) {
PrintVersionString(UART_WriteChar);
}
else {
UART_PrintString(kNotAvailableResponse);
}
UART_PrintString(kNewLine);
break;
/*
case COMMAND_BACKLITE:
UART_PrintString( "+BL\r\n" );
backlite_power = PROTO_GetBacklitePower();
break;
*/
case PROTO_ID_SPI:
if (0 && PROTO_SPI_GetAction() == PROTO_SPI_ACTION_READ) {
int len = PROTO_SPI_GetLength();
func_printf_nofloat(UART_WriteChar, "%02X:", len);
for (i = 0; i < len; i++) {
uint8_t b;
b = SPI_ReadByte();
func_printf_nofloat(UART_WriteChar, " %02X", b);
}
}
else if (PROTO_SPI_GetAction() == PROTO_SPI_ACTION_WRITE) {
uint8_t *data = PROTO_SPI_GetData();
int len = PROTO_SPI_GetLength();
SPI_Write(data, len);
UART_PrintString(kOkResponse);
}
else {
UART_PrintString(kNotAvailableResponse);
}
UART_PrintString(kNewLine);
break;
case PROTO_ID_RFID:
if (PROTO_RF_GetAction() == PROTO_RF_ACTION_READ) {
int len = PROTO_RF_GetLength();
func_printf_nofloat(UART_WriteChar, "%02X:", len);
for (i = 0; i < len; i++) {
int addr = PROTO_RF_GetAddress();
uint8_t b;
if (PROTO_RF_GetMode() == PROTO_RF_MODE_INCREMENT_ADDRESS)
addr += i;
if (PROTO_RF_GetTarget() == PROTO_RF_TARGET_PORT)
b = CL632_SpiReadByte(addr);
else if (PROTO_RF_GetTarget() == PROTO_RF_TARGET_MEMORY)
CL632_ReadE2(addr, &b, 1);
func_printf_nofloat(UART_WriteChar, " %02X", b);
}
}
else if (PROTO_RF_GetAction() == PROTO_RF_ACTION_WRITE) {
int addr = PROTO_RF_GetAddress();
uint8_t *data = PROTO_RF_GetData();
int len = PROTO_RF_GetLength();
int same_address = PROTO_RF_GetMode() == PROTO_RF_MODE_SAME_ADDRESS;
if (PROTO_RF_GetTarget() == PROTO_RF_TARGET_PORT) {
CL632_SpiWrite(addr, same_address, data, len);
}
else if (PROTO_RF_GetTarget() == PROTO_RF_TARGET_MEMORY) {
CL632_WriteE2(addr, data, len);
}
UART_PrintString(kOkResponse);
}
else {
UART_PrintString(kNotAvailableResponse);
}
UART_PrintString(kNewLine);
break;
case PROTO_ID_RGB:
switch (PROTO_RGB_GetCommand()) {
case PROTO_RGB_COMMAND_CAPABILITIES:
UART_PrintString("RGB,TRAN");
break;
case PROTO_RGB_COMMAND_PRINT_SEQUENCE:
UART_PrintString("S");
for (i = 0; i < SEQ_GetSequenceLength(); i++) {
const COMMAND *cmd = &(SEQ_GetSequence()[i]);
func_printf_nofloat(UART_WriteChar, " L%d#%02X%02X%02X",
cmd->interval, cmd->color.red, cmd->color.green, cmd->color.blue);
}
break;
case PROTO_RGB_COMMAND_SET_SEQUENCE:
SEQ_SetSequence(PROTO_RGB_GetSequence(), PROTO_RGB_GetSequenceLength());
UART_PrintString(kOkResponse);
break;
default:
UART_PrintString(kNotAvailableResponse);
break;
}
UART_PrintString(kNewLine);
break;
}
}
}
}
int setupui(void)
{
char *p, *ctype, Rlocale[1000] = ""; /* Windows' locales can be very long */
initapp(0, 0);
/* set locale before doing anything with menus */
setlocale(LC_CTYPE, ""); /* necessary in case next fails to set
a valid locale */
if((p = getenv("LC_ALL"))) strcpy(Rlocale, p);
if((p = getenv("LC_CTYPE"))) strcpy(Rlocale, p);
if (strcmp(Rlocale, "C") == 0) strcpy(Rlocale, "en");
setlocale(LC_CTYPE, Rlocale);
mbcslocale = MB_CUR_MAX > 1;
ctype = setlocale(LC_CTYPE, NULL);
p = strrchr(ctype, '.');
if(p && isdigit(p[1])) localeCP = atoi(p+1); else localeCP = 1252;
readconsolecfg();
int flags = StandardWindow | Document | Menubar;
if(mbcslocale) flags |= UseUnicode;
if (RguiMDI & RW_MDI) {
TRACERUI("Rgui");
RFrame = newwindow(
#ifdef _WIN64
"RGui (64-bit)",
#else
"RGui (32-bit)",
#endif
MDIsize,
StandardWindow | Menubar | Workspace);
setclose(RFrame, closeconsole);
show(RFrame);
TRACERUI("Rgui done");
TRACERUI("Console");
if (!(RConsole = newconsole("R Console", flags ))) return 0;
TRACERUI("Console done");
} else {
TRACERUI("Console");
#ifdef _WIN64
if (!(RConsole = newconsole("R Console (64-bit)", flags ))) return 0;
#else
if (!(RConsole = newconsole("R Console (32-bit)", flags ))) return 0;
#endif
TRACERUI("Console done");
}
if (ismdi()) {
int btsize = 24;
rect r = rect(2, 2, btsize, btsize);
control tb, bt;
MCHECK(tb = newtoolbar(btsize + 4));
addto(tb);
MCHECK(bt = newtoolbutton(open_image, r, menueditoropen));
MCHECK(addtooltip(bt, G_("Open script")));
r.x += (btsize + 1) ;
MCHECK(bt = newtoolbutton(open1_image, r, menuloadimage));
MCHECK(addtooltip(bt, G_("Load workspace")));
r.x += (btsize + 1) ;
MCHECK(bt = newtoolbutton(save_image, r, menusaveimage));
MCHECK(addtooltip(bt, G_("Save workspace")));
r.x += (btsize + 6);
MCHECK(bt = newtoolbutton(copy_image, r, buttoncopy));
MCHECK(addtooltip(bt, G_("Copy")));
r.x += (btsize + 1);
MCHECK(bt = newtoolbutton(paste_image, r, buttonpaste));
MCHECK(addtooltip(bt, G_("Paste")));
r.x += (btsize + 1);
MCHECK(bt = newtoolbutton(copypaste_image, r, buttoncopypaste));
MCHECK(addtooltip(bt, G_("Copy and paste")));
r.x += (btsize + 6);
MCHECK(bt = newtoolbutton(stop_image, r, buttonkill));
MCHECK(addtooltip(bt, G_("Stop current computation")));
r.x += (btsize + 6) ;
MCHECK(bt = newtoolbutton(print_image, r, menuprint));
MCHECK(addtooltip(bt, G_("Print")));
}
if (ismdi() && (RguiMDI & RW_STATUSBAR)) {
TRACERUI("status bar");
addstatusbar();
addto(RConsole);
TRACERUI("status bar done");
}
if (ismdi()) {
char s[256];
PrintVersionString(s, 256);
setstatus(s);
}
addto(RConsole);
setclose(RConsole, closeconsole);
setdrop(RConsole, dropconsole);
MCHECK(RConsolePopup = gpopup(popupact, ConsolePopup));
MCHECK(RMenuBar = newmenubar(menuact));
MCHECK(newmenu(G_("File")));
MCHECK(msource = newmenuitem(G_("Source R code..."), 0, menusource));
MCHECK(newmenuitem(G_("New script"), 0, menueditornew));
MCHECK(newmenuitem(G_("Open script..."), 0, menueditoropen));
MCHECK(mdisplay = newmenuitem(G_("Display file(s)..."), 0, menudisplay));
MCHECK(newmenuitem("-", 0, NULL));
MCHECK(mload = newmenuitem(G_("Load Workspace..."), 0, menuloadimage));
MCHECK(msave = newmenuitem(G_("Save Workspace..."), 'S', menusaveimage));
MCHECK(newmenuitem("-", 0, NULL));
MCHECK(mloadhistory = newmenuitem(G_("Load History..."), 0,
menuloadhistory));
MCHECK(msavehistory = newmenuitem(G_("Save History..."), 0,
menusavehistory));
MCHECK(newmenuitem("-", 0, NULL));
MCHECK(newmenuitem(G_("Change dir..."), 0, menuchangedir));
MCHECK(newmenuitem("-", 0, NULL));
MCHECK(newmenuitem(G_("Print..."), 'P', menuprint));
MCHECK(newmenuitem(G_("Save to File..."), 0, menusavefile));
MCHECK(newmenuitem("-", 0, NULL));
MCHECK(newmenuitem(G_("Exit"), 0, menuexit));
MCHECK(newmenu(G_("Edit")));
MCHECK(mcopy = newmenuitem(G_("Copy"), 'C', menucopy));
MCHECK(mpaste = newmenuitem(G_("Paste"), 'V', menupaste));
MCHECK(mpastecmds = newmenuitem(G_("Paste commands only"), 0,
menupastecmds));
MCHECK(mcopypaste = newmenuitem(G_("Copy and Paste"), 'X', menucopypaste));
MCHECK(newmenuitem(G_("Select all"), 0, menuselectall));
MCHECK(newmenuitem(G_("Clear console"), 'L', menuclear));
MCHECK(newmenuitem("-", 0, NULL));
MCHECK(mde = newmenuitem(G_("Data editor..."), 0, menude));
MCHECK(newmenuitem("-", 0, NULL));
MCHECK(mconfig = newmenuitem(G_("GUI preferences..."), 0, menuconfig));
if (ismdi()) {
MCHECK(newmenu(G_("View")));
MCHECK(mtools = newmenuitem(G_("Toolbar"), 0, menutools));
MCHECK(mstatus = newmenuitem(G_("Statusbar"), 0, menustatus));
if(RguiMDI & RW_TOOLBAR) check(mtools);
if(RguiMDI & RW_STATUSBAR) check(mstatus);
}
MCHECK(newmenu(G_("Misc")));
MCHECK(newmenuitem(G_("Stop current computation \tESC"), 0,
menukill));
MCHECK(newmenuitem(G_("Stop all computations"), 0, menukillall));
if (DebugMenuitem || isdebuggerpresent())
MCHECK(newmenuitem(G_("Break to debugger"), 0, menudebug));
MCHECK(newmenuitem("-", 0, NULL));
MCHECK(mlazy = newmenuitem(G_("Buffered output"), 'W', menulazy));
MCHECK(mcomplete = newmenuitem(G_("Word completion"), 0, menucomplete));
check(mcomplete);
MCHECK(mfncomplete = newmenuitem(G_("Filename completion"), 0,
menufncomplete));
if(check_file_completion())
check(mfncomplete);
else
uncheck(mfncomplete);
MCHECK(newmenuitem("-", 0, NULL));
MCHECK(mls = newmenuitem(G_("List objects"), 0, menuls));
MCHECK(mrm = newmenuitem(G_("Remove all objects"), 0, menurm));
MCHECK(msearch = newmenuitem(G_("List search &path"), 0, menusearch));
pmenu = (PkgMenuItems) malloc(sizeof(struct structPkgMenuItems));
RguiPackageMenu(pmenu);
RguiWindowMenu();
MCHECK(m = newmenu(G_("Help")));
MCHECK(newmenuitem(G_("Console"), 0, menuconsolehelp));
MCHECK(newmenuitem("-", 0, NULL));
CheckForManuals();
hmenu = (HelpMenuItems) malloc(sizeof(struct structHelpMenuItems));
RguiCommonHelp(m, hmenu);
consolesetbrk(RConsole, menukill, ESC, 0);
wgl_hist_init(R_HistorySize, 0);
if (R_RestoreHistory) wgl_loadhistory(R_HistoryFile);
if (ismdi() && !(RguiMDI & RW_TOOLBAR)) toolbar_hide();
show(RConsole);
return 1;
}
