/*********************************************************************//**
* @brief c_entry: Main MPU program body
* @param[in] None
* @return int
**********************************************************************/
int c_entry(void)
{
uint32_t test;
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
_DBG(menu);
//Turn off all LEDs
GPIO_SetDir(BRD_LED_1_CONNECTED_PORT, BRD_LED_1_CONNECTED_MASK, GPIO_DIRECTION_OUTPUT);
GPIO_SetValue(BRD_LED_1_CONNECTED_PORT, BRD_LED_1_CONNECTED_MASK);
/* - Region 0: 0x00000000 - 0x0007FFFF --- on-chip non-volatile memory
* + Size: 512kB
* + Acess permission: full access
*/
MPU->RNR = 0;//indicate MPU region 0
MPU->RBAR = 0x00000000; // update the base address for the region 0
MPU->RASR = MPU_RASR_ACCESS_PERMISSION(MPU_FULL_ACCESS) //full access
|MPU_RASR_REGION_SIZE(MPU_REGION_SIZE_512KB) //512Kb size
|MPU_REGION_ENABLE; //region enable
/* - Region 1: 0x10000000 - 0x1000FFFF --- on-chip SRAM
* + Size: 64kB
* + Access permission: full access
*/
MPU->RNR = 1;
MPU->RBAR = 0x10000000; // update the base address for the region 1
MPU->RASR = MPU_RASR_ACCESS_PERMISSION(MPU_FULL_ACCESS)
|MPU_RASR_REGION_SIZE(MPU_REGION_SIZE_64KB)
|MPU_REGION_ENABLE;
/* - Region 2: 0x40000000 - 0x400FFFFF --- APB peripheral
* + Size: 1MB
* + Access permission: full access
*/
MPU->RNR = 2;
MPU->RBAR = 0x40000000; // update the base address for the region 2
MPU->RASR = MPU_RASR_ACCESS_PERMISSION(MPU_FULL_ACCESS)
|MPU_RASR_REGION_SIZE(MPU_REGION_SIZE_1MB)
|MPU_REGION_ENABLE;
/* - Region 3: 0x20080000 - 0x200BFFFF --- AHB peripheral
* + Size: 256KB
* + AP=b011: full access
*/
MPU->RNR = 3;
MPU->RBAR = 0x20080000; // update the base address for the region 3
MPU->RASR = MPU_RASR_ACCESS_PERMISSION(MPU_FULL_ACCESS)
|MPU_RASR_REGION_SIZE(MPU_REGION_SIZE_256KB)
|MPU_REGION_ENABLE;
/* - Region 4: 0xE0000000 - 0xE00FFFFF --- System control
* + Size: 1MB
* + Access permission: full access
*/
MPU->RNR = 4;
MPU->RBAR = 0xE0000000; // update the base address for the region 4
MPU->RASR = MPU_RASR_ACCESS_PERMISSION(MPU_FULL_ACCESS)
|MPU_RASR_REGION_SIZE(MPU_REGION_SIZE_1MB)
|MPU_REGION_ENABLE;
/* - Region 5:0x20000000 - 0x20007FFF --- on chip SRAM
* + Size: 32kB
* + Access permission: full access
*/
MPU->RNR = 5;
MPU->RBAR = 0x20000000; // update the base address for the region 5
MPU->RASR = MPU_RASR_ACCESS_PERMISSION(MPU_NO_ACCESS)
|MPU_RASR_REGION_SIZE(MPU_REGION_SIZE_32KB)
|MPU_REGION_ENABLE;
_DBG_("Setup MPU: \n\r"
"This provide 6 regions: \n\r"
"Region 0 - Privileged code: 0x00000000 - 0x0007FFFF(512kB)\n\r"
"Region 1 - Privileged data: 0x10000000 - 0x1000FFFF(64kB)\n\r"
"Region 2 - APB Peripheral: 0x40000000 - 0x400FFFFF(1MB)\n\r"
"Region 3 - AHB peripheral: 0x20080000 - 0x200BFFFF(256KB)\n\r"
"Region 4 - System control: 0xE0000000 - 0xE00FFFFF(1MB)\n\r"
"Region 5 - On-chip SRAM: 0x20000000 - 0x20007FFF(32kB)\n\r"
"Region 5 can not access (just used for testing)");
SCB->SHCSR |=(1<<16); //Enable Memory management fault
MPU->CTRL =(1<<0); //Enable the MPU
_DBG_("Enable MPU!");
//try to access to this memory range
_DBG_("Press '1' to try to read memory from region 1");
while(_DG !='1');
test = (*(unsigned int *)0x10000000);
_DBG_("Read successful!!!");
_DBG_("Press '2' to try to read memory from region 5\n\r"
"Read memory at this region is not allow, LED p1.28 will blink...");
while(_DG !='2');
test = (*(unsigned int *)0x20000000);
test++;
while(test);
return 1;
}
/*********************************************************************//**
* @brief c_entry: Main program body
* @param[in] None
* @return None
**********************************************************************/
void c_entry (void)
{
uint32_t pre_secval = 0, inc = 0, calib_cnt = 0;
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
// print welcome screen
print_menu();
/* In this example:
* Suppose that the RTC need periodically adjust after each 5 second.
* And the time counter need by incrementing the counter by 2 instead of 1
* We will observe timer counter after calibration via serial display
*/
// Init RTC module
RTC_Init(LPC_RTC);
/* Enable rtc (starts increase the tick counter and second counter register) */
RTC_ResetClockTickCounter(LPC_RTC);
RTC_Cmd(LPC_RTC, ENABLE);
//Set current time = 0
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_SECOND, 0);
/* Setting Timer calibration
* Calibration value = 6s;
* Direction = Forward calibration
* So after each 6s, calibration logic can periodically adjust the time counter by
* incrementing the counter by 2 instead of 1
*/
RTC_CalibConfig(LPC_RTC, 6, RTC_CALIB_DIR_FORWARD);
RTC_CalibCounterCmd(LPC_RTC, ENABLE);
/* Set the CIIR for second counter interrupt*/
RTC_CntIncrIntConfig (LPC_RTC, RTC_TIMETYPE_SECOND, ENABLE);
/* Enable RTC interrupt */
NVIC_EnableIRQ(RTC_IRQn);
/* Loop forever */
while(1)
{
if(pre_secval != secval)
{
if(pre_secval > secval)
inc = 60 + secval - pre_secval;
else
inc = secval - pre_secval;
if(inc > 1)
{
_DBG ("Second: "); _DBD(secval); _DBG("--> Increase ");_DBD(inc); _DBG(" after ");_DBD(calib_cnt);_DBG(" seconds");
_DBG_("");
calib_cnt = 0;
}
else
{
_DBG ("Second: "); _DBD(secval); _DBG_("");
calib_cnt++;
}
pre_secval = secval;
}
}
}
// ----------------------------------------------------------------------------------
// These are the static routines used in io.
// ----------------------------------------------------------------------------------
static int sendToServer( SOCKET s, TCHAR *msg ) {
_DBG(fprintf(log_fd,"Sending message to the server: %s\n",msg));
return sendReply( s, msg)*strlen(msg);
}
int CHttpServer::processHttpMessage(int nClientFD, message *m)
{
const char *http_res =
"HTTP/1.1 200 OK\r\n"
"Server: pm_manager\r\n"
"Date: Wed, 07 Mar 2012 09:43:02 GMT\r\n"
"Content-Type: application/json; charset=utf-8\r\n"
"Connection: keep-alive\r\n"
#ifdef NOSETEST
"Content-Length: 20\r\n\r\n{\"result\":\"success\"}";
#else
"Content-Length: 15\r\n\r\n{\"result\":true}";
#endif
if (m->method == HTTP_POST)
{
_DBG("client POST to: %s", m->url);
_DBG("content: %s", m->body);
if (strncmp("/event", m->url, 6) == 0)
{
//std::string jsonStr = "{\"sn\":123456789,\"component_name\":\"sensor\",\"event\":\"shutdown\",\"hostname\":\"TPE1A0109\"}";
if (strlen(m->body) == 0) return 1;
std::string jsonStr(m->body);
Json::Reader reader;
Json::Value value;
if(reader.parse(jsonStr, value))
{
char hostname[BUF_SIZE], event[BUF_SIZE];
_DBG("GOT HTTP event: %s", value["event"].asString().c_str());
strcpy(event, value["event"].asString().c_str());
if (strncmp(event, "poweroff", 8) == 0)
{
char status[BUF_SIZE];
Json::Value nodes = value["nodes"];
for (unsigned int index = 0; index < nodes.size(); ++index)
{
memset(hostname, 0, sizeof(hostname));
memset(status, 0, sizeof(status));
strcpy(hostname, nodes[index]["hostname"].asString().c_str());
strcpy(status, nodes[index]["status"].asString().c_str());
_DBG("%s is POWERED OFF !!", hostname);
if (-1 != m_nEventFilter)
{
sendMessage(m_nEventFilter, EVENT_MONITOR_SHUTDOWN, nClientFD, strlen(hostname), hostname);
}
else
{
sendMessage(EVENT_FILTER_HTTP_SERVER, EVENT_MONITOR_SHUTDOWN, nClientFD, strlen(hostname), hostname);
}
}
}
else if (strncmp(event, "heartbeat", 9) == 0)
{
char status[BUF_SIZE];
Json::Value nodes = value["nodes"];
for (unsigned int index = 0; index < nodes.size(); ++index)
{
memset(hostname, 0, sizeof(hostname));
memset(status, 0, sizeof(status));
strcpy(hostname, nodes[index]["hostname"].asString().c_str());
strcpy(status, nodes[index]["status"].asString().c_str());
if (strncmp(status, "heartbeat", 9) == 0)
{
if (-1 != m_nEventFilter)
{
sendMessage(m_nEventFilter, EVENT_MONITOR_BOOT, nClientFD, strlen(hostname), hostname);
}
else
{
sendMessage(EVENT_FILTER_HTTP_SERVER, EVENT_MONITOR_BOOT, nClientFD, strlen(hostname), hostname);
}
}
}
}
else if (strncmp(event, "dead", 4) == 0)
{
char status[BUF_SIZE];
Json::Value nodes = value["nodes"];
for (unsigned int index = 0; index < nodes.size(); ++index)
{
memset(hostname, 0, sizeof(hostname));
memset(status, 0, sizeof(status));
strcpy(hostname, nodes[index]["hostname"].asString().c_str());
strcpy(status, nodes[index]["status"].asString().c_str());
_DBG("%s is DEAD !! T_T", hostname);
if (-1 != m_nEventFilter)
{
sendMessage(m_nEventFilter, EVENT_MONITOR_DEAD, nClientFD, strlen(hostname), hostname);
}
else
{
sendMessage(EVENT_FILTER_HTTP_SERVER, EVENT_MONITOR_DEAD, nClientFD, strlen(hostname), hostname);
}
}
}
}
}
}
socketSend(nClientFD, http_res, strlen(http_res));
return 0;
}
void unhandledException (const std::exception *e, const String &sourceFilename, int lineNumber)
{
_DBG("CtrlrApplication::unhandledException");
_DBG("\tfile: "+sourceFilename+":"+_STR(lineNumber));
_DBG("\t"+_STR(e->what()));
}
/*********************************************************************//**
* @brief Main GPDMA program body
**********************************************************************/
int c_entry(void)
{
GPDMA_Channel_CFG_Type GPDMACfg;
// DeInit NVIC and SCBNVIC
NVIC_DeInit();
NVIC_SCBDeInit();
/* Configure the NVIC Preemption Priority Bits:
* two (2) bits of preemption priority, six (6) bits of sub-priority.
* Since the Number of Bits used for Priority Levels is five (5), so the
* actual bit number of sub-priority is three (3)
*/
NVIC_SetPriorityGrouping(0x05);
// Set Vector table offset value
#if (__RAM_MODE__==1)
NVIC_SetVTOR(0x10000000);
#else
NVIC_SetVTOR(0x00000000);
#endif
/*
* Initialize debug via UART
*/
debug_frmwrk_init();
// print welcome screen
print_menu();
/* GPDMA block section -------------------------------------------- */
/* Initialize buffer */
_DBG_("Initialize Buffer...");
Buffer_Init();
/* Disable GPDMA interrupt */
NVIC_DisableIRQ(DMA_IRQn);
/* preemption = 1, sub-priority = 1 */
NVIC_SetPriority(DMA_IRQn, ((0x01<<3)|0x01));
/* Initialize GPDMA controller */
GPDMA_Init();
// Setup GPDMA channel --------------------------------
// channel 0
GPDMACfg.ChannelNum = 0;
// Source memory
GPDMACfg.SrcMemAddr = DMA_SRC;
// Destination memory
GPDMACfg.DstMemAddr = DMA_DST;
// Transfer size
GPDMACfg.TransferSize = DMA_SIZE;
// Transfer width
GPDMACfg.TransferWidth = GPDMA_WIDTH_WORD;
// Transfer type
GPDMACfg.TransferType = GPDMA_TRANSFERTYPE_M2M;
// Source connection - unused
GPDMACfg.SrcConn = 0;
// Destination connection - unused
GPDMACfg.DstConn = 0;
// Linker List Item - unused
GPDMACfg.DMALLI = 0;
// Setup channel with given parameter
GPDMA_Setup(&GPDMACfg, GPDMA_Callback);
/* Reset terminal counter */
Channel0_TC = 0;
/* Reset Error counter */
Channel0_Err = 0;
_DBG_("Start transfer...");
// Enable GPDMA channel 0
GPDMA_ChannelCmd(0, ENABLE);
/* Enable GPDMA interrupt */
NVIC_EnableIRQ(DMA_IRQn);
/* Wait for GPDMA processing complete */
while ((Channel0_TC == 0) && (Channel0_Err == 0));
/* Verify buffer */
Buffer_Verify();
_DBG(compl_menu);
/* Loop forever */
while(1);
return 1;
}
/*********************************************************************//**
* @brief c_entry: Main program body
* @param[in] None
* @return int
**********************************************************************/
int c_entry(void)
{
GPDMA_Channel_CFG_Type GPDMACfg;
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
// print welcome screen
print_menu();
/* GPDMA block section -------------------------------------------- */
/* Initialize buffer */
_DBG_("Initialize Buffer...");
Buffer_Init();
/* Disable GPDMA interrupt */
NVIC_DisableIRQ(DMA_IRQn);
/* preemption = 1, sub-priority = 1 */
NVIC_SetPriority(DMA_IRQn, ((0x01<<3)|0x01));
/* Initialize GPDMA controller */
GPDMA_Init();
// Setup GPDMA channel --------------------------------
// channel 0
GPDMACfg.ChannelNum = 0;
// Source memory
GPDMACfg.SrcMemAddr = DMA_SRC;
// Destination memory
GPDMACfg.DstMemAddr = DMA_DST;
// Transfer size
GPDMACfg.TransferSize = DMA_SIZE;
// Transfer width
GPDMACfg.TransferWidth = GPDMA_WIDTH_WORD;
// Transfer type
GPDMACfg.TransferType = GPDMA_TRANSFERTYPE_M2M;
// Source connection - unused
GPDMACfg.SrcConn = 0;
// Destination connection - unused
GPDMACfg.DstConn = 0;
// Linker List Item - unused
GPDMACfg.DMALLI = 0;
// Setup channel with given parameter
GPDMA_Setup(&GPDMACfg);
/* Reset terminal counter */
Channel0_TC = 0;
/* Reset Error counter */
Channel0_Err = 0;
_DBG_("Start transfer...");
// Enable GPDMA channel 0
GPDMA_ChannelCmd(0, ENABLE);
/* Enable GPDMA interrupt */
NVIC_EnableIRQ(DMA_IRQn);
/* Wait for GPDMA processing complete */
while ((Channel0_TC == 0) && (Channel0_Err == 0));
/* Verify buffer */
Buffer_Verify();
_DBG(compl_menu);
/* Loop forever */
while(1);
return 1;
}
static int parse_scan_elements(const char *payload, int size, struct wscn_scan_elements *elements)
{
char tag[512];
char value[128];
int i;
char *tail=(char *)payload;
memset(elements, 0, sizeof(struct wscn_scan_elements));
while (1)
{
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
if (!tag[0])
break; /* done */
if(strncmp(tag, "ColorEntries", 12) == 0)
{
int h=1;
while(h)
{
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
if(strncmp(tag, "Platen", 6) ==0) break;
if(strncmp(tag, "/ColorEntries", 13) ==0) break;
if(strncmp(tag, "ColorType", 9)==0)
{
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
if (strcmp(value, ce_element[CE_K1]) == 0)
elements->config.settings.color[CE_K1] = CE_K1;
else if (strcmp(value, ce_element[CE_GRAY8]) == 0)
elements->config.settings.color[CE_GRAY8] = CE_GRAY8;
else if (strcmp(value, ce_element[CE_COLOR8]) == 0)
elements->config.settings.color[CE_COLOR8] = CE_COLOR8;
// else
// _BUG("unknowned element=%s, sf_element[SF_JPEG]=%s, sf_element[SF_RAW]=%s\n", value, sf_element[SF_JPEG], sf_element[SF_RAW] );
_DBG("FormatSupported:%s\n", value);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
if(strncmp(tag, "/ColorEntries", 13) == 0) h=0;
}
if(strncmp(tag, "/ColorEntries", 13) == 0) h=0;
}
}
if(strncmp(tag, "Platen", 6) == 0)
{
elements->config.platen.flatbed_supported = 1;
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.platen.minimum_size.width=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.platen.minimum_size.height=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.platen.maximum_size.width=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.platen.maximum_size.height=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.platen.optical_resolution.width=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.platen.optical_resolution.height=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
i=1;
elements->config.platen.platen_resolution_list[0]=0;
while(strcmp(tag, "/SupportedResolutions"))
{
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
if(!strcmp(tag, "Resolution"))
{
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
_DBG ("parse_scan_elements platen_resolution_list value=%s\n", value);
if(strtol(value, NULL, 10) && elements->config.platen.platen_resolution_list[i-1] != strtol(value, NULL, 10))
elements->config.platen.platen_resolution_list[i++]=strtol(value, NULL, 10);
}
}
elements->config.platen.platen_resolution_list[0]=i-1;
}
if(strncmp(tag, "Adf", 3) == 0 && strlen(tag) == 3)
{
elements->config.adf.supported = 1;
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.adf.minimum_size.width=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.adf.minimum_size.height=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.adf.maximum_size.width=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.adf.maximum_size.height=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.adf.optical_resolution.width=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
elements->config.adf.optical_resolution.height=strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
i=1;
elements->config.adf.adf_resolution_list[0]=0;
while(strcmp(tag, "/SupportedResolutions"))
{
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
if(!strcmp(tag, "Resolution"))
{
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
_DBG ("parse_scan_elements adf_resolution_list value=%s", value);
if(strtol(value, NULL, 10) && elements->config.adf.adf_resolution_list[i-1] != strtol(value, NULL, 10))
elements->config.adf.adf_resolution_list[i++]=strtol(value, NULL, 10);
}
}
elements->config.adf.adf_resolution_list[0]=i-1;
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);//FeederCapacity
get_element(tail, size-(tail-payload), value, sizeof(value), &tail);
_DBG ("parse_scan_elements FeederCapacity=%s", value);
elements->config.settings.feeder_capacity = strtol(value, NULL, 10);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
get_tag(tail, size-(tail-payload), tag, sizeof(tag), &tail);
if(!strcmp(tag, "AdfDuplexer"))
{
elements->config.adf.duplex_supported = 1;
_DBG ("parse_scan_elements duplex_supported");
}
}
} /* end while (1) */
return 0;
} /* parse_scan_elements */
static int read_http_payload(struct ledm_session *ps, char *payload, int max_size, int sec_timeout, int *bytes_read)
{
struct bb_ledm_session *pbb = ps->bb_session;
int stat=1, total=0, len;
int tmo=sec_timeout;
enum HTTP_RESULT ret;
int payload_length=-1;
char *temp=NULL;
*bytes_read = 0;
if(http_read_header(pbb->http_handle, payload, max_size, tmo, &len) != HTTP_R_OK)
goto bugout;
_DBG("read_http_payload len=%d %s\n",len,payload);
temp = strstr(payload, "HTTP/1.1 201 Created");
if (temp)
{
*bytes_read = total = len;
stat=0;
return stat ;
}
temp=strstr(payload, "Content-Length:");
if (temp)
{
temp=temp+16;
temp=strtok(temp, "\r\n");
payload_length=strtol(temp, NULL, 10);
if (payload_length == 0)
{
*bytes_read = total = len;
stat=0;
return stat ;
}
}
memset(payload, ' ', len);
if(payload_length==-1)
{
int i=10;
while(i)
{
len = 0;
ret = http_read(pbb->http_handle, payload+total, max_size-total, tmo, &len);
total+=len;
tmo=1;
i--;
if (ret == HTTP_R_EOF)
{
_DBG("read_http_payload1 DONE......\n");
break; /* done */
}
if (!(ret == HTTP_R_OK || ret == HTTP_R_EOF))
{
_DBG("read_http_payload1 ERROR......\n");
goto bugout;
}
}//end while(i)
}//end if(payload_length==-1)
else
{
len=payload_length;
while (total < payload_length)
{
ret = http_read(pbb->http_handle, payload+total, max_size-total, tmo, &len);
total+=len;
tmo=1;
if (ret == HTTP_R_EOF)
{
_DBG("read_http_payload2 DONE......\n");
break; /* done */
}
if (!(ret == HTTP_R_OK || ret == HTTP_R_EOF))
{
_DBG("read_http_payload2 ERROR......\n");
goto bugout;
}
}//end while()
}//end else
*bytes_read = total;
stat=0;
bugout:
return stat;
} /* read_http_payload */
/*********************************************************************//**
* @brief c_entry: Main QEI program body
* @param[in] None
* @return int
**********************************************************************/
int c_entry(void)
{
PINSEL_CFG_Type PinCfg;
QEI_CFG_Type QEIConfig;
QEI_RELOADCFG_Type ReloadConfig;
uint32_t rpm, averageVelo;
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
_DBG_("Hello QEI ...");
_DBG("Speed will be sampled every each ");
_DBD32(CAP_PERIOD);
_DBG_(" us");
_DBG_("This value will be accumulated to display as RPM after every each");
_DBD32(DISP_TIME);
_DBG_(" us");
/* Initialize QEI configuration structure to default value */
#if CAP_MODE
QEIConfig.CaptureMode = QEI_CAPMODE_4X;
#else
QEIConfig.CaptureMode = QEI_CAPMODE_2X;
#endif
QEIConfig.DirectionInvert = QEI_DIRINV_NONE;
QEIConfig.InvertIndex = QEI_INVINX_NONE;
#if SIGNAL_MODE
QEIConfig.SignalMode = QEI_SIGNALMODE_CLKDIR;
#else
QEIConfig.SignalMode = QEI_SIGNALMODE_QUAD;
#endif
/* Set QEI function pin
* P1.20: MCI0
* P1.23: MCI1
* P1.24: MCI2
*/
PinCfg.Funcnum = 1;
PinCfg.OpenDrain = 0;
PinCfg.Pinmode = 0;
PinCfg.Portnum = 1;
PinCfg.Pinnum = 20;
PINSEL_ConfigPin(&PinCfg);
PinCfg.Pinnum = 23;
PINSEL_ConfigPin(&PinCfg);
PinCfg.Pinnum = 24;
PINSEL_ConfigPin(&PinCfg);
/* Initialize QEI peripheral with given configuration structure */
QEI_Init(LPC_QEI, &QEIConfig);
// Set timer reload value for QEI that used to set velocity capture period
ReloadConfig.ReloadOption = QEI_TIMERRELOAD_USVAL;
ReloadConfig.ReloadValue = CAP_PERIOD;
QEI_SetTimerReload(LPC_QEI, &ReloadConfig);
/* preemption = 1, sub-priority = 1 */
NVIC_SetPriority(QEI_IRQn, ((0x01<<3)|0x01));
/* Enable interrupt for QEI */
NVIC_EnableIRQ(QEI_IRQn);
// Reset VeloAccFlag
VeloAccFlag = RESET;
// Reset value of Acc and Acc count to default
VeloAcc = 0;
VeloCapCnt = 0;
// Enable interrupt for velocity Timer overflow for capture velocity into Acc */
QEI_IntCmd(LPC_QEI, QEI_INTFLAG_TIM_Int, ENABLE);
// Enable interrupt for direction change */
QEI_IntCmd(LPC_QEI, QEI_INTFLAG_DIR_Int, ENABLE);
#ifdef VIRTUAL_QEI_SIGNAL
// This used for generating virtual QEI signal
VirtualQEISignal_Init();
#endif
// Main loop
while (1) {
// Check VeloAccFlag continuously
if (VeloAccFlag == SET) {
// Get Acc
averageVelo = (uint32_t)(VeloAcc / VeloCapCnt);
rpm = QEI_CalculateRPM(LPC_QEI, averageVelo, ENC_RES);
// Disp the result
_DBG("Sampling Speed: ");
_DBD32(rpm);
_DBG_("RPM");
// Reset VeloAccFlag
VeloAccFlag = RESET;
// Reset value of Acc and Acc count to default
VeloAcc = 0;
VeloCapCnt = 0;
}
}
return 1;
}
/*********************************************************************//**
* @brief c_entry: main function
* @param[in] none
* @return int
**********************************************************************/
int c_entry(void) { /* Main Program */
uint32_t temp;
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
//print menu
_DBG(menu);
/* test Bit-banding SRAM first --------------------------------------------------------- */
_DBG_("Test bit-band SRAM... ");
//read variable at VAR_ADDRESS
temp = (*(volatile uint32_t *)(VAR_ADDRESS));
//print temp value
_DBG("The value at address "); _DBH32(VAR_ADDRESS); _DBG(": ");
_DBH32(temp); _DBG_("");
/* Use bitband function to read VAR_BIT value */
temp = BITBAND_SRAM_GetBit(VAR_ADDRESS,VAR_BIT);
_DBG("Use bit-band function to get value at bit 3: ");_DBG_("");
_DBH32(temp); _DBG_("");
/* clear bit */
BITBAND_SRAM_ClearBit(VAR_ADDRESS,VAR_BIT);
/* re-read temp value */
temp = (*(volatile uint32_t *)(VAR_ADDRESS));
_DBG("Value after clear bit 3 value by using bit-band function: ");_DBG_("");
_DBH32(temp); _DBG_("");
/* Set bit */
BITBAND_SRAM_SetBit(VAR_ADDRESS,VAR_BIT);
/* re-read temp value */
temp = (*(volatile uint32_t *)(VAR_ADDRESS));
_DBG("Value after set bit 3 value by using bit-band function: ");_DBG_("");
_DBH32(temp); _DBG_("");
_DBG_("");
/* Then, test Bit-banding PERI --------------------------------------------------------- */
_DBG_("Test bit-band PERIPHERAL... ");
LPC_SPI->SPCR =(1<<5)|(1<<3)|(10<<8);
/* Read the current value of peripheral register */
temp = (*(volatile uint32_t *)(PERI_ADDRESS));
_DBG("The value of peripheral register at "); _DBH32(PERI_ADDRESS); _DBG(": ");_DBG_("");
_DBH32(temp); _DBG_("");
/* Use bitband function to read VAR_BIT value */
temp = BITBAND_PERI_GetBit(PERI_ADDRESS,PERI_BIT);
_DBG("Use bit-band function to get value at bit 5: ");_DBG_(""); _DBH32(temp); _DBG_("");
/* clear bit */
BITBAND_PERI_ClearBit(PERI_ADDRESS,PERI_BIT);
/* re-read temp value */
temp = (*(volatile uint32_t *)(PERI_ADDRESS));
_DBG("Peripheral register after clear bit 5 value by using bit-band function: ");_DBG_("");
_DBH32(temp); _DBG_("");
/* Set bit */
BITBAND_PERI_SetBit(PERI_ADDRESS,PERI_BIT);
/* re-read temp value */
temp = (*(volatile uint32_t *)(PERI_ADDRESS));
_DBG("Peripheral register after set bit 5 value by using bit-band function: ");_DBG_("");
_DBH32(temp); _DBG_("");
while (1);
return 0;
}
/*********************************************************************//**
* @brief c_entry: main function
* @param[in] none
* @return int
**********************************************************************/
int c_entry(void) /* Main Program */
{
uint32_t priviledge_status;
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
LED_Init();
//print menu
_DBG(menu);
_DBG_(menu2);
/* Thread mode is privilege out of reset */
/* First checking Thread mode is privilege or un-privilege */
priviledge_status = __get_CONTROL();
if((priviledge_status & (~THREAD_PRIVILEDGED_MASK))==THREAD_PRIVILEGED)
{
_DBG_("Thread mode is privileged!");
Turn_on_LED(PRIVILEGE_LED);
}
else
{
_DBG_("Theard mode is unprivileged! It's not compliant with Cortex-M3 Technical");
while(1); //Error loop
}
/* Wait user press '1' character to change to un-privilege mode */
_DBG_("Press '1' to change to unprivilege mode ...\n\r");
while(_DG !='1');
/* Changing to un-privilege mode */
__set_CONTROL((priviledge_status & THREAD_PRIVILEDGED_MASK)|THREAD_UNPRIVILEGED);
_DBG_("Changed to unprivilege mode!");
/* Check */
priviledge_status = __get_CONTROL();
if((priviledge_status & ~THREAD_PRIVILEDGED_MASK)==THREAD_UNPRIVILEGED)
{
_DBG_("Check: Thread mode change to unprivilege successful!");
Turn_off_LED(PRIVILEGE_LED);
Turn_on_LED(UNPRIVILEGE_LED);
}
else
{
_DBG_("Check: Thread mode is still privileged! ERROR...");
while(1); //Error loop
}
/* Wait user press '1' character to change to un-privilege mode */
_DBG_("Press '2' to change to privilege mode by calling system call exception...\n\r");
while(_DG !='2');
/* Call system call exception to re-change Thread mode into privilege */
__SVC();
_DBG_("Called system call exception!");
/* Check */
priviledge_status = __get_CONTROL();
if((priviledge_status & ~THREAD_PRIVILEDGED_MASK)==THREAD_PRIVILEGED)
{
_DBG_("Check: Thread mode change to privilege successful!");
Turn_off_LED(UNPRIVILEGE_LED);
Turn_on_LED(PRIVILEGE_LED);
}
else
{
_DBG_("Check: Theard mode is still unprivileged! ERROR...");
while(1); //Error loop
}
_DBG_("Demo terminate!");
while (1);
return 0;
}
/**
* @brief Main program body
*/
int c_entry(void)
{
PINSEL_CFG_Type PinCfg;
GPDMA_Channel_CFG_Type GPDMACfg;
uint32_t adc_value, tmp;
// DeInit NVIC and SCBNVIC
NVIC_DeInit();
NVIC_SCBDeInit();
/* Configure the NVIC Preemption Priority Bits:
* two (2) bits of preemption priority, six (6) bits of sub-priority.
* Since the Number of Bits used for Priority Levels is five (5), so the
* actual bit number of sub-priority is three (3)
*/
NVIC_SetPriorityGrouping(0x05);
// Set Vector table offset value
#if (__RAM_MODE__==1)
NVIC_SetVTOR(0x10000000);
#else
NVIC_SetVTOR(0x00000000);
#endif
/*
* Initialize debug via UART
*/
debug_frmwrk_init();
// print welcome screen
print_menu();
/* GPDMA block section -------------------------------------------- */
/* Disable GPDMA interrupt */
NVIC_DisableIRQ(DMA_IRQn);
/* preemption = 1, sub-priority = 1 */
NVIC_SetPriority(DMA_IRQn, ((0x01<<3)|0x01));
/*
* Init LPC_ADC pin connect
* AD0.2 on P0.25
*/
PinCfg.Funcnum = 1;
PinCfg.OpenDrain = 0;
PinCfg.Pinmode = 0;
PinCfg.Pinnum = 25;
PinCfg.Portnum = 0;
PINSEL_ConfigPin(&PinCfg);
/* Configuration for ADC :
* Frequency at 1Mhz
* ADC channel 2, generate interrupt to make a request for DMA source
*/
ADC_Init(LPC_ADC, 1000000);
ADC_IntConfig(LPC_ADC,ADC_ADINTEN2,SET);
ADC_ChannelCmd(LPC_ADC,ADC_CHANNEL_2,SET);
/* Initialize GPDMA controller */
GPDMA_Init();
// Setup GPDMA channel --------------------------------
// channel 0
GPDMACfg.ChannelNum = 0;
// Source memory - unused
GPDMACfg.SrcMemAddr = 0;
// Destination memory
GPDMACfg.DstMemAddr = (uint32_t) &adc_value;
// Transfer size
GPDMACfg.TransferSize = DMA_SIZE;
// Transfer width - unused
GPDMACfg.TransferWidth = 0;
// Transfer type
GPDMACfg.TransferType = GPDMA_TRANSFERTYPE_P2M;
// Source connection
GPDMACfg.SrcConn = GPDMA_CONN_ADC;
// Destination connection - unused
GPDMACfg.DstConn = 0;
// Linker List Item - unused
GPDMACfg.DMALLI = 0;
// Setup channel with given parameter
GPDMA_Setup(&GPDMACfg, GPDMA_Callback);
/* Reset terminal counter */
Channel0_TC = 0;
/* Reset Error counter */
Channel0_Err = 0;
/* Enable GPDMA interrupt */
NVIC_EnableIRQ(DMA_IRQn);
while (1) {
// Enable GPDMA channel 0
GPDMA_ChannelCmd(0, ENABLE);
ADC_StartCmd(LPC_ADC,ADC_START_NOW);
/* Wait for GPDMA processing complete */;
while ((Channel0_TC == 0) );
// Disable GPDMA channel 0
GPDMA_ChannelCmd(0, DISABLE);
//Display the result of conversion on the UART0
_DBG("ADC value on channel 2: ");
_DBD32(ADC_DR_RESULT(adc_value));
_DBG_("");
// Wait for a while
for(tmp = 0; tmp < 1000000; tmp++);
// Re-setup channel
GPDMA_Setup(&GPDMACfg, GPDMA_Callback);
/* Reset terminal counter */
Channel0_TC = 0;
/* Reset Error counter */
Channel0_Err = 0;
}
ADC_DeInit(LPC_ADC);
return 1;
}
/******************************************************************************
** Main Function main()
******************************************************************************/
void c_entry (void)
{
uint8_t error = 0;
st_Mci_CardId cidval;
en_Mci_CardType cardType;
debug_frmwrk_init();
_DBG_("");_DBG(mciCidCardMenu);_DBG_("");
#if MCI_DMA_ENABLED
/* on DMA channel 0, source is memory, destination is MCI FIFO. */
/* On DMA channel 1, source is MCI FIFO, destination is memory. */
GPDMA_Init();
#endif
/* For the SD card I tested, the minimum required block length is 512 */
/* For MMC, the restriction is loose, due to the variety of SD and MMC
card support, ideally, the driver should read CSD register to find the
right speed and block length for the card, and set them accordingly.
In this driver example, it will support both MMC and SD cards, and it
does read the information by send SEND_CSD to poll the card status,
however, to simplify the example, it doesn't configure them accordingly
based on the CSD register value. This is not intended to support all
the SD and MMC cards. */
if(MCI_Init(BRD_MCI_POWERED_ACTIVE_LEVEL) != MCI_FUNC_OK)
{
_DBG_("MCI_Init FAILED");
while( 1 ); /* fatal error */
}
cardType = MCI_GetCardType();
switch (cardType)
{
case MCI_SDHC_SDXC_CARD:
_DBG_("Currently the SDXC/SDHC CARD ver2.0 is being used");
break;
case MCI_SDSC_V2_CARD:
_DBG_("Currently the SD CARD ver2.0 is being used");
break;
case MCI_SDSC_V1_CARD:
_DBG_("Currently the SD CARD ver1.0 is being used");
break;
case MCI_MMC_CARD:
_DBG_("Currently the MMC CARD is being used");
break;
case MCI_CARD_UNKNOWN:
_DBG_("No CARD is being plugged, Please check!!!");
error = 1;
break;
}
if(error)
while(1);
if (MCI_GetCID(&cidval) != MCI_FUNC_OK)
{
_DBG_("Get CID Failed");
while ( 1 ); /* fatal error */
}
else
{
_DBG("\n\r\t- Manufacture ID: ");_DBH32(cidval.MID);_DBG_("");
_DBG("\n\r\t- OEM/Application ID: ");_DBH32(cidval.OID);_DBG_("");
_DBG("\n\r\t- Product Name: ");_DBH(cidval.PNM_H);_DBH32_(cidval.PNM_L);_DBG_("");
_DBG("\n\r\t- Product Revision: ");_DBH32(cidval.PRV);_DBG_("");
_DBG("\n\r\t- Product Serial Number: ");_DBH32(cidval.PSN);_DBG_("");
_DBG("\n\r\t- Manufacturing Date: ");_DBH32(cidval.MDT);_DBG_("");
}
while(1);
}
/*********************************************************************//**
* @brief c_entry: Main TIMER program body
* @param[in] None
* @return int
**********************************************************************/
int c_entry(void)
{
PINSEL_CFG_Type PinCfg;
TIM_TIMERCFG_Type TIM_ConfigStruct;
TIM_MATCHCFG_Type TIM_MatchConfigStruct;
uint8_t idx;
uint16_t tem;
uint32_t freq1, freq2;
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
// print welcome screen
print_menu();
while(1)
{
// Select frequency for channel1 (MAT0.0)
idx=0;freq1=0;tem=0;
while(idx<3)
{
if(idx==0)
_DBG("\n\rPlease input frequency for channel1 (from 1 to 999 hz):");
tem = _DG;
switch(tem)
{
case '0':case'1':case '2':case '3':case '4':case '5':case '6':case '7':case'8':case '9':
tem = tem - 0x30;
idx++;
if(idx==1) tem = tem * 100;
else if (idx==2) tem = tem * 10;
freq1 = freq1 + tem;
if(idx==3)_DBD16(freq1);
tem = 0;
break;
default:
_DBG("...Please input digits from 0 to 9 only!");
idx = 0; tem = 0; freq1 = 0;
break;
}
}
idx=0;freq2=0;tem=0;
while(idx<3)
{
if(idx==0)
_DBG("\n\rPlease input frequency for channel2 (from 1 to 999 hz):");
tem = _DG;
switch(tem)
{
case '0':case'1':case '2':case '3':case '4':case '5':case '6':case '7':case'8':case '9':
tem = tem - 0x30;
idx++;
if(idx==1) tem = tem * 100;
else if (idx==2) tem = tem * 10;
freq2 = freq2 + tem;
if(idx==3)_DBD16(freq2);
tem = 0;
break;
default:
_DBG("...Please input digits from 0 to 9 only!");
idx = 0; tem = 0; freq2 = 0;
break;
}
}
// Configure P1.28 as MAT0.0
PinCfg.Funcnum = 3;
PinCfg.OpenDrain = 0;
PinCfg.Pinmode = 0;
PinCfg.Portnum = 1;
PinCfg.Pinnum = 28;
PINSEL_ConfigPin(&PinCfg);
// Configure P0.6 as MAT2.0
PinCfg.Funcnum = 3;
PinCfg.OpenDrain = 0;
PinCfg.Pinmode = 0;
PinCfg.Portnum = 0;
PinCfg.Pinnum = 6;
PINSEL_ConfigPin(&PinCfg);
// Initialize timer, prescale count time of 1uS
TIM_ConfigStruct.PrescaleOption = TIM_PRESCALE_USVAL;
TIM_ConfigStruct.PrescaleValue = 1;
TIM_Init(LPC_TIM0, TIM_TIMER_MODE,&TIM_ConfigStruct);
TIM_Init(LPC_TIM2, TIM_TIMER_MODE,&TIM_ConfigStruct);
// use channel 0, MR0
TIM_MatchConfigStruct.MatchChannel = 0;
// Disable interrupt when MR0 matches the value in TC register
TIM_MatchConfigStruct.IntOnMatch = FALSE;
//Enable reset on MR0: TIMER will reset if MR0 matches it
TIM_MatchConfigStruct.ResetOnMatch = TRUE;
//Stop on MR0 if MR0 matches it
TIM_MatchConfigStruct.StopOnMatch = FALSE;
//Toggle MR0.0 pin if MR0 matches it
TIM_MatchConfigStruct.ExtMatchOutputType =TIM_EXTMATCH_TOGGLE;
// Set Match value
TIM_MatchConfigStruct.MatchValue = 500000/freq1;
TIM_ConfigMatch(LPC_TIM0,&TIM_MatchConfigStruct);
// Set Match value
TIM_MatchConfigStruct.MatchValue = 500000/freq2;
TIM_ConfigMatch(LPC_TIM2,&TIM_MatchConfigStruct);
TIM_Cmd(LPC_TIM0,ENABLE);
TIM_Cmd(LPC_TIM2,ENABLE);
_DBG("\n\rGenerating two different frequency signals..");
_DBG("\n\rPress ESC if you want to terminate and choose other frequencies");
while(_DG!=27);
TIM_DeInit(LPC_TIM0);
TIM_DeInit(LPC_TIM2);
}
return (1);
}
int bb_open(struct ledm_session *ps)
{
struct bb_ledm_session *pbb;
struct device_settings *ds;
int stat=1, i, j;
_DBG("bb_open()\n");
if ((ps->bb_session = create_session()) == NULL)
goto bugout;
pbb = ps->bb_session;
/* Get scanner elements from device. */
if (get_scanner_elements(ps, &pbb->elements))
{
goto bugout;
}
/* Determine supported Scan Modes. */
ds = &pbb->elements.config.settings;
for(i=0, j=0; i<CE_MAX; i++)
{
if (ds->color[i] == CE_K1)
{
ps->scanModeList[j] = SANE_VALUE_SCAN_MODE_LINEART;
ps->scanModeMap[j++] = CE_K1;
}
if (ds->color[i] == CE_GRAY8)
{
ps->scanModeList[j] = SANE_VALUE_SCAN_MODE_GRAY;
ps->scanModeMap[j++] = CE_GRAY8;
}
if (ds->color[i] == CE_COLOR8)
{
ps->scanModeList[j] = SANE_VALUE_SCAN_MODE_COLOR;
ps->scanModeMap[j++] = CE_COLOR8;
}
}
/* Determine scan input sources. */
i=0;
if (pbb->elements.config.platen.flatbed_supported)
{
ps->inputSourceList[i] = STR_ADF_MODE_FLATBED;
ps->inputSourceMap[i++] = IS_PLATEN;
}
if (pbb->elements.config.adf.supported)
{
ps->inputSourceList[i] = STR_ADF_MODE_ADF;
ps->inputSourceMap[i++] = IS_ADF;
}
if (pbb->elements.config.adf.duplex_supported)
{
ps->inputSourceList[i] = STR_TITLE_DUPLEX;
ps->inputSourceMap[i++] = IS_ADF_DUPLEX;
}
/* Determine if jpeg quality factor is supported. */
if (pbb->elements.config.settings.jpeg_quality_factor_supported)
ps->option[LEDM_OPTION_JPEG_QUALITY].cap &= ~SANE_CAP_INACTIVE;
else
ps->option[LEDM_OPTION_JPEG_QUALITY].cap |= SANE_CAP_INACTIVE;
/* Set flatbed x,y extents. */
ps->platen_min_width = SANE_FIX(pbb->elements.config.platen.minimum_size.width/1000.0*MM_PER_INCH);
ps->platen_min_height = SANE_FIX(pbb->elements.config.platen.minimum_size.height/1000.0*MM_PER_INCH);
ps->platen_tlxRange.max = SANE_FIX(pbb->elements.config.platen.maximum_size.width/11.811023);
ps->platen_brxRange.max = ps->platen_tlxRange.max;
ps->platen_tlyRange.max = SANE_FIX(pbb->elements.config.platen.maximum_size.height/11.811023);
ps->platen_bryRange.max = ps->platen_tlyRange.max;
/* Set adf/duplex x,y extents. */
ps->adf_min_width = SANE_FIX(pbb->elements.config.adf.minimum_size.width/1000.0*MM_PER_INCH);
ps->adf_min_height = SANE_FIX(pbb->elements.config.adf.minimum_size.height/1000.0*MM_PER_INCH);
ps->adf_tlxRange.max = SANE_FIX(pbb->elements.config.adf.maximum_size.width/11.811023);
ps->adf_brxRange.max = ps->adf_tlxRange.max;
ps->adf_tlyRange.max = SANE_FIX(pbb->elements.config.adf.maximum_size.height/11.811023);
ps->adf_bryRange.max = ps->adf_tlyRange.max;
if (pbb->elements.config.platen.flatbed_supported)
{
i = pbb->elements.config.platen.platen_resolution_list[0] + 1;
while(i--)
{
_DBG("bb_open platen_resolution_list = %d\n", pbb->elements.config.platen.platen_resolution_list[i]);
ps->platen_resolutionList[i] = pbb->elements.config.platen.platen_resolution_list[i];
ps->resolutionList[i] = pbb->elements.config.platen.platen_resolution_list[i];
}
}
if (pbb->elements.config.adf.supported)
{
i = pbb->elements.config.adf.adf_resolution_list[0] + 1;
while(i--)
{
_DBG("bb_open adf_resolution_list = %d\n", pbb->elements.config.adf.adf_resolution_list[i]);
ps->adf_resolutionList[i] = pbb->elements.config.adf.adf_resolution_list[i];
ps->resolutionList[i] = pbb->elements.config.adf.adf_resolution_list[i];
}
}
stat = 0;
bugout:
return stat;
} /* bb_open */
/*********************************************************************//**
* @brief c_entry: Main RTC program body
* @param[in] None
* @return int
**********************************************************************/
int c_entry(void)
{
RTC_TIME_Type RTCFullTime;
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
// print welcome screen
print_menu();
/* RTC Block section ------------------------------------------------------ */
// Init RTC module
RTC_Init(LPC_RTC);
/* Disable RTC interrupt */
NVIC_DisableIRQ(RTC_IRQn);
/* preemption = 1, sub-priority = 1 */
NVIC_SetPriority(RTC_IRQn, ((0x01<<3)|0x01));
/* Enable rtc (starts increase the tick counter and second counter register) */
RTC_ResetClockTickCounter(LPC_RTC);
RTC_Cmd(LPC_RTC, ENABLE);
RTC_CalibCounterCmd(LPC_RTC, DISABLE);
/* Set current time for RTC */
// Current time is 8:00:00PM, 2009-04-24
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_SECOND, 0);
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_MINUTE, 0);
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_HOUR, 20);
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_MONTH, 4);
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_YEAR, 2009);
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_DAYOFMONTH, 24);
/* Set ALARM time for second */
RTC_SetAlarmTime (LPC_RTC, RTC_TIMETYPE_SECOND, 10);
// Get and print current time
RTC_GetFullTime (LPC_RTC, &RTCFullTime);
_DBG( "Current time set to: ");
_DBD((RTCFullTime.HOUR)); _DBG (":");
_DBD ((RTCFullTime.MIN)); _DBG (":");
_DBD ((RTCFullTime.SEC)); _DBG(" ");
_DBD ((RTCFullTime.DOM)); _DBG("/");
_DBD ((RTCFullTime.MONTH)); _DBG("/");
_DBD16 ((RTCFullTime.YEAR)); _DBG_("");
_DBG("Second ALARM set to ");
_DBD (RTC_GetAlarmTime (LPC_RTC, RTC_TIMETYPE_SECOND));
_DBG_("s");
/* Set the CIIR for second counter interrupt*/
RTC_CntIncrIntConfig (LPC_RTC, RTC_TIMETYPE_SECOND, ENABLE);
/* Set the AMR for 10s match alarm interrupt */
RTC_AlarmIntConfig (LPC_RTC, RTC_TIMETYPE_SECOND, ENABLE);
/* Enable RTC interrupt */
NVIC_EnableIRQ(RTC_IRQn);
/* Loop forever */
while(1);
return 1;
}
/* Set scan parameters. If scan has started, use actual known parameters otherwise estimate. */
int bb_get_parameters(struct ledm_session *ps, SANE_Parameters *pp, int option)
{
struct bb_ledm_session *pbb = ps->bb_session;
pp->last_frame = SANE_TRUE;
int factor;
_DBG("bb_get_parameters(option=%d)\n", option);
switch(ps->currentScanMode)
{
case CE_K1:
pp->format = SANE_FRAME_GRAY; /* lineart (GRAY8 converted to MONO by IP) */
pp->depth = 1;
factor = 1;
break;
case CE_GRAY8:
pp->format = SANE_FRAME_GRAY; /* grayscale */
pp->depth = 8;
factor = 1;
break;
case CE_COLOR8:
default:
pp->format = SANE_FRAME_RGB; /* color */
pp->depth = 8;
factor = 3;
break;
}
switch (option)
{
case SPO_STARTED: /* called by xsane */
if (ps->currentCompression == SF_RAW && ps->currentScanMode != CE_GRAY8)
{
/* Set scan parameters based on scan job response values */
//pp->lines = pbb->job.lines;
pp->lines = (int)(SANE_UNFIX(ps->effectiveBry - ps->effectiveTly)/MM_PER_INCH*ps->currentResolution);
pp->pixels_per_line = pbb->job.pixels_per_line;
pp->bytes_per_line = pbb->job.bytes_per_line;
}
else /* Must be SF_JFIF or ScanMode==CE_BLACK_AND_WHITE1. */
{
/* Set scan parameters based on IP. Note for Linart, use IP for hpraw and jpeg. */
//pp->lines = ps->image_traits.lNumRows;
pp->lines = (int)(SANE_UNFIX(ps->effectiveBry - ps->effectiveTly)/MM_PER_INCH*ps->currentResolution);
pp->pixels_per_line = ps->image_traits.iPixelsPerRow;
pp->bytes_per_line = BYTES_PER_LINE(pp->pixels_per_line, pp->depth * factor);
}
break;
case SPO_STARTED_JR: /* called by sane_start */
/* Set scan parameters based on scan job response values */
pp->lines = pbb->job.lines;
pp->pixels_per_line = pbb->job.pixels_per_line;
pp->bytes_per_line = pbb->job.bytes_per_line;
break;
case SPO_BEST_GUESS: /* called by xsane & sane_start */
/* Set scan parameters based on best guess. */
pp->lines = (int)round(SANE_UNFIX(ps->effectiveBry - ps->effectiveTly)/MM_PER_INCH*ps->currentResolution);
pp->pixels_per_line = (int)round(SANE_UNFIX(ps->effectiveBrx -ps->effectiveTlx)/MM_PER_INCH*ps->currentResolution);
pp->bytes_per_line = BYTES_PER_LINE(pp->pixels_per_line, pp->depth * factor);
break;
default:
break;
}
return 0;
}
void RTC_print_time(void){
char buffer[100];
time_t rawtime;
struct tm * timeinfo;
// xprintf(INFO "%d/%d/%d %d:%d:%d" " (%s:%d)\n",GetDOM(),GetM(),GetY(),GetHH(),GetMM(),GetSS(),_F_,_L_);
time( &rawtime );
timeinfo = localtime ( &rawtime );
strftime(buffer,90,"%d/%m/%Y %I:%M:%S%p WOY:%U DOY:%j",timeinfo);
xprintf(INFO "%s" " (%s:%d)\n", buffer,_F_,_L_);
// xprintf(INFO "%d/%d/%d %d:%d:%d" " (%s:%d)\n",_F_,_L_);
// xprintf(INFO "Unix: %d" " (%s:%d)\n",time2.unix,_F_,_L_);
// xprintf(INFO "Sunrise: %d" " (%s:%d)\n",time2.sunrise_unix,_F_,_L_);
timeinfo = localtime ( &time2.sunrise_unix );
strftime(buffer,80,"Sunrise: %I:%M:%S%p.",timeinfo);
xprintf(INFO "%s" " (%s:%d)\n", buffer,_F_,_L_);
// xprintf(INFO "Sunset: %d" " (%s:%d)\n",time2.sunset_unix,_F_,_L_);
timeinfo = localtime ( &time2.sunset_unix );
strftime(buffer,80,"Sunset: %I:%M:%S%p.",timeinfo);
xprintf(INFO "%s" " (%s:%d)\n", buffer,_F_,_L_);
// xprintf(INFO "Noon: %d" " (%s:%d)\n",time2.noon_unix,_F_,_L_);
timeinfo = localtime ( &time2.noon_unix );
strftime(buffer,80,"Noon: %I:%M:%S%p.",timeinfo);
xprintf(INFO "%s" " (%s:%d)\n", buffer,_F_,_L_);
xprintf(INFO "It's %s" " (%s:%d)\n",time2.day_night ? "Night time" : "Day time" ,_F_,_L_);
// xprintf(INFO "Day/Night: %d" " (%s:%d)\n",time2.day_night,_F_,_L_);
xprintf(INFO "DST begin: %d end: %d" " (%s:%d)\n",time2.DST_begin_calculated,time2.DST_end_calculated,_F_,_L_);
#if 0
_DBG("[INFO]-Date=");
_DBD(GetDOM());
_DBG("/");
_DBD(GetM());
_DBG("/");
_DBD16(GetY());
_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
_DBG("[INFO]-Time=");
_DBD(GetHH());
_DBG(":");
_DBD(GetMM());
_DBG(":");
_DBD(GetSS());
_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
_DBG("[INFO]-Unix: ");
_DBD32(time2.unix);
_DBG(" Sunrise: ");
_DBD32(time2.sunrise_unix);
_DBG(" Sunset: ");
_DBD32(time2.sunset_unix);
_DBG(" Noon: ");
_DBD32(time2.noon_unix);
_DBG(" Day/Night: ");
_DBD(time2.day_night);
_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
_DBG("[INFO]-DST begin: ");
_DBD32(time2.DST_begin_calculated);
_DBG(" end: ");
_DBD32(time2.DST_end_calculated);
_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
#endif
}
SANE_Status bb_start_scan(struct ledm_session *ps)
{
char buf[4096] = {0};
char buf1[1024]={0};
int len, bytes_read, paper_status;
int i, timeout = 10 ;
char szPage_ID[5] = {0};
char szJob_ID[5] = {0};
SANE_Status stat = SANE_STATUS_IO_ERROR;
struct bb_ledm_session *pbb = ps->bb_session;
ps->user_cancel = 0;
_DBG("bb_start_scan() entering...job_id=%d\n", ps->job_id);
if (ps->job_id == 0)
{
if(http_open(ps->dd, HPMUD_S_LEDM_SCAN, &pbb->http_handle) != HTTP_R_OK)
{
_BUG("unable to open channel HPMUD_S_LEDM_SCAN \n");
goto bugout;
}
if (http_write(pbb->http_handle, GET_SCANNER_STATUS, sizeof(GET_SCANNER_STATUS)-1, timeout) != HTTP_R_OK)
{
_BUG("unable to GET_SCANNER_STATUS \n");
goto bugout;
}
read_http_payload(ps, buf, sizeof(buf), timeout, &bytes_read);
if(!strstr(buf, SCANNER_IDLE))
{
stat = SANE_STATUS_DEVICE_BUSY;
goto bugout;
}
http_close(pbb->http_handle);
pbb->http_handle = 0;
if(http_open(ps->dd, HPMUD_S_LEDM_SCAN, &pbb->http_handle) != HTTP_R_OK)
{
_BUG("unable to open channel HPMUD_S_LEDM_SCAN \n");
goto bugout;
}
len = snprintf(buf, sizeof(buf), CREATE_SCAN_JOB_REQUEST,
ps->currentResolution,//<XResolution>
ps->currentResolution,//<YResolution>
(int) (ps->currentTlx / 5548.7133),//<XStart>
(int) ((ps->currentBrx / 5548.7133) - (ps->currentTlx / 5548.7133)),//<Width>
(int) (ps->currentTly / 5548.7133),//<YStart>
(int) ((ps->currentBry / 5548.7133) - (ps->currentTly / 5548.7133)),//<Height>
"Jpeg",//<Format>
(! strcmp(ce_element[ps->currentScanMode], "Color8")) ? "Color" : (! strcmp(ce_element[ps->currentScanMode], "Gray8")) ? "Gray" : "Gray",//<ColorSpace>
((! strcmp(ce_element[ps->currentScanMode], "Color8")) || (! strcmp(ce_element[ps->currentScanMode], "Gray8"))) ? 8: 8,//<BitDepth>
ps->currentInputSource == IS_PLATEN ? is_element[1] : is_element[2],//<InputSource>
ps->currentInputSource == IS_PLATEN ? is_element[1] : is_element[2],//<InputSourceType>
ps->currentInputSource != IS_ADF_DUPLEX ? "" : "<AdfOptions><AdfOption>Duplex</AdfOption></AdfOptions>",
(int)ps->currentBrightness,//<Brightness>
(int)ps->currentContrast);//<Contrast>
len = len + strlen(ZERO_FOOTER);
len = snprintf(buf1, sizeof(buf1), POST_HEADER, len);
if (http_write(pbb->http_handle, buf1, strlen(buf1), timeout) != HTTP_R_OK)
{
//goto bugout;
}
if (http_write(pbb->http_handle, buf, strlen(buf), 1) != HTTP_R_OK)
{
//goto bugout;
}
/* Write zero footer. */
if (http_write(pbb->http_handle, ZERO_FOOTER, sizeof(ZERO_FOOTER)-1, 1) != HTTP_R_OK)
{
//goto bugout;
}
memset(buf, 0, sizeof(buf));
/* Read response. */
if (read_http_payload(ps, buf, sizeof(buf), timeout, &bytes_read))
goto bugout;
http_close(pbb->http_handle);
pbb->http_handle = 0;
char joblist[64];
char* jl=strstr(buf, "Location:");
if (!jl) goto bugout;
jl=jl+10;
int i=0;
while(*jl != '\r')
{
joblist[i]=*jl;
jl=jl+1; i++;
}
joblist[i]='\0';
strcpy(ps->url, joblist);
char *c=ps->url;
c=strstr(c, "JobList");
if (c)
{
c=c+8;
int job_id=strtol(c, NULL, 10);
itoa(job_id, szJob_ID,10);
itoa(1, szPage_ID,10);
ps->page_id = 1;
ps->job_id = job_id;
}
}
else
{
if (ps->currentInputSource == IS_PLATEN)
{
stat = SANE_STATUS_INVAL;
goto bugout;
}
ps->page_id++;
itoa(ps->job_id,szJob_ID,10);
itoa(ps->page_id, szPage_ID,10);
}
_DBG("bb_start_scan() url=%s page_id=%d\n", ps->url, ps->page_id);
memset(buf, 0, sizeof(buf)-1);
if(http_open(ps->dd, HPMUD_S_LEDM_SCAN, &pbb->http_handle) != HTTP_R_OK)
{
_BUG("unable to open channel HPMUD_S_LEDM_SCAN \n");
goto bugout;
}
while(strstr(buf, READY_TO_UPLOAD) == NULL)
{
_DBG("bb_start_scan() ENTERING....buf=%s\n", buf);
len = snprintf(buf, sizeof(buf), GET_SCAN_JOB_URL, ps->url);
if (http_write(pbb->http_handle, buf, strlen(buf), 1) != HTTP_R_OK)
{
//goto bugout;
break ;
}
if (read_http_payload (ps, buf, sizeof(buf), 5, &len) != HTTP_R_OK)
{
//goto bugout
_DBG("bb_start_scan() read_http_payload FAILED len=%d buf=%s\n", len, buf);
break;
}
//For a new scan, buf must contain <PreScanPage>.
if (NULL == strstr(buf,PRESCANPAGE))
{ //i.e Paper is not present in Scanner
stat = SANE_STATUS_NO_DOCS;
goto bugout;
}
if (strstr(buf,JOBSTATE_CANCELED) || strstr(buf, CANCELED_BY_DEVICE) || strstr(buf, CANCELED_BY_CLIENT))
{
_DBG("bb_start_scan() SCAN CANCELLED\n");
stat = SANE_STATUS_GOOD;
ps->user_cancel = 1;
goto bugout;
}
if (strstr(buf, JOBSTATE_COMPLETED))
{
stat = SANE_STATUS_GOOD;
goto bugout;
}
usleep(500000);//0.5 sec delay
}//end while()
char *c = strstr(buf, "<BinaryURL>");
_DBG("bb_start_scan() BinaryURL=%s \n", c);
if (!c) goto bugout;
c +=11;
char BinaryURL[30];
i = 0;
while(*c != '<')
{
BinaryURL[i++] = *c ;
c++;
}
BinaryURL[i] = '\0';
//_DBG("bb_start_scan() BinaryURL=%s\n", BinaryURL);
len = snprintf(buf, sizeof(buf), GET_SCAN_JOB_URL, BinaryURL);
if (http_write(pbb->http_handle, buf, strlen(buf), timeout) != HTTP_R_OK)
{
//goto bugout;
}
if (http_read_header(pbb->http_handle, buf, sizeof(buf), timeout, &len) != HTTP_R_OK)
{
//goto bugout;
}
if(strstr(buf, "HTTP/1.1 400 Bad Request")) http_read_header(pbb->http_handle, buf, sizeof(buf), timeout, &len);
stat = SANE_STATUS_GOOD;
bugout:
if (stat && pbb->http_handle)
{
http_close(pbb->http_handle); /* error, close http connection */
pbb->http_handle = 0;
}
return stat;
} /* bb_start_scan */
int CHttpServer::runClientHandler(int nClientFD)
{
int result;
char pBuf[BUF_SIZE];
void* pvBuf = pBuf;
http_parser *parser = (http_parser*)malloc(sizeof(http_parser));
http_parser_settings *settings = (http_parser_settings*)malloc(sizeof(http_parser_settings));
size_t nparsed;
struct message *m;
m = (message *)malloc(sizeof(message));
memset(m, 0, sizeof(message));
pthread_setspecific(m_threadDatakey, m);
settings->on_url = onURL;
settings->on_header_field = onHeaderField;
settings->on_header_value = onHeaderValue;
settings->on_body = onBody;
settings->on_message_begin = onMessageBegin;
settings->on_headers_complete = onHeadersComplete;
settings->on_message_complete = onMessageComplete;
http_parser_init(parser, HTTP_REQUEST);
while (1)
{
memset(pBuf, 0, sizeof(pBuf));
result = socketrecv(nClientFD, &pvBuf);
if (0 >= result)
{
nparsed = http_parser_execute(parser, settings, pBuf, 0);
_DBG("nparsed: %lu state: %d method: %d", nparsed, parser->state, parser->method);
socketClose(nClientFD);
_DBG("socket close client: %d", nClientFD);
break;
}
if (0 < result)
{
nparsed = http_parser_execute(parser, settings, pBuf, result);
_DBG("nparsed: %lu state: %d method: %d", nparsed, parser->state, parser->method);
if (nparsed != (size_t)result)
{
/* Error. Close connecttion */
socketClose(nClientFD);
_DBG("http_parse error!");
break;
}
if (m->message_complete_cb_called)
{
processHttpMessage(nClientFD, m);
}
}
}
free(parser);
free(settings);
sendMessage(EVENT_FILTER_HTTP_SERVER, EVENT_COMMAND_THREAD_EXIT,
threadHandler->getThreadID(), 0, NULL);
threadHandler->threadSleep(1);
threadHandler->threadExit();
return 0;
}
static ssize_t proc_thecus_io_write(struct file *file,
const char __user * buf, size_t length,
loff_t * ppos)
{
char *buffer, buf1[20];
int i, err, v1, v2;
u8 val;
if (!buf || length > PAGE_SIZE)
return -EINVAL;
err = -ENOMEM;
buffer = (char *) __get_free_page(GFP_KERNEL);
if (!buffer)
goto out2;
err = -EFAULT;
if (copy_from_user(buffer, buf, length))
goto out;
err = -EINVAL;
if (length < PAGE_SIZE) {
buffer[length] = '\0';
#define LF 0xA
if (length > 0 && buffer[length - 1] == LF)
buffer[length - 1] = '\0';
} else if (buffer[PAGE_SIZE - 1])
goto out;
memset(buf1, 0, sizeof(buf1));
/*
* Usage: echo "S_LED 1-16 0|1|2" >/proc/thecus_io //2:Blink * LED SATA 1-16 ERROR led
* Usage: echo "U_LED 0|1|2" >/proc/thecus_io //2:Blink * USB BUSY led
* Usage: echo "UF_LED 0|1|2" >/proc/thecus_io //2:Blink * USB ERROR led
* Usage: echo "Fail 0|1" >/proc/thecus_io * LED System Fail
* Usage: echo "Busy 0|1" >/proc/thecus_io * LED System Busy
* Usage: echo "Buzzer 0|1" >/proc/thecus_io * Buzzer
* Usage: echo "RESET_PIC" >/proc/thecus_io * RESET_PIC
*/
if (!strncmp(buffer, "S_LED", strlen("S_LED"))) {
i = sscanf(buffer + strlen("S_LED"), "%d %d\n", &v1, &v2);
if (i == 2) //two input
{
if (v2 == 0) //input 0: want to turn off
val = LED_OFF;
else if (v2 == 1) //turn on
val = LED_ON;
else
val = LED_BLINK1;
if (v1 >= 1 && v1 <= 16) {
v1 = v1 - 1;
if((board_idx == 0) || (board_idx == 3) || (board_idx == 7)) { // only for N8900 back board, it's error led begin 8~15
if(v1 >= 0 && v1 <= 7)
pca9532_set_led(v1+8, val);
else
pca9532_set_led(v1, val);
} else {
pca9532_set_led(v1, val);
}
}
}
} else if (!strncmp(buffer, "UF_LED", strlen("UF_LED"))) {
i = sscanf(buffer + strlen("UF_LED"), "%d\n", &v1);
if (i == 1) //only one input
{
_DBG(1, "UF_LED %d\n", v1);
if (v1 == 0) //input 0: want to turn off
val = LED_OFF;
else if (v1 == 1) //turn on
val = LED_ON;
else
val = LED_BLINK1;
led_usb_err = val;
pca9532_id_set_led(11, val);
}
} else if (!strncmp(buffer, "U_LED", strlen("U_LED"))) {
i = sscanf(buffer + strlen("U_LED"), "%d\n", &v1);
if (i == 1) //only one input
{
_DBG(1, "U_LED %d\n", v1);
if (v1 == 0) //input 0: want to turn off
val = LED_OFF;
else if (v1 == 1) //turn on
val = LED_ON;
else
val = LED_BLINK1;
led_usb_busy = val;
pca9532_id_set_led(12, val);
}
} else if (!strncmp(buffer, "PWR_LED", strlen("PWR_LED"))) {
i = sscanf(buffer + strlen("PWR_LED"), "%d\n", &v1);
if (i == 1) //only one input
{
_DBG(1, "PWR_LED %d\n", v1);
if (v1 == 0) //input 0: want to turn off
val = LED_OFF;
else if (v1 == 1) //turn on
val = LED_ON;
else
val = LED_BLINK1;
led_sys_power = val;
pca9532_id_set_led(13, val);
}
} else if (!strncmp(buffer, "Busy", strlen("Busy"))) {
i = sscanf(buffer + strlen("Busy"), "%d\n", &v1);
if (i == 1) //only one input
{
_DBG(1, "Busy %d\n", v1);
if (v1 == 0) //input 0: want to turn off
val = LED_OFF;
else if (v1 == 1) //turn on
val = LED_ON;
else
val = LED_BLINK1;
led_sys_busy = val;
pca9532_id_set_led(14, val);
}
} else if (!strncmp(buffer, "Fail", strlen("Fail"))) {
i = sscanf(buffer + strlen("Fail"), "%d\n", &v1);
if (i == 1) //only one input
{
_DBG(1, "Fail %d\n", v1);
if (v1 == 0) //input 0: want to turn off
val = LED_OFF;
else if (v1 == 1) //turn on
val = LED_ON;
else
val = LED_BLINK1;
led_sys_err = val;
pca9532_id_set_led(15, val);
}
/*
} else if (!strncmp(buffer, "GPIO2", strlen("GPIO2"))) {
i = sscanf(buffer + strlen("GPIO2"), "%d\n", &v1);
if (i == 1) //only one input
{
printk("GPIO2 %d\n", v1);
PCH_6_gpio_write_bit(2,v1);
}
} else if (!strncmp(buffer, "GPIO3", strlen("GPIO3"))) {
i = sscanf(buffer + strlen("GPIO3"), "%d\n", &v1);
if (i == 1) //only one input
{
printk("GPIO3 %d\n", v1);
PCH_6_gpio_write_bit(3,v1);
}
*/
} else if (!strncmp(buffer, "Buzzer", strlen("Buzzer"))) {
i = sscanf(buffer + strlen("Buzzer"), "%d\n", &v1);
if (i == 1) //only one input
{
_DBG(1, "Buzzer %d\n", v1);
if (v1 == 0) //input 0: want to turn off
val = BUZZER_OFF;
else
val = BUZZER_ON;
keep_BUZZER = val;
kd_mksound(val * 440, 0);
}
} else if (!strncmp(buffer, "RESET_PIC", strlen("RESET_PIC"))) {
reset_pic();
}
err = length;
out:
free_page((unsigned long) buffer);
out2:
*ppos = 0;
return err;
}
void CHttpTestHandler::onCommand(int nClientFD, int nDataLen, const void *pData)
{
_DBG("nClientFD: %d nDataLen: %d", nClientFD, nDataLen);
}
void CSocketClient::runSMSSocketReceive(int nSocketFD)
{
int result = 0;
char szTmp[16];
int nTotalLen = 0;
int nBodyLen = 0;
int nCommand = generic_nack;
int nSequence = 0;
CMP_PACKET cmpPacket;
void* pHeader = &cmpPacket.cmpHeader;
void* pBody = &cmpPacket.cmpBody;
CMP_HEADER cmpHeader;
void *pHeaderResp = &cmpHeader;
int nCommandResp;
struct sockaddr_in *clientSockaddr;
clientSockaddr = new struct sockaddr_in;
while ( 1 )
{
memset( &cmpPacket, 0, sizeof(CMP_PACKET) );
result = socketrecv( nSocketFD, sizeof(CMP_HEADER), &pHeader, clientSockaddr );
if ( sizeof(CMP_HEADER) == result )
{
nTotalLen = ntohl( cmpPacket.cmpHeader.command_length );
/* nCommand = ntohl( cmpPacket.cmpHeader.command_id );
nSequence = ntohl( cmpPacket.cmpHeader.sequence_number );
if ( enquire_link_request == nCommand )
{
_DBG( "[Socket Server] Receive Enquir Link Request Sequence:%d Socket FD:%d", nSequence, nSocketFD );
memset( &cmpHeader, 0, sizeof(CMP_HEADER) );
nCommandResp = generic_nack | nCommand;
cmpHeader.command_id = htonl( nCommandResp );
cmpHeader.command_status = htonl( STATUS_ROK );
cmpHeader.sequence_number = htonl( nSequence );
cmpHeader.command_length = htonl( sizeof(CMP_HEADER) );
socketSend( nSocketFD, &cmpHeader, sizeof(CMP_HEADER) );
_DBG( "[Socket Server] Send Enquir Link Response Sequence:%d Socket FD:%d", nSequence, nSocketFD );
continue;
}
*/
nBodyLen = nTotalLen - sizeof(CMP_HEADER);
if ( 0 < nBodyLen )
{
result = socketrecv( nSocketFD, nBodyLen, &pBody, 0 );
if ( result != nBodyLen )
{
if ( externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect )
{
sendMessage( externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nSocketFD, 0, 0 );
}
socketClose( nSocketFD );
_DBG( "[Socket Client] socket client close : %d , packet length error: %d != %d", nSocketFD, nBodyLen, result );
break;
}
}
}
else
{
if ( externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect )
{
sendMessage( externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nSocketFD, 0, 0 );
}
socketClose( nSocketFD );
_DBG( "[Socket Client] socket client close : %d , packet header length error: %d", nSocketFD, result );
break;
}
if ( 0 >= result )
{
if ( externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect )
{
sendMessage( externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nSocketFD, 0, 0 );
}
socketClose( nSocketFD );
_DBG( "[Socket Client] socket client close: %d", nSocketFD );
break;
}
if ( externalEvent.isValid() )
{
// _DBG("[Socket Server] Send Message : FD=%d len=%d", nFD, result);
ClientReceive( nSocketFD, nTotalLen, &cmpPacket );
//sendMessage( externalEvent.m_nEventFilter, externalEvent.m_nEventRecvCommand, nSocketFD, nTotalLen, &cmpPacket );
}
else
{
sendMessage( m_nInternalFilter, EVENT_COMMAND_SOCKET_RECEIVE, nSocketFD, nTotalLen, &cmpPacket );
}
} // while
sendMessage( m_nInternalFilter, EVENT_COMMAND_THREAD_EXIT, threadHandler->getThreadID(), 0, NULL );
threadHandler->threadSleep( 1 );
threadHandler->threadExit();
}
/*********************************************************************//**
* @brief Print Welcome menu
* @param[in] none
* @return None
**********************************************************************/
void print_menu(void)
{
_DBG(menu);
}
/*********************************************************************//**
* @brief c_entry: Main ADC program body
* @param[in] None
* @return int
**********************************************************************/
int c_entry(void)
{
PINSEL_CFG_Type PinCfg;
uint32_t adc_value, tmp;
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
// print welcome screen
print_menu();
/* Initialize ADC ----------------------------------------------------*/
/* Because the potentiometer on different boards (MCB & IAR) connect
* with different ADC channel, so we have to configure correct ADC channel
* on each board respectively.
* If you want to check other ADC channels, you have to wire this ADC pin directly
* to potentiometer pin (please see schematic doc for more reference)
*/
#ifdef MCB_LPC_1768
/*
* Init ADC pin connect
* AD0.2 on P0.25
*/
PinCfg.Funcnum = 1;
PinCfg.OpenDrain = 0;
PinCfg.Pinmode = 0;
PinCfg.Pinnum = 25;
PinCfg.Portnum = 0;
PINSEL_ConfigPin(&PinCfg);
#elif defined (IAR_LPC_1768)
/*
* Init ADC pin connect
* AD0.5 on P1.31
*/
PinCfg.Funcnum = 3;
PinCfg.OpenDrain = 0;
PinCfg.Pinmode = 0;
PinCfg.Pinnum = 31;
PinCfg.Portnum = 1;
PINSEL_ConfigPin(&PinCfg);
#endif
/* Configuration for ADC :
* Select: ADC channel 2 (if using MCB1700 board)
* ADC channel 5 (if using IAR-LPC1768 board)
* ADC conversion rate = 200Khz
*/
ADC_Init(LPC_ADC, 200000);
ADC_IntConfig(LPC_ADC,_ADC_INT,DISABLE);
ADC_ChannelCmd(LPC_ADC,_ADC_CHANNEL,ENABLE);
while(1)
{
// Start conversion
ADC_StartCmd(LPC_ADC,ADC_START_NOW);
//Wait conversion complete
while (!(ADC_ChannelGetStatus(LPC_ADC,_ADC_CHANNEL,ADC_DATA_DONE)));
adc_value = ADC_ChannelGetData(LPC_ADC,_ADC_CHANNEL);
//Display the result of conversion on the UART0
#ifdef MCB_LPC_1768
_DBG("ADC value on channel 2: ");
#elif defined (IAR_LPC_1768)
_DBG("ADC value on channel 5: ");
#endif
_DBD32(adc_value);
_DBG_("");
//delay
for(tmp = 0; tmp < 1000000; tmp++);
}
ADC_DeInit(LPC_ADC);
return 1;
}
int main(void)
{
//CTIMER_DECLARE();
#if 0
uint32_t memory = SRAM1_LOC;
uint32_t lut = SRAM1_LOC;
//while(1);
memset((void *)QQ_LOC, 0x01, 0x3000);
g_qqueue->writeIndex = 0;
g_qqueue->produced = 0;
g_qqueue->consumed = 0;
while(1)
getRLSFrame(&memory, &lut);
#endif
#if 0
int i = 0x12345678;
foo(&i);
printf("%d\n", i);
while(1);
#endif
#if 0
int i;
uint32_t lut = SRAM1_LOC;
uint32_t memory = SRAM1_LOC+0x1000;
uint8_t *plut = (uint8_t *)lut;
for (i=0; i<0x4000; i++)
plut[i] = i%5==0 ? 1 : 0;
while(1)
getRLSFrame(&memory, &lut);
#endif
#if 1
_DBG("M0 start\n");
chirpOpen();
exec_init();
frame_init();
rls_init();
#if 0
while(1)
{
if (g_foo)
loop0();
}
#endif
#if 0
vsync();
#endif
#if 0
//while(g_loop);
uint8_t type = CAM_GRAB_M1R2;
uint32_t memory = SRAM1_LOC;
uint16_t offset = 0;
uint16_t width = 320;
uint16_t height = 200;
while(1)
{
getFrame(&type, &memory, &offset, &offset, &width, &height);
i++;
if (i%50==0)
{
_DBD32(i), _CR();
}
}
#endif
//printf("M0 ready\n");
exec_loop();
#endif
#if 0
while(1)
{
CTIMER_START();
syncM1((uint32_t *)&LPC_GPIO_PORT->PIN[1], 0x2000);
CTIMER_STOP();
printf("%d\n", CTIMER_GET());
}
#endif
#if 0
{
uint32_t i;
uint8_t *lut = (uint8_t *)SRAM1_LOC + 0x10000;
uint32_t memory = SRAM1_LOC;
uint32_t size = SRAM1_SIZE/2;
for (i=0; i<0x10000; i++)
lut[i] = 0;
lut[0xb400] = 0;
lut[0xb401] = 1;
lut[0xb402] = 1;
lut[0xb403] = 1;
lut[0xb404] = 0;
lut[0xb405] = 1;
lut[0xb406] = 1;
lut[0xb407] = 0;
lut[0xb408] = 0;
lut[0xb409] = 0;
while(1)
getRLSFrame(&memory, &size); //, (uint32_t *)&lut);
}
#endif
return 0;
}
/* 调试相关定义***********************************************/
void uip_log(char *m)
{
_DBG("uIP log message: ");
_DBG(m);
_DBG_("");
}
/*********************************************************************//**
* @brief c_entry: Main MCPWM program body
* @param[in] None
* @return int
**********************************************************************/
int c_entry(void)
{
// MCPWM Channel configuration data
MCPWM_CHANNEL_CFG_Type channelsetup[3];
uint32_t i;
PINSEL_CFG_Type PinCfg;
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
_DBG_("Hello MCPWM ...");
/* Pin configuration for MCPWM function:
* Assign: - P1.19 as MCOA0 - Motor Control Channel 0 Output A
* - P1.22 as MCOB0 - Motor Control Channel 0 Output B
* - P1.25 as MCOA1 - Motor Control Channel 1 Output A
* - P1.26 as MCOB1 - Motor Control Channel 1 Output B
* - P1.28 as MCOA2 - Motor Control Channel 2 Output A
* - P1.29 as MCOB2 - Motor Control Channel 2 Output B
* - P1.20 as MCI0 - Motor Control Feed Back Channel 0
* Warning: According to Errata.lpc1768-18.March.2010: Input pin (MIC0-2)
* on the Motor Control PWM peripheral are not functional
*/
PinCfg.Funcnum = 1;
PinCfg.OpenDrain = 0;
PinCfg.Pinmode = 0;
PinCfg.Portnum = 1;
PinCfg.Pinnum = 19;
PINSEL_ConfigPin(&PinCfg);
PinCfg.Pinnum = 22;
PINSEL_ConfigPin(&PinCfg);
PinCfg.Pinnum = 25;
PINSEL_ConfigPin(&PinCfg);
PinCfg.Pinnum = 26;
PINSEL_ConfigPin(&PinCfg);
PinCfg.Pinnum = 28;
PINSEL_ConfigPin(&PinCfg);
PinCfg.Pinnum = 29;
PINSEL_ConfigPin(&PinCfg);
PinCfg.Pinnum = 20;
PINSEL_ConfigPin(&PinCfg);
/* Disable interrupt for MCPWM */
NVIC_DisableIRQ(MCPWM_IRQn);
/* preemption = 1, sub-priority = 1 */
NVIC_SetPriority(MCPWM_IRQn, ((0x01<<3)|0x01));
/* Init MCPWM peripheral */
MCPWM_Init(LPC_MCPWM);
channelsetup[0].channelType = MCPWM_CHANNEL_EDGE_MODE;
channelsetup[0].channelPolarity = MCPWM_CHANNEL_PASSIVE_LO;
channelsetup[0].channelDeadtimeEnable = DISABLE;
channelsetup[0].channelDeadtimeValue = 0;
channelsetup[0].channelUpdateEnable = ENABLE;
channelsetup[0].channelTimercounterValue = 0;
channelsetup[0].channelPeriodValue = 300;
channelsetup[0].channelPulsewidthValue = 0;
channelsetup[1].channelType = MCPWM_CHANNEL_EDGE_MODE;
channelsetup[1].channelPolarity = MCPWM_CHANNEL_PASSIVE_LO;
channelsetup[1].channelDeadtimeEnable = DISABLE;
channelsetup[1].channelDeadtimeValue = 0;
channelsetup[1].channelUpdateEnable = ENABLE;
channelsetup[1].channelTimercounterValue = 0;
channelsetup[1].channelPeriodValue = 300;
channelsetup[1].channelPulsewidthValue = 100;
channelsetup[2].channelType = MCPWM_CHANNEL_EDGE_MODE;
channelsetup[2].channelPolarity = MCPWM_CHANNEL_PASSIVE_LO;
channelsetup[2].channelDeadtimeEnable = DISABLE;
channelsetup[2].channelDeadtimeValue = 0;
channelsetup[2].channelUpdateEnable = ENABLE;
channelsetup[2].channelTimercounterValue = 0;
channelsetup[2].channelPeriodValue = 300;
channelsetup[2].channelPulsewidthValue = 200;
MCPWM_ConfigChannel(LPC_MCPWM, 0, &channelsetup[0]);
MCPWM_ConfigChannel(LPC_MCPWM, 1, &channelsetup[1]);
MCPWM_ConfigChannel(LPC_MCPWM, 2, &channelsetup[2]);
#if DC_MODE_TEST
/*
* - DC mode enabled.
* - Invert Output enabled
* - A0 and A1 output pin is internally routed to A0 signal
*/
MCPWM_DCMode(LPC_MCPWM, ENABLE, ENABLE, (MCPWM_PATENT_A0|MCPWM_PATENT_A1));
#endif
#if AC_MODE_TEST
/*
* - AC mode is enabled.
*/
MCPWM_ACMode(LPC_MCPWM, ENABLE);
#endif
#if CAPTURE_MODE_TEST
/*
* Capture mode in this case is used to detect the falling edge on MCO0B output pin.
* The MCFB0 input pin therefore must be connected to MCO0B. (P1.20 - P1.22)
* - Capture Channel 0.
* - Capture falling edge on MCFB0 input pin.
* - Interrupt enabled on capture event.
*/
captureCfg.captureChannel = 0;
captureCfg.captureFalling = ENABLE;
captureCfg.captureRising = DISABLE;
captureCfg.hnfEnable = DISABLE;
captureCfg.timerReset = DISABLE;
MCPWM_ConfigCapture(LPC_MCPWM, 0, &captureCfg);
// Reset flag for the first time
CapFlag = RESET;
// Enable interrupt for capture event on MCI0 (MCFB0)
MCPWM_IntConfig(LPC_MCPWM, MCPWM_INTFLAG_CAP0, ENABLE);
/* Enable interrupt for MCPWM */
NVIC_EnableIRQ(MCPWM_IRQn);
#endif
MCPWM_Start(LPC_MCPWM, ENABLE, ENABLE, ENABLE);
// Main loop
while (1) {
// Timer_Wait(LPC_TIM0, 1000);
//delay
for(i=0; i<100000; i++);
channelsetup[0].channelPulsewidthValue = (channelsetup[0].channelPulsewidthValue >= 300) ?
0 : channelsetup[0].channelPulsewidthValue + 20;
channelsetup[1].channelPulsewidthValue = (channelsetup[1].channelPulsewidthValue >= 300) ?
0 : channelsetup[1].channelPulsewidthValue + 20;
channelsetup[2].channelPulsewidthValue = (channelsetup[2].channelPulsewidthValue >= 300) ?
0 : channelsetup[2].channelPulsewidthValue + 20;
_DBG_("Update!");
MCPWM_WriteToShadow(LPC_MCPWM, 0, &channelsetup[0]);
MCPWM_WriteToShadow(LPC_MCPWM, 1, &channelsetup[1]);
MCPWM_WriteToShadow(LPC_MCPWM, 2, &channelsetup[2]);
#if CAPTURE_MODE_TEST
// Check capture flag is set or not
if (CapFlag) {
// Print out the value
_DBG("Capture Value: ");
_DBD32(CapVal);
_DBG_("");
// Setup a new capture event
MCPWM_ConfigCapture(LPC_MCPWM, 0, &captureCfg);
// Re-Enable interrupt for capture event on MCI0 (MCFB0)
MCPWM_IntConfig(LPC_MCPWM, MCPWM_INTFLAG_CAP0, ENABLE);
// Reset flag
CapFlag = RESET;
}
#endif
}
/* Loop forever */
return 1;
}
// Menu handler
static void menu(gpointer d, guint action, GtkWidget *w) {
char *name;
switch(action) {
case MID_OPEN12:
_DBG(_DBG_GUI,"open DPS12\n");
name = get_file("Open DPS12 backup", FALSE);
if (name)
open_backup("-dps12", name);
break;
case MID_OPEN16:
_DBG(_DBG_GUI,"open DPS16\n");
name = get_file("Open DPS16 backup", FALSE);
if (name)
open_backup("-dps16", name);
break;
case MID_CLOSE:
_DBG(_DBG_GUI,"close\n");
close_backup();
break;
case MID_PROPS:
_DBG(_DBG_GUI,"properties\n");
show_project_info();
break;
case MID_EXIT:
quit(w, NULL, d);
break;
case MID_SELASS:
_DBG(_DBG_GUI,"select assigned\n");
select_tracks(action);
break;
case MID_SELNOE:
_DBG(_DBG_GUI,"select non-empty\n");
select_tracks(action);
break;
case MID_SELALL:
_DBG(_DBG_GUI,"select all\n");
select_tracks(action);
break;
case MID_SELNONE:
_DBG(_DBG_GUI,"select none\n");
select_tracks(action);
break;
case MID_SELEXP:
_DBG(_DBG_GUI,"export selected\n");
if (g_proj.splbyte==2)
extract_tracks();
else
about_box("FIXME: only 16-bit data can be exported");
break;
case MID_HELP:
_DBG(_DBG_GUI,"help about\n");
about_box(NULL);
break;
case MID_VERSION:
_DBG(_DBG_GUI,"help versions\n");
{
char buf[256];
sprintf(buf, "deepstripper-gtk: %s\ngtk-build: %d.%d.%d\ngtk-runtime: %d.%d.%d",
RELEASE, GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION,
gtk_major_version, gtk_minor_version, gtk_micro_version);
about_box(buf);
}
break;
case MID_MULTI:
_DBG(_DBG_GUI,"change project: %s\n", ((AkaiOsDisk_Dirent *)d)->name);
open_project(g_dps, (AkaiOsDisk_Dirent *)d);
break;
default:
_DBG(_DBG_GUI,"unknown action: %d\n", action);
break;
}
}
