uint16_t ir_read(uint8_t* buf, uint16_t maxlen, uint8_t* data)
{
if(strlen(data) == 0){
// "Index" action
return snprintf_P(buf, maxlen, PSTR(
"<h1>Choose frequency:</h1>"
"<div id=\"l\"><ul>"
"<li><a href=\"38\">38 kHz</a>"
"<li><a href=\"56\">56 kHz</a>"
"</ul></div>"
"<br>"
"<br>"
"<br>"
"<br>"
"Instructions:<br>"
"Press and hold a button on remote control, then click on desired<br>"
"frequency above. The output format is described <a href=\"../send/\">here</a>."
"<h4><a href=\"../\">Return</a></h4>"
));
}else if(strcmp_P(data, PSTR("38")) == 0 ){
return ir_read_38(buf, maxlen, data);
}else if(strcmp_P(data, PSTR("56")) == 0 ){
return ir_read_56(buf, maxlen, data);
}else{
//error
return snprintf_P(buf, maxlen, PSTR(
"<h1>Improper request</h1>"
"<br><br><br><br><br><br>"
"<h4><a href=\"../\">Return</a></h4>"
));
return 0;
}
}
uint8_t TelnetServer::iParse(char buffer[])
{
char temp[FULLIP_TELNET_LINE_SIZE];
//Serial.println(PSTR("quit"));
if (strcmp_P(buffer,PSTR(""))==0) {
strcpy_P(temp,PSTR("Welcome to telnet"));
client.println(temp);
strcpy_P(temp,PSTR("Type ? to display a list of commands"));
client.println(temp);
return _iParse(buffer);
} else if (strcmp_P(buffer,PSTR("quit"))==0) {
//strcpy_P(temp,PSTR("Bye"));
//client.println(temp);
disconnect();
return 1;
} else if (strcmp_P(buffer,PSTR("?"))==0) {
strcpy_P(temp,PSTR("quit : close the connection"));
client.println(temp);
return _iParse(buffer);
} else {
uint8_t ret=_iParse(buffer);
if (ret!=1) {
strcpy_P(temp,PSTR("command not found"));
client.println(temp);
}
}
return 0;
}
void wifiServerSaveConfig() {
Serial.println(F("Saving settings"));
int fail = 0;
while (strcmp_P(useLineBuffer(), PSTR("begin")) != 0)
wifiBufferLoop();
while (1) {
wifiBufferLoop();
if (hasNewLine()) {
if (strcmp_P(useLineBuffer(), PSTR("end")) == 0)
break;
if (!configParseRequest(useLineBuffer())) {
Serial.println(F("fail:"));
Serial.println(useLineBuffer());
Serial.println(F("end"));
wifiInitiateSend(linkID);
wifiServerSendPGMP(http400, &stream);
wifiEndSend();
fail = 1;
break;
}
}
}
if (fail == 0) {
configWrite();
Serial.println(linkID);
wifiInitiateSend(linkID);
wifiServerSendPGMP(http200json, &stream);
wifiServerSendPGMP(success, &stream);
wifiEndSend();
}
}
static void
soap_parse_element (soap_context_t *ctx)
{
if (*ctx->buf != '<')
SOAP_STREAM_ERROR();
if (ctx->buf[1] == '?')
return; /* ignore parser instruction. */
if (ctx->parsing_complete)
return;
ctx->buf[ctx->buflen] = 0;
SOAP_DEBUG ("parse_element %s\n", ctx->buf);
if (!ctx->found_envelope)
{
if (strncmp_P (ctx->buf + 1, PSTR("Envelope"), 8))
SOAP_STREAM_ERROR();
ctx->found_envelope = 1;
}
else if (!ctx->found_body)
{
if (strncmp_P (ctx->buf + 1, PSTR("Body"), 4))
return; /* ignore anything until <Body> */
ctx->found_body = 1;
}
else if (!ctx->found_funcname)
{
soap_lookup_funcname (ctx);
ctx->found_funcname = 1;
}
else if (strncmp_P (ctx->buf + 1, PSTR("/Body"), 5) == 0)
{
ctx->parsing_complete = 1;
}
else if (ctx->buf[1] != '/' && ctx->argslen < SOAP_MAXARGS)
{
char *ptr = strstr_P (ctx->buf + 1, PSTR("type="));
if (!ptr)
SOAP_STREAM_ERROR ();
ptr += 6; /* Skip type=" */
char *end = strchr (ptr, '"');
if (!end)
SOAP_STREAM_ERROR ();
*end = 0; /* chop off rest beyond type specifier */
end = strchr (ptr, ':');
if (end) ptr = end + 1; /* Ignore namespace specifier */
SOAP_DEBUG ("found arg type: '%s'\n", ptr);
if (strcmp_P (ptr, PSTR("int")) == 0)
ctx->args[ctx->argslen].type = SOAP_TYPE_INT;
else if (strcmp_P (ptr, PSTR("string")) == 0)
ctx->args[ctx->argslen].type = SOAP_TYPE_STRING;
else
SOAP_STREAM_ERROR ();
}
}
ModemGSM::EStandardAnswer ModemGSM::WaitAnswer(unsigned int pTimeoutMS, boolean pHandleURC)
{
//DEBUG_P("WaitAnswer --> ");
for(;;)
{
if(Readln(pTimeoutMS, false) == TIMEOUT)
{
DEBUG_P(PSTR("** TIMEOUT"LB));
return saTimeout;
}
//DEBUGLN(FRXBuff);
if(strcmp_P(FRXBuff,PSTR("OK")) == 0)
{
//DEBUGLN_P("OK");
return saOk;
}
else if( (strcmp_P(FRXBuff,PSTR("ERROR")) == 0) ||
(strncmp_P(FRXBuff,PSTR("+CME ERROR:"), 11) == 0) ||
(strncmp_P(FRXBuff,PSTR("+CMS ERROR:"), 11) == 0))
{
DEBUG_P(PSTR("** "));
DEBUGLN(FRXBuff);
return saError;
}
else if(pHandleURC)
HandleURC();
else
return saUnknown;
}
}
// pinMode( arg[0], arg[1] )
void Mode(void)
{
if ( (command_done == 10) )
{
// check that arg[0] is a digit
if ( ( !( isdigit(arg[0][0]) ) ) )
{
printf_P(PSTR("{\"err\":\"pModeNaN\"}\r\n"));
initCommandBuffer();
return;
}
// and arg[0] value is 2|3|24|25|26|27
uint8_t a = atoi(arg[0]);
if ( (a != 2) && (a != 3) && ( ( a < 24) || (a > 27) ) )
{
printf_P(PSTR("{\"err\":\"pModeOutOfRng\"}\r\n"));
initCommandBuffer();
return;
}
// also arg[1] is not ('INPUT' or 'OUTPUT')
if ( !( (strcmp_P( arg[1], PSTR("INPUT")) == 0) || (strcmp_P( arg[1], PSTR("OUTPUT")) == 0) ) )
{
printf_P(PSTR("{\"err\":\"pModeNaMode\"}\r\n"));
initCommandBuffer();
return;
}
serial_print_started_at = millis();
if (strcmp_P( arg[1], PSTR("OUTPUT")) == 0 )
{
pinMode(a, OUTPUT);
}
else
{
pinMode(a, INPUT);
}
printf_P(PSTR("{\""));
command_done = 11;
}
else if ( (command_done == 11) )
{
echo_digital_pin_in_json_rply();
printf_P(PSTR("\":\""));
command_done = 12;
}
else if ( (command_done == 12) )
{
printf( arg[1] );
printf_P(PSTR("\"}\r\n"));
initCommandBuffer();
}
else
{
printf_P(PSTR("{\"err\":\"pModeCmdDnWTF\"}\r\n"));
initCommandBuffer();
}
}
int
ThingSpeak::TalkBack::execute_next_command()
{
// Use an iostream for the http post request
Socket* sock = m_client->m_sock;
IOStream page(sock);
// Connect to the server
int res = m_client->connect();
if (res < 0) goto error;
// Generate the http post request with talkback id and key
page << PSTR("POST /talkbacks/") << m_id
<< PSTR("/commands/execute?api_key=") << m_key
<< PSTR(" HTTP/1.1") << CRLF
<< PSTR("Host: api.thingspeak.com") << CRLF
<< PSTR("Connection: close") << CRLF
<< PSTR("Content-Length: 0") << CRLF
<< CRLF;
sock->flush();
// Wait for the reply
while ((res = sock->available()) == 0) delay(16);
if (res < 0) goto error;
// Parse reply header
Command* command;
uint8_t length;
char line[64];
sock->gets(line, sizeof(line));
res = -1;
if (strcmp_P(line, PSTR("HTTP/1.1 200 OK\r"))) goto error;
do {
sock->gets(line, sizeof(line));
} while ((sock->available() > 0) && (strcmp_P(line, PSTR("\r"))));
if (sock->available() <= 0) goto error;
// Parse reply length and command string
sock->gets(line, sizeof(line));
length = (uint8_t) strtol(line, NULL, 16);
if (length <= 0) goto error;
sock->gets(line, sizeof(line));
line[length] = 0;
// Lookup the command and execute. Disconnect before and the command might
// issue an add command request
res = -5;
command = lookup(line);
if (command == NULL) goto error;
m_client->disconnect();
command->execute();
return (0);
error:
m_client->disconnect();
return (res);
}
/*
* This method parses a incoming string (the message is expected to be complete)
* Depending on the instruction the action is undertaken.
*/
void SerialCommunicator::setReceivedMessage(const char* newMessage)
{
if (strcmp_P(newMessage, DUMP) == 0)
{
dumpAllFields();
} else if (strncmp_P(newMessage, GET, 4) == 0)
{
SerialOutput.println((__FlashStringHelper *) GET);
FieldData *fieldData = FieldData::findField(newMessage + 4);
if (fieldData != 0) fieldData->dump();
} else if (strncmp_P(newMessage, SET, 4) == 0)
{
SerialOutput.println((__FlashStringHelper *) SET);
FieldData *fp = FieldData::findField(newMessage + 4);
if (fp != 0)
{
fp->setValue(newMessage + 4 + strlen_P((const char *) fp->myClassName) + strlen_P((const char *) fp->myFieldName) + 2);
fp->dump();
}
} else if (strncmp_P(newMessage, SET, 3) == 0)
{
SerialOutput.println((__FlashStringHelper *) SET);
FieldData::visitAllFields(dumpWritableData, true);
} else if (strcmp_P(newMessage, LOG_HEADER) == 0)
{
SerialOutput.print((__FlashStringHelper *) LOG_HEADER);
SerialOutput.print(FIELDSEPERATOR);
FieldData::visitAllFields(logHeaderVisitor, true);
SerialOutput.println();
return;
} else if (strcmp_P(newMessage, LOG_VALUE) == 0)
{
logValue();
return;
//#ifdef I_USE_RESET
// } else if (strcmp_P(newMessage, RESET) == 0)
// {
// ForceHardReset();
//#endif
} else
{
dumpCommands();
if ('?' != newMessage[0])
{
SerialOutput.print((__FlashStringHelper *) ERROR);
//Even though it is handy to see what has been send
//The yun bootloader sends press ard to stop bootloader
//echoing this means the bootloader receives ard
//SerialOutput.println(newMessage);
}
return;
}
SerialOutput.println((__FlashStringHelper *) DONE);
}
/* function called when cmd_color is parsed successfully */
static void cmd_color_parsed(void *parsed_result, void *data)
{
struct cmd_color_result *res = (struct cmd_color_result *) parsed_result;
if (!strcmp_P(res->color, PSTR("yellow"))) {
ballboard.our_color = I2C_COLOR_YELLOW;
}
else if (!strcmp_P(res->color, PSTR("blue"))) {
ballboard.our_color = I2C_COLOR_BLUE;
}
printf_P(PSTR("Done\r\n"));
}
void ProcessCmd()
{
if ( (strcmp_P( command, PSTR("/id?")) == 0) && ( (arg_count == 0) || (arg_count == 1) ) )
{
Id("CCtest");
}
if ( (strcmp_P( command, PSTR("/cctest?")) == 0) && ( (arg_count == 0) || (arg_count == 1) || (arg_count == 3) ) )
{
CCtest();
}
}
int16_t parse_cmd_pin_set(char *cmd, char *output, uint16_t len)
{
uint16_t port, pin, on;
/* Parse String */
uint8_t ret = sscanf_P(cmd, PSTR("%u %u %u"), &port, &pin, &on);
/* Fallback to named pins */
if ( ret != 3 && *cmd) {
char *ptr = strchr(cmd + 1, ' ');
if (ptr) {
*ptr = 0;
uint8_t pincfg = named_pin_by_name(cmd + 1);
if (pincfg != 255) {
port = pgm_read_byte(&portio_pincfg[pincfg].port);
pin = pgm_read_byte(&portio_pincfg[pincfg].pin);
if (ptr[1]) {
ptr++;
if(sscanf_P(ptr, PSTR("%u"), &on) == 1)
ret = 3;
else {
if (strcmp_P(ptr, PSTR("on")) == 0) {
on = 1;
ret = 3;
}
else if (strcmp_P(ptr, PSTR("off")) == 0) {
on = 0;
ret = 3;
}
}
}
}
}
}
if (ret == 3 && port < IO_PORTS && pin < 8) {
/* Set only if it is output */
if (vport[port].read_ddr(port) & _BV(pin)) {
uint8_t pincfg = named_pin_by_pin(port, pin);
uint8_t active_high = 1;
if (pincfg != 255)
active_high = pgm_read_byte(&portio_pincfg[pincfg].active_high);
if (XOR_LOG(on, !active_high))
vport[port].write_port(port, vport[port].read_port(port) | _BV(pin));
else
vport[port].write_port(port, vport[port].read_port(port) & ~_BV(pin));
return ECMD_FINAL(snprintf_P(output, len, on ? PSTR("on") : PSTR("off")));
} else
return ECMD_FINAL(snprintf_P(output, len, PSTR("error: pin is input")));
} else
return ECMD_ERR_PARSE_ERROR;
}
CommandStatusIdType CommandSetLogMem(const char* InParam)
{
if (strcmp_P(InParam, PSTR(COMMAND_LOGMEM_LOADBIN)) == 0) {
XModemSend(LogMemLoadBlock);
return COMMAND_INFO_XMODEM_WAIT_ID;
} else if (strcmp_P(InParam, PSTR(COMMAND_LOGMEM_CLEAR)) == 0) {
LogMemClear();
return COMMAND_INFO_OK_ID;
} else {
return COMMAND_ERR_INVALID_PARAM_ID;
}
}
int8_t parse_error_led_command(char *command, char *bfr, uint16_t buffer_size)
{
if (0 == strcmp_P(command, PSTR("SEL")))
{
return parse_set_error_led(bfr, buffer_size);
}
else if (0 == strcmp_P(command, PSTR("GEL")))
{
return parse_get_error_led();
}
else
return ERR_CMD;
}
int8_t parse_encoder_command(char *command, char *bfr, uint16_t buffer_size)
{
if (0 == strcmp_P(command, PSTR("GES")))
{
return parse_get_encoder_speed(); //
}
else if (0 == strcmp_P(command, PSTR("GEC")))
{
return parse_get_encoder_counts(); //
}
else
return ERR_CMD;
}
void commandInterpreter(const commandStruct *cmdTable) {
int ch;
char cBuf[16];
int bIdx;
int i;
handler ptr;
while (1) {
while (1) {
printf_P(PSTR("->")); // print the command prompt
bIdx = 0;
do { // read a command from serial port
ch = getChar();
uart_putc(ch);
cBuf[bIdx] = (char)ch;
bIdx++;
} while ((ch!=0x0d) && (ch!=0x0a)); // check for newline and carriage return
bIdx--;
cBuf[bIdx] = '\0'; // null terminate string
//printf_P(PSTR("Entered Command = %s\n"), cBuf);
uart_putc('\n');
if (!strcmp_P(cBuf, PSTR("help"))) {
printCommands(cmdTable);
}
i = 0;
//cmdId = pgm_read_word(&cmdTable[i].id); // identify command
ptr = (handler)pgm_read_word(&cmdTable[i].function);
while (ptr!=NULL) {
if (!strcmp_P(cBuf, &cmdTable[i].name)) { // command found,break search
ptr = (handler)pgm_read_word(&cmdTable[i].function);
if (ptr!=NULL) {
//printf_P(PSTR("Function found\n"));
ptr();
}
break;
} else {
i++;
//cmdId = pgm_read_word(&cmdTable[i].id);
ptr = (handler)pgm_read_word(&cmdTable[i].function);
}
}
}
}
}
void ATEMclient::_parseGetCommands(const char *cmdStr) {
uint8_t mE;
uint16_t videoSource;
long temp;
uint8_t readBytesForTlSr;
if (!strcmp_P(cmdStr, PSTR("AMLv"))) {
_readToPacketBuffer(36);
} else if (!strcmp_P(cmdStr, PSTR("TlSr"))) {
readBytesForTlSr = ((ATEM_packetBufferLength-2)/3)*3+2;
_readToPacketBuffer(readBytesForTlSr);
} else {
_readToPacketBuffer(); // Default
}
if(!strcmp_P(cmdStr, PSTR("PrgI"))) {
mE = _packetBuffer[0];
if (mE<=1) {
#if ATEM_debug
temp = atemProgramInputVideoSource[mE];
#endif
atemProgramInputVideoSource[mE] = word(_packetBuffer[2], _packetBuffer[3]);
#if ATEM_debug
if ((_serialOutput==0x80 && atemProgramInputVideoSource[mE]!=temp) || (_serialOutput==0x81 && !hasInitialized())) {
Serial.print(F("atemProgramInputVideoSource[mE=")); Serial.print(mE); Serial.print(F("] = "));
Serial.println(atemProgramInputVideoSource[mE]);
}
#endif
}
} else
if(!strcmp_P(cmdStr, PSTR("PrvI"))) {
mE = _packetBuffer[0];
if (mE<=1) {
#if ATEM_debug
temp = atemPreviewInputVideoSource[mE];
#endif
atemPreviewInputVideoSource[mE] = word(_packetBuffer[2], _packetBuffer[3]);
#if ATEM_debug
if ((_serialOutput==0x80 && atemPreviewInputVideoSource[mE]!=temp) || (_serialOutput==0x81 && !hasInitialized())) {
Serial.print(F("atemPreviewInputVideoSource[mE=")); Serial.print(mE); Serial.print(F("] = "));
Serial.println(atemPreviewInputVideoSource[mE]);
}
#endif
}
}
}
/* function called when cmd_pwm is parsed successfully */
static void cmd_pwm_parsed(void * parsed_result, void * data)
{
#ifdef HOST_VERSION
printf("not implemented\n");
#else
void * pwm_ptr = NULL;
struct cmd_pwm_result * res = parsed_result;
if (!strcmp_P(res->arg1, PSTR("1(4A)")))
pwm_ptr = &gen.pwm1_4A;
else if (!strcmp_P(res->arg1, PSTR("2(4B)")))
pwm_ptr = &gen.pwm2_4B;
else if (!strcmp_P(res->arg1, PSTR("3(1A)")))
pwm_ptr = &gen.pwm3_1A;
else if (!strcmp_P(res->arg1, PSTR("4(1B)")))
pwm_ptr = &gen.pwm4_1B;
else if (!strcmp_P(res->arg1, PSTR("s1(3C)")))
pwm_ptr = &gen.servo1;
else if (!strcmp_P(res->arg1, PSTR("s2(5A)")))
pwm_ptr = &gen.servo2;
else if (!strcmp_P(res->arg1, PSTR("s3(5B)")))
pwm_ptr = &gen.servo3;
else if (!strcmp_P(res->arg1, PSTR("s3(5C)")))
pwm_ptr = &gen.servo4;
if (pwm_ptr)
pwm_ng_set(pwm_ptr, res->arg2);
printf_P(PSTR("done\r\n"));
#endif
}
void ProcessCmd()
{
if ( (strcmp_P( command, PSTR("/id?")) == 0) && ( (arg_count == 0) || (arg_count == 1)) )
{
Id("Eeprom");
}
if ( (strcmp_P( command, PSTR("/ee?")) == 0) && (arg_count == 1 ) )
{
EEread();
}
if ( (strcmp_P( command, PSTR("/ee")) == 0) && (arg_count == 2 ) )
{
EEwrite();
}
}
/*------------------------------------------------------------------------------------*/
s08 pv_cmdWrLog(char *s)
{
if ((!strcmp_P( strupr(s), PSTR("ON")))) {
systemVars.log = ON;
return(TRUE);
}
if ((!strcmp_P( strupr(s), PSTR("OFF")))) {
systemVars.log = OFF;
return(TRUE);
}
return(FALSE);
}
void Check (int line, const char *s1, const char *s2, int clr, int pnt)
{
char t1[300];
char *sp;
char *rp;
if (strlen_P(s1) > sizeof(t1) - 1)
exit (1);
strcpy_P (t1, s1);
sp = t1;
rp = strsep_P (&sp, s2);
if (rp != t1) {
PRINTFLN (line, "false return value");
EXIT (5000 + line);
}
if (clr < 0) {
if (strcmp_P (t1, s1)) {
PRINTFLN (line, "string is changed");
EXIT (line);
}
} else {
if (strlen (t1) != (size_t)clr) {
PRINTFLN (line, "strlen: expect= %d result= %d",
clr, strlen (t1));
EXIT (1000 + line);
}
if (memcmp_P (t1, s1, clr)
|| t1[clr]
|| strcmp_P (t1 + clr + 1, s1 + clr + 1))
{
PRINTFLN (line, "string mismatch");
EXIT (2000 + line);
}
}
if (pnt < 0) {
if (sp) {
PRINTFLN (line, "sp is not a NULL");
EXIT (3000 + line);
}
} else {
if (sp != t1 + pnt) {
PRINTFLN (line, "sp: expect= %d result= %d",
pnt, sp - t1);
EXIT (4000 + line);
}
}
}
static NUTFILE *UromOpen(NUTDEVICE * dev, CONST char *name, int mode,
int acc)
{
NUTFILE *fp = malloc(sizeof(NUTFILE));
ROMENTRY *rome;
ROMFILE *romf = 0;
if (fp == 0) {
errno = ENOMEM;
return NUTFILE_EOF;
}
for (rome = romEntryList; rome; rome = rome->rome_next) {
if (strcmp_P(name, rome->rome_name) == 0)
break;
}
if (rome) {
if ((romf = calloc(1, sizeof(ROMFILE))) != 0)
romf->romf_entry = rome;
else
errno = ENOMEM;
} else
errno = ENOENT;
if (romf) {
fp->nf_next = 0;
fp->nf_dev = dev;
fp->nf_fcb = romf;
} else {
free(fp);
fp = NUTFILE_EOF;
}
return fp;
}
bool SerialConsole::handleCommand(const char *buffer, const uint8_t len)
{
if (buffer[0] == 0)
return false;
for (uint8_t i = 0; i != MAX_COMMANDS; ++i)
{
if (commands[i].hasParam)
{
const uint8_t cmd_len = strlen_P(commands[i].command);
if (strncmp_P(buffer, commands[i].command, cmd_len) == 0)
{
(this->*commands[i].handler) (buffer, len);
return true;
}
} else if (strcmp_P(buffer, commands[i].command) == 0) {
(this->*commands[i].handler) (buffer, len);
return true;
}
}
uart << PGM << STR_HELP_UNKNOWN;
uart << " (" << buffer << ")" << CR;
return false;
}
ThingSpeak::TalkBack::Command*
ThingSpeak::TalkBack::lookup(const char* name)
{
for (Command* c = m_first; c != NULL; c = c->m_next)
if (!strcmp_P(name, c->m_string)) return (c);
return (NULL);
}
bool UbirchSIM800::connect(const char *address, unsigned short int port, uint16_t timeout) {
if (!expect_AT(F("+CIPSHUT"), F("SHUT OK"))) return false;
if (!expect_AT_OK(F("+CMEE=2"))) return false;
if (!expect_AT_OK(F("+CIPQSEND=1"))) return false;
// bring connection up, force it
print(F("AT+CSTT=\""));
print(_apn);
println(F("\""));
if (!expect_OK()) return false;
if (!expect_AT_OK(F("+CIICR"))) return false;
// try five times to get an IP address
bool connected;
do {
char ipaddress[23];
println(F("AT+CIFSR"));
expect_scan(F("%s"), ipaddress);
connected = strcmp_P(ipaddress, PSTR("ERROR")) != 0;
if (!connected) delay(1);
} while (timeout-- && !connected);
if (!connected) return false;
print(F("AT+CIPSTART=0,\"TCP\",\""));
print(address);
print(F("\",\""));
print(port);
println(F("\""));
if (!expect_OK()) return false;
if (!expect(F("0, CONNECT OK"), 30000)) return false;
return connected;
}
void testrun_nessie_des(const char* param){
if(!param){
bcal_nessie_multiple(algolist);
}else{
uint8_t i=0;
bcdesc_t* ptr;
for(;;){
ptr = (bcdesc_t*)pgm_read_word(&algolist[i++]);
if(ptr == NULL){
cli_putstr_P(PSTR("\r\nunknown algorithm: "));
cli_putstr(param);
cli_putstr_P(PSTR("\r\navailable algorithms are:"));
i = 0;
while((ptr = (bcdesc_t*)pgm_read_word(&algolist[i++]))){
cli_putstr_P(PSTR("\r\n\t"));
cli_putstr_P((const char*)pgm_read_word(&ptr->name));
}
return;
}
if(!strcmp_P(param, (const char*)pgm_read_word(&ptr->name))){
bcal_nessie(ptr);
return;
}
}
}
}
static void
soap_lookup_funcname (soap_context_t *ctx)
{
ctx->buf[ctx->buflen - 1] = 0; /* Strip away '>' */
char *funcname = ctx->buf + 1;
for (char *ptr = funcname; *ptr; ptr ++)
if (isblank (*ptr))
{
*ptr = 0;
break;
}
for (uint8_t i = 0;; i++)
{
PGM_P text = (PGM_P)pgm_read_word (&soap_cmds[i].name);
if (text == NULL)
/* End of list, i.e. not found */
SOAP_STREAM_ERROR ();
if (strcmp_P (funcname, text))
continue; /* Mis-match, try next. */
ctx->rpc.name = text;
ctx->rpc.handler = (void *) pgm_read_word (&soap_cmds[i].handler);
return;
}
}
void run_sprf (const struct sprf_s *pt, int testno)
{
static char s[300];
int n;
int code;
#ifdef __AVR__
n = sprintf_P (s, pt->fmt, pgm_read_dword (& pt->val));
#else
n = sprintf (s, pt->fmt, pt->val);
#endif
if (n != (int)strlen_P (pt->pattern))
code = testno + 1000;
else if (strcmp_P (s, pt->pattern))
code = testno;
else
return;
#if !defined(__AVR__)
printf ("\ntestno %3d: expect: %3d, \"%s\","
"\n output: %3d, \"%s\"\n",
testno, strlen(pt->pattern), pt->pattern, n, s);
exit (code < 256 ? testno : 255);
#elif defined(DEBUG)
exit ((int)s);
#endif
exit (code);
}
int8_t DLGSM::GPRS_check_conn_state() {
uint8_t k = 0;
char d[15];
get_from_flash(&(gsm_string_table[5]), _gsm_buff);
GSM_send(_gsm_buff);
GSM_process("STATE:", 20);
if (strcmp_P(_gsm_buff, PSTR("STATE:")) >= 0) {
for(k=0; k < GPRSS_LEN; k++) {
if (strcmp_flash(_gsm_buff+7, &(gprs_state_table[k]), d) == 0) {
if (k == GPRSS_IP_INITIAL ||
k == GPRSS_IP_START ||
k == GPRSS_IP_CONFIG) { // Reinitialize GPRS
GSM_init();
GPRS_init();
} else if (k == GPRSS_IP_GPRSACT) { // Just need to query the local IP...
get_from_flash(&(gprs_init_string_table[9]), _gsm_buff);
GSM_send(_gsm_buff);
GSM_process(NULL, 25);
} else if (k == GPRSS_CONNECT_OK) {
CONN_set_flag(CONN_CONNECTED, 1);
} else if (k == GPRSS_TCP_CLOSED ||
k == GPRSS_UDP_CLOSED) {
CONN_set_flag(CONN_CONNECTED, 0);
} else if (k == GPRSS_PDP_DEACT) { // Reinitialize GPRS
GSM_init();
GPRS_init();
}
return k;
}
}
}
return -1;
}
/*------------------------------------------------------------------------------------------------------------*/
void cgi_reset( void * pStruct )
{
struct HTTP_REQUEST * http_request;
http_request = (struct HTTP_REQUEST *) pStruct;
cgi_PrintHttpheaderStart();
if ( http_request->argc == 0 )
{
printf_P( PSTR( "<form action=\"reset.cgi\" method=\"get\" accept-charset=\"ISO-8859-1\">"
"<p><input type=\"submit\" name=\"reset\" value=\"reset\"></p></form>" ));
cgi_PrintHttpheaderEnd();
}
else if( PharseCheckName_P( http_request, PSTR("reset") ) )
{
if ( !strcmp_P( http_request->argvalue[ PharseGetValue_P( http_request, PSTR("reset") ) ] , PSTR("reset") ) )
{
printf_P( PSTR("Reset"));
cgi_PrintHttpheaderEnd();
STDOUT_Flush();
CloseTCPSocket( http_request->HTTP_SOCKET );
softreset();
while(1);
}
}
}
static void
Check (int line, unsigned long val, const char *rslt, int radix)
{
char s[40];
#ifndef __AVR__
if (radix >= 2 && radix <= 36) {
unsigned long x = strtoul (rslt, 0, radix);
if (x != val) {
PRINTFLN (line, "strtoul(\"%s\",,%d)= %lu, val= %lu",
rslt, radix, x, val);
EXIT (2000 + line);
}
}
#endif
memset (s, 0xff, sizeof (s) - 1);
s[sizeof (s) - 1] = 0;
if (ultoa (val, s, radix) != s) {
PRINTFLN (line, "Incorrect result");
EXIT (1000 + line);
}
if (strcmp_P (s, rslt)) {
PRINTFLN (line, "ultoa(%lu,,%d) puts: %s, must: %s",
val, radix, s, rslt);
EXIT (line);
}
}
