int main() { int dia, mes, anio; long int fecha; writeLnString("ingrese la fecha en formato AAAAMMDD"); readLong(fecha); anio = fecha/10000; fecha -= anio * 10000; mes = fecha/100; fecha -= mes * 100; dia = fecha; writeString("La Fecha es "); writeInteger(dia); writeString("/"); writeInteger(mes); writeString("/"); writeInteger(anio); return 0; }
int Path::write(std::ofstream &out, std::string &msg) { short record_size; record_size = 4; writeShort(out, record_size); writeByte(out, PATH); writeByte(out, NoData); record_size = 6; writeShort(out, record_size); writeByte(out, EFLAGS); writeByte(out, Integer_2); writeShort(out, Eflags); record_size = 6; writeShort(out, record_size); writeByte(out, LAYER); writeByte(out, Integer_2); writeShort(out, Layer); record_size = 6; writeShort(out, record_size); writeByte(out, DATATYPE); writeByte(out, Integer_2); writeShort(out, Data_type); record_size = 8; writeShort(out, record_size); writeByte(out, WIDTH); writeByte(out, Integer_4); writeInteger(out, Width); record_size = 6; writeShort(out, record_size); writeByte(out, PATHTYPE); writeByte(out, Integer_2); writeShort(out, Path_type); record_size = 4 + short(8 * Pts.size()); writeShort(out, record_size); writeByte(out, XY); writeByte(out, Integer_4); for (auto p : Pts) { writeInteger(out, p.x); writeInteger(out, p.y); } record_size = 4; writeShort(out, record_size); writeByte(out, ENDEL); writeByte(out, NoData); return out.fail() ? FILE_ERROR : 0; }
void writeFloat(JsonFloat value, int digits = 2) { if (Polyfills::isNaN(value)) return writeRaw("NaN"); if (value < 0.0) { writeRaw('-'); value = -value; } if (Polyfills::isInfinity(value)) return writeRaw("Infinity"); short powersOf10; if (value > 1000 || value < 0.001) { powersOf10 = Polyfills::normalize(value); } else { powersOf10 = 0; } // Round correctly so that print(1.999, 2) prints as "2.00" JsonFloat rounding = 0.5; for (uint8_t i = 0; i < digits; ++i) rounding /= 10.0; value += rounding; // Extract the integer part of the value and print it JsonUInt int_part = static_cast<JsonUInt>(value); JsonFloat remainder = value - static_cast<JsonFloat>(int_part); writeInteger(int_part); // Print the decimal point, but only if there are digits beyond if (digits > 0) { writeRaw('.'); } // Extract digits from the remainder one at a time while (digits-- > 0) { remainder *= 10.0; JsonUInt toPrint = JsonUInt(remainder); writeInteger(JsonUInt(remainder)); remainder -= static_cast<JsonFloat>(toPrint); } if (powersOf10 < 0) { writeRaw("e-"); writeInteger(-powersOf10); } if (powersOf10 > 0) { writeRaw('e'); writeInteger(powersOf10); } }
void writeFloat(JsonFloat value, uint8_t digits = 2) { if (Polyfills::isNaN(value)) return writeRaw("NaN"); if (value < 0.0) { writeRaw('-'); value = -value; } if (Polyfills::isInfinity(value)) return writeRaw("Infinity"); short powersOf10; if (value > 1000 || value < 0.001) { powersOf10 = Polyfills::normalize(value); } else { powersOf10 = 0; } // Round up last digit (so that print(1.999, 2) prints as "2.00") value += getRoundingBias(digits); // Extract the integer part of the value and print it JsonUInt int_part = static_cast<JsonUInt>(value); JsonFloat remainder = value - static_cast<JsonFloat>(int_part); writeInteger(int_part); // Print the decimal point, but only if there are digits beyond if (digits > 0) { writeRaw('.'); } // Extract digits from the remainder one at a time while (digits-- > 0) { // Extract digit remainder *= 10.0; char currentDigit = char(remainder); remainder -= static_cast<JsonFloat>(currentDigit); // Print writeRaw(char('0' + currentDigit)); } if (powersOf10 < 0) { writeRaw("e-"); writeInteger(-powersOf10); } if (powersOf10 > 0) { writeRaw('e'); writeInteger(powersOf10); } }
int main(void) { initRobotBase(); setLEDs(0b111111); mSleep(500); setLEDs(0b000000); writeString_P("\nJust a simple counter program\n\n"); uint16_t counter = 0; while(true) { timer = 0; if(counter < 100) { writeString_P("Counter: "); writeInteger(counter, BIN); writeString_P("(BIN) | "); writeInteger(counter, OCT); writeString_P("(OCT) | "); writeInteger(counter, DEC); writeString_P("(DEC) | "); writeInteger(counter, HEX); writeString_P("(HEX) "); } else { writeString_P("Counter L: "); writeIntegerLength(counter, BIN, 16); writeString_P("(BIN) | "); writeIntegerLength(counter, OCT, 6); writeString_P("(OCT) | "); writeIntegerLength(counter, DEC, 6); writeString_P("(DEC) | "); writeIntegerLength(counter, HEX, 4); writeString_P("(HEX) "); } writeChar(' '); writeInteger(timer,DEC); writeString(" *100us"); writeChar('\n'); counter++; mSleep(100); } return 0; }
void test(uint8_t number) { bars(2); writeString_P("#### TEST #"); writeInteger(number, DEC); writeString_P(" ####\n"); }
void SendDataOverUART(int value) { // These functions send data over the UART writeString_P("Counter: "); writeInteger(value, DEC); writeString_P("(DEC) | "); writeInteger(value, HEX); writeString_P("(HEX) | "); writeInteger(value, BIN); writeString_P("(BIN) "); writeChar('\n'); // New Line }
void BranchState::writeInteger( Token::Argument& argument ) { assert( argument.type() == Token::Argument::INTEGER_REGISTER ); if( argument.content() == Token::Argument::REGISTER ) { writeInteger( argument.regNumber() ); } else if( argument.content() == Token::Argument::ALIAS ) { std::map< std::string, State >::iterator i = m_integers.find( argument.alias() ); if( i == m_integers.end() ) { State newState; m_integers[ argument.alias() ] = newState; i = m_integers.find( argument.alias() ); // this could be retrieved directly, but I've had issues with inserting into maps and retrieving the iterator in the same operation assert( i != m_integers.end() ); } i->second.setFields( 1 ); i->second.clearAddress(); updateDependency( argument, i->second, Alias::INTEGER, i->first, false ); } }
/** * This function gets called automatically if there was an I2C Error like * the slave sent a "not acknowledge" (NACK, error codes e.g. 0x20 or 0x30). */ void I2C_transmissionError(uint8_t errorState) { writeString_P("\n############ I2C ERROR!!!!! - TWI STATE: 0x"); writeInteger(errorState, HEX); writeChar('\n'); errors++; }
extern void FilterRequestData(REQUEST_STRUCT* request, char request_buffer[], size_t separatorindex, size_t startindex, size_t endindex) { if((separatorindex - startindex) > 0 && (endindex - separatorindex) > 2 && request != NULL) { char cmdbuffer[(separatorindex - startindex)+1]; strncpy(cmdbuffer, request_buffer+startindex, ((separatorindex - startindex)+1)); static char* proper_keys[2] = {"cmd", "val"}; int index = -1; for(uint8_t i = 0; i < 2;i++) { if(strncmp(cmdbuffer, proper_keys[i], strlen(proper_keys[i])) == 0) { index = i; break; } } switch(index) { case 0://CMD { uint16_t length = (endindex-separatorindex+1); if(length > 0) { // char filtervalue [length]; strncpy(filtervalue, request_buffer+(separatorindex+1), length); uint16_t value = strtol(filtervalue, NULL, 0); writeString("{cmd=0x"); writeInteger(value, HEX); writeChar('}'); (*request).cmd = value; } // break; } case 1: //VAL { // char filtervalue [(endindex-separatorindex)+1]; strncpy(filtervalue, request_buffer+(separatorindex+1), (endindex-separatorindex+1)); if(strlen(filtervalue) > 0) { uint16_t value = strtol(filtervalue, NULL, 0); (*request).val = value; } // break; } } } }
/* initializeCommand () ** ** Initialize the BLITZ DISK file by writing out an empty directory. */ void initializeCommand () { if (commandOptionV) printf ("INITIALIZING THE FILE SYSTEM...\n"); openDiskFile (0); /* Existing = false */ seekTo (4); /* Skip past "BLZd" magic number */ writeInteger (0x73747562); /* Magic number = "stub" */ writeInteger (0); /* Number of file */ writeInteger (1); /* Next Free Sector */ if (commandOptionV) printf ("Number of files on disk = 0\n"); if (commandOptionV) printf ("Next free sector = 1\n"); if (commandOptionV) printf ("Number of available sectors = %d\n", numberSectorsOnDisk-1); closeFiles (); }
void AMFWriter::writeNumber(double value){ _lastReference=0; if(!amf0Preference && value<=AMF_MAX_INTEGER && round(value) == value) { writeInteger((Int32)value); return; } packet.write8(_amf3 ? AMF3_NUMBER : AMF_NUMBER); // marker packet.writeNumber<double>(value); }
/* writeDirectory () ** ** Print the directory back to the BLITZ DISK. */ void writeDirectory () { Entry * e = firstEntry; seekTo (8); writeInteger (numberOfFiles); writeInteger (nextFreeSector); while (e) { // printf ("writing next entry...\n"); // printf ("\t%d\t\t%d\t\t%d\t\t%s\n", // e->startingSector, // e->sizeInBytes, // e->lengthOfName, // e->name); writeInteger (e->startingSector); writeInteger (e->sizeInBytes); writeInteger (e->lengthOfName); writeString (e->name, e->lengthOfName); e = e->next; } }
/* Write an integer to the Marshal object */ void Marshal::Write(int val) { writeDataType(MTYPE_INT); // check for stream write error CHECK_WRITE_ERROR(m_stream); writeInteger(val); // check for stream write error CHECK_WRITE_ERROR(m_stream); }
/** * A simple counter that outputs it's value on the * Serialport each time it is incremented. * It is incremented every 400ms. */ void task_counter1(void) { static uint8_t counter; if(getStopwatch2() > 400) // 400ms = 0.4s { writeString_P("CNT1 : "); writeInteger(counter, DEC); writeChar('\n'); counter++; setStopwatch2(0); // Reset stopwatch } }
/** * A second counter, with different interval (0.8s) and * binary output format. */ void task_counter2(void) { static uint8_t counter2; if(getStopwatch3() > 800) // 800ms = 0.8s { writeString_P("\t CNT2 : "); writeInteger(counter2, BIN); writeChar('\n'); counter2++; setStopwatch3(0); // Reset stopwatch } }
void BinaryPropertyListPlan::writeIntegerArray(const int* integers, size_t size) { size_t savedAggregateSize = ++m_currentAggregateSize; ASSERT(size); IntegerArrayMap::AddResult addResult = m_integerArrays.add(IntegerArray(integers, size), 0); if (!addResult.isNewEntry) return; for (size_t i = 0; i < size; ++i) writeInteger(integers[i]); addResult.iterator->value = m_currentObjectReference++; writeArrayObject(size); m_currentAggregateSize = savedAggregateSize; }
void sendByteAndReceiveByte(void) { if(getStopwatch1() > 500) { I2CTWI_transmitByte(ARDUINO_WRITE_ADDRESS, speed); //writing the speed of rp6 uint8_t someByteToRead = 0; someByteToRead = I2CTWI_readByte(ARDUINO_READ_ADDRESS); //read the maximum speed writeInteger(someByteToRead, DEC); getSpeedLimit(someByteToRead); setStopwatch1(0); } }
/* Write a SCXRegexWithIndex object to the Marshal object */ void Marshal::Write(const SCXRegexWithIndex& ri) { writeDataType(MTYPE_REGEX_INDEX); // check for stream write error CHECK_WRITE_ERROR(m_stream); writeInteger((int) ri.index); CHECK_WRITE_ERROR(m_stream); Write(ri.regex->Get()); }
/* Write a vector of SCXRegexWithIndex object to the Marshal object */ void Marshal::Write(const vector<SCXRegexWithIndex>& vri) { writeDataType(MTYPE_VECTOR_REGEX_INDEX); // check for stream write error CHECK_WRITE_ERROR(m_stream); int vecSize = (int) vri.size(); writeInteger(vecSize); CHECK_WRITE_ERROR(m_stream); for(int i = 0; i < vecSize; i++) { Write(vri[i]); } }
/* Write a vector of wstring to the Marshal object */ void Marshal::Write(const vector<wstring>& vws) { writeDataType(MTYPE_VECTOR_WSTRING); // check for stream write error CHECK_WRITE_ERROR(m_stream); int vecSize = (int) vws.size(); writeInteger(vecSize); CHECK_WRITE_ERROR(m_stream); for(int i = 0; i < vecSize; i++) { Write(vws[i]); } }
int QCaInteger::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { typedef qcaobject::QCaObject QMocSuperClass; _id = QMocSuperClass::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { switch (_id) { case 0: integerChanged((*reinterpret_cast< const long(*)>(_a[1])),(*reinterpret_cast< QCaAlarmInfo(*)>(_a[2])),(*reinterpret_cast< QCaDateTime(*)>(_a[3])),(*reinterpret_cast< const uint(*)>(_a[4]))); break; case 1: writeInteger((*reinterpret_cast< const long(*)>(_a[1]))); break; case 2: convertVariant((*reinterpret_cast< const QVariant(*)>(_a[1])),(*reinterpret_cast< QCaAlarmInfo(*)>(_a[2])),(*reinterpret_cast< QCaDateTime(*)>(_a[3]))); break; default: ; } _id -= 3; } return _id; }
/* Write a wstring to the Marshal object */ void Marshal::Write(const wstring& ws) { writeDataType(MTYPE_WSTRING); // check for stream write error CHECK_WRITE_ERROR(m_stream); int strSize = (int) (ws.length() * sizeof(wchar_t)); writeInteger(strSize); CHECK_WRITE_ERROR(m_stream); vector<char> buf(strSize, '\0'); memcpy(&buf[0], ws.c_str(), strSize); m_stream.write(&buf[0], strSize); // check for stream write error CHECK_WRITE_ERROR(m_stream); }
static void serializeUntypedTerm(A2PWriter writer, ATerm value){ int type = ATgetType(value); switch(type){ case AT_INT: writeInteger(writer, (ATermInt) value); break; case AT_REAL: writeDouble(writer, (ATermReal) value); break; case AT_APPL: { ATermAppl appl = (ATermAppl) value; AFun fun = ATgetAFun(appl); if(ATisQuoted(fun) == ATfalse){ A2PType expected = A2PnodeType(); ATermList annotations = (ATermList) ATgetAnnotations(value); if(annotations == NULL){ writeNode(writer, expected, appl); }else{ if(((A2PNodeType) expected->theType)->declaredAnnotations == NULL){ fprintf(stderr, "Node term has annotations, but none are declared.\n"); exit(1); } writeAnnotatedNode(writer, expected, appl, annotations); } }else{ if(ATgetArity(fun) != 0){ fprintf(stderr, "Quoted appl (assumed to be a string) has a non-zero arity.\n"); exit(1);} writeString(writer, appl); } } break; case AT_LIST: writeList(writer, A2PlistType(A2PvalueType()), (ATermList) value); break; default: fprintf(stderr, "Encountered unwriteable type: %d.\n", type); exit(1); } }
void pilot::JSONFileHandler::writeUInt(const char* name, std::uint32_t value) { writeInteger(name, value); }
void pilot::JSONFileHandler::writeShort(const char* name, std::int16_t value) { writeInteger(name, value); }
void AMFWriter::writeObjectProperty(const string& name,Int32 value) { writePropertyName(name); writeInteger(value); }
int main(void) { initRP6Control(); // Always call this first! The Processor will not work // correctly otherwise. bars(2); writeString_P("\n\nRP6Control Selftest!\n\n"); bars(2); setLEDs(0b1111); mSleep(50); initLCD(); showScreenLCD("################", "################"); mSleep(400); showScreenLCD("################", "################"); showScreenLCD("RP6Control M32", "SELFTEST"); mSleep(1000); uint8_t keynumber = 0; while(keynumber < 6) { uint8_t key = checkReleasedKeyEvent(); if(key == keynumber) { keynumber++; showScreenLCD("PRESS BUTTON", "NUMBER "); writeIntegerLCD(keynumber,DEC); setLEDs(0b0000); writeString_P("### PRESS BUTTON NUMBER "); writeInteger(keynumber,DEC); writeString_P("!\n"); } } showScreenLCD("Testing", "BEEPER & LEDS"); mSleep(250); // Play a sound to indicate that our program starts: sound(50,50,100); setLEDs(0b0000); sound(80,50,100); setLEDs(0b0001); sound(100,50,100);setLEDs(0b0010); sound(120,50,100);setLEDs(0b0100); sound(140,50,100);setLEDs(0b1000); sound(160,50,100);setLEDs(0b1001); sound(180,50,100);setLEDs(0b1011); sound(200,50,100);setLEDs(0b1111); mSleep(400); setLEDs(0b0000); showScreenLCD("Testing", "EERPOM"); test(1); writeString_P("\nEEPROM TEST\n"); writeString_P("\nErasing 250 Bytes...\n"); uint8_t cnt; for(cnt = 0; cnt < 250; cnt++) { SPI_EEPROM_writeByte(cnt, 0xFF); while(SPI_EEPROM_getStatus() & SPI_EEPROM_STAT_WIP); } writeString_P("...Done!\nWriting 250 Bytes to EEPROM:\n"); for(cnt = 0; cnt < 250; cnt++) { writeIntegerLength(cnt, DEC, 3); SPI_EEPROM_writeByte(cnt, cnt); while(SPI_EEPROM_getStatus() & SPI_EEPROM_STAT_WIP); writeChar(','); if(cnt % 10 == 0) writeChar('\n'); } mSleep(400); setLEDs(0b1111); writeString_P("\nReading and verifying:\n"); for(cnt = 0; cnt < 250; cnt++) { uint8_t result = SPI_EEPROM_readByte(cnt); if(result != cnt) { writeString_P("\nEEPROM VERIFY ERROR!!!! EEPROM DAMAGED!!!\n"); writeString_P("Data read: "); writeInteger(result,DEC); writeString_P(", should be: "); writeInteger(cnt,DEC); writeChar('\n'); errors++; } else writeIntegerLength(result,DEC,3); writeChar(','); if(cnt % 10 == 0) writeChar('\n'); } writeString_P("\nErasing 250 Bytes...\n"); for(cnt = 0; cnt < 250; cnt++) { SPI_EEPROM_writeByte(cnt, 0xFF); while(SPI_EEPROM_getStatus() & SPI_EEPROM_STAT_WIP); } mSleep(400); setLEDs(0b0000); writeString_P("\nEEPROM TEST DONE!\n"); writeString_P("\nI2C TWI TEST:\n"); showScreenLCD("I2C TWI", "TEST"); I2CTWI_initMaster(100); I2CTWI_setTransmissionErrorHandler(I2C_transmissionError); uint8_t runningLight = 1; for(cnt = 0; cnt < 24; cnt++) { writeIntegerLength(cnt,DEC,3); writeChar(':'); writeIntegerLength(runningLight,DEC,3); writeChar(','); writeChar(' '); I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, 3, runningLight); I2CTWI_transmitByte(I2C_RP6_BASE_ADR, 29); uint8_t result = I2CTWI_readByte(I2C_RP6_BASE_ADR); if(result != runningLight) { writeString_P("\nTWI TEST ERROR!\n"); errors++; } runningLight <<= 1; if(runningLight > 32) runningLight = 1; if((cnt+1) % 6 == 0) writeChar('\n'); mSleep(100); } I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, 3, 0); writeString_P("\nTWI TEST DONE!\n"); writeString_P("\nMicrophone Test\n"); writeString_P("Hit the Microphone three times with your finger!\n"); showScreenLCD("MIC TEST:", ""); #define PREPARE 1 #define WAIT 2 uint8_t state = PREPARE; startStopwatch2(); while(true) { static uint8_t peak_count = 3; if(state == PREPARE) { if(getStopwatch2() > 250) { setCursorPosLCD(1, 6); writeIntegerLengthLCD( peak_count, DEC, 1); dischargePeakDetector(); state = WAIT; setStopwatch2(0); } } else if(state == WAIT) { uint8_t key = checkReleasedKeyEvent(); if(key) { break; } if(getStopwatch2() > 50) { uint16_t tmp = getMicrophonePeak(); if(tmp > 4) { externalPort.LEDS = 0; uint16_t i; uint8_t j; for(i = 0, j = 2; i < tmp; i+= 40) { if(i < 40) { externalPort.LEDS++; } else { externalPort.LEDS <<=1; externalPort.LEDS++; } } outputExt(); if(tmp > 120) { state = PREPARE; peak_count--; } if(peak_count == 0) break; } else setLEDs(0b0000); setStopwatch2(0); } } } writeString_P("\nMICROPHONE TEST DONE!\n"); showScreenLCD("ALL TESTS", "DONE!"); writeString_P("\n\n\n\n"); bars(2); writeString_P("\n\nALL TESTS DONE!\n\n"); if(errors) { bars(4); writeString_P("\nERROR ERROR ERROR ERROR ERROR ERROR ERROR\n"); writeString_P("\nATTENTION: TESTS FINISHED WITH ERRORS!!!\n"); writeString_P("PLEASE CHECK RP6-M32 ASSEMBLY!!!\n\n"); bars(4); writeString_P("\n\n"); } // Now we just show a running light... startStopwatch1(); uint8_t runLEDs = 1; uint8_t dir = 0; while(true) { if(getStopwatch1() > 100) { setLEDs(runLEDs); if(dir == 0) runLEDs <<= 1; else runLEDs >>= 1; if(runLEDs > 7 ) dir = 1; else if (runLEDs < 2 ) dir = 0; setStopwatch1(0); } }
/* Note: the following private methods serve as helper functions */ void Marshal::writeDataType(MarshalDataType val) { writeInteger((int) val); }
/** * This function gets called automatically if there was an I2C Error like * the slave sent a "not acknowledge" (NACK, error codes e.g. 0x20 or 0x30). */ void I2C_transmissionError(uint8_t errorState) { writeString_P_WIFI("\nI2C ERROR - TWI STATE: 0x"); writeInteger(errorState, HEX); writeChar_WIFI('\n'); }