Thứ Sáu, 19 tháng 4, 2019

Điều khiển góc quay 10 động cơ servo từ xa bằng biến trở dùng NRF24L01 - 2.4GHz

thachdt tháng 4 19, 2019 0

Chào các bạn !
thachdt tiếp tục chia sẽ toàn bộ project điều khiển góc quay 10 động cơ servo từ xa bằng 10 biến trở dùng module NRF24L01 và IC vi điều khiển PIC16F886
Facebook : https://www.facebook.com/thachdt.co
Khoảng cách khi dùng module này là 10m trở lại , nếu dùng module có PA công xuất cao hơn thì khoản cách thu phát lên đến 1km
Ảnh chụp mạch thực tế :

Sơ đồ mạch thu và phát :

sơ đồ mạch thu

sơ đồ mạch phát

Video test mạch :

Code C của mạch phát :
////////////////////////////////////////////////
Blog : thachdt.com
Email : machdienhay@gmail.com
///////////////////////////////////////////////
#include <16F886.h>
#device adc=8

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOMCLR                   //Master Clear pin used for I/O
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOCPD                    //No EE protection
#FUSES NOBROWNOUT               //No brownout reset
#FUSES IESO                     //Internal External Switch Over mode enabled
#FUSES FCMEN                    //Fail-safe clock monitor enabled
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOWRT                    //Program memory not write protected
#FUSES BORV40                   //Brownout reset at 4.0V
#FUSES RESERVED                 //Used to set the reserved FUSE bits

#use delay(clock=16000000)

extern unsigned char TxBuf[32];
//*********************************************NRF24L01*************************************
#define TX_ADR_WIDTH    5      // 5 uints TX address width
#define RX_ADR_WIDTH    5      // 5 uints RX address width
#define TX_PLOAD_WIDTH 10     // 32 uints TX payload
#define RX_PLOAD_WIDTH 10     // 32 uints TX payload

//***************************************NRF24L01*******************************************************
#define READ_REG        0x00     //
#define WRITE_REG       0x20    //
#define RD_RX_PLOAD     0x61     //
#define WR_TX_PLOAD     0xA0     //
#define FLUSH_TX        0xE1    //
#define FLUSH_RX        0xE2     //
#define REUSE_TX_PL     0xE3     //
#define NOP             0xFF     //
//*************************************SPI(nRF24L01)·****************************************************
#define CONFIG          0x00 //
#define EN_AA           0x01 //
#define EN_RXADDR       0x02 //
#define SETUP_AW        0x03 //
#define SETUP_RETR      0x04 //
#define RF_CH           0x05 //
#define RF_SETUP        0x06 //
#define STATUS          0x07 //
#define OBSERVE_TX      0x08 // ·
#define CD              0x09 //
#define RX_ADDR_P0      0x0A //
#define RX_ADDR_P1      0x0B //
#define RX_ADDR_P2      0x0C //
#define RX_ADDR_P3      0x0D //
#define RX_ADDR_P4      0x0E //
#define RX_ADDR_P5      0x0F //
#define TX_ADDR         0x10 //
#define RX_PW_P0        0x11 //
#define RX_PW_P1        0x12 //
#define RX_PW_P2        0x13 //
#define RX_PW_P3        0x14 //
#define RX_PW_P4        0x15 //
#define RX_PW_P5        0x16 //
#define FIFO_STATUS     0x17 //
//**************************************************************************************
#define CE PIN_C7
#define CSN PIN_C3
#define SCK PIN_C6
#define MOSI PIN_C2
#define MISO PIN_C5
#define LED PIN_C1
//**************************************************************************************
unsigned char TxBuf[10]=
{
   0x01,0x02,0x03,0x4,0x05,0x06,0x07,0x08,
   0x09,0x10,
};
unsigned char TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};   //
unsigned char RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};   //
//****************************************************************************************
void init_NRF24L01(void);
unsigned char SPI_RW(unsigned char Buff);
unsigned char SPI_Read_reg(unsigned char reg);
unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value);
unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char uchars);
unsigned char SPI_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned uchars);
void SetRX_Mode(void);
void SetTX_Mode(void);
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
void nRF24L01_TxPacket(unsigned char * tx_buf);

