Lập trình STM32 ,STM32H7 Mở rộng IO Đầu vào 74HC595

Đăng bởi Trần Văn Bùi ngày 09/28/2021 03:16:11 bình luận

Hôm nay mình giới thiệu lập trình mở rộng đầu vào ra cho Arduino STM32

Sơ đồ cơ bản

chân CS nối trở 10k chống nhiễu cho HC595

Các chân QA-QH đầu ra dữ liệu ,

Chân 12 LATCH Chân CS

Chân số 11 :CLK Xung clok HC595

Chân 13 OE cho phép xuất ra output

Chân số 14:data in Tương ứng dữ liệu HC595

Chân số 9 Chính chân Nối tiếp IC tiếp theo

Nguyên lý hoạt động

Chương trình Với STM32

Hàm write cơ bản :

void HC595_WRITE(uint8_t dat)

{

uint8_t i; for(i=0;i<8;i++)

{

if(dat & 0x01) { SER_H; }

else { SER_L; } dat >>= 1; SCK_L;

Delay_Us(1); SCK_H; Delay_Us(1);

}

RCK_L; RCK_H;

}

Full Chương trình với STM32H7

unsigned char LED_0F[] =
{// 0   1   2   3   4   5   6   7   8   9   A   b   C d   E F -
   0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x8C,0xBF,0xC6,0xA1,0x86,0xFF,0xbf
};
unsigned char LED1[8] =
{
0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F,
};
int k=0;
unsigned char LED[4];
#define SCLK PA_4
#define RCLK PA_5
#define DIO PA_7
long int cnt_led=0;
long int cnt_m=0;
void setup ()
{
pinMode(SCLK,OUTPUT);
pinMode(RCLK,OUTPUT);
pinMode(DIO,OUTPUT);
}
void loop()
{

LED_OUT(0x00); LED_OUT(0x00); LED_OUT(0x00);
digitalWrite(RCLK,LOW);
// delay(1);

digitalWrite(RCLK,HIGH);

delay(100);
LED_OUT(0xFF); LED_OUT(0xFF); LED_OUT(0xFF); digitalWrite(RCLK,LOW);
// delay(1);
digitalWrite(RCLK,HIGH);


delay(100);



}

void LED4_Display (void)
{
   unsigned char *led_table; // ????
   unsigned char i;


   led_table = LED_0F + LED[0];
   i = *led_table;
   LED_OUT(0x01);
   LED_OUT(i);
digitalWrite(RCLK,LOW);
digitalWrite(RCLK,HIGH);
   led_table = LED_0F + LED[1];
   i = *led_table;
   LED_OUT(0x02);
   LED_OUT(i);
digitalWrite(RCLK,LOW);
digitalWrite(RCLK,HIGH);
   led_table = LED_0F + LED[2];
   i = *led_table;
   LED_OUT(0x04);
   LED_OUT(i);
digitalWrite(RCLK,LOW);
digitalWrite(RCLK,HIGH);
   led_table = LED_0F + LED[3];
   i = *led_table;
   LED_OUT(0x08);
   LED_OUT(i);
digitalWrite(RCLK,LOW);
digitalWrite(RCLK,HIGH);
}

void LED_OUT(unsigned char X)
{
   unsigned char i;
   for(i=8;i>=1;i--)
   {
       if (X&0x80)
{
digitalWrite(DIO,HIGH);
}
else
{
digitalWrite(DIO,LOW);
}
       X<<=1;
digitalWrite(SCLK,LOW);

// delay(1);

digitalWrite(SCLK,HIGH);
   }

}
void convert(unsigned char x)
{ // do chuc nang ghi dich 8 bit vao noi tiep ra song song
// do do vong for duoi se cho dich 8 lan de du 8 chan dau ra cho vdk
int i,tam;
for(i=0;i<8;i++) // 8 lan dich de co 8 bit
{
tam=x;
tam=tam&0x80;
if(tam==0x80) digitalWrite(DIO,HIGH);
else digitalWrite(DIO,LOW);
x=x<<1; // dich bit nhu sau
digitalWrite(SCLK,LOW);
delay(100);
digitalWrite(SCLK,HIGH);

}

digitalWrite(RCLK,LOW);

digitalWrite(RCLK,HIGH);

}
void display(unsigned int m)
{
int a,b,c,d;

a=m/1000;
b=(m-a*1000)/100;
c=(m-a*1000-b*100)/10;
d=(m-a*1000-b*100-c*10);
LED[0]=a;
LED[1]=b;
LED[2]=c;
LED[3]=d;
LED4_Display();
}
Chương trình điều khiển từng LED Kết hợp HMI công nghiệp

