FlProg

Код: Выделить всё

#include <TM1638.h>
#include <TM16xxDisplay.h>
#include <TM16xxButtons.h>
uint32_t dwButtons;

TM1638 module(8, 9, 7);   // DIO=8, CLK=9, STB=7
TM16xxButtons buttons(&module);       // TM16xx button
TM16xxDisplay display(&module, 8);    // TM16xx object, 8 digits

void setup()
{
  Serial.begin(115200);
  module.clearDisplay();              // clear display
  module.setupDisplay(true, 1);       // set intensity 0-7, 7=highest
  delay(50);
  module.setDisplayToString("o-HELLO-");
  delay(900);
  module.clearDisplay();
}

void loop()
{
  dwButtons = buttons.tick();
  display.setDisplayToHexNumber(dwButtons, 0, false);
  Serial.print(F("Button "));
  Serial.println(dwButtons, HEX);
}

Код: Выделить всё

/*
TM16xxButtons.cpp - Buttons class for TM16xx.
The TM16xxButtons class supports the key-scanning features of TM16xx chips, such as TM1637 or TM1638. 
It extends the getButtons() function of the base class and provides these features:
 - setting callback functions
 - multi-state keys (similar to OneButton): Press, LongPress, Click, Doubleclick

These are some TM16xx chips that support key-scanning:
   TM1637   8 x 2 single    DIO/CLK
   TM1638   8 x 3 multi     DIO/CLK/STB
   TM1668   10 x 2 multi    DIO/CLK/STB

Made by Maxint R&D. See https://github.com/maxint-rd/
Partially based on OneButton library by Matthias Hertel. See https://github.com/mathertel/OneButton

*/

//#define TM16XX_DEBUG 1

#include "TM16xxButtons.h"

// constructor
TM16xxButtons::TM16xxButtons(TM16xx *pTM16xx, byte nNumButtons) : _nNumButtons(nNumButtons), _pTM16xx(pTM16xx)
{
	// TODO: reduce memory by using dynamic memory allocation instead of static arrays for button states
	// requires additional constructor parameter to allow less than TM16XX_BUTTONS_MAXBUTTONS

	//_pTM16xx=pTM16xx;
#if(TM16XX_OPT_BUTTONS_MALLOC)
	_state=malloc(_nNumButtons*sizeof(byte));
  _startTime=malloc(_nNumButtons*sizeof(unsigned long));
  _stopTime=malloc(_nNumButtons*sizeof(unsigned long));
#endif

	reset();
}



// explicitly set the number of millisec that have to pass by before a click is
// detected.
void TM16xxButtons::setClickTicks(int ticks)
{
  _clickTicks = ticks;
} // setClickTicks


// explicitly set the number of millisec that have to pass by before a long
// button press is detected.
void TM16xxButtons::setLongPressTicks(int ticks)
{
  _longPressTicks = ticks;
} // setLongPressTicks

#if(TM16XX_OPT_BUTTONS_EVENT)
// set function for release event
void TM16xxButtons::attachEventHandler(callbackTM16xxButtonsEvent newFunction)
{
  _eventFunc = newFunction;
} // attachEventHandler
#else
void TM16xxButtons::attachRelease(callbackTM16xxButtons newFunction)
{
  _releaseFunc = newFunction;
} // attachRelease

// set function for click event
void TM16xxButtons::attachClick(callbackTM16xxButtons newFunction)
{
  _clickFunc = newFunction;
} // attachClick

// set function for doubleClick event
void TM16xxButtons::attachDoubleClick(callbackTM16xxButtons newFunction)
{
  _doubleClickFunc = newFunction;
} // attachDoubleClick


// set function for longPressStart event
void TM16xxButtons::attachLongPressStart(callbackTM16xxButtons newFunction)
{
  _longPressStartFunc = newFunction;
} // attachLongPressStart

