uint8_t sensirion::sendCommandSHT(uint8_t _command, int _dataPin, int _clockPin) { if (sendCommandSHT_internal(_command, _dataPin, _clockPin) != 0){ // no ack, reset the interface and retry ONE time digitalWrite(_dataPin, HIGH); digitalWrite(_clockPin, LOW); pinMode(_dataPin, OUTPUT); pinMode(_clockPin, OUTPUT); digitalWrite(_dataPin, HIGH); digitalWrite(_clockPin, LOW); shtDelay(1); // send >9 clocks to reset interface shiftOut(_dataPin, _clockPin, MSBFIRST, 0xff, SHT_NOACK); shtDelay(1); shiftOut(_dataPin, _clockPin, MSBFIRST, 0xff, SHT_NOACK); // if we reset, do a real 1 ms delay delay(1); return sendCommandSHT_internal(_command, _dataPin, _clockPin); } else{ // success return SHT_SUCCESS; } }
void Multiplex7Seg4Digit::update() { if (pclass && pclass->_isNumDefined) { if(pclass->_num < 0 || pclass->_num > 9999) return; // Crear display. We can't just use clear() method here digitalWrite(pclass->_latchPin, LOW); shiftOut(pclass->_dataPin, pclass->_clockPin, MSBFIRST , 0b00000000); shiftOut(pclass->_dataPin, pclass->_clockPin, MSBFIRST , 0b00000000); digitalWrite(pclass->_latchPin, HIGH); String numStr = String(pclass->_num); if(pclass->_num < 10) { pclass->displayDecimal(pclass->_num, 3); } else if(pclass->_num < 100) { pclass->displayDecimal(numStr.charAt(0)-'0', 2); pclass->displayDecimal(numStr.charAt(1)-'0', 3); } else if(pclass->_num < 1000) { pclass->displayDecimal(numStr.charAt(0)-'0', 1); pclass->displayDecimal(numStr.charAt(1)-'0', 2); pclass->displayDecimal(numStr.charAt(2)-'0', 3); } else if(pclass->_num < 10000) { pclass->displayDecimal(numStr.charAt(0)-'0', 0); pclass->displayDecimal(numStr.charAt(1)-'0', 1); pclass->displayDecimal(numStr.charAt(2)-'0', 2); pclass->displayDecimal(numStr.charAt(3)-'0', 3); } } }
void ShiftLCD::write4bits(uint8_t value, uint8_t mode) { int EN_SWITCH = B00000010; int RS_SWITCH = B00000001; int cmd = 0; int data = 0; if (!mode) { cmd = 0 | _backlight; } else { cmd = LCD_RS_PIN | _backlight; } data = value<<4 & B11110000; cmd |= EN_SWITCH; digitalWrite(_latch_pin, HIGH); shiftOut(_data_pin, _clock_pin, LSBFIRST, data | cmd); digitalWrite(_latch_pin, LOW); delayMicroseconds(1); cmd &= ~EN_SWITCH; digitalWrite(_latch_pin, HIGH); shiftOut (_data_pin, _clock_pin, LSBFIRST, data | cmd); digitalWrite(_latch_pin, LOW); delayMicroseconds(1); cmd |= EN_SWITCH; digitalWrite(_latch_pin, HIGH); shiftOut(_data_pin, _clock_pin, LSBFIRST, data | cmd); digitalWrite(_latch_pin, LOW); delayMicroseconds(100); }
void LEDDisplay74HC595::setDisplayByte(byte displayByte, int pos) { shiftOut(_displayIO, _shiftClock, MSBFIRST, ~displayByte); shiftOut(_displayIO, _shiftClock, MSBFIRST, POS[pos]); digitalWrite(_resetClock, LOW); digitalWrite(_resetClock, HIGH); }
void LED47::displayDigital( int pos, char letter ) { digitalWrite(_rclkPin, LOW); shiftOut(_dioPin, _sclkPin, MSBFIRST, getBinCode(letter)); shiftOut(_dioPin, _sclkPin, MSBFIRST, getPosCode(pos)); digitalWrite(_rclkPin, HIGH); }
void Visor::loop(){ //visualizar digitos digitalWrite(VISOR_LATCH_PIN, LOW); shiftOut(VISOR_DATA_PIN, VISOR_CLOCK_PIN, MSBFIRST, digitos[0].getCifraSegmentByte()); shiftOut(VISOR_DATA_PIN, VISOR_CLOCK_PIN, MSBFIRST, digitos[1].getCifraSegmentByte()); digitalWrite(VISOR_LATCH_PIN, HIGH); }
void DSP0801Class::display() { for (int i = 0; i < MAX_CURSOR; i++) { shiftOut(_MOSI, _CLK, MSBFIRST, highByte(data_array[i])); shiftOut(_MOSI, _CLK, MSBFIRST, lowByte(data_array[i])); } pulseLAT(); }
void phi_liudr_keypads::updateShiftRegister(byte first8, byte next8) { digitalWrite(latchPin, LOW); // Disable update to the output buffers. shiftOut(dataPin, clockPin, MSBFIRST, first8);//MSBFIRST when flat LSBFIRST when standing. shiftOut(dataPin, clockPin, LSBFIRST, next8);//MSBFIRST when flat LSBFIRST when standing. digitalWrite(latchPin, HIGH); // Enable update to the output buffers. }
void loop() { for (int j = 0; j < 16; j++) { digitalWrite(latchPin, 0); if (j<8) { dataGREEN = dataArrayGREEN[j]; shiftOut(dataPin, clockPin, dataGREEN); } else { dataRED = dataArrayRED[j/2]; shiftOut(dataPin, clockPin, dataRED); } //return the latch pin high to signal chip that it //no longer needs to listen for information digitalWrite(latchPin, 1); delay(300); } }
void DdxCtl::turnOff() { shiftOut(DATAPIN, CLOCKPIN, MSBFIRST, 0); shiftOut(DATAPIN, CLOCKPIN, MSBFIRST, 0); shiftOut(DATAPIN, CLOCKPIN, MSBFIRST, 0); this->toggleLatch(); }
stdReturnType MaxMatrix::setDot(byte Column, byte Row, byte Value) { if(Column >= 0 && Column < MAXMATRIX_NUMBER_OF_COLUMNS && Row >= 0 && Row < MAXMATRIX_ROW_NUMBER_OF_MODULE) { bitWrite(buffer[Column], Row, Value); int Module = Column / MAXMATRIX_COLUMN_NUMBER_OF_MODULE; int ModuleColumn = Column % MAXMATRIX_COLUMN_NUMBER_OF_MODULE; digitalWrite(ChipSelectPin, LOW); for(int i = 0; i < NumberOfModules; i++) { if (i == Module) { shiftOut(DataInPin, ClockPin, MSBFIRST, ModuleColumn + 1); shiftOut(DataInPin, ClockPin, MSBFIRST, buffer[Column]); } else { shiftOut(DataInPin, ClockPin, MSBFIRST, 0); shiftOut(DataInPin, ClockPin, MSBFIRST, 0); } } digitalWrite(ChipSelectPin, LOW); digitalWrite(ChipSelectPin, HIGH); return E_OK; } else { return E_NOT_OK; } }
void draw(int col, int row, int holdtime, int color){ shiftOut(ROW_DAT,ROW_CLK,MSBFIRST,row); shiftOut(color,COL_CLK,MSBFIRST,col); delay(holdtime); shiftOut(ROW_DAT,ROW_CLK,MSBFIRST,0); shiftOut(color,COL_CLK,MSBFIRST,0); }
void Multiplex7Seg4Digit::clear() { _isNumDefined = false; digitalWrite(_latchPin, LOW); shiftOut(_dataPin, _clockPin, MSBFIRST , 0b00000000); shiftOut(_dataPin, _clockPin, MSBFIRST , 0b00000000); digitalWrite(_latchPin, HIGH); }
void update_display(void) { digitalWrite(LATCH, LOW); shiftOut(DATA, CLOCK, LSBFIRST, 1<<(current_row-Y_OFFSET)); shiftOut(DATA, CLOCK, LSBFIRST, (display[current][current_row]<<X_OFFSET)); digitalWrite(LATCH, HIGH); current_row = (current_row+1)%RES_Y; }
/* void displayPrint(uint8_t num) { #ifdef USE_EEPROM #else shiftOut(numbers[num%10]); #endif #if (DIGITS_NUMBER > 1) uint8_t a; //SEG_0= 1; SEG_PORT|= seg[0]; for (uint8_t i = 20; i > 0; i--) { asm("nop\n"); } if(num/=10) { a= num%10; //SEG_0= 0; SEG_PORT&= ~seg[0]; #ifdef USE_EEPROM #else shiftOut(numbers[a]); #endif //SEG_1= 1; SEG_PORT|= seg[1]; for (uint8_t i = 20; i > 0; i--) { asm("nop\n"); } #if (DIGITS_NUMBER == 2) //SEG_1 = 0; SEG_PORT&= ~seg[1]; #endif #endif #if (DIGITS_NUMBER > 2) if(num/=10) { a= num%10; //SEG_1= 0; SEG_PORT&= ~seg[1]; #ifdef USE_EEPROM #else shiftOut(numbers[a]); #endif //SEG_2= 1; SEG_PORT|= seg[2]; for (uint8_t i = 20; i > 0; i--) { asm("nop\n"); } #if (DIGITS_NUMBER == 3) //SEG_2 = 0; SEG_PORT&= ~seg[2]; #endif #endif #if (DIGITS_NUMBER > 3) if(num/=10) { a= num%10; //SEG_2= 0; SEG_PORT&= ~seg[2]; #ifdef USE_EEPROM #else shiftOut(numbers[a]); #endif //SEG_3= 1; SEG_PORT|= seg[3]; for (uint8_t i = 20; i > 0; i--) { asm("nop\n"); } //SEG_3= 0; SEG_PORT&= ~seg[3]; } else { return; } #endif #if (DIGITS_NUMBER > 2) } else { return; } #endif #if (DIGITS_NUMBER > 1) } else { return; } #endif for (uint8_t i= 20; i > 0; i--) { asm("nop\n"); } } */ void displayPrintESR(int16_t num) { if (digit_index == 0) { segm_flag= DIGIT; if (num < 0) { calc_var= (uint16_t)(0 - num); negative= 1; } else { calc_var= num; negative= 0; } } if (digit_index < DIGITS_NUMBER) { if (segm_flag&DIGIT) { uint8_t a= calc_var%10; #ifdef USE_EEPROM uint8_t b= eeprom_read(a); //seg[digit_index]= 0; SEG_PORT&= ~seg[prev_digit_index]; shiftOut(b); #else //seg[digit_index]= 0; SEG_PORT&= ~seg[prev_digit_index]; shiftOut(numbers[a]); #endif } else if (segm_flag&MINUS) { SEG_PORT &= ~seg[prev_digit_index]; shiftOut(_minus); } else { SEG_PORT&= ~seg[prev_digit_index]; shiftOut(0x00); } //seg[digit_index]= 1; SEG_PORT |= seg[digit_index]; prev_digit_index= digit_index; digit_index++; if (digit_index == DIGITS_NUMBER) { digit_index= 0; } if (segm_flag&DIGIT) { calc_var/= 10; if (!calc_var) { if (negative) { segm_flag= MINUS; } else { segm_flag= SPACE; } } } else if (segm_flag&MINUS){ if (prev_digit_index != (DIGITS_NUMBER - 1)){ segm_flag= SPACE; } } } }
void FU2_SO_Class::write(uint8_t b1, uint8_t b2, uint8_t b3) { digitalWrite(_latchPin, LOW); shiftOut(_dataPin, _clockPin, MSBFIRST, b1); shiftOut(_dataPin, _clockPin, MSBFIRST, b2); shiftOut(_dataPin, _clockPin, MSBFIRST, b3); digitalWrite(_latchPin, HIGH); }
void LedControl::spiTransfer(volatile uint8_t opcode, volatile uint8_t data) { // digitalWrite(10,LOW); PORTB &= ~_BV(PB2); shiftOut(opcode); shiftOut(data); // digitalWrite(10,HIGH); PORTB |= _BV(PB2); }
//Funcion para mandar valores a la placa void Matriz::imprimirPantalla(byte fila, byte columna){ //Como usamos un regirtro de desplazamiento utilizamos la funcion shiftOut para enviarle los datos enviando primero el bit mas significativo digitalWrite(pinLatch, LOW); shiftOut(pinDatos, pinReloj, MSBFIRST, fila); shiftOut(pinDatos, pinReloj, MSBFIRST, columna); digitalWrite(pinLatch, HIGH); }
void AD9850::update() { for (int i=0; i<4; i++, deltaphase>>=8) { shiftOut(DATA, W_CLK, LSBFIRST, deltaphase & 0xFF); } shiftOut(DATA, W_CLK, LSBFIRST, phase & 0xFF); pulse(FQ_UD); }
void WriteLEDs(void) { // Now we write the actual values to the hardware shiftOut(LEDDataPin, LEDClockPin, MSBFIRST, Display3); shiftOut(LEDDataPin, LEDClockPin, MSBFIRST, Display2); shiftOut(LEDDataPin, LEDClockPin, MSBFIRST, Display1); digitalWrite(LEDStrobePin,HIGH); delay(2); digitalWrite(LEDStrobePin,LOW); }
void DotDisplay::disablePins(){ byte secondbyte = B00000000; byte firstbyte = B00000000; digitalWrite(_latchPin, LOW); shiftOut(_dataPin, _clockPin, MSBFIRST, firstbyte); shiftOut(_dataPin, _clockPin, MSBFIRST, secondbyte); digitalWrite(_latchPin, HIGH); }
void MaxMatrix::setCommand(byte command, byte value) //gelen komut ve değere göre dot matrix üzerindeki ilgili komutu gerçekleştirir. { digitalWrite(cs, LOW); //dot matrix'e veri göndermeden önce CS pinini low yaptık. Daha sonra High yaparız. Pulse işlemini sağlamış oluruz. shiftOut(data, clock, MSBFIRST, command); //shiftOut fonksiyonu ile komutu yolladık shiftOut(data, clock, MSBFIRST, value); //daha sonra komutun ihtiyaç duyduğu değeri shiftOut ile yolladık. digitalWrite(cs, HIGH); }
void MaxMatrix::setColumnAll(byte col, byte value) //8x8'lik dot matrix'teki tüm led'lere aynı değeri atmayı sağlayan fonksiyon, clear fonksiyonu tarafından kullanılır. { digitalWrite(cs, LOW); shiftOut(data, clock, MSBFIRST, col + 1); shiftOut(data, clock, MSBFIRST, value); digitalWrite(cs, HIGH); }
void MaxMatrix::setColumn(byte col, byte value) //dot matrix'te hangi sütunun hangi verilerle yanacağını yapan fonksiyon { digitalWrite(cs, LOW); //gönderim öncesi CS low alınır, daha sonra high ayarlanır tekrardan. shiftOut(data, clock, MSBFIRST, col + 1); //komut olarak sütun numarası yollandı, yani dot matrix yazdırma işlemi yapacağını bu kodla anlar shiftOut(data, clock, MSBFIRST, value); //ayarlanan sütuna yazdırılacak olan veri yollanır digitalWrite(cs, HIGH); }
void Multiplex7Seg4Digit::displayDecimal(int dec, int pos) { if(dec < 0 || dec > 9) return; if(pos < 0 || pos > 4) return; digitalWrite(_latchPin, LOW); shiftOut(_dataPin, _clockPin, MSBFIRST , Multiplex7Seg4Digit::ARR_POS[pos]); shiftOut(_dataPin, _clockPin, MSBFIRST , Multiplex7Seg4Digit::ARR_NUM[dec]); digitalWrite(_latchPin, HIGH); }
void setMX7219Reg(byte reg, byte value) { // Shift reg then byte since MX7219 expects data in MSB order. digitalWrite(DLOAD, LOW); shiftOut(MOSI, SCLK, MSBFIRST, reg); shiftOut(MOSI, SCLK, MSBFIRST, value); // Pulse DLOAD digitalWrite(DLOAD, HIGH); digitalWrite(DLOAD, LOW); }
void writeOutputs () { analogWrite (plate0Pin, gain * plate0Temp); analogWrite (plate1Pin, gain * plate1Temp); analogWrite (plate2Pin, gain * plate2Temp); analogWrite (plate3Pin, gain * plate3Temp); digitalWrite (buzzerPin, buzzer); digitalWrite (latchPin, 0); shiftOut (dataPin, clockPin, LSBFIRST, 1 << int (3 - digitIndex)); shiftOut (dataPin, clockPin, LSBFIRST, ~(power ? (segments [int (digitValue)] + (digitDot ? dot : dark)) : dark)); // Active low digitalWrite (latchPin, 1); }
void setup() { // [MIDI_PITCH] = SOLENOID NUMBER TANGENT_PITCH_MAP[G4] = EXTRA_SOL;//reserved for open TANGENT_PITCH_MAP[Ab4] = 16; TANGENT_PITCH_MAP[A4] = 15; TANGENT_PITCH_MAP[Bb4] = 14; TANGENT_PITCH_MAP[B4] = 13; TANGENT_PITCH_MAP[C5] = 12; TANGENT_PITCH_MAP[Db5] = 11; TANGENT_PITCH_MAP[D5] = 10; TANGENT_PITCH_MAP[Eb5] = 9; TANGENT_PITCH_MAP[E5] = 8; TANGENT_PITCH_MAP[F5] = 7; TANGENT_PITCH_MAP[Gb5] = 6; TANGENT_PITCH_MAP[G5] = 5; TANGENT_PITCH_MAP[Ab5] = 4; TANGENT_PITCH_MAP[A5] = 3; TANGENT_PITCH_MAP[Bb5] = 2; TANGENT_PITCH_MAP[B5] = 1; pinMode(latchPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(dataPin, OUTPUT); pinMode(debugPin, OUTPUT); pinMode(MOSI, OUTPUT); digitalWrite(MOSI, LOW); //handle initialization of shift registers digitalWrite(latchPin, LOW); delay(1); shiftOut(dataPin, clockPin, MSBFIRST, 0); shiftOut(dataPin, clockPin, MSBFIRST, 0); shiftOut(dataPin, clockPin, MSBFIRST, 0); delay(1); digitalWrite(latchPin, HIGH); MIDI.begin(1); MIDI.setHandleNoteOn(_handler_MIDI_Note_On); MIDI.setHandleNoteOff(_handler_MIDI_Note_Off); MIDI.setHandleControlChange(_handler_MIDI_Control_Change); //fun blinky blinky int i; for (i=0; i<10; i++) { digitalWrite(14, HIGH); delay(30); digitalWrite(14, LOW); delay(30); } //startup delay for debugging delay(200); }
void shiftPin(int pos, int value) { if(pos<8) { bitWrite(shiftByte1, pos, value); } else { bitWrite(shiftByte2, pos-8, value); } digitalWrite(LE,LOW); shiftOut(SDI,CLK,MSBFIRST,shiftByte2); //High byte first shiftOut(SDI,CLK,MSBFIRST,shiftByte1); //Low byte second digitalWrite(LE,HIGH); }
void GASignalMatrix::setCommand(byte command, byte value) { digitalWrite( load, LOW ); for ( int i = 0; i < 1; i++ ) { shiftOut( data, clock, MSBFIRST, command ); shiftOut( data, clock, MSBFIRST, value ); } digitalWrite( load, LOW ); digitalWrite( load, HIGH ); }