/*
* Example to demonstrate thread definition, semaphores, and thread sleep.
*/

#include <Modbus.h>
#include <ModbusSerial.h>
#include <Wire.h>
#include "MCP4728.h"
#include <HardwareSerial.h>

#define TX1_pin 10
#define RX1_pin 9

#define TX2_pin 26
#define RX2_pin 27
//HardwareSerial Serial1(1);
#include <Adafruit_ADS1015.h>
#define BitSet(arg,posn) ((arg) | (1L << (posn)))
#define BitClr(arg,posn) ((arg) & ~(1L << (posn)))

#define BIT_SET(x,y) ((x) |= (y))
#define BIT_CLEAR(x,y) ((x) &= (~(y)))

unsigned int data595[16];
enum {Y0,Y1,//P47
Y2,Y3,//P70
Y4,Y5,//P48
Y6,Y7,//P71
Y8,Y9,
Y10,Y11,
Y12,Y13,
Y14,Y15,
};

//PWWM

//led
unsigned char LED_0F[] =
{// 0 1 2 3 4 5 6 7 8 9 A b C d E F -
0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x8C,0xBF,0xC6,0xA1,0x86,0xFF,0xbf
};
unsigned char LED[4];
#define SCLK PA_4
#define RCLK PA_5
#define DIO PA_7
int EN485 = 38;
long int cnt_led=0;
long int cnt_m=0;
const int PWM[4] = {12,11,45,46};
//#include <Arduino_FreeRTOS.h>

// define two tasks for Blink & AnalogRead

// Modbus Registers Offsets (0-9999)

// Used Pins
const int ledPin = 13;
const int LED1_VAL = 0; //primeiro led posição 0
const int LED2_VAL = 1; //segundo led posição 1
unsigned int cnt_mb=0,cnt_mb1=0,cnt_mb2=0,cnt_mb3=0;
int ADC0 = 34;
int ADC1 = 35;
int ADC2 = 36;
int ADC3 = 36;
int sensorValue[10]={};
long int Value=0;
const int switchPin0 = 100;
const int switchPin1 = 101;

const int Val0X[16]={0,1,2,3,4,5,6,12,8,9,10,11,13,14,16,17};
const int Val1X[24]={0,1,2,3,4,5,6,16,8,9,10,11,12,13,14,17,18,19,20,21,22,26,24,25};
const int Val3X[10]={1,2,3,4,5,6,7,8,9};
const int Val4X[10]={1,2,3,4,5,6,7,8,9};
//
const int LAMP0x0000_COIL =Val0X[0];
const int LAMP0x0001_COIL =Val0X[1];
const int LAMP0x0002_COIL =Val0X[2];
const int LAMP0x0003_COIL =Val0X[3];
const int LAMP0x0004_COIL =Val0X[4];
const int LAMP0x0005_COIL =Val0X[5];
const int LAMP0x0006_COIL =Val0X[6];
const int LAMP0x0007_COIL =Val0X[7];
const int LAMP0x0008_COIL =Val0X[8];
const int LAMP0x0009_COIL =Val0X[9];
const int LAMP0x00010_COIL =Val0X[10];
const int LAMP0x00011_COIL =Val0X[11];
const int LAMP0x00012_COIL =Val0X[12];
const int LAMP0x00013_COIL =Val0X[13];
const int LAMP0x00014_COIL =Val0X[14];
const int LAMP0x00015_COIL =Val0X[15];
//
const int SWITCH_1x0000 = Val1X[0];
const int SWITCH_1x0001 = Val1X[1];
const int SWITCH_1x0002 = Val1X[2];
const int SWITCH_1x0003 = Val1X[3];
const int SWITCH_1x0004 = Val1X[4];
const int SWITCH_1x0005 = Val1X[5];
const int SWITCH_1x0006 = Val1X[6];