// set function for longPressStop event
void TM16xxButtons::attachLongPressStop(callbackTM16xxButtons newFunction)
{
  _longPressStopFunc = newFunction;
} // attachLongPressStop

// set function for during longPress event
void TM16xxButtons::attachDuringLongPress(callbackTM16xxButtons newFunction)
{
  _duringLongPressFunc = newFunction;
} // attachDuringLongPress
#endif

// function to get the current long pressed state
bool TM16xxButtons::isPressed(byte nButton)
{
	if(nButton>=_nNumButtons) return(false);
  return(_state[nButton]==TM16XX_BUTTONS_STATE_PRESSED || _state[nButton]==TM16XX_BUTTONS_STATE_DBLPRESS || _state[nButton]==TM16XX_BUTTONS_STATE_LPRESS);
}

// function to get the current long pressed state
bool TM16xxButtons::isLongPressed(byte nButton)
{
	if(nButton>=_nNumButtons) return(false);
	return(_state[nButton]==TM16XX_BUTTONS_STATE_LPRESS);
}

int TM16xxButtons::getPressedTicks(byte nButton)
{
	if(nButton>=_nNumButtons) return(0);
  return((_stopTime[nButton] - _startTime[nButton]));		// uint16_t subtraction may overflow, but is still fine   0x01 - 0xFC = 0x05
}

void TM16xxButtons::reset(void)
{
  for(byte n=0; n<_nNumButtons; n++)
  {
	  _state[n] = TM16XX_BUTTONS_STATE_START; // restart.
	  _startTime[n] = 0;
	  _stopTime[n] = 0;
	}
}


/**
 * @brief Check input of the configured pin and then advance the finite state
 * machine (FSM).
 */
uint32_t TM16xxButtons::tick(void)
{	// update the state of each button and call callback functions as needed
	uint32_t dwButtons=_pTM16xx->getButtons();
#ifdef TM16XX_DEBUG
  Serial.print(F("TM16xxButtons: "));
  Serial.print(dwButtons, HEX);
  Serial.print(F(", state: "));
  for(byte n=0; n<_nNumButtons; n++)
  {
	  tick(n, (dwButtons&bit(n))>0);		// MMOLE 181103: _BV only works on 16-bit values!
	  Serial.print(_state[n]);
	}
  Serial.print(F("    "));
#else
  for(byte n=0; n<_nNumButtons; n++)
	  tick(n, dwButtons&bit(n));		// MMOLE 181103: _BV only works on 16-bit values!
#endif
	return(dwButtons);
}

/**
 * @brief Advance the finite state machine (FSM) using the given level.
 */
