void slave_status::print_channel_state(Print& out, const channel_state_t& state)
{
switch (state)
{
case channel_working:
out.print("Working Normally");
break;
case channel_disconnected:
out.print("Disconnected / Solenoid Not Found");
break;
case channel_failed_short:
out.print("Short-Circuited");
break;
case channel_failed_open:
out.print("Failed Open-Circuit");
break;
default:
out.print("Unknown / Invalid Channel Status");
break;
}
}
void CApplicationMonitor::Dump(Print &rDestination, bool bOnlyIfPresent) const
{
CApplicationMonitorHeader Header;
CCrashReport Report;
uint8_t uReport;
uint32_t uAddress;
LoadHeader(Header);
if (!bOnlyIfPresent || Header.m_uSavedReports != 0)
{
rDestination.println(F("Application Monitor"));
rDestination.println(F("-------------------"));
PrintValue(rDestination, F("Saved reports: "), Header.m_uSavedReports, DEC, true);
PrintValue(rDestination, F("Next report: "), Header.m_uNextReport, DEC, true);
for (uReport = 0; uReport < Header.m_uSavedReports; ++uReport)
{
LoadReport(uReport, Report);
rDestination.print(uReport);
uAddress = 0;
memcpy(&uAddress, Report.m_auAddress, PROGRAM_COUNTER_SIZE);
PrintValue(rDestination, F(": word-address=0x"), uAddress, HEX, false);
PrintValue(rDestination, F(": byte-address=0x"), uAddress * 2, HEX, false);
PrintValue(rDestination, F(", data=0x"), Report.m_uData, HEX, true);
}
}
}
void GAnalogSensor::printdesc(Print& prn)
{
// e.g. A0:
prn.print(F("A"));
prn.print(_pin);
prn.print(F(": "));
}
void OSCBundle::send(Print &p){
//don't send a bundle with errors
if (hasError()){
return;
}
//write the bundle header
static uint8_t header[] = {'#', 'b', 'u', 'n', 'd', 'l', 'e', 0};
p.write(header, 8);
//write the timetag
{
osctime_t time = timetag;
uint32_t d = BigEndian(time.seconds);
uint8_t * ptr = (uint8_t *) &d;
p.write(ptr, 4);
d = BigEndian(time.fractionofseconds);
ptr = (uint8_t *) &d;
p.write(ptr, 4);
}
//send the messages
for (int i = 0; i < numMessages; i++){
OSCMessage * msg = getOSCMessage(i);
int msgSize = msg->bytes();
//turn the message size into a pointer
uint32_t s32 = BigEndian((uint32_t) msgSize);
uint8_t * sptr = (uint8_t *) &s32;
//write the messsage size
p.write(sptr, 4);
msg->send(p);
}
}
void printDigits(Print &print, int digits) {
// utility function for digital clock display: prints preceding colon and leading 0
print.print(":");
if (digits < 10)
print.print('0');
print.print(digits);
}
size_t IPAddress::printTo(Print& p) const {
size_t n = 0;
if (!isSet())
return p.print(F("(IP unset)"));
#if LWIP_IPV6
if (isV6()) {
int count0 = 0;
for (int i = 0; i < 8; i++) {
uint16_t bit = PP_NTOHS(raw6()[i]);
if (bit || count0 < 0) {
n += p.printf("%x", bit);
if (count0 > 0)
// no more hiding 0
count0 = -8;
} else
count0++;
if ((i != 7 && count0 < 2) || count0 == 7)
n += p.print(':');
}
return n;
}
#endif
for(int i = 0; i < 4; i++) {
n += p.print((*this)[i], DEC);
if (i != 3)
n += p.print('.');
}
return n;
}
void setDateFromStream(Stream &in, Print& out) {
out.print("set date (MM/DD/YYYY): ");
int month, day, year;
int val = in.peek();
while(val <= ' ') {
in.read();
val = in.peek();
}
do {
month = in.parseInt();
} while(month == 0);
if(in.peek() != '/') {
out.println("Syntax error");
return;
}
day = in.parseInt();
if(in.peek() != '/') {
out.println("Syntax error");
return;
}
year = in.parseInt();
if(year < 100) {
year += 2000;
}
rtc_clock.set_date(day, month, year);
}
void JsonPrinter::booleanValue(Print& printer, boolean value) {
if (value == true) {
printer.print("true");
} else {
printer.print("false");
}
}
void setTimeFromStream(Stream &in, Print& out) {
out.print("set time (HH:MM:SS): ");
int second, minute, hour;
int val = in.peek();
while(val < '0' || val > '9') {
if(val > ' ') {
out.println("Syntax error");
return;
}
in.read();
val = in.peek();
}
hour = in.parseInt();
if(in.peek() != ':') {
out.println("Syntax error");
return;
}
minute = in.parseInt();
if(in.peek() != ':') {
second = 0;
} else {
second = in.parseInt();
}
rtc_clock.set_time(hour, minute, second);
}
size_t JsonObjectBase::printTo(Print& p) const
{
size_t n = 0;
n += p.write('{');
// NB: the code has been optimized for a small size on a 8-bit AVR
const KeyValuePair* current = items;
for (int i = count; i > 0; i--)
{
n += EscapedString::printTo(current->key, p);
n += p.write(':');
n += current->value.printTo(p);
current++;
if (i > 1)
{
n += p.write(',');
}
}
n += p.write('}');
return n;
}
void printErrorCb(TxStatusResponse& r, uintptr_t data) {
Print *p = (Print*)data;
if (!r.isSuccess()) {
p->print(F("Error sending packet. Delivery status: "));
p->println(r.getStatus());
}
}
void digitalDateDisplay(Print& print) {
print.print(day());
print.print(".");
print.print(month());
print.print(".");
print.print(year());
}
void digitalClockDisplay(Print &print) {
// digital clock display of the time
digitalTimeDisplay(print);
print.print(" ");
digitalDateDisplay(print);
print.println();
}
void BuildGraph::print_setting (void) {
cout << "filename : " << filename_ << endl;
print.Vector("sentences", sentences_);
print.Dict("relscore", *relscore_);
cout << "winsize : " << winsize_ << endl;
print.Array("lambda", lamb_list_, lamb_size_);
print.Array("cutoff_path", cutoff_list_, cutoff_size_);
}
void CApplicationMonitor::PrintValue(Print &rDestination, const __FlashStringHelper *pLabel,
uint32_t uValue, uint8_t uRadix, bool bNewLine) const
{
rDestination.print(pLabel);
rDestination.print(uValue, uRadix);
if (bNewLine)
rDestination.println();
}
static inline size_t printCharTo(char c, Print& p)
{
char specialChar = getSpecialChar(c);
return specialChar != 0
? p.write('\\') + p.write(specialChar)
: p.write(c);
}
void printResponseCb(ZBTxStatusResponse& status, uintptr_t data) {
Print *p = (Print*)data;
p->println(F("ZBTxStatusResponse received:"));
printField(p, F(" FrameId: 0x"), status.getFrameId());
printField(p, F(" To: 0x"), status.getRemoteAddress());
printField(p, F(" Delivery status: 0x"), status.getDeliveryStatus());
printField(p, F(" Discovery status: 0x"), status.getDiscoveryStatus());
}
void printErrorCb(RemoteAtCommandResponse& r, uintptr_t data) {
Print *p = (Print*)data;
if (!r.isOk()) {
p->print(F("Error sending remote "));
p->write(r.getCommand(), 2);
p->print(F(" command. Status: "));
p->println(r.getStatus());
}
}
size_t IPAddress::printTo(Print& p) const {
size_t n = 0;
for(int i = 0; i < 3; i++) {
n += p.print(_address.bytes[i], DEC);
n += p.print('.');
}
n += p.print(_address.bytes[3], DEC);
return n;
}
int main(void) {
unsigned int i = 0;
while(1) {
Print* myprint = new HelloWorld(i++);
myprint->print();
delete myprint;
}
}
void StringMap::print(Print &client, StringMapKey key) const {
if (!this->contains(key)) return;
char * s = this->find(key);
if (!s) return;
if (isProgmem(key))
client.print((__FlashStringHelper *)s);
else
client.print(s);
}
void printResponseCb(Rx64IoSampleResponse& rx, uintptr_t data) {
Print *p = (Print*)data;
p->println("Rx64IoSampleResponse received:");
printField(p, F(" From: 0x"), rx.getRemoteAddress64());
printField(p, F(" Rssi: 0x"), rx.getRssi());
printField(p, F(" Receive options: 0x"), rx.getOption());
printField(p, F(" Number of samples: 0x"), rx.getSampleSize());
printSamples(p, rx);
}
void BuildGraph::print_graph (void) {
print.Set("nodes", graph_.nodes);
cout << "edges ";
for (map<string, set<string> >::iterator itr = graph_.edges.begin(); itr != graph_.edges.end(); ++itr) {
set<string> dst = itr->second;
cout << "src : " << itr->first << endl;
print.Set("dst", dst);
}
};
size_t IPAddress::printTo(Print& p) const
{
int i=0;
while (1) {
p.print(_address.bytes[i], DEC);
if (++i >= 4) return 4;
p.write('.');
}
}
int main()
{
Print *p;
p = new PrintBanner("Hello");
p->printWeak();
p->printStrong();
delete p;
return 0;
}
void printRawResponseCb(XBeeResponse& response, uintptr_t data) {
Print *p = (Print*)data;
p->print("Response received: ");
// Reconstruct the original packet
uint8_t header[] = {START_BYTE, response.getMsbLength(), response.getLsbLength(), response.getApiId()};
printHex(*p, header, sizeof(header), F(" "), NULL);
p->write(' ');
printHex(*p, response.getFrameData(), response.getFrameDataLength(), F(" "), NULL);
p->println();
}
void slight_StepperManager::print_error(Print &out, error_t error) {
switch (error) {
case ERROR_none: {
out.print(F("none"));
} break;
case ERROR_timeout: {
out.print(F("timeout"));
} break;
case ERROR_limitswitch_wrong_dir: {
// out.print(F("LimitSw wrong dir"));
out.print(F("LimitSwDirection"));
} break;
case ERROR_limitswitchs: {
out.print(F("LimitSw blocked"));
} break;
case ERROR_motorstart: {
out.print(F("motor start"));
} break;
case ERROR_motorstop: {
out.print(F("motor stop"));
} break;
case ERROR_calibrating: {
out.print(F("calibrating"));
} break;
case ERROR_mechanics_moved: {
out.print(F("mechanics moved"));
} break;
case ERROR_emergencystop: {
out.print(F("emergency stop"));
} break;
}
}
size_t QuotedString::printTo(const char *s, Print &p) {
if (!s) return p.print("null");
size_t n = p.write('\"');
while (*s) {
n += printCharTo(*s++, p);
}
return n + p.write('\"');
}
void PBBP::printLastError(Print &p) {
if (this->last_error < sizeof(error_code_str) / sizeof(*error_code_str))
p.print(error_code_str[this->last_error]);
else
p.print(this->last_error);
if (this->last_error == NACK) {
p.print(", slave error code: 0x");
p.print(this->last_slave_error, HEX);
}
}
size_t IP64Address::printTo(Print& p) const
{
size_t n = 0;
for (int i =0; i < 7; i++)
{
n += p.print(_address[i], DEC);
n += p.print('.');
}
n += p.print(_address[7], DEC);
return n;
}