const int SWITCH_1x0007 = Val1X[7];
const int SWITCH_1x0008 = Val1X[8];
const int SWITCH_1x0009 = Val1X[9];
const int SWITCH_1x00010 = Val1X[10];
const int SWITCH_1x00011 = Val1X[11];
const int SWITCH_1x00012 = Val1X[12];
const int SWITCH_1x00013 = Val1X[13];
const int SWITCH_1x00014 = Val1X[14];
const int SWITCH_1x00015 = Val1X[15];
const int SWITCH_1x00016 = Val1X[16];
const int SWITCH_1x00017 = Val1X[17];
const int SWITCH_1x00018 = Val1X[18];
const int SWITCH_1x00019 = Val1X[19];
const int SWITCH_1x00020 = Val1X[20];
const int SWITCH_1x00021 = Val1X[21];
const int SWITCH_1x00022 = Val1X[22];
const int SWITCH_1x00023 = Val1X[23];

//
const int JK3x0001_VAL = Val3X[0];
const int JK3x0002_VAL = Val3X[1];
const int JK3x0003_VAL = Val3X[2];
const int JK3x0004_VAL = Val3X[3];
const int JK3x0005_VAL = Val3X[4];
const int JK3x0006_VAL = Val3X[5];
const int JK3x0007_VAL = Val3X[6];
const int JK3x0008_VAL = Val3X[7];
const int JK3x0009_VAL = Val3X[8];
//
const int JK4x0001 = Val4X[0];
const int JK4x0002 = Val4X[1];
const int JK4x0003 = Val4X[2];
const int JK4x0004 = Val4X[3];
const int JK4x0005 = Val4X[4];
const int JK4x0006 = Val4X[5];
const int JK4x0007 = Val4X[6];
const int JK4x0008 = Val4X[7];
const int JK4x0009 = Val4X[8];
const int JK4x0020 = Val4X[9];

// ModbusSerial object
ModbusSerial mb;

// The LED is attached to pin 13 on Arduino.
const uint8_t LED_PIN = 100;
const uint8_t LED_PIN1 = 100;
const uint8_t LED_PIN2 = 100;
const uint8_t LED_PIN3 = 100;
const uint8_t LED_PIN4 = 100;
const uint8_t LED_PIN5 = 100;
const uint8_t LED_PIN6 = 100;
const uint8_t LED_PIN7 = 100;
const uint8_t LED_PIN8 = 100;
const uint8_t LED_PIN9 =100;
const uint8_t LED_PIN10 =100;
const uint8_t LED_PIN11 =100;
const uint8_t LED_PIN12 =100;
const uint8_t LED_PIN13 =100;
const uint8_t LED_PIN14 =100;
const uint8_t LED_PIN15 =100;

//------------------------------------------------------------------------------
/*
* Threads static table, one entry per thread. A thread's priority is
* determined by its position in the table with highest priority first.
*
* These threads start with a null argument. A thread's name may also
* be null to save RAM since the name is currently not used.
*/
////------------------------------------------------------------------------------

//------------------------------------------------------------------------------
/*
* Thread 2, turn the LED on and signal thread 1 to turn the LED off.
*/
// Declare a stack with 128 bytes beyond context switch and interrupt needs.