void TM16xxButtons::tick(byte nButton, bool activeLevel)
{
  //unsigned long now = millis(); // current (relative) time in msecs.
  uint16_t now = (uint16_t) millis(); // current (relative) time in msecs. To safe RAM we only use the bottom word (16 bits for instead of 32 for approx. 50 days)

  // Implementation of the state machine
  switch(_state[nButton])
  {
  case TM16XX_BUTTONS_STATE_START:	// waiting for button being pressed.
    if (activeLevel)
    {
      _state[nButton] = TM16XX_BUTTONS_STATE_PRESSED; // step to pressed state
      _startTime[nButton] = now; // remember starting time
    } // if
    break;

  case TM16XX_BUTTONS_STATE_PRESSED: // waiting for button being released.
    if (!activeLevel)
    {
      _state[nButton] = TM16XX_BUTTONS_STATE_RELEASED; // step to released state
      _stopTime[nButton] = now; // remember stopping time
#if(TM16XX_OPT_BUTTONS_EVENT)
      if (_eventFunc)
        _eventFunc(TM16XX_BUTTONS_EVENT_RELEASE, nButton);
#else
      if (_releaseFunc)
        _releaseFunc(nButton);
#endif
    }
    else if ((activeLevel) && ((unsigned long)(now - _startTime[nButton]) > _longPressTicks))
    {
      _state[nButton] = TM16XX_BUTTONS_STATE_LPRESS; // step to long press state
      _stopTime[nButton] = now; // remember stopping time
#if(TM16XX_OPT_BUTTONS_EVENT)
      if (_eventFunc)
      {
        _eventFunc(TM16XX_BUTTONS_EVENT_LONGPRESSSTART, nButton);
        _eventFunc(TM16XX_BUTTONS_EVENT_LONGPRESSBUSY, nButton);
      }
#else
      if (_longPressStartFunc)
        _longPressStartFunc(nButton);
      if (_duringLongPressFunc)
        _duringLongPressFunc(nButton);
#endif
    } else {
      // wait. Stay in this state.
    } // if
    break;

  case TM16XX_BUTTONS_STATE_RELEASED: // waiting for button being pressed the second time or timeout.
#if(TM16XX_OPT_BUTTONS_EVENT)
    if ((unsigned long)(now - _startTime[nButton]) > _clickTicks)
#else
    if (_doubleClickFunc == NULL || (unsigned long)(now - _startTime[nButton]) > _clickTicks)
#endif
    {
      // this was only a single short click
#if(TM16XX_OPT_BUTTONS_EVENT)
      if (_eventFunc)
        _eventFunc(TM16XX_BUTTONS_EVENT_CLICK, nButton);
#else
      if (_clickFunc)
        _clickFunc(nButton);
#endif
      _state[nButton] = TM16XX_BUTTONS_STATE_START; // restart.
    }
    else if ((activeLevel))
    {
      _state[nButton] = TM16XX_BUTTONS_STATE_DBLPRESS; // step to doubleclick state
      _startTime[nButton] = now; // remember starting time
    } // if
    break;

  case TM16XX_BUTTONS_STATE_DBLPRESS: // waiting for button being released finally.
    if ((!activeLevel))
   	{
      // this was a 2 click sequence.
      _state[nButton] = TM16XX_BUTTONS_STATE_START; // restart.
      _stopTime[nButton] = now; // remember stopping time
#if(TM16XX_OPT_BUTTONS_EVENT)
      if (_eventFunc)
      {
        _eventFunc(TM16XX_BUTTONS_EVENT_RELEASE, nButton);
        _eventFunc(TM16XX_BUTTONS_EVENT_DOUBLECLICK, nButton);
      }
#else
      if (_releaseFunc)
        _releaseFunc(nButton);
      if (_doubleClickFunc)
        _doubleClickFunc(nButton);
#endif
    } // if
    break;

  case TM16XX_BUTTONS_STATE_LPRESS: // waiting for button being release after long press.
    if (!activeLevel)
    {
      _state[nButton] = TM16XX_BUTTONS_STATE_START; // restart.
      _stopTime[nButton] = now; // remember stopping time
#if(TM16XX_OPT_BUTTONS_EVENT)
      if (_eventFunc)
      {
        _eventFunc(TM16XX_BUTTONS_EVENT_RELEASE, nButton);
        _eventFunc(TM16XX_BUTTONS_EVENT_LONGPRESSSTOP, nButton);
      }
#else
      if (_releaseFunc)
        _releaseFunc(nButton);
      if (_longPressStopFunc)
        _longPressStopFunc(nButton);
#endif
    }
    else
    {
      // button is being long pressed
#if(TM16XX_OPT_BUTTONS_EVENT)
      if (_eventFunc)
        _eventFunc(TM16XX_BUTTONS_EVENT_LONGPRESSBUSY, nButton);
#else
      if (_duringLongPressFunc)
        _duringLongPressFunc(nButton);
#endif
    } // if
		break;
  } // switch
} // TM16xxButtons.tick(nButton)

Код: Выделить всё

