uint16_t ClientAJAKumoTCP::calculateChecksum(uint8_t* packet, uint8_t len) {
    uint16_t retVal = 0;
    uint16_t sum = 0;
    uint8_t idx = 1;
    while(idx++ < len) sum += packet[idx-1];
    sum = 256 - (sum & 255);

    retVal = toASCII(sum >> 4) << 8;
    retVal |= toASCII(sum & 0xF);

    return retVal;
}
/*
*Contains algorithm to turn an image into ASCII art!
*Parameters:
*filename: the file to write our art to.
*pixAmount: the amount of pixels per character (in a square)
*img: a pointer to our image in memory.
*
*return 0 if no errors were encountered, 1 otherwise.
*/
int ascii(Image* img, char* filename, int pixAmount) {
	// if we don't have a file in memory, say so.
	if(img->data == NULL) {
	fprintf(stderr, "Error, no file currently in memory\n");
		return 1;
	}
	//first we need to pixelate
	pixelate(img, pixAmount);
	//then turn it into grayscale
	toGrayscale(img);
	//our file to write to
	FILE* fout= fopen(filename, "w");
	// our indicator of brightness
	int brightness = 0;
	//the character we want to use to write
	char c = ' ';
	//for each "square" of our image
	for(int j=0; j<(img->rowNum/pixAmount); j++) {
		for(int i=0; i<(img->colNum/pixAmount); i++) {
			//our brightness value is equal to the actual brightness over 8, because we're 
			//using 31 different characters to create our image.
			brightness =(int)((img->data[pixAmount*((j*img->colNum)+i)].r)/(2.34375));
			//mapping brightness to character
			c = toASCII(brightness);
			//printing the character twice so we can have a square image.
			fprintf(fout,"%c%c",c,c);
			
		}
		//print a line break.
		fprintf(fout,"\n");
	}
	//close our file!			
	fclose(fout);
	
	return 0;	
	
}
void ClientAJAKumoTCP::transmitPacket(char* data) {
    uint8_t len = strlen(data);
    uint8_t *_buffer = (uint8_t*)malloc(6 + len);
    // Prepare packet
    _buffer[0] = 0x01; // SOH
    _buffer[1] = 'N'; // Protocol ID
    _buffer[2] = toASCII(_sessionID & 0xF);

    for(uint8_t i = 0; i < len; i++) {
        if(data[i] == ',') {
            _buffer[3+i] = 0x09; // HT
        } else {
            _buffer[3+i] = data[i];
        }
    }

    uint16_t checksum = calculateChecksum(_buffer, 3+len);

    _buffer[3+len] = checksum >> 8;
    _buffer[4+len] = checksum & 0xFF;

    _buffer[5+len] = 0x04; // EOT

    if(_client.connected()) {
        if(_serialOutput > 1) {
            for(uint8_t j=0; j<6+len; j++) {
                Serial << _HEXPADL(_buffer[j], 2, "0") << ":";
            }
            Serial << "\n";
        }

        _client.write(_buffer, 6 + len);
    }

    free(_buffer);
}
Exemplo n.º 4
0
void toUSB_sendhex8( uint8_t value) {
    toUSB_send('0');
    toUSB_send('x');
    toUSB_send(toASCII(value >> 4));
    toUSB_send(toASCII(value & 0x0f));
}
Exemplo n.º 5
0
/// Read the content of the named file.  The file content is read into the
/// buffer in one-shot and then digested.
///
/// This function determines the version of the dictionary and invokes the
/// necessary reading function to perform the actual reading operations.
/// Currently there are three possible version of dictioanries
/// 0x02000000 - the version produced by the current write function,
/// 0x01000000 - the version with 64-bit offsets, consecutive kyes, strings
///              are stored in key order
/// 0x00000000 - the version 32-bit offsets and stores strings in
///              sorted order.
/// unmarked   - the version without a header, only has the bare strings in
///              the code order.
int ibis::dictionary::read(const char* name) {
    if (name == 0 || *name == 0) return -1;
    std::string evt = "dictionary::read";
    if (ibis::gVerbose > 1) {
        evt += '(';
        evt += name;
        evt += ')';
    }

    // open the file to read
    int ierr = 0;
    FILE* fptr = fopen(name, "rb");
    if (fptr == 0) {
        LOGGER(ibis::gVerbose > 3)
            << "Warning -- " << evt << " failed to open the file ... "
            << (errno ? strerror(errno) : "no free stdio stream");
        return -2;
    }

    ibis::util::timer mytimer(evt.c_str(), 4);
    IBIS_BLOCK_GUARD(fclose, fptr);
    ierr = fseek(fptr, 0, SEEK_END); // to the end
    if (ierr != 0) {
        LOGGER(ibis::gVerbose > 1)
            << "Warning -- " << evt << " failed to seek to the end of the file";
        return -3;
    }

    uint32_t version = 0xFFFFFFFFU;
    long int sz = ftell(fptr); // file size
    if (sz > 24) {
        char header[20];
        ierr = fseek(fptr, 0, SEEK_SET);
        if (ierr != 0) {
            LOGGER(ibis::gVerbose > 1)
                << "Warning -- " << evt << " failed to seek to the beginning "
                "of the file";
            return -4;
        }

        ierr = fread(header, 1, 20, fptr);
        if (ierr != 20) {
            LOGGER(ibis::gVerbose > 1)
                << "Warning -- " << evt << " failed to read the 20-byte header";
            return -5;
        }
        if (header[0] == _fastbit_dictionary_header[0] &&
            header[1] == _fastbit_dictionary_header[1] &&
            header[2] == _fastbit_dictionary_header[2] &&
            header[3] == _fastbit_dictionary_header[3] &&
            header[4] == _fastbit_dictionary_header[4] &&
            header[5] == _fastbit_dictionary_header[5] &&
            header[6] == _fastbit_dictionary_header[6] &&
            header[7] == _fastbit_dictionary_header[7] &&
            header[8] == _fastbit_dictionary_header[8] &&
            header[9] == _fastbit_dictionary_header[9] &&
            header[10] == _fastbit_dictionary_header[10] &&
            header[11] == _fastbit_dictionary_header[11] &&
            header[12] == _fastbit_dictionary_header[12] &&
            header[13] == _fastbit_dictionary_header[13] &&
            header[14] == _fastbit_dictionary_header[14] &&
            header[15] == _fastbit_dictionary_header[15]) {
            version = (header[16] << 24 | header[17] << 16 |
                       header[18] << 8 | header[19]);
            LOGGER(ibis::gVerbose > 3)
                << evt << " detected dictionary version 0x" << std::hex
                << version << std::dec;
        }
        else {
            LOGGER(ibis::gVerbose > 2)
                << evt << " did not find the expected header, assume "
                "to have no header (oldest version of dictioinary)";
        }
    }

    // invoke the actual reader based on version number
    switch (version) {
    case 0x02000000:
            ierr = readKeys2(evt.c_str(), fptr);
            break;
    case 0x01000000:
            ierr = readKeys1(evt.c_str(), fptr);
            break;
    case 0x00000000:
            ierr = readKeys0(evt.c_str(), fptr);
            break;
    default:
            ierr = readRaw(evt.c_str(), fptr);
            break;
    }
    if (ibis::gVerbose > 3) {
        ibis::util::logger lg;
        lg() << evt << " completed with ";
        toASCII(lg());
    }
    return ierr;
} // ibis::dictionary::read
Exemplo n.º 6
0
void send_serial_hex_USB( uint8_t value) {
    send_serial_USB('0');
    send_serial_USB('x');
    send_serial_USB(toASCII(value >> 4));
    send_serial_USB(toASCII(value & 0x0f));
}