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 );
}
