String ESP8266WebServer::urlDecode(const String& text)
{
String decoded = "";
char temp[] = "0x00";
unsigned int len = text.length();
unsigned int i = 0;
while (i < len)
{
char decodedChar;
char encodedChar = text.charAt(i++);
if ((encodedChar == '%') && (i + 1 < len))
{
temp[2] = text.charAt(i++);
temp[3] = text.charAt(i++);
decodedChar = strtol(temp, NULL, 16);
}
else {
if (encodedChar == '+')
{
decodedChar = ' ';
}
else {
decodedChar = encodedChar; // normal ascii char
}
}
decoded += decodedChar;
}
return decoded;
}
Variant f_range(CVarRef low, CVarRef high, CVarRef step /* = 1 */) {
bool is_step_double = false;
double dstep = 1.0;
if (step.isDouble()) {
dstep = step.toDouble();
is_step_double = true;
} else if (step.isString()) {
int64_t sn;
double sd;
DataType stype = step.toString()->isNumericWithVal(sn, sd, 0);
if (stype == KindOfDouble) {
is_step_double = true;
dstep = sd;
} else if (stype == KindOfInt64) {
dstep = (double)sn;
} else {
dstep = step.toDouble();
}
} else {
dstep = step.toDouble();
}
/* We only want positive step values. */
if (dstep < 0.0) dstep *= -1;
if (low.isString() && high.isString()) {
String slow = low.toString();
String shigh = high.toString();
if (slow.size() >= 1 && shigh.size() >=1) {
int64_t n1, n2;
double d1, d2;
DataType type1 = slow->isNumericWithVal(n1, d1, 0);
DataType type2 = shigh->isNumericWithVal(n2, d2, 0);
if (type1 == KindOfDouble || type2 == KindOfDouble || is_step_double) {
if (type1 != KindOfDouble) d1 = slow.toDouble();
if (type2 != KindOfDouble) d2 = shigh.toDouble();
return ArrayUtil::Range(d1, d2, dstep);
}
int64_t lstep = (int64_t) dstep;
if (type1 == KindOfInt64 || type2 == KindOfInt64) {
if (type1 != KindOfInt64) n1 = slow.toInt64();
if (type2 != KindOfInt64) n2 = shigh.toInt64();
return ArrayUtil::Range((double)n1, (double)n2, lstep);
}
return ArrayUtil::Range((unsigned char)slow.charAt(0),
(unsigned char)shigh.charAt(0), lstep);
}
}
if (low.is(KindOfDouble) || high.is(KindOfDouble) || is_step_double) {
return ArrayUtil::Range(low.toDouble(), high.toDouble(), dstep);
}
int64_t lstep = (int64_t) dstep;
return ArrayUtil::Range(low.toDouble(), high.toDouble(), lstep);
}
byte Convert::toHex(String input)
{
input.toUpperCase();
byte result = 0x00;
//input checking
if(input.length()==4) input = input.substring(2);
else if(input.length()==3||input.length()>4) return 0x00;
//
result=this->value(input.charAt(0)); //first hex
result=result<<4; //bitshift 4 places to the left
result+=this->value(input.charAt(1)); //second hex
return result;
}
/*******************************************************************************
* Function Name : tinkerDigitalRead
* Description : Reads the digital value of a given pin
* Input : Pin
* Output : None.
* Return : Value of the pin (0 or 1) in INT type
Returns a negative number on failure
*******************************************************************************/
int tinkerDigitalRead(String pin)
{
//convert ascii to integer
int pinNumber = pin.charAt(1) - '0';
//Sanity check to see if the pin numbers are within limits
if (pinNumber < 0 || pinNumber > 7) return -1;
if(pin.startsWith("D"))
{
pinMode(pinNumber, INPUT_PULLDOWN);
return digitalRead(pinNumber);
}
else if (pin.startsWith("A"))
{
pinMode(pinNumber+10, INPUT_PULLDOWN);
return digitalRead(pinNumber+10);
}
#if Wiring_Cellular
else if (pin.startsWith("B"))
{
if (pinNumber > 5) return -3;
pinMode(pinNumber+24, INPUT_PULLDOWN);
return digitalRead(pinNumber+24);
}
else if (pin.startsWith("C"))
{
if (pinNumber > 5) return -4;
pinMode(pinNumber+30, INPUT_PULLDOWN);
return digitalRead(pinNumber+30);
}
#endif
return -2;
}
char VirtuinoEthernet_WebServer::getCommandType(String aCommand){
char commandType= aCommand.charAt(0);
if (!(commandType == 'I' || commandType == 'Q' || commandType == 'D' ||commandType == 'A' ||commandType == 'O' || commandType == 'V' || commandType == 'C')){
commandType='E'; //error command
}
return commandType;
}
void render() {
translate(width/2, height/2);
steps += 5;
if (steps > production.length()) {
steps = production.length();
}
for (int i = 0; i < steps; i++) {
char step = production.charAt(i);
if (step == 'F') {
rect(0, 0, -drawLength, -drawLength);
noFill();
translate(0, -drawLength);
}
else if (step == '+') {
rotate(theta);
}
else if (step == '-') {
rotate(-theta);
}
else if (step == '[') {
pushMatrix();
}
else if (step == ']') {
popMatrix();
}
}
}
void Morse::emitWord(String word) {
int len = word.length();
int i, ci;
for (i = 0; i < len; i++) {
String code = textToMorse(word.charAt(i));
int codeLen = code.length();
for (ci = 0; ci < codeLen; ci++) {
if (code[ci] == '.') {
dot();
} else {
dash();
}
}
// morse code states there should be a 3 time unit pause between
// characters
// 2 here and one at the end of dot/dash
delay(_timeUnit * 2);
}
// morse code states there should be a 7 time unit pause between words
// 4 here and 3 above
delay(_timeUnit * 4);
}
void PusherClient::getAuthString(const String& channel, String& auth)
{
Sha256Class sha256;
//Sha init with secret key
{
String secret;
getPusherInfoItem(2, secret);
sha256.initHmac((uint8_t*)&secret[0], secret.length());
}
//Set the data to encrypt
{
String text;
text.reserve(_socketid.length() + 1 + channel.length());
text = _socketid;
text += ':';
text += channel;
sha256.print(text);
}
uint8_t* result = sha256.resultHmac();
String hexChars;
getStringTableItem(19, hexChars);
auth.reserve(21 /*key*/ + 1 + 64 /*sha256*/);
getPusherInfoItem(1, auth); //key
auth += ':';
for (int i=0; i<32; i++)
{
auth += hexChars.charAt(result[i]>>4);
auth += hexChars.charAt(result[i]&0xf);
}
}
/*******************************************************************************
* Function Name : tinkerDigitalWrite
* Description : Sets the specified pin HIGH or LOW
* Input : Pin and value
* Output : None.
* Return : 1 on success and a negative number on failure
*******************************************************************************/
int tinkerDigitalWrite(String command)
{
bool value = 0;
//convert ascii to integer
int pinNumber = command.charAt(1) - '0';
//Sanity check to see if the pin numbers are within limits
if (pinNumber< 0 || pinNumber >7) return -1;
if(command.substring(3,7) == "HIGH") value = 1;
else if(command.substring(3,6) == "LOW") value = 0;
else return -2;
if(command.startsWith("D"))
{
pinMode(pinNumber, OUTPUT);
digitalWrite(pinNumber, value);
return 1;
}
else if(command.startsWith("A"))
{
pinMode(pinNumber+10, OUTPUT);
digitalWrite(pinNumber+10, value);
return 1;
}
else return -3;
}
String runString(CppiaCtx *ctx)
{
String val = strVal->runString(ctx);
BCR_CHECK;
int idx = a0->runInt(ctx);
BCR_CHECK;
return val.charAt(idx);
}
void Minitel::text(String s, int orientation) {
for (int i=0; i<s.length(); i++) {
char c = s.charAt(i);
boolean indent = false;
if (isAccent(c)) {
i+=1; // chars with accents take 2 array indexes
c = s.charAt(i);
indent = printAccentChar(c);
}
else {
indent = textChar(c);
}
if (indent && orientation == VERTICAL) {
moveCursor(LEFT);
moveCursor(DOWN);
}
}
}
boolean Clock::parseDate(String t)
{
// dd/mm/yyyy
int d;
int m;
int y;
if (t.length() != 10) return false;
if (t.charAt(2) != '/' || t.charAt(5) != '/') return false;
d=t.substring(0,2).toInt();
m=t.substring(3,5).toInt();
y=t.substring(6,10).toInt();
if (d ==0 || m==0 || y==0) return false;
//Todo adjust for local time?
set(y,m,d,hour(),minute(),second());
return true;
}
/**
* Precondition: m_originalURL and m_queryString are set
* Postcondition: Output is false and we are redirecting OR
* m_rewrittenURL is set and m_queryString is updated if needed
*/
bool RequestURI::rewriteURL(const VirtualHost *vhost, Transport *transport,
const std::string &pathTranslation,
const std::string &sourceRoot) {
bool qsa = false;
int redirect = 0;
std::string host = transport->getHeader("host");
m_rewrittenURL = m_originalURL;
if (vhost->rewriteURL(host, m_rewrittenURL, qsa, redirect)) {
m_rewritten = true;
if (qsa && !m_queryString.empty()) {
m_rewrittenURL += (m_rewrittenURL.find('?') < 0) ? "?" : "&";
m_rewrittenURL += m_queryString;
}
if (redirect) {
if (m_rewrittenURL.substr(0, 7) != s_http &&
m_rewrittenURL.substr(0, 8) != s_https) {
PrependSlash(m_rewrittenURL);
}
transport->redirect(m_rewrittenURL.c_str(), redirect, "rewriteURL");
return false;
}
splitURL(m_rewrittenURL, m_rewrittenURL, m_queryString);
}
m_rewrittenURL = String(
Util::canonicalize(m_rewrittenURL.c_str(), m_rewrittenURL.size()),
AttachString);
if (!m_rewritten && m_rewrittenURL.charAt(0) == '/') {
// A un-rewritten URL is always relative, so remove prepending /
m_rewrittenURL = m_rewrittenURL.substr(1);
}
// If the URL refers to a folder but does not end
// with a slash, then we need to redictect
String url = m_rewrittenURL;
if (!url.empty() &&
url.charAt(url.length() - 1) != '/') {
if (virtualFolderExists(vhost, sourceRoot, pathTranslation, url)) {
url += "/";
m_rewritten = true;
String queryStr;
m_rewrittenURL = m_originalURL;
m_rewrittenURL += "/";
if (!m_queryString.empty()) {
m_rewrittenURL += "?";
m_rewrittenURL += m_queryString;
}
if (m_rewrittenURL.substr(0, 7) != s_http &&
m_rewrittenURL.substr(0, 8) != s_https) {
PrependSlash(m_rewrittenURL);
}
transport->redirect(m_rewrittenURL.c_str(), 301, "rewriteURL");
return false;
}
}
return true;
}
long Convert::toInt(String input)
{
boolean negative = false;
long result = 0;
//if number negative
if(input.charAt(0) == 45)
{
input = input.substring(1);
negative = true;
}
for (int i=0; i<input.length(); i++)
{
result = (result*10) + this->value(input.charAt(i));
}
if(negative) result*=-1;
return result;
}
void InternetButton::playNote(String note, int duration){
int noteNum = 0;
int octave = 5;
int freq = 256;
//if(9 - int(command.charAt(1)) != null){
char octavo[5];
String tempString = note.substring(1,2);
tempString.toCharArray(octavo,5);
octave = atoi(octavo);
//}
if(duration != 0){
duration = 1000/duration;
}
switch(note.charAt(0)){
case 'C':
noteNum = 0;
break;
case 'D':
noteNum = 2;
break;
case 'E':
noteNum = 4;
break;
case 'F':
noteNum = 5;
break;
case 'G':
noteNum = 7;
break;
case 'A':
noteNum = 9;
break;
case 'B':
noteNum = 11;
break;
case 'R': // Rest note
octave = -1;
break;
default:
break;
//return -1;
}
// based on equation at http://www.phy.mtu.edu/~suits/NoteFreqCalcs.html and the Verdi tuning
// fn = f0*(2^1/12)^n where n = number of half-steps from the reference frequency f0
freq = float(256*pow(1.05946,( 12.0*(octave-4) +noteNum)));
// C4^ (2^1/12)^ 12 half-steps in an octave ^how many extra half-steps within that octave, 0 for a C
tone(D2,int(freq),duration);
delay(duration);
noTone(D2);
//return freq;
}
bool TheThingsUno::sendCommand(String cmd, String value, int waitTime) {
debugPrintLn("Sending: " + cmd + " with value " + value);
modemStream->print(cmd + " ");
for (int i = 0; i < value.length(); i++)
modemStream->print(String(value.charAt(i), HEX));
modemStream->println();
return waitForOK(waitTime);
}
String HexString::Encode(const String& str){
char tmp[3] = { 0 };
String ret;
for (int i = 0; i < str.length(); i++) {
unsigned char c = str.charAt(i);
sprintf(tmp, "%02x", c);
ret += tmp;
}
return ret;
}
int VirtuinoEthernet_WebServer::getCommandPin(String aCommand){
char p1= aCommand.charAt(1);
char p2= aCommand.charAt(2);
String s="-1";
if (isDigit(p1) && isDigit(p2)) {
s="";
s.concat(p1);
s.concat(p2);
}
return s.toInt();
}
hx::Object *runObject(CppiaCtx *ctx)
{
String val = strVal->runString(ctx);
BCR_CHECK;
int idx = a0->runInt(ctx);
BCR_CHECK;
if (CODE)
return val.charCodeAt(idx).mPtr;
else
return Dynamic(val.charAt(idx)).mPtr;
}
void PusherClient::parseMessageMember(const String& message, const String& name, String& value)
{
//name must be in the "name" format
int memberNameStart = message.indexOf(name);
if (memberNameStart == -1)
{
value = "";
return;
}
int memberDataStart = memberNameStart + name.length();
char currentCharacter;
do {
memberDataStart++;
currentCharacter = message.charAt(memberDataStart);
} while (currentCharacter == ' ' || currentCharacter == ':' || currentCharacter == '\"');
int memberDataEnd = memberDataStart;
bool isString = message.charAt(memberDataStart-1) == '\"';
if (!isString) {
do {
memberDataEnd++;
currentCharacter = message.charAt(memberDataEnd);
} while (currentCharacter != ' ' && currentCharacter != ',');
}
else {
char previousCharacter;
currentCharacter = ' ';
do {
memberDataEnd++;
previousCharacter = currentCharacter;
currentCharacter = message.charAt(memberDataEnd);
} while (currentCharacter != '"' || previousCharacter == '\\');
}
value = message.substring(memberDataStart, memberDataEnd);
value.replace("\\\"", "\"");
}
//void (*resetFunc)(void) = 0;
//void WaterSensorWire::CheckConnection() {
////Serial.println(millis() - _lastReqReceived);
////Serial.println(millis() - _lastReqReceived > 180000);
//if(millis() - _lastReqReceived > 180000) { //check every 3 minute. 180000
//Serial.println(F("Wire Connection Lost Reseting.."));
//delay(1000);
////_lastReqReceived = millis();
//wdt_reset();
//resetFunc();
//}
//}
String ROTankWire::SplitString(String data, char separator, int index) {
int found = 0;
int strIndex[] = {0, -1};
int maxIndex = data.length() - 1;
for(int i = 0; i <= maxIndex && found <= index; i++) {
if(data.charAt(i) == separator || i == maxIndex) {
found++;
strIndex[0] = strIndex[1] + 1;
strIndex[1] = (i == maxIndex) ? i + 1 : i;
}
}
return found > index ? data.substring(strIndex[0], strIndex[1]) : "";
}
boolean Clock::parseTime(String t)
{
int h;
int m;
int s;
s=0;
if (t.length() != 5 && t.length() != 8) return false;
if (t.charAt(2) != ':') return false;
h=t.substring(0,2).toInt();
if (h>23) return false;
m=t.substring(3,5).toInt();
if (m>59) return false;
if (t.length() == 8) {
if (t.charAt(5) != ':') return false;
s = t.substring(6,8).toInt();
}
//Todo adjust for local time?
set(year(),month(),day(),h,m,s);
return true;
}
void EvalObjectData::o_setArray(CArrRef props) {
for (ArrayIter it(props); !it.end(); it.next()) {
String k = it.first();
if (!k.empty() && k.charAt(0) == '\0') {
int subLen = k.find('\0', 1) + 1;
String cls = k.substr(1, subLen - 2);
String key = k.substr(subLen);
if (cls == "*") cls = o_getClassName();
props->load(k, o_lval(key, Variant(), cls));
}
}
DynamicObjectData::o_setArray(props);
}
bool ESP8266::sATCIPSENDSingle(String &str)
{
rx_empty();
m_puart->print("AT+CIPSEND=");
m_puart->println(str.length());
if (recvFind(">", 5000)) {
rx_empty();
for (uint32_t i = 0; i < str.length(); i++) {
m_puart->write(str.charAt(i));
}
return recvFind("SEND OK", 10000);
}
return false;
}
int ledControl(String command)
{
int state = 0;
//find out the pin number and convert the ascii to integer
int pinNumber = (command.charAt(1) - '0') - 1;
//Sanity check to see if the pin numbers are within limits
if (pinNumber < 0 || pinNumber > 1) return -1;
// find out the state of the led
if(command.substring(3,7) == "HIGH") state = 1;
else if(command.substring(3,6) == "LOW") state = 0;
else return -1;
// write to the appropriate pin
digitalWrite(pinNumber, state);
return 1;
}
float Convert::toFloat(String var)
{
long dot = var.indexOf(".");
boolean negative = false;
float fpoint = 1;
float result;
if (dot == -1)
{
dot = var.length();
}
//if number negative
if (var.charAt(0) == 45)
{
negative = true;
var = var.substring(1);
dot--;
}
//convert value
result = toInt(var.substring(0,dot));
for(int i = dot+1; i< var.length(); i++)
{
fpoint *= 0.1;
result = result + (this->value(var.charAt(i))*fpoint);
}
//fix negative number
if(negative)
{
result *=-1;
}
return result;
}
void LCD_LAUNCHPAD::displayText(String s, char pos)
{
int length = s.length();
int i;
for (i=0; i<pos; i++)
{
showChar(' ', i);
}
for (i=pos; i<length; i++)
{
showChar(s.charAt(i-pos), i);
}
}
// command format r1,ON or r1,OFF or r1,SWITCH
int relayControl(String command)
{
// parse the relay number
int relayNumber = command.charAt(1) - '0';
// do a sanity check
if (relayNumber < 1 || relayNumber > 4) return -1;
// find out the state of the relay
if (command.substring(3,5) == "ON") relay[relayNumber - 1].on();
else if (command.substring(3,6) == "OFF") relay[relayNumber - 1].off();
else if (command.substring(3,9) == "SWITCH") relay[relayNumber - 1].toggle();
else if (command.substring(3,8) == "PULSE") relay[relayNumber - 1].pulse();
else return -1;
return 1;
}
int main() {
String foo = newString("This is FOO!");
foo = foo.insertCharAt(&foo,'a',foo.length(&foo) - 1);
foo.printString(&foo);
foo = foo.substring(&foo,8,10);
foo.printString(&foo);
String bar = newString(" BAR");
foo = foo.concat(&foo,&bar);
foo.printString(&foo);
StringArr foobar = split(&foo, " ");
printf("%s\n",foobar[0]);
printf("%s\n",foobar[1]);
foo = foo.toLowerCase(&foo);
bar = bar.toLowerCase(&bar);
bar = bar.removeSpaces(&bar);
foo.printString(&foo);
bar.printString(&bar);
if(foo.equals(&foo,&bar))
printf("Same!\n");
else
printf("Not the same!\n");
bar = newString("foo");
if(foo.equals(&foo,&bar))
printf("Same!\n");
else
printf("Not the same!\n");
foo = foo.reverse(&foo);
foo.printString(&foo);
printf("%c\n",foo.charAt(&foo,1));
bar = newString("bar");
bar = bar.toUpperCase(&bar);
printString(&bar);
}
/*******************************************************************************
* Function Name : tinkerAnalogRead
* Description : Reads the analog value of a pin
* Input : Pin
* Output : None.
* Return : Returns the analog value in INT type (0 to 4095)
Returns a negative number on failure
*******************************************************************************/
int tinkerAnalogRead(String pin)
{
//convert ascii to integer
int pinNumber = pin.charAt(1) - '0';
//Sanity check to see if the pin numbers are within limits
if (pinNumber< 0 || pinNumber >7) return -1;
if(pin.startsWith("D"))
{
return -3;
}
else if (pin.startsWith("A"))
{
return analogRead(pinNumber+10);
}
return -2;
}