// -------------------------------------------------------
void main()
{
set_tris_c(0b00100000);
output_c(0x00);
char RxBuf[10];
setup_adc_ports(sAN0|sAN1|sAN2|sAN3|sAN4|sAN8|sAN9|sAN10|sAN11|sAN12|VSS_VDD);
setup_adc(ADC_CLOCK_DIV_2);
delay_ms(1000);
init_NRF24L01();
SetTX_Mode();
char sv1,sv2,sv3,sv4,sv5;
char sv6,sv7,sv8,sv9,sv10;
while(true)
{
           set_adc_channel(0);
           delay_us(10);
           sv1 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[0] = sv1;
           delay_us(10);

           set_adc_channel(1);
           delay_us(10);
           sv2 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[1] = sv2;
           delay_us(10);

           set_adc_channel(2);
           delay_us(10);
           sv3 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[2] = sv3;
           delay_us(10);

           set_adc_channel(3);
           delay_us(10);
           sv4 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[3] = sv4;
           delay_us(10);

           set_adc_channel(4);
           delay_us(10);
           sv5 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[4] = sv5;
           delay_us(10);
/////////////////////////////////////////
           set_adc_channel(11);
           delay_us(10);
           sv6 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[5] = sv6;
           delay_us(10);

           set_adc_channel(9);
           delay_us(10);
           sv7 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[6] = sv7;
           delay_us(10);

           set_adc_channel(8);
           delay_us(10);
           sv8 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[7] = sv8;
           delay_us(10);

           set_adc_channel(10);
           delay_us(10);
           sv9 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[8] = sv9;
           delay_us(10);

           set_adc_channel(12);
           delay_us(10);
           sv10 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[9] = sv10;
           delay_us(10);
/////////////////////////////////////////////////////////////
          // SetTX_Mode();
          // delay_ms(10);
            nRF24L01_TxPacket(RxBuf); // Transmit Tx buffer data
            SPI_RW_Reg(WRITE_REG+STATUS,0XFF); // Clear Bit Send
            output_toggle(LED);
            delay_ms(1);
}
}
//*NRF24L01
//***************************************************************************************/

void init_NRF24L01(void)
{
     delay_us(100);
   output_low(CE);    // chip enable
   output_high(CSN);   // Spi disable
   output_low(SCK);   // Spi clock line init high
   SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    //
   SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); //
   SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      // EN P0, 2-->P1
   SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); //Enable data P0
   SPI_RW_Reg(WRITE_REG + RF_CH, 0);        // Chanel 0 RF = 2400 + RF_CH* (1or 2 M)
   SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); // Do rong data truyen 32 byte
   SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);         // 1M, 0dbm
   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);          // Enable CRC, 2 byte CRC, Send

}
/****************************************************************************************************/
//unsigned char SPI_RW(unsigned char Buff)
//NRF24L01
/****************************************************************************************************/
unsigned char SPI_RW(unsigned char Buff)
{
      unsigned char bit_ctr;
      for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
      {
         if(Buff & 0x80) output_high(MOSI) ;   // output 'uchar', MSB to MOSI
         else output_low(MOSI);
         delay_us(5);
         Buff = (Buff << 1);           // shift next bit into MSB..
         output_high(SCK);                      // Set SCK high..
         delay_us(5);
         if((input(MISO))==1)Buff |= 0x01;             // capture current MISO bit
         output_low(SCK);                    // ..then set SCK low again
      }
      return(Buff);                   // return read uchar
}
/****************************************************************************************************/
//unsigned char SPI_Read(unsigned char reg)
//NRF24L01
/****************************************************************************************************/
unsigned char SPI_Read_reg(unsigned char reg)
{
   unsigned char reg_val=0;
   output_low(CSN);                // CSN low, initialize SPI communication...
   SPI_RW(reg);            // Select register to read from..
   reg_val = SPI_RW(0);    // ..then read registervalue
   output_high(CSN);                // CSN high, terminate SPI communication
   return (reg_val);        // return register value
}
/****************************************************************************************************/
//unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value)
/****************************************************************************************************/
unsigned char SPI_RW_Reg(unsigned char reg,unsigned char value)
{
   unsigned char status1;
   output_low(CSN);                   // CSN low, init SPI transaction
   status1 = SPI_RW(reg);      // select register
   SPI_RW(value);             // ..and write value to it..
   output_high(CSN);     // CSN high again
   return(status1);            // return nRF24L01 status uchar
}
/****************************************************************************************************/
//unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char uchars)
//
/****************************************************************************************************/
unsigned char SPI_Read_Buf(unsigned char reg,unsigned char *pBuf,unsigned char uchars)
{
   unsigned char status1,uchar_ctr;

   output_low(CSN);                           // Set CSN low, init SPI tranaction
   status1 = SPI_RW(reg);             // Select register to write to and read status uchar
   for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++) pBuf[uchar_ctr] = SPI_RW(0);    //
   output_high(CSN);
   return(status1);                    // return nRF24L01 status uchar
}
/*********************************************************************************************************/
//uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
/*****************************************************************************************************/
unsigned char SPI_Write_Buf(unsigned char reg,unsigned char *pBuf,unsigned char uchars)
{
   unsigned char status1,uchar_ctr;
   output_low(CSN);           //SPI
   status1 = SPI_RW(reg);
   for(uchar_ctr=0; uchar_ctr<uchars; uchar_ctr++) //
   SPI_RW(*pBuf++);
   output_high(CSN);           //SPI
   return(status1);    //
}
/****************************************************************************************************/
//void SetRX_Mode(void)
//
/****************************************************************************************************/
void SetRX_Mode(void)
{
   output_low(CE);
   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);         // Enable CRC, 2 byte CRC, Recive
   output_high(CE);
   delay_us(130);    //
}
/****************************************************************************************************/
//void SetTX_Mode(void)
//
/****************************************************************************************************/
void SetTX_Mode(void)
{
   output_low(CE);
   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);         // Enable CRC, 2 byte CRC, Send
   output_high(CE);
   delay_us(130);    //
}