/*
TM16xx.h - Library for TM1637, TM1638 and similar chips.
Modified by Maxint R&D. See https://github.com/maxint-rd/

Copyright (C) 2011 Ricardo Batista (rjbatista <at> gmail <dot> com)

This program is free software: you can redistribute it and/or modify
it under the terms of the version 3 GNU General Public License as
published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#if defined(ARDUINO) && ARDUINO >= 100
	#include "Arduino.h"
#else
	#include "WProgram.h"
#endif

#include "TM16xx.h"
//#include "string.h"

TM16xx::TM16xx(byte dataPin, byte clockPin, byte strobePin, byte maxDisplays, byte digits, boolean activateDisplay,	byte intensity)
{
  this->dataPin = dataPin;
  this->clockPin = clockPin;
  this->strobePin = strobePin;
  this->_maxDisplays = maxDisplays;
  this->digits = digits;

  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(strobePin, OUTPUT);

  digitalWrite(strobePin, HIGH);
  digitalWrite(clockPin, HIGH);

  //sendCommand(TM16XX_CMD_DISPLAY | (activateDisplay ? 8 : 0) | min(7, intensity));		// display command: on or intensity

/*
  sendCommand(TM16XX_CMD_DATA_AUTO);			// data command: set data mode to auto-increment write mode
	start();
  send(TM16XX_CMD_ADDRESS);					// address command + address C0H
  for (int i = 0; i < 16; i++) {		// TM1638 and TM1640 have 16 data addresses, TM1637 and TM1668 have less, but will wrap.
    send(0x00);
  }
	stop();
*/	
	// Note: calling these methods should be done in constructor of derived class in order to use properly initialized members!
/*
	clearDisplay();
	setupDisplay(activateDisplay, intensity);
/**/
}

void TM16xx::setupDisplay(boolean active, byte intensity)
{
  sendCommand(TM16XX_CMD_DISPLAY | (active ? 8 : 0) | min(7, intensity));
}

void TM16xx::clearDisplay()
{	// Clear all data registers. The number of registers depends on the chip.
	// TM1638 (10x8): 10 segments per grid, stored in two bytes. The first byte contains the first 8 display segments, second byte has seg9+seg10  => 16 bytes
	// TM1640 (8x16): one byte per grid => 16 bytes
	// TM1637 (8x6): one byte per grid => 6 bytes
	// TM1668 (10x7 - 14x3): two bytes per grid => 14 bytes
  sendCommand(TM16XX_CMD_DATA_AUTO);		// set auto increment addressing mode

	// send the address followed by bulk-sending of the data to clear the display memory
	start();
  send(TM16XX_CMD_ADDRESS);
  for (int i = 0; i < _maxDisplays; i++) {
    send(0x00);
    if(_maxSegments>8)
    	send(0x00);		// send second byte (applicable to TM1638 and TM1668)
  }
	stop();

}

void TM16xx::setSegments(byte segments, byte position)
{	// set 8 leds on common grd as specified
	// TODO: support 10-14 segments on chips like TM1638/TM1668
	if(position<_maxDisplays)
		sendData(position, segments);
		//sendData(TM16XX_CMD_ADDRESS | position, segments);
}

void TM16xx::sendChar(byte pos, byte data, boolean dot)
{
/*
	if(pos<_maxDisplays)
	  sendData(pos, data | (dot ? 0b10000000 : 0));
*/
	setSegments(data | (dot ? 0b10000000 : 0), pos);
}

void TM16xx::setDisplayDigit(byte digit, byte pos, boolean dot, const byte numberFont[])
{
  sendChar(pos, pgm_read_byte_near(numberFont + (digit & 0xF)), dot);
}

void TM16xx::setDisplayToDecNumber(int nNumber, byte bDots)		// byte bDots=0
{	// Function to display a decimal number on a n-digit clock display.
	// Kept simple to fit in ATtiny44A
	// For extended display features use the TM16xxDisplay class

	// TODO: support large displays such as 8segx16 on TM1640
  for(byte nPos=1; nPos<=digits; nPos++)
  {
    setDisplayDigit(nNumber % 10, digits - nPos, bDots&_BV(nPos));
    nNumber/=10;
  }
}