//------------------------------------------------------------------------------
int x = 0;
int n = 1;
int x1 = 0;
int n1 = 2;
int x2 = 0;
int n2 = 3;
int16_t adc0, adc1, adc2, adc3;
Adafruit_ADS1115 ads;
const float multiplier = 0.0625F;
MCP4728 dac;
#define TX1_pin 12
#define RX1_pin 13
void setup() {
// Start Nil RTOS.

// Serial.begin(9600);

// Descomentar el que interese
// ads.setGain(GAIN_TWOTHIRDS); +/- 6.144V 1 bit = 0.1875mV (default)
//ads.setGain(GAIN_ONE); // +/- 4.096V 1 bit = 0.125mV
ads.setGain(GAIN_TWO); // +/- 2.048V 1 bit = 0.0625mV
// ads.setGain(GAIN_FOUR); +/- 1.024V 1 bit = 0.03125mV
// ads.setGain(GAIN_EIGHT); +/- 0.512V 1 bit = 0.015625mV
// ads.setGain(GAIN_SIXTEEN); +/- 0.256V 1 bit = 0.0078125mV
ads.begin();

Wire.begin();
dac.attach(Wire, 14);
dac.readRegisters();

dac.selectVref(MCP4728::VREF::VDD, MCP4728::VREF::VDD, MCP4728::VREF::VDD, MCP4728::VREF::VDD);
dac.selectPowerDown(MCP4728::PWR_DOWN::GND_100KOHM, MCP4728::PWR_DOWN::GND_100KOHM, MCP4728::PWR_DOWN::GND_500KOHM, MCP4728::PWR_DOWN::GND_500KOHM);
dac.selectGain(MCP4728::GAIN::X2, MCP4728::GAIN::X2, MCP4728::GAIN::X2, MCP4728::GAIN::X2);
dac.analogWrite(MCP4728::DAC_CH::A, 111);
dac.analogWrite(MCP4728::DAC_CH::B, 222);
dac.analogWrite(MCP4728::DAC_CH::C, 333);
dac.analogWrite(MCP4728::DAC_CH::D, 444);

dac.enable(true);

dac.readRegisters();

//Serial1.begin(9600, SERIAL_8N1, RX1_pin, TX1_pin);
// Serial1.begin(9600, SERIAL_8N1, RX1_pin, TX1_pin);
// Serial2.begin(9600, SERIAL_8N1, RX2_pin, TX2_pin);
mb.config(&Serial2, 9600, SERIAL_8N1);


// Set the Slave ID (1-247)
mb.setSlaveId(1);
pinMode( EN485 , OUTPUT);
digitalWrite(EN485, HIGH);
for (int ipwm = 0; ipwm <= 3; ipwm++) {
pinMode(PWM[ ipwm], OUTPUT);
}
pinMode(switchPin0, INPUT);
pinMode(switchPin1, INPUT);

pinMode(SCLK,OUTPUT);
pinMode(RCLK,OUTPUT);
pinMode(DIO,OUTPUT);

//
// pinMode(SCLK,OUTPUT);
// pinMode(RCLK,OUTPUT);
// pinMode(DIO,OUTPUT);

// Set ledPin mode
pinMode(ledPin, OUTPUT);
pinMode( LED_PIN, OUTPUT);
pinMode( LED_PIN1, OUTPUT);
pinMode( LED_PIN2, OUTPUT);
pinMode( LED_PIN3, OUTPUT);
pinMode( LED_PIN4, OUTPUT);
pinMode( LED_PIN5, OUTPUT);
pinMode( LED_PIN6, OUTPUT);
pinMode( LED_PIN7, OUTPUT);
pinMode( LED_PIN8, OUTPUT);
pinMode( LED_PIN9, OUTPUT);
pinMode( LED_PIN10, OUTPUT);
pinMode( LED_PIN11, OUTPUT); pinMode( LED_PIN12, OUTPUT); pinMode( LED_PIN13, OUTPUT); pinMode( LED_PIN14, OUTPUT); pinMode( LED_PIN15, OUTPUT);
// Add LAMP1_COIL register - Use addCoil() for digital outputs
//0X0001
mb.addCoil(LAMP0x0000_COIL);
mb.addCoil(LAMP0x0001_COIL);
mb.addCoil(LAMP0x0002_COIL);
mb.addCoil(LAMP0x0003_COIL);
mb.addCoil(LAMP0x0004_COIL);
mb.addCoil(LAMP0x0005_COIL);
mb.addCoil(LAMP0x0006_COIL);
mb.addCoil(LAMP0x0007_COIL);
mb.addCoil(LAMP0x0008_COIL);
mb.addCoil(LAMP0x0009_COIL);
mb.addCoil(LAMP0x00010_COIL);
mb.addCoil(LAMP0x00011_COIL);
mb.addCoil(LAMP0x00012_COIL);
mb.addCoil(LAMP0x00013_COIL);
mb.addCoil(LAMP0x00014_COIL);
mb.addCoil(LAMP0x00015_COIL);
//1x0001
mb.addIsts( SWITCH_1x0000);
mb.addIsts( SWITCH_1x0001);
mb.addIsts( SWITCH_1x0002);
mb.addIsts( SWITCH_1x0003);
mb.addIsts( SWITCH_1x0004);
mb.addIsts( SWITCH_1x0005);
mb.addIsts( SWITCH_1x0006);
mb.addIsts( SWITCH_1x0007);
mb.addIsts( SWITCH_1x0008);
mb.addIsts( SWITCH_1x0009);
mb.addIsts( SWITCH_1x00010);
mb.addIsts( SWITCH_1x00011);
mb.addIsts( SWITCH_1x00012);
mb.addIsts( SWITCH_1x00013);
mb.addIsts( SWITCH_1x00014);
mb.addIsts( SWITCH_1x00015);
mb.addIsts( SWITCH_1x00016);
mb.addIsts( SWITCH_1x00015);
mb.addIsts( SWITCH_1x00017);
mb.addIsts( SWITCH_1x00018);
mb.addIsts( SWITCH_1x00019);
mb.addIsts( SWITCH_1x00020);
mb.addIsts( SWITCH_1x00021);
mb.addIsts( SWITCH_1x00022);
mb.addIsts( SWITCH_1x00023);

//3x0000

mb.addIreg(JK3x0001_VAL);
mb.addIreg(JK3x0002_VAL);
mb.addIreg(JK3x0003_VAL);
mb.addIreg(JK3x0004_VAL);
mb.addIreg(JK3x0005_VAL);
mb.addIreg(JK3x0006_VAL);

//4X
mb.addHreg(JK4x0001);
mb.addHreg(JK4x0002);
mb.addHreg(JK4x0003);
mb.addHreg(JK4x0004);

// Serial.begin(9600);
// Serial.println(F("In Setup function"));

}
//------------------------------------------------------------------------------
// Loop is the idle thread. The idle thread must not invoke any
// kernel primitive able to change its state to not runnable.
void loop() {
// Not used.
// if(cnt_led>9999) cnt_led=0;
// display(cnt_led);
// if(++cnt_m>1) {cnt_m=0; cnt_led++;}
if(++cnt_mb>65535) cnt_mb=0;
//sensorValue[0] = analogRead( ADC0 );
// sensorValue[1] = analogRead( ADC1 );
// sensorValue[2] = analogRead( ADC2 );
// sensorValue[3] = analogRead( ADC3 );

adc0 = ads.readADC_SingleEnded(0);
adc1 = ads.readADC_SingleEnded(1);
adc2 = ads.readADC_SingleEnded(2);
adc3 = ads.readADC_SingleEnded(3);

mb.Ireg(JK3x0001_VAL,adc0*5.556* multiplier);
mb.Ireg(JK3x0002_VAL, adc1*5.556* multiplier);
mb.Ireg(JK3x0005_VAL,adc2*5.556* multiplier);
mb.Ireg(JK3x0006_VAL, adc3*5.556* multiplier);

mb.Ireg(JK3x0003_VAL,cnt_mb);
// mb.Ireg(JK3x0004_VAL,cnt_mb3);
mb.Hreg(JK4x0001,Value);
Value= mb.Hreg(JK4x0002);

dac.analogWrite(Value, Value, Value, Value);

// delay(10);
dac.readRegisters();

//
// mb.Ists(SWITCH_1x0000, digitalRead(switchPin0));
// mb.Ists(SWITCH_1x0001, digitalRead(switchPin1));

//
if(mb.Coil(LAMP0x0000_COIL)==1) {data595[Y1]=1;send_595(); } else {data595[Y1]=0;send_595(); }
if(mb.Coil(LAMP0x0001_COIL)==1) {data595[Y2]=1;send_595(); } else {data595[Y2]=0;send_595(); }
if(mb.Coil(LAMP0x0002_COIL)==1) {data595[Y3]=1;send_595(); } else {data595[Y3]=0;send_595(); }
if(mb.Coil(LAMP0x0003_COIL)==1) {data595[Y4]=1;send_595(); } else {data595[Y4]=0;send_595(); }
if(mb.Coil(LAMP0x0004_COIL)==1) {data595[Y5]=1;send_595(); } else {data595[Y5]=0;send_595(); }
if(mb.Coil(LAMP0x0005_COIL)==1) {data595[Y6]=1;send_595(); } else {data595[Y6]=0;send_595(); }
if(mb.Coil(LAMP0x0006_COIL)==1) {data595[Y7]=1;send_595(); } else {data595[Y7]=0;send_595(); }
if(mb.Coil(LAMP0x0007_COIL)==1) {cnt_mb3=1; data595[Y9]=1;send_595(); } else {cnt_mb3=0; data595[Y9]=0;send_595(); }
if(mb.Coil(LAMP0x0008_COIL)==1) { data595[Y10]=1;send_595(); } else { data595[Y10]=0;send_595(); }
if(mb.Coil(LAMP0x0009_COIL)==1) { data595[Y11]=1;send_595(); } else { data595[Y11]=0;send_595(); }
if(mb.Coil(LAMP0x00010_COIL)==1) { data595[Y12]=1;send_595(); } else { data595[Y12]=0;send_595(); }
if(mb.Coil(LAMP0x00011_COIL)==1) { data595[Y13]=1;send_595(); } else { data595[Y13]=0;send_595(); }
if(mb.Coil(LAMP0x00012_COIL)==1) { data595[Y14]=1;send_595(); } else { data595[Y14]=0;send_595(); }
if(mb.Coil(LAMP0x00013_COIL)==1) { data595[Y15]=1;send_595(); } else { data595[Y15]=0;send_595(); }
if(mb.Coil(LAMP0x00014_COIL)==1) { data595[Y8]=1;send_595(); } else { data595[Y8]=0;send_595(); }
if(mb.Coil(LAMP0x00015_COIL)==1) { data595[Y0]=1;send_595(); } else { data595[Y0]=0;send_595(); }

mb.task();
// digitalWrite(ledPin, mb.Coil(LAMP1_COIL));
}