/******************************************************************************************************/
//unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
/******************************************************************************************************/
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
{
    unsigned char revale=0;
    unsigned char sta;
   //if(RX_DR)            // Data in RX FIFO
   sta=SPI_Read_reg(STATUS);   // Read Status
   if(sta&0x40)      // Data in RX FIFO
   {
      output_low(CE);          //SPI
      SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
      revale =1;
   }
   SPI_RW_Reg(WRITE_REG+STATUS,sta);
   return(revale);
}
/***********************************************************************************************************/
//void nRF24L01_TxPacket(unsigned char * tx_buf)
//
/**********************************************************************************************************/
void nRF24L01_TxPacket(unsigned char * tx_buf)
{
   output_low(CE);
   SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // Send Address
   SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);           //send data
   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);          // Send Out
   output_high(CE);
}

// --------------------END OF FILE------------------------
// -------------------------------------------------------

Code C mạch thu :

////////////////////////////////////////////////
Blog : thachdt.com
Email : machdienhay@gmail.com
///////////////////////////////////////////////
#include <16F886.h>
#device adc=8

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOMCLR                   //Master Clear pin used for I/O
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOCPD                    //No EE protection
#FUSES NOBROWNOUT               //No brownout reset
#FUSES IESO                     //Internal External Switch Over mode enabled
#FUSES FCMEN                    //Fail-safe clock monitor enabled
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOWRT                    //Program memory not write protected
#FUSES BORV40                   //Brownout reset at 4.0V
#FUSES RESERVED                 //Used to set the reserved FUSE bits

#use delay(clock=16000000)

//************************************************************************************************8

extern unsigned char TxBuf[32];
//*********************************************NRF24L01*************************************
#define TX_ADR_WIDTH    5      // 5 uints TX address width
#define RX_ADR_WIDTH    5      // 5 uints RX address width
#define TX_PLOAD_WIDTH 10     // 32 uints TX payload
#define RX_PLOAD_WIDTH 10     // 32 uints TX payload

