//function for analog measure, return measured value //255=4.7V; 0 = 0V inline unsigned char Measure(unsigned char input_pin, unsigned char min, unsigned char max) { //REFS1 REFS0 ADLAR - MUX3 MUX2 MUX1 MUX0 ADMUX = 0x20 + input_pin; //ADEN ADSC ADFR ADIF ADIE ADPS2 ADPS1 ADPS0 ADCSRA = 0xC6; //start conversion, divide clk 64 while(readBit(ADCSRA, 6)); //wait until conversion is complete unsigned char measured = 0; if (ADCH<min) { measured=0; } if(ADCH<max) { measured-=min; } else { measured=(max-min); } return measured; }
int main(int argc, const char* argv[]) { FILE* inf = fopen(argv[1], "rb"); FILE* outf = fopen(argv[2], "wb"); int8_t in[320*200]; int8_t out[(320*200)/8]; memset(out, 0, (320*200)/8); int8_t* loc = in; for(int i=0; i < 320*200; ++i) { int16_t sh; fread(&sh, 2, 1, inf); *loc = 0x03 & sh; loc+=1; } for(int i=0; i < 320*200; ++i) { c64WriteBit(out, i, readBit(in, i)); } loc = out; for(int i=0; i < (320*200)/8; ++i) { fwrite(loc, 1, 1, outf); loc+=1; } fclose(inf); fclose(outf); return 0; }
unsigned ArithmeticDecoder::decode(DataModel* dataModel) { uint64_t range = intervalHigh - intervalLow + 1; auto scale = dataModel->getCumulativeFreq(dataModel->size() - 1); auto cumulativeFreq = ((value - intervalLow + 1) * scale - 1) / range; unsigned symbol = 0; // find i where cumuliveFreqs[i-1] < cumulativeFreq < cumulativeFreqs[i] for (size_t i = 0; i < dataModel->size(); ++i) { auto lowerBound = i != 0 ? dataModel->getCumulativeFreq(i - 1) : 0U; auto upperBound = dataModel->getCumulativeFreq(i); if (lowerBound <= cumulativeFreq && cumulativeFreq < upperBound) { symbol = i; break; } } // compute new interval bounds // interval upper bound is intervalHigh = intervalLow + (range * dataModel->getCumulativeFreq(symbol)) / scale - 1; // interval lower bound is computed as low + (r * cumFreq(i-1)) / s and cumFreq(-1) == 0 so // if symbol == 0 then interval lower bound is not modified if (symbol != 0) { intervalLow += (range * dataModel->getCumulativeFreq(symbol - 1)) / scale; } // enlarge interval and get bits from data // loop ends when interval is large enough for (;;) { // interval is in lower half of possible range if (intervalHigh < IntervalTraitsType::HALF) { ; // do nothing // interval is in upper half of possible range } else if (intervalLow >= IntervalTraitsType::HALF) { intervalLow -= IntervalTraitsType::HALF; intervalHigh -= IntervalTraitsType::HALF; value -= IntervalTraitsType::HALF; // interval is in middle of possible range } else if (intervalLow >= IntervalTraitsType::QUARTER && intervalHigh <= IntervalTraitsType::THREE_QUARTERS) { intervalLow -= IntervalTraitsType::QUARTER; intervalHigh -= IntervalTraitsType::QUARTER; value -= IntervalTraitsType::QUARTER; // none of these cases so break loop } else break; intervalLow <<= 1; intervalHigh = (intervalHigh << 1) + 1; readBit(); } // on adaptive data model we increase symbol frequency auto adaptiveModel = dynamic_cast<AdaptiveDataModel*>(dataModel); if (adaptiveModel != nullptr) adaptiveModel->incSymbolFreq(symbol); return symbol; }
void HeightEntry::writeBit(unsigned int b, bool v) { if(v) { if(!readBit(b)) { height.bytes[b / 8] += 1 << (b % 8); } } else { if(readBit(b)) { height.bytes[b / 8] -= 1 << (b % 8); } } }
void sendByte(unsigned char sByte){ unsigned char i=0; for(i=0;i<8;i++){ writeBit(sByte>>(7-i)); } writeBit(1); //MACK readBit(); //nosak }
/** * @brief get tap axes reg to choose which axis using in tap detection. * @param AXIS axis - axis want to get. * @return true axis already use. */ bool ADXL345::getTapAxes(AXIS axis){ bool state; switch (axis) { case AXIS_X: state = readBit(TAP_AXES_REG, 2); break; case AXIS_Y: state = readBit(TAP_AXES_REG, 1); break; case AXIS_Z: state = readBit(TAP_AXES_REG, 0); break; default: break; } return state; }
/** * @brief read act inact control register to get which axes * using in inactivity detection * @param adxl345_axis_t axis - axes want to read * @return true axis already using */ bool ADXL345::getInactControl(AXIS axis){ bool state; switch (axis) { case AXIS_X: state = readBit(ACT_INACT_CTL_REG, 2); break; case AXIS_Y: state = readBit(ACT_INACT_CTL_REG, 1); break; case AXIS_Z: state = readBit(ACT_INACT_CTL_REG, 0); break; default: break; } return state; }
ArithmeticDecoder::ArithmeticDecoder(std::shared_ptr<BitStreamReader>& bsr) : bitStreamReader(bsr), intervalLow(0), intervalHigh(IntervalTraitsType::MAX) { // read first IntervalTraitsType::BITS from data to value value = 0; for (size_t i = 0; i < IntervalTraitsType::BITS; ++i) readBit(); }
uint8_t readByte(void){ uint8_t i = 8, n = 0; while(i--){ //Shift one position right and store read value n >>= 1; n |= (readBit() << 7); } return n; }
/* Apply state changes to each GPIO */ void changeStateGPIO(gpio pins[], unsigned char data, int nbPins) { int i; if (pins != NULL) { for (i = 0; i < nbPins; i++) writeValueToGPIO(readBit(data, i), pins[i].name); } }
void ArithmeticDecoder::reset() { intervalLow = 0; intervalHigh = IntervalTraitsType::MAX; // read first IntervalTraitsType::BITS from data to value value = 0; for (size_t i = 0; i < IntervalTraitsType::BITS; ++i) readBit(); }
LByte BitReader::readByte() { LByte rv = 0x00; for(int i = 0; i < 8; i++) { setBit(rv, i, readBit()); } return rv; }
void SoftI2C::write(uint8_t value) { uint8_t mask = 0x80; while (mask != 0) { writeBit((value & mask) != 0); mask >>= 1; } if (readBit()) // 0: ACK, 1: NACK acked = false; }
uint32_t SWD::read(bool ap, int reg) { int ack = writeCommand(ap, 1, reg); if (ack == ACK_OK) { uint32_t value = 0; int parity = 0; for (unsigned int i = 0; i < 32; i++) { value >>= 1; int bit = readBit(); value |= bit << 31; parity ^= bit; } if (parity == readBit()) { pinMode(SWDAT, OUTPUT); writeBit(0); errors = std::max(errors - 1, 0); return value; } std::cout << "value: " << std::hex << value << std::endl; } else if (ack == ACK_FAULT) {
unsigned char Decoder::readByte() { unsigned char c=0; for (unsigned short i = 0; i < 8; i++) { if (readBit()) { c |= (1 << (7 - i)); } } return c; }
HeightArray HeightEntry::getHeightBits() const { HeightArray bits; for(unsigned int i = 0; i < HEIGHT_BITS; i++) { bits[i] = readBit(i); } return bits; }
void test_readBit(void){ { setPinLow_CMockExpect(49, 5); setPinHigh_CMockExpect(49, 5); getPin_CMockExpectAndReturn(49, 4, 1); }; uint8_t bit; bit = readBit(4); UnityAssertEqualNumber((_U_SINT)((1)), (_U_SINT)((bit)), (((void *)0)), (_U_UINT)52, UNITY_DISPLAY_STYLE_INT); }
unsigned char lastRead(void){ unsigned char i=0; unsigned char dummy = 0; for(i=0;i<8;i++){ dummy |= readBit(); dummy <<= 1; } writeBit(0); //NoMACK sak(); //sak return dummy; }
void GammaCompressor::decompressUnsignedInt(ifstream * invertedFile, unsigned int * number, unsigned char * bitCode, int * currentBit) { int numberSizeByBit = 1; while (readBit(invertedFile, bitCode, currentBit) == 1) { numberSizeByBit++; } if (numberSizeByBit == 1) { if (readBit(invertedFile, bitCode, currentBit) == 0) { *number = 0; } else { *number = 1; } } else { *number = 1; while (numberSizeByBit > 1) { *number = *number * 2 + readBit(invertedFile, bitCode, currentBit); numberSizeByBit--; } } }
unsigned char readByte(void){ unsigned char i=0; unsigned char dummy = 0; for(i=0;i<8;i++){ dummy |= readBit(); dummy <<= 1; } writeBit(1); //MACK sak(); //sak return dummy; }
// Read BYTE Function uint8_t OneWire::read(void) { uint8_t byte = 0; uint8_t i; for (i = 0; i < 8; i++) { byte >>= 1; if (readBit()) { byte |= 0x80; } } return byte; }
void Decoder::makeFile() { Node *node = &huffmanTree->getRoot(); while (!inFile.eof()) { if(readBit()){ node = &node->right(); }else{ node = &node->left(); } if (&node->left() == &HT::NIL and &node->right() == &HT::NIL) { outFile << static_cast<char>(node->key()); node = &huffmanTree->getRoot(); } } }
/** DS18B20 busy waiting. * * @return 0 if no timeout has occurred. */ int DS18B20::busyWait() { unsigned int enterTime = mstimer_get(); while ((!readBit()) && (mstimer_get() - enterTime < TEMP_CONVERSION_TIMEOUT)); if ((mstimer_get() - enterTime) >= TEMP_CONVERSION_TIMEOUT) { return -1; } else { return 0; } }
//----------------------------------------------------------------------------- // Read 1-Wire data byte and return it // int OWReadByte(void) { int loop, result=0; for (loop = 0; loop < 8; loop++) { // shift the result to get it ready for the next bit result >>= 1; // if result is one, then set MS bit if (readBit()) result |= 0x80; } return result; }
std::string HeightEntry::toString() const { std::string str = ""; str += coplanarTriangles ? '1' : '0'; str += coplanarSquares ? '1' : '0'; str += unused[0] ? '1' : '0'; str += unused[1] ? '1' : '0'; for(int i = HEIGHT_BITS - 1; i >= 0; i--) { str += readBit(i) ? '1' : '0'; } return str; }
uint8_t SoftI2C::read() { uint8_t value = 0; for (uint8_t bit = 0; bit < 8; ++bit) value = (value << 1) | readBit(); if (readCount > 1) { // More bytes left to read - send an ACK. writeBit(false); --readCount; } else { // Last byte - send the NACK and a stop condition. writeBit(true); stop(); readCount = 0; } return value; }
BitVectorInput(std::vector<std::string> const & rfilenames, uint64_t const offset) : filenames(rfilenames), nextfile(0), bitsleft(0), shift(-1), v(0) { std::pair<uint64_t,uint64_t> O = getOffset(filenames,offset); nextfile = O.first; if ( nextfile < filenames.size() ) { std::string const fn = filenames[nextfile++]; libmaus2::aio::InputStreamInstance::unique_ptr_type tistr( new libmaus2::aio::InputStreamInstance(fn) ); istr = UNIQUE_PTR_MOVE(tistr); istr->seekg(-8,std::ios::end); libmaus2::aio::SynchronousGenericInput<uint64_t>::unique_ptr_type nSGI( new libmaus2::aio::SynchronousGenericInput<uint64_t>(*istr,1) ); bool const ok = nSGI->getNext(bitsleft); assert ( ok ); // number of complete words to skip uint64_t wordskip = O.second / 64; istr->clear(); istr->seekg(8*wordskip,std::ios::beg); bitsleft -= 64*wordskip; O.second -= 64*wordskip; libmaus2::aio::SynchronousGenericInput<uint64_t>::unique_ptr_type tSGI( new libmaus2::aio::SynchronousGenericInput<uint64_t>(*istr,8*1024) ); SGI = UNIQUE_PTR_MOVE(tSGI); // skip over rest of offset by reading the bits while ( O.second ) { readBit(); --O.second; } } }
void GammaCompressor::readAndDecompress(ifstream * inputInvertedFile, DocumentTerm ** postingList, int size) { DocumentTerm *myPostingList = (DocumentTerm*)malloc(sizeof(DocumentTerm)*size); unsigned int delta = 0; unsigned int realNumber = 0; unsigned char bitCode = 0; int currentBit = 7; readBit(inputInvertedFile, &bitCode, ¤tBit); for (int i = 0; i < size; i++) { DocumentTerm docTerm; decompressUnsignedInt(inputInvertedFile, &delta,&bitCode,¤tBit); realNumber += delta; docTerm.documentIndex = realNumber; decompressUnsignedInt(inputInvertedFile, &(docTerm.ftd), &bitCode, ¤tBit); myPostingList[i] = docTerm; } *postingList = myPostingList; }
Decoder::Node& Decoder::readHeader() { if (readBit()) { Node *z = new Node(readByte(),0); z->setParent(HT::NIL).setLeft(HT::NIL).setRight(HT::NIL); return *z; } else { Node* leftChild = &readHeader(); Node* rightChild = &readHeader(); Node* z = new Node(0,0); z->setLeft(*leftChild); z->setRight(*rightChild); return *z; } }
/*! @brief Returns temperature read from BS18B20 @note Reading is returned mutiplied by 10000 i.e. for 25.8750 degrees the result will be 258750 */ uint32_t ds18b20GetTemparature(){ //Reset, skip ROM and start temperature conversion if(reset()) { printf("DS18B20 is not responding%s", CFG_PRINTF_NEWLINE); return 0; } writeByte(CMD_SKIPROM); writeByte(CMD_CONVERTTEMP); //Wait until conversion is complete uint16_t timeout = 0xFFFF; while(!readBit() && timeout > 0) { timeout--; } if(0 == timeout) { printf("BS18B20 temperature conversion has timed out%s", CFG_PRINTF_NEWLINE); return 0; } //Reset, skip ROM and send command to read Scratchpad if(reset()) { printf("DS18B20 is not responding%s", CFG_PRINTF_NEWLINE); return 0; } writeByte(CMD_SKIPROM); writeByte(CMD_RSCRATCHPAD); uint8_t scratchpad[2] = {0, 0}; //Read Scratchpad (only 2 first bytes) scratchpad[0] = readByte(); scratchpad[1] = readByte(); //Store temperature integer digits and decimal digits int8_t digit = scratchpad[0] >> 4; digit |= (scratchpad[1] & 0x7) << 4; //Store decimal digits uint16_t decimal = scratchpad[0] & 0xf; decimal *= DECIMAL_STEPS_12BIT; return digit * 10000 + decimal; }