void TM16xx::clearDisplayDigit(byte pos, boolean dot)
{
  sendChar(pos, 0, dot);
}

void TM16xx::setDisplay(const byte values[], byte size)
{	// send an array of values to the display
  for (byte i = 0; i < size; i++) {
    sendChar(i, pgm_read_byte_near(values+i), 0);
  }
}

void TM16xx::setDisplayToString(const char* string, const word dots, const byte pos, const byte font[])
{
  for (int i = 0; i < digits - pos; i++) {
  	if (string[i] != '\0') {
		  sendChar(i + pos, pgm_read_byte_near(font+(string[i] - 32)), (dots & (1 << (digits - i - 1))) != 0);
		} else {
		  break;
		}
  }
}

// key-scanning method, implemented in chip specific derived class
uint32_t TM16xx::getButtons()
{	// return state of up to 32 keys.
	return(0);
}


//
//  Protected methods
//

void TM16xx::bitDelay()
{	// if needed derived classes can add a delay (eg. for TM1637)
	//delayMicroseconds(50);
}

void TM16xx::start()
{	// if needed derived classes can use different patterns to start a command (eg. for TM1637)
  digitalWrite(strobePin, LOW);
  bitDelay();
}

void TM16xx::stop()
{	// if needed derived classes can use different patterns to stop a command (eg. for TM1637)
  digitalWrite(strobePin, HIGH);
  bitDelay();
}

void TM16xx::send(byte data)
{
	// MMOLE 180203: shiftout does something, but is not okay (tested on TM1668)
	//shiftOut(dataPin, clockPin, LSBFIRST, data);
  for (int i = 0; i < 8; i++) {
    digitalWrite(clockPin, LOW);
    bitDelay();
    digitalWrite(dataPin, data & 1 ? HIGH : LOW);
    bitDelay();
    data >>= 1;
    digitalWrite(clockPin, HIGH);
    bitDelay();
  }
  bitDelay();		// NOTE: TM1638 specifies a Twait between bytes of minimal 1us.
}

void TM16xx::sendCommand(byte cmd)
{
	start();
  send(cmd);
  stop();
}

void TM16xx::sendData(byte address, byte data)
{
  sendCommand(TM16XX_CMD_DATA_FIXED);							// use fixed addressing for data
	start();
  send(TM16XX_CMD_ADDRESS | address);						// address command + address
  send(data);
  stop();
}

byte TM16xx::receive()
{
  byte temp = 0;

  // Pull-up on
  pinMode(dataPin, INPUT);
  digitalWrite(dataPin, HIGH);

  for (int i = 0; i < 8; i++) {
    temp >>= 1;

    digitalWrite(clockPin, LOW);
    bitDelay();		// NOTE: on TM1637 reading keys should be slower than 250Khz (see datasheet p3)

    if (digitalRead(dataPin)) {
      temp |= 0x80;
    }

    digitalWrite(clockPin, HIGH);
    bitDelay();
  }

  // Pull-up off
  pinMode(dataPin, OUTPUT);
  digitalWrite(dataPin, LOW);

  return temp;
}

Код: Выделить всё