//***************************************NRF24L01*******************************************************
#define READ_REG        0x00     //
#define WRITE_REG       0x20    //
#define RD_RX_PLOAD     0x61     //
#define WR_TX_PLOAD     0xA0     //
#define FLUSH_TX        0xE1    //
#define FLUSH_RX        0xE2     //
#define REUSE_TX_PL     0xE3     //
#define NOP             0xFF     //
//*************************************SPI(nRF24L01)·****************************************************
#define CONFIG          0x00 //
#define EN_AA           0x01 //
#define EN_RXADDR       0x02 //
#define SETUP_AW        0x03 //
#define SETUP_RETR      0x04 //
#define RF_CH           0x05 //
#define RF_SETUP        0x06 //
#define STATUS          0x07 //
#define OBSERVE_TX      0x08 // ·
#define CD              0x09 //
#define RX_ADDR_P0      0x0A //
#define RX_ADDR_P1      0x0B //
#define RX_ADDR_P2      0x0C //
#define RX_ADDR_P3      0x0D //
#define RX_ADDR_P4      0x0E //
#define RX_ADDR_P5      0x0F //
#define TX_ADDR         0x10 //
#define RX_PW_P0        0x11 //
#define RX_PW_P1        0x12 //
#define RX_PW_P2        0x13 //
#define RX_PW_P3        0x14 //
#define RX_PW_P4        0x15 //
#define RX_PW_P5        0x16 //
#define FIFO_STATUS     0x17 //
//**************************************************************************************
#define CE PIN_C7
#define CSN PIN_C3
#define SCK PIN_C6
#define MOSI PIN_C2
#define MISO PIN_C5
#define LED PIN_C1
//**************************************************************************************
unsigned char TxBuf[10]=
{
   0x01,0x02,0x03,0x4,0x05,0x06,0x07,0x08,
   0x09,0x10,
};
unsigned char TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};   //
unsigned char RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};   //
//****************************************************************************************
void init_NRF24L01(void);
unsigned char SPI_RW(unsigned char Buff);
unsigned char SPI_Read_reg(unsigned char reg);
unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value);
unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char uchars);
unsigned char SPI_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned uchars);
void SetRX_Mode(void);
void SetTX_Mode(void);
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
void nRF24L01_TxPacket(unsigned char * tx_buf);
char count=0;
char sv1=15,sv2=15,sv3=15,sv4=15,sv5=15;
char sv6=15,sv7=15,sv8=15,sv9=15,sv10=15;
// -------------------------------------------------------
#int_TIMER0
void TIMER0_isr(void)
{
set_timer0(168);
count++;
if(count>=200)
{

output_b(0xFF);
output_a(0xFF);
count=0;
}
if(count>=sv1)output_low(PIN_A0);
if(count>=sv2)output_low(PIN_A1);
if(count>=sv3)output_low(PIN_A2);
if(count>=sv4)output_low(PIN_A3);
if(count>=sv5)output_low(PIN_A4);
/////////////////////////////////
if(count>=sv6)output_low(PIN_B6);
if(count>=sv7)output_low(PIN_B5);
if(count>=sv8)output_low(PIN_B4);
if(count>=sv9)output_low(PIN_B3);
if(count>=sv10)output_low(PIN_B2);
}
void main()
{
set_tris_c(0b00100000);
set_tris_b(0x00);
set_tris_a(0x00);
output_a(0x00);
output_b(0x00);
output_c(0x00);
delay_ms(1000);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_4);
set_timer0(164);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
char RxBuf[10];
output_low(LED);
init_NRF24L01();
SetRX_Mode();
enable_interrupts(INT_TIMER0);
enable_interrupts(GLOBAL);
char st=0;
while(true)
{
   if(nRF24L01_RxPacket(RxBuf)==1)   // Neu nhan duoc du lieu
       {
       sv1=RxBuf[0];
       sv2=RxBuf[1];
       sv3=RxBuf[2];
       sv4=RxBuf[3];
       sv5=RxBuf[4];
       ////////////
       sv6=RxBuf[5];
       sv7=RxBuf[6];
       sv8=RxBuf[7];
       sv9=RxBuf[8];
       sv10=RxBuf[9];
       output_toggle(LED);
       SetRX_Mode();
       }
}
}