void LED4_Display (void)
{
unsigned char *led_table; // 查表指针
unsigned char i;


led_table = LED_0F + LED[0];
i = *led_table;
LED_OUT(0x01);
LED_OUT(i);
digitalWrite(RCLK,LOW);
digitalWrite(RCLK,HIGH);
led_table = LED_0F + LED[1];
i = *led_table;
LED_OUT(0x02);
LED_OUT(i);
digitalWrite(RCLK,LOW);
digitalWrite(RCLK,HIGH);
led_table = LED_0F + LED[2];
i = *led_table;
LED_OUT(0x04);
LED_OUT(i);
digitalWrite(RCLK,LOW);
digitalWrite(RCLK,HIGH);
led_table = LED_0F + LED[3];
i = *led_table;
LED_OUT(0x08);
LED_OUT(i);
digitalWrite(RCLK,LOW);
digitalWrite(RCLK,HIGH);
}

void LED_OUT(unsigned char X)
{
unsigned char i;
for(i=8;i>=1;i--)
{
if (X&0x80)
{
digitalWrite(DIO,HIGH);
}
else
{
digitalWrite(DIO,LOW);
}
X<<=1;
digitalWrite(SCLK,LOW);
digitalWrite(SCLK,HIGH);
}
}
void display(unsigned int m)
{
int a,b,c,d;

a=m/1000;
b=(m-a*1000)/100;
c=(m-a*1000-b*100)/10;
d=(m-a*1000-b*100-c*10);
LED[0]=a;
LED[1]=b;
LED[2]=c;
LED[3]=d;
LED4_Display();
}
void convert_HC595_F1(unsigned char x,unsigned char x1)
{ // do chuc nang ghi dich 8 bit vao noi tiep ra song song
// do do vong for duoi se cho dich 8 lan de du 8 chan dau ra cho vdk
int i,tam;
for(i=0;i<8;i++) // 8 lan dich de co 8 bit
{
tam=x;
tam=tam&0x80;
if(tam==0x80) digitalWrite(DIO,HIGH);
else digitalWrite(DIO,LOW);
x=x<<1; // dich bit nhu sau
digitalWrite(SCLK,LOW);
digitalWrite(SCLK,HIGH);
}

int i1,tam1;
for(i1=0;i1<8;i1++) // 8 lan dich de co 8 bit
{
tam1=x1;
tam1=tam1&0x80;
if(tam1==0x80) digitalWrite(DIO,HIGH);
else digitalWrite(DIO,LOW);
x1=x1<<1; // dich bit nhu sau
digitalWrite(SCLK,LOW);
digitalWrite(SCLK,HIGH);
}

digitalWrite(RCLK,LOW);
digitalWrite(RCLK,HIGH);

}

void LAT595(void)
{

digitalWrite(RCLK,LOW);
digitalWrite(RCLK,HIGH);
}
void CLK595(void)
{
digitalWrite(SCLK,LOW);
digitalWrite(SCLK,HIGH);
}

void send_595()
{
signed int i;
for(i=16;i>-1;i--)
{
if(data595[i]) digitalWrite(DIO,HIGH);
else digitalWrite(DIO,LOW);
CLK595();
}
LAT595();
}
void xoa_595()
{
signed int t=0;
for(t=0;t<16;t++)
{data595[t]=0;}
send_595();
}

Cảm ơn các bạn đã ghé thăm shop.

Các bạn cần độ ổn định cao tham khảo FPGA công nghiệp .

← Cũ hơn Mới hơn →

Lập trình STM32 ,STM32H7 Mở rộng IO Đầu vào 74HC595

CHÍNH SÁCH

Hộ kinh doanh

Lập trình STM32 ,STM32H7 Mở rộng IO Đầu vào 74HC595

CHÍNH SÁCH

Hộ kinh doanh

Tên sản phẩm