/*
TM1638.cpp - Library implementation for TM1638.

Copyright (C) 2011 Ricardo Batista (rjbatista <at> gmail <dot> com)
Rewrite for TM16xx library by Maxint R&D. See https://github.com/maxint-rd/

This program is free software: you can redistribute it and/or modify
it under the terms of the version 3 GNU General Public License as
published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#if defined(ARDUINO) && ARDUINO >= 100
	#include "Arduino.h"
#else
	#include "WProgram.h"
#endif

#include "TM1638.h"

TM1638::TM1638(byte dataPin, byte clockPin, byte strobePin, byte numDigits, boolean activateDisplay, byte intensity)
	: TM16xx(dataPin, clockPin, strobePin, TM1638_MAX_POS, numDigits, activateDisplay, intensity)
{
  _maxSegments=10;		// on the LED & KEY modules the extra segments are used to drive individual red or red/green LEDs

	clearDisplay();
	setupDisplay(activateDisplay, intensity);
}

void TM1638::setSegments(byte segments, byte position)
{	// set 8 leds on common grd as specified
	// TODO: support 10-14 segments on chips like TM1638/TM1668
  // TM1638 uses 10 segments in two bytes, similar to TM1668
  // for the digit displays only the first byte (containing seg1-seg8) is sent
	// Only the LSB (SEG1-8) is sent to the display
	if(position<_maxDisplays)
		sendData(position << 1, segments);
}

void TM1638::setSegments16(uint16_t segments, byte position)
{	// method to send more than 8 segments (10 max for TM1638)
  // TM1638 uses 10 segments in two bytes, similar to TM1668
  // segments 0-7 are in bits 0-7 of position bytes 0,2,4,6,8,10,12,14
  // segments 8-9 are in bits 0-1 of position bytes 1,3,5,7,9,11,13,15
	if(position<_maxDisplays)
	{
		sendData(position << 1, (byte)segments&0xFF);
		sendData((position << 1) | 1, (byte)(segments>>8)&0x03);
	}
}

void TM1638::setLED(byte color, byte pos)
{ // TM1638 uses 10 segments in two bytes, for the LEDs only the second byte (containing seg9-seg10) is send
    sendData((pos << 1) + 1, color);
}

void TM1638::setLEDs(word leds)
{
  for (int i = 0; i < digits; i++) {
    byte color = 0;

    if ((leds & (1 << i)) != 0) {
      color |= TM1638_COLOR_RED;
    }

    if ((leds & (1 << (i + 8))) != 0) {
      color |= TM1638_COLOR_GREEN;
    }

    setLED(color, i);
  }
}

uint32_t TM1638::getButtons(void)
{
	// TM1638 returns 4 bytes/8 nibbles for keyscan. Each byte has K3, K2 and K1 status in lower bits of each nibble for KS1-KS8
	// NOTE: K1/K2 are implemented for this class, but the TM1638 LED&KEY module only uses K3.
	//       Also note that the buttons are wired in odd sequence: S1=KS1, S5=KS2, S2=KS3, S6=KS4, S3=KS5, S7=KS6, S4=KS7, S8=KS8
  byte keys_K1 = 0;
  byte keys_K2 = 0;
  byte keys_K3 = 0;

  start();
  send(TM16XX_CMD_DATA_READ); // B01000010 Read the key scan data

  for (int i = 0; i < 4; i++)
  {
	  byte rec = receive();
    keys_K1 |= ((rec&_BV(2))>>2 | (rec&_BV(6))>>5) << (2*i);			// bits 2 and	6 for K1/KS1 and K1/KS2
    keys_K2 |= ((rec&_BV(1))>>1 | (rec&_BV(5))>>4) << (2*i);			// bits 1 and	5 for K2/KS1 and K2/KS2
    keys_K3 |= ((rec&_BV(0))    | (rec&_BV(4))>>3) << (2*i);			// bits 0 and	4 for K3/KS1 and K3/KS2
  }

  stop();

  return((uint32_t)keys_K3<<16 | (uint32_t)keys_K2<<8 | (uint32_t)keys_K1);
}

Код: Выделить всё

#define dataPin 8
#define clockPin 9
#define strobePin 7

#define DIO_HIGH pinMode(dataPin, INPUT)
#define DIO_LOW pinMode(dataPin, OUTPUT)
#define DIO_READ digitalRead(dataPin)
#define DIO_WRITE digitalWrite(dataPin,LOW)

#define CLK_HIGH pinMode(clockPin, INPUT)
#define CLK_LOW pinMode(clockPin, OUTPUT)
#define CLK_WRITE digitalWrite(clockPin,LOW)

#define STB_HIGH pinMode(strobePin, INPUT)
#define STB_LOW pinMode(strobePin, OUTPUT)

void setup()
{
  Serial.begin(115200);
  delay(50);
}

void loop()
{
  unsigned long read24keys = getButtons_24();
  byte keys1_8 = (read24keys) & 0xFF;
  byte keys9_16 = (read24keys >> 8) & 0xFF;
  byte keys17_24 = (read24keys >> 16) & 0xFF;
  Serial.print(F("Button "));
  Serial.print(keys1_8, HEX); // здесь получаю 0
  Serial.print(F("-- "));
  Serial.print(keys9_16, HEX); // и здесь
  Serial.print(F("-- "));
  Serial.println(keys17_24, HEX); // эдесь тоже 0, с библой от Батиста всё выводит нормально
}

unsigned long getButtons_24(void)
{
  unsigned long keys_24 = 0;
  STB_LOW;
  send(0x42);
  keys_24 = fullReceive();
  STB_HIGH;
  delay(5);
  return keys_24;
}
// Вспомогательные функции
void send(byte data)
{
  for (byte i = 0; i < 8; i++) {
    CLK_LOW;
    digitalWrite(dataPin, data & 1 ? HIGH : LOW);
    data >>= 1;
    CLK_HIGH;
  }
}
unsigned long fullReceive()
// For matrix keyboard 3x8 buttons on K1, K2, K3 pins of IC TM1638 connected
{
  unsigned long temp = 0;
  DIO_HIGH;
  for (byte i = 0; i < 31; i++)
  {
    CLK_LOW;
    if ((i & 0b1) && (i & 0b10)) //3,7,11,15,19,23,27 bits excluded
    {
      CLK_HIGH;
      continue;
    }
    else
    {
      temp <<= 1;
      if (DIO_READ) bitSet(temp, 0);
      else bitClear(temp, 0);
      CLK_HIGH;
    }
  }
  DIO_LOW;
  return temp;
}

Код: Выделить всё

#define PIN_DIO 8
#define PIN_CLK 9
#define PIN_STB 10
/////////////    ТИПА "библиотека" ДЛЯ TM1668    ////////////
#define LED_DATA_LENGTH 16 // достаточно 16 байтов на светодиоды и 2 на кнопки

// Глобальные переменные
static uint16_t ledGRID[LED_DATA_LENGTH / 2]; // текущее состояние экрана
static uint16_t saveGRID[LED_DATA_LENGTH / 2]; // нужно для сохранения состояния экрана на время теста
static uint8_t currentBrightness = 1; // текущая яркость

//  Запись одиночной команды в TM1668
void writeSingleCommand(const uint8_t command) {
  digitalWrite(PIN_STB, LOW);
  shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, command);
  digitalWrite(PIN_STB, HIGH);
  delayMicroseconds(1); // Пауза до следующей команды
}

//  Запись состояния дисплея в TM1668
void updateDisplay(void) {
  writeSingleCommand(0x40);  // запись данных, автоматический адрес
  digitalWrite(PIN_STB, LOW);
  shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, 0xC0); // Установка адреса в 0
  uint8_t * p = (uint8_t *) ledGRID;
  for (int8_t i = 0; i < LED_DATA_LENGTH; i++, p++) shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, *p); // запись данных
  digitalWrite(PIN_STB, HIGH);
  delayMicroseconds(1); // Пауза до следующей команды
}

//  Чтение состояния кнопок с TM1668
uint32_t getButtons_24(void)
{
  uint32_t keys_24 = 0;
  digitalWrite(PIN_STB, LOW);//STB_LOW;
  shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, 0x42);  // чтение данных //send(0x42);
  pinMode(PIN_DIO, INPUT_PULLUP);//DIO_HIGH;
  delayMicroseconds(1);
  for (byte i = 0; i < 31; i++)
  {
    digitalWrite(PIN_CLK, LOW);//CLK_LOW;
    keys_24 <<= 1;
    if (digitalRead(PIN_DIO)) bitSet(keys_24, 0);
    //else bitClear(keys_24, 0);
    digitalWrite(PIN_CLK, HIGH);//CLK_HIGH;
  }
  pinMode(PIN_DIO, OUTPUT);//DIO_LOW;
  digitalWrite(PIN_STB, HIGH);//STB_HIGH;
  return keys_24;
}

// Установить яркость от 0 (выключено) до 8
// (возвращает старую яркость)
static inline uint8_t setBrightness(const uint8_t newBrighness) {
  const uint8_t res = currentBrightness;
  currentBrightness = (newBrighness > 8) ? 8 : newBrighness;
  if (currentBrightness == 0) writeSingleCommand(0x80); // Выключить дисплей
  else writeSingleCommand(0x88 + (currentBrightness - 1)); // Установить яркость
  return res;
}

// Зажечь произвольные символы
void matrix(byte leds_0, byte leds_1, byte leds_2, byte leds_3, byte leds_4, byte leds_5, byte leds_6, byte leds_7, byte Brightness)
{
  memcpy(saveGRID, ledGRID, sizeof(saveGRID));
  ledGRID[0] = leds_0;
  ledGRID[1] = leds_1;
  ledGRID[2] = leds_2;
  ledGRID[3] = leds_3;
  ledGRID[4] = leds_4;
  ledGRID[5] = leds_5;
  ledGRID[6] = leds_6;
  ledGRID[7] = leds_7;
  setBrightness(Brightness);
  updateDisplay();
}

void setup(void) {
  Serial.begin(115200);
  // Инициализация пинов
  pinMode(PIN_CLK, OUTPUT);
  pinMode(PIN_DIO, OUTPUT);
  pinMode(PIN_STB, OUTPUT);
  digitalWrite(PIN_STB, HIGH);
  digitalWrite(PIN_CLK, HIGH);
  // Инициализация экрана
  writeSingleCommand(0x03); // Режим отображения (1 и 2 - ничего не меняется)
}

void loop(void) {
  matrix(1, 127, 4, 8, 16, 33, 64, 128, 7);
  delay(50);
  //  Читаем состояние кнопок
  // и отрабатываем команды
  uint32_t read24keys = getButtons_24();
  byte keys1 = (read24keys) & 0xFF;
  byte keys2 = (read24keys >> 8) & 0xFF;
  byte keys3 = (read24keys >> 16) & 0xFF;
  byte keys4 = (read24keys >> 24) & 0xFF;
  Serial.print(F("Button "));
  Serial.print(keys1);
  Serial.print(F("-- "));
  Serial.print(keys2);
  Serial.print(F("-- "));
  Serial.print(keys3);
  Serial.print(F("-- "));
  Serial.println(keys4);
}

Код: Выделить всё

void loop() {
  if (currentBrightness != newBrightness){
	currentBrightness = newBrightness ;
	 setBright(currentBrightness);}
}

void TM16xx::setBright(byte newBrightness)
  {
    byte intensity = 0x80;  // display OFF mode, 0x88- ON mode
    if (newBrightness) intensity += (newBrightness + 7); 
    // или то же с защитой от превышения диапазона (отсекаем 4,5,6 биты)
    // if (newBrightness) intensity += ((newBrightness&0xF)+ 7);
    send(intensity);
// ф-я от Батисты
void TM16XX::send(byte data)
{
  for (byte i = 0; i < 8; i++) {
    CLK_LOW;
    digitalWrite(dataPin, data & 1 ? HIGH : LOW);
    data >>= 1;
    CLK_HIGH;
  }
}