//*NRF24L01
//***************************************************************************************/
void init_NRF24L01(void)
{
     delay_us(100);
   output_low(CE);    // chip enable
   output_high(CSN);   // Spi disable
   output_low(SCK);   // Spi clock line init high
   SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    //
   SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); //
   SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      // EN P0, 2-->P1
   SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); //Enable data P0
   SPI_RW_Reg(WRITE_REG + RF_CH, 0);        // Chanel 0 RF = 2400 + RF_CH* (1or 2 M)
   SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); // Do rong data truyen 32 byte
   SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);         // 1M, 0dbm
   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);          // Enable CRC, 2 byte CRC, Send

}
/****************************************************************************************************/
//unsigned char SPI_RW(unsigned char Buff)
//NRF24L01
/****************************************************************************************************/
unsigned char SPI_RW(unsigned char Buff)
{
      unsigned char bit_ctr;
      for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
      {
         if(Buff & 0x80) output_high(MOSI) ; // output 'uchar', MSB to MOSI
         else output_low(MOSI);
         delay_us(5);
         Buff = (Buff << 1);           // shift next bit into MSB..
         output_high(SCK);                      // Set SCK high..
         delay_us(5);
         if((input(MISO))==1)Buff |= 0x01;               // capture current MISO bit
         output_low(SCK);                    // ..then set SCK low again
      }
      return(Buff);                   // return read uchar
}
/****************************************************************************************************/
//unsigned char SPI_Read(unsigned char reg)
//NRF24L01
/****************************************************************************************************/
unsigned char SPI_Read_reg(unsigned char reg)
{
   unsigned char reg_val;
   output_low(CSN);                // CSN low, initialize SPI communication...
   SPI_RW(reg);            // Select register to read from..
   reg_val = SPI_RW(0);    // ..then read registervalue
   output_high(CSN);                // CSN high, terminate SPI communication
   return (reg_val);        // return register value
}
/****************************************************************************************************/
//unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value)
/****************************************************************************************************/
unsigned char SPI_RW_Reg(unsigned char reg,unsigned char value)
{
   unsigned char status1;
   output_low(CSN);                   // CSN low, init SPI transaction
   status1 = SPI_RW(reg);      // select register
   SPI_RW(value);             // ..and write value to it..
   output_high(CSN);     // CSN high again
   return(status1);            // return nRF24L01 status uchar
}

Đọc thêm »

Thứ Năm, 28 tháng 3, 2019

Cách kiểm tra MOSFET, FET còn sống hay chết

thachdt tháng 3 28, 2019 0

Cách kiểm tra MOSFET, FET còn sống hay chết

Chuẩn bị: Một đồng hồ vạn năng với 2 que đo, để đồng hồ thang x1KΩ, kiểm tra dây đo còn tốt, dụng cụ kẹp linh kiện cố định hay miếng lót cách điện.
Trước khi đo Mosfet – FET (FET) dùng dây dẫn hay tô vít nối tắt 3 chân của MosFet – FET lại để khử hết điện tích trên các chân (lý do FET là linh kiện rất nhạy cảm, điện tích trên các chân có thể ảnh hưởng đến kết quả đo)

1. Mosfet – Fet còn tốt thì kết quả đo sẽ như sau:

B1: Đo giữa G và S cả hai chiều kim không lên (tiếp giáp GS chưa bị thủng)

B2. Đo giữa G và D cả hai chiều kim không lên ( tiếp giáp G D chưa bị thủng)

B3. Dùng Tô vít nối tắt G vào D để thoát điện tích trên cực G (do quá trình đo đã để lại điện tích trên chân G)

B4. Đo giữa D và S (Sau khi G đã thoát điện cực G thì ) có một chiều kim không lên (có đảo que đo)

2. Các trường hợp sau là Mosfet – Fet bị hỏng

Đo giữa G và S kim lên => là chập G S

Đo giữa G và D kim lên là chập G D

Dùng tô vít chập chân G D để thoát điện tích chân G,

Đo giữa D và S kim vẫn lên sau khi đã thoát điện cực G là bị chập DS

3. Các đo nhanh và xem khả năng mở kênh của Mostfet – Fet

Kiểm tra Mosfet – Fet kênh N.
1. Đặt thang x10K, đặt FET lên vật cách điện hay kẹp chặt bằng dụng cụ không dẫn điện.
2. Đặt que đỏ vào cực S, que đen vào cực D, thông thường VOM sẽ chỉ một giá trị nào đó (do điện tích còn tồn tại trên chân G làm mở)
3. Giữ que đo như ở bước 2, chạm ngón tay từ cực G sang cực D sẽ thấy kim nhíc lên (thường gần bằng 0), chạm tay từ G sang S sẽ thấy kim tụt đi (có trường hợp tụt gần về vô cùng). Để thấy kim thay đổi nhiều hơn thì hay để ngón tay chạm dính nước hoặc chạm vào đầu lưỡi vào cực G.
Đó là FET còn sống, nếu ko có thay đổi là FET chết.

Kiểm tra Mosfet – Fet kênh P.
Với FET kênh P cách làm tương tự nhưng cần đảo que đo.

Mạch điều khiển từ xa RF 4 kênh dùng PT2272- PT2262

thachdt tháng 3 19, 2019 0

Xin chào !

Bạn có muốn điều khiển bật tắt 1 bóng đèn từ xa ở khoản cách vài mét đến vài chục mét hay là vài km mà không cần phải lê thân tới chổ có công tắt không , hay chỉ đơn giản là bạn muốn bật tắt 1 bóng đèn trong phòng lúc bạn đã đặt lưng trên giường ngủ và đang ở chế độ lười chỉ muốn nằm . Hãy để mạch sau đây thay bạn làm những việc đó

Thêm chú thích

Sau đây là video mô tả hoạt động trên mạch thực tế :

Để bắt đầu làm mạch này bạn cần phải có những đồ nghề sau :
+ Máy hàn nhỏ ,chì hàn , nhựa thông , kìm bấm , đồng hồ đo điện ( không có cũng được mà có thì càng tốt )
+ Mạch nạp pitkit2 hoặc burn-e để nạp chương trình cho vi điều khiển PIC ( có kèm phần mềm nạp ) , 1 máy tính laptop
+ 1 cục nguồn 220V – 12V để test mạch

Linh kiện : ( nên lấy mỗi thứ 10 con nhỡ có hỏng con nào thì có mà thay vô )
+ PIC16F54 , PT2272-M4 , C1815 , 78L05 , nút nhấn nhỏ loại tròn 2 chân , module thu sóng 315Mhz loại không có IC , Role 12V 5 chân , Domino 2C ( màu xanh ) , Diode 1N4007 , Diode 1N4148 , đèn LED 3mm ( màu gì cũng được ) , điện trở 10K , điện trở 4K7 , điện trở 1K , điện trở 620k ( phải mua đúng loại điện trở này ) , tụ hóa 220uF-16V ,tụ hóa 47uF-16V , tụ gốm 100nF ( tụ trên lưng có ghi số 104 ) , loa chíp nhỏ loại 12V
+ Remote 315Mhz loại có 4 nút ( giống như hình )

Sơ đồ mạch :

Trong sơ đồ có con vi điều khiển PIC16F54 cần phải nạp chương trình thì mạch mới chạy , bạn tải file ad đã đính kèm link , trong đó có file main.hex bạn dùng file đó nạp vào chíp , bạn có thể xem thêm bài viết về cách nạp chương trình cho chíp hoặc nhờ chổ bản chíp nạp dùm

Mạch dưới dạng layout vẽ trên proteus 8 :

Làm mạch in : trong file tải về ( ở cuối bài viết ) có file mach.pdsprj , các bạn dùng proteus 8 để mở file đó lên và chuyển sang phần layout để in mạch , mạch có thể làm thủ công hoặc đặt bên chuyên gia công mạch in làm ( bạn có thể tùy chỉnh file layout này )

Ảnh mạch thực tế ad làm thủ công như hình sau :

Cấu hình địa chỉ của remote 4 nút để mạch nhận remote : mở 3 con vít nhỏ để tháo remote ra và để trông 8 chân địa chỉ khoanh vùng màu đỏ trên mạch

Sơ đồ đấu ghép bóng đèn với mạch :

Code viết trên CCS :

//////////////////////////////////////////////////////////////////////////////////////////////
///////////////////// Blog: https://220von.blogspot.com ////////////////
//////////////////// Email : 220von.com@gmail.com ////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
#include <16f54.h>

#FUSES WDT // Watch Dog Timer
#FUSES LP //Low power osc < 200 khz
#FUSES PROTECT //Code protected from reading
#FUSES NODEBUG //No Debug mode for ICD
#FUSES RESERVED //Used to set the reserved FUSE bits
#use delay(clock=68000,RESTART_WDT)

#define R4 PIN_B4
#define R3 PIN_B5
#define R2 PIN_B6
#define R1 PIN_B7

#define D0 PIN_A2
#define D1 PIN_A3
#define D2 PIN_A0
#define D3 PIN_A1

#define N1 PIN_B0
#define N2 PIN_B1
#define N3 PIN_B2
#define N4 PIN_B3

void main (void)
{
SETUP_WDT(WDT_1152MS );
RESTART_WDT();
set_tris_b(0b11110000);
set_tris_a(0xff);
output_low(R1);
output_low(R2);
output_low(R3);
output_low(R4);
int1 R1_set=0,R2_set=0,R3_set=0,R4_set=0;
while(true)
{
RESTART_WDT();

if((input(D0))&&(R1_set==1)){output_toggle(R1);R1_set=0;}
else if((input(N1))&&(R1_set==1)){output_toggle(R1);R1_set=0;}
if(((input(D0))==0)&&((input(N1))==0))R1_set=1;

if((input(D1))&&(R2_set==1)){output_toggle(R2);R2_set=0;}
else if((input(N2))&&(R2_set==1)){output_toggle(R2);R2_set=0;}
if(((input(D1))==0)&&((input(N2))==0))R2_set=1;

if((input(D2))&&(R3_set==1)){output_toggle(R3);R3_set=0;}
else if((input(N3))&&(R3_set==1)){output_toggle(R3);R3_set=0;}
if(((input(D2))==0)&&((input(N3))==0))R3_set=1;

if((input(D3))&&(R4_set==1)){output_toggle(R4);R4_set=0;}
else if((input(N4))&&(R4_set==1)){output_toggle(R4);R4_set=0;}
if(((input(D3))==0)&&((input(N4))==0))R4_set=1;
}
}

Chúc các bạn lắp ráp mạch thành công

Link tải về : https://drive.google.com/file/d/0B62EeYKHBAm1akE3MXgtcTFCbEE

Ghi chú : không sao chép bài viết này lên các trang khác , nếu chia sẽ xin hay chia sẽ đường link bài viết , xin cám ơn !

Nếu các bạn muốn hợp tác với mình để mở rộng chức năng cho ứng dụng này hoặc chia sẻ ý tưởng ứng dụng vào cuộc sống thì gửi mail cho mình theo địa chỉ : 220von.com@gmail.com

Hoặc theo dõi trang fan page facebook : https://www.facebook.com/220von/

TSOP based IR Sensor

Cảm biến hồng ngoại

thachdt tháng 3 01, 2019 0

In this article I will discuss about more advanced IR sensor as compared to the one proposed in previous article. It provides accurate results even in sunlight and is not affected by surrounding light sources.

Simple IR Sensor has a disadvantage that it gives false detection when used in presence of sunlight. We can make more complex IR sensor which is able to differentiate between IR light from its own source and sunlight or any other light from surrounding light sources. Here I am going to introduce TSOP based IR Sensor.

Basic Idea :

In simple IR sensor (link) an IR LED is used to transmit a continuous beam of IR light and a Photo Diode is used to detect reflected light from any surface (surface can be of any obstacle or floor when we are using this sensor in line follower robot).

In TSOP based IR Sensor a modulated IR light at selected frequency is transmitted and a receiver is made that would only detect light of the same frequency, filtering out light of other frequencies.

TSOP is a miniaturized receiver for infrared remote control systems. It consists of a PIN diode and a pre-amplifier in a single package. Output of TSOP is active low. As shown in figure ambient light is filtered out by the epoxy package and then the output of PIN diode is amplified and pass through a band pass filter. The output of TSOP can directly be connected by any I/O pin of microcontroller.

There are various TSOP available in market cantered to different frequency —

For example – TSOP1736 can detect light of 36 KHz frequency and TSOP1740 can detect light of 40 KHz.

Here I am taking TSOP1736 to make TSOP based IR Sensor module.

Circuit of Rx :-

In the above circuit 100 Ω resistance and 4.7 µF is connected to suppress power supply disturbances. An LED is connected at the output pin of TSOP to indicate the logic level.

Đọc thêm »

Thứ Tư, 13 tháng 2, 2019

Mạch điều khiển động cơ servo bằng biến trở dùng NE555

RC Servo

thachdt tháng 2 13, 2019 0

Chào các bạn, hôm nay mình xin chia sẽ với các bạn mạch điều khiển động cơ RC Servo, mạch này dùng để test các động cơ RC Servo hoặc dùng để điều khiển góc quay động cơ RC Servo

Về nguyên lí thì mạch này sử dụng ic timer NE555 để tạo ra xung PWM có tần số 50Hz với độ rộng xung mức cao từ 0.7ms đến 2.4ms để làm cho động cơ quay được một góc từ 0° đến 180°

Xem bài chia sẻ điều khiển 10 động cơ servo từ xa : http://220von.blogspot.com/2017/10/ieu-khien-goc-quay-10-ong-co-servo-tu.html

Động cơ MG995

Động cơ RC Servo có 3 dây :
+ Dây màu vàng : pwm (xung pwm )
+ Dây màu đỏ : +5V
+ Dây màu nâu : GND

Nguyên lí hoạt động của động cơ RC servo được miêu tả trong hình sau :

Sơ đồ mạch :

Sơ đồ mạch RC SERVO dùng NE555

Hình ảnh mạch mình lắp :

Đọc thêm »

Thứ Tư, 30 tháng 1, 2019

Mạch điều khiển mực nước

Nông Nghiệp

thachdt tháng 1 30, 2019 4

Hiện nay hầu hết các gia đình đều sử dụng các bồn nước có dung tích từ 500 lít đến 3000 lít để dự trữ nước dùng cho sinh hoạt hằng ngày , nước thường được bơm vào bồn từ các nguồn nước của giếng khoan hoặc từ nguồn nước máy

Vấn đề ở đây là quá trình máy bơm bơm nước vào bồn phải được giám sát, nếu bơm liên tục nước vào bồn trong một thời gian dài trong khi máy bơm không được tắt đi sẽ làm bồn nước đầy và dẫn đến tràn nước ra khỏi bồn , hoặc xảy ra tình trạng không có nước sử dụng cho sinh hoạt khi trong bồn không còn nước dự trữ , lúc đó ta phải bật máy bơm để bơm nước vào bồn

Mạch điều khiển mực nước giới thiệu sau đây sẽ giải quyết được vấn đề trên , tức là sẽ đảm bảo lượng nước trong bồn luôn luôn có để sử dụng , khi mực nước thấp thì bộ điều khiển mức nước sẽ tự động bật bơm nước để bơm nước vào bồn , khi nào bồn đầy bộ điều khiển mực nước sẽ tự động tắt bơm , quá trình sẽ diễn ra một cách tự động hoàn toàn ( có một số bồn đắt tiền hơn được lắp hệ thống điều khiển mực nước điện tử này hoặc bằng công tắc cơ khí )

Sơ đồ mạch như sau :

Đọc thêm »

Thứ Hai, 28 tháng 1, 2019

ESP8266 điều khiển bật tắt 4 LED qua Webserver

Webserver

thachdt tháng 1 28, 2019 3

Bài viết này sẽ hướng dẫn bạn từng bước xây dựng một Webserver trên ESP8266 để điều 4 đèn Led độc lập qua mạng internet. Webserver trên ESP8266 mà mình sẽ hướng dẫn đáp ứng tất cả các trình duyệt trên điện thoại thông minh, như vậy các bạn có thể truy cập vào thiết bị bằng máy tính PC hoặc điện thoại thông minh trong mạng cục bộ ( mạng LAN ) thông qua địa chỉ IP của thiết bị

Đọc thêm »

HOT

Post Top Ad

Thứ Sáu, 19 tháng 4, 2019

Điều khiển góc quay 10 động cơ servo từ xa bằng biến trở dùng NRF24L01 - 2.4GHz

Thứ Năm, 28 tháng 3, 2019

Cách kiểm tra MOSFET, FET còn sống hay chết

Cách kiểm tra MOSFET, FET còn sống hay chết

Thứ Ba, 19 tháng 3, 2019

Mạch điều khiển từ xa RF 4 kênh dùng PT2272- PT2262

Thứ Sáu, 1 tháng 3, 2019

TSOP based IR Sensor

Basic Idea :

Circuit of Rx :-

Thứ Tư, 13 tháng 2, 2019

Mạch điều khiển động cơ servo bằng biến trở dùng NE555

Thứ Tư, 30 tháng 1, 2019

Mạch điều khiển mực nước

Thứ Hai, 28 tháng 1, 2019

ESP8266 điều khiển bật tắt 4 LED qua Webserver

Post Top Ad

Thông tin về tác giả thachdientu

Đăng kí theo dõi kênh youtube của thachdt

Facebook thachdt

Bài đăng

Lưu trữ

Bình luận

Lịch sử các bài đăng

Mục bài viết

Giới thiệu về tác giả thachdt

Gửi email đặt hàng thachdt

Kênh youtube của thachdt