Thứ Tư, 7 tháng 8, 2019

Tại sao hầu hết bảng mạch in lại có màu xanh lá cây trong khi của Apple lại màu đen

thachdt tháng 8 07, 2019 1

Dù các bảng mạch màu xanh lá cây giúp việc kiểm tra bản mạch hiệu quả hơn, nhưng khi quá trình này được tự động hóa cao hơn, màu sắc của nó trở nên không còn quá quan trọng nữa.

Các sản phẩm của Apple không chỉ làm nên ấn tượng bởi ngoại hình bên ngoài mà còn cả bằng nội thất bên trong. Những kỹ sư lành nghề khi mổ xẻ nội thất bên trong mỗi chiếc MacBook của Apple đều ấn tượng với bảng mạch màu đen sạch sẽ với các linh kiện được sắp xếp một cách gọn gàng bên trong.

Khác với Apple, đại đa số các hãng điện tử khác lại thường chọn màu xanh lá cây cho bảng mạch của mình. Đối với nhiều người, màu xanh lá cây này trông thật nhàm chán nhưng tại sao đến giờ nó vẫn được sử dụng trong hầu hết thiết bị điện tử như vậy?

Trên thực tế, màu xanh lá cây đó không phải của bản thân bảng mạch, mà là của lớp chất dẻo phủ lên trên bảng mạch. Mục đích của lớp chất dẻo này là nhằm bảo vệ các đường dẫn điện bằng đồng trên bề mặt bảng mạch khỏi bị oxi hóa, cũng như ngăn không cho hình thành các cầu nối điện giữa mối hàn với những đường dẫn điện xung quanh. Và trong những ngày đầu của kỹ thuật hàn sóng (wave soldering), nó giúp ngăn chất hàn vô tình tràn vào bảng mạch trong quá trình hàn.

Điều này cho thấy vai trò của lớp chất dẻo phủ quanh bảng mạch không liên quan mấy đến màu sắc của nó, tại sao hầu hết các bảng mạch in lại có màu xanh?

Trên thực tế, màu sắc phủ lên các bảng mạch in này có nhiều màu khác nhau, ví dụ như xanh lá cây, đỏ, vàng, xanh dương và đen.

Nhưng nhiều năm trước đây, khi sản xuất nên các bảng mạch in, các công ty sử dụng loại nhựa epoxy sợi thủy tinh, có màu xanh lá cây tự nhiên. Vì vậy, các bảng mạch in ban đầu thường có màu xanh lá cây. Dần dần màu xanh này trở thành yếu tố mặc định cho các bảng mạch điện vì tác dụng của nó trong quá trình kiểm tra các mối hàn.

Màu xanh lá cây được chọn để phủ lên hầu hết bảng mạch in vì đó là màu sắc làm mắt ít phải điều tiết nhất khi nhìn vào. Khi việc kiểm tra các mối hàn vẫn được làm thủ công, điều này sẽ giúp ích rất nhiều cho công việc kiểm tra bảng mạch. Hiện nay, ngay cả khi việc kiểm tra đã được tự động hóa, vẫn cần có người kiểm tra nhiều lần trước khi hoàn thiện. Do vậy, màu xanh vẫn có tác dụng trong việc tăng hiệu suất trong quá trình sản xuất.

Khi màu xanh lá cây trở thành lựa chọn mặc định cho các nhà sản xuất bảng mạch in, loại màu này trở nên rất dễ kiếm và có giá thành rẻ hơn hầu hết các loại màu sắc khác. Điều này càng thúc đẩy các nhà sản xuất tiếp tục sản xuất trên các bảng mạch in có màu xanh lá cây, duy trì ngôi vị thống trị của nó trên các bảng mạch.

Tuy nhiên, cùng với việc tự động hóa trong quá trình kiểm tra bảng mạch ngày càng hoàn thiện hơn, việc sử dụng màu xanh lá cây trên các bảng mạch in dần trở nên không còn cần thiết nữa.

Cùng với đó, đến đầu những năm 2000, các nhà sản xuất bắt đầu chú ý hơn đến màu sắc của các bảng mạch in PCB, một phần vì nhu cầu muốn phân biệt phẩm cấp giữa các sản phẩm của mình. Do đó các nhà sản xuất thường sử dụng hai màu sắc khác nhau để phân biệt giữa dòng sản phẩm cao cấp và dòng sản phẩm cấp thấp hơn của mình.

Ví dụ Asus thường sử dụng màu vàng cho các bảng mạch chủ thông thường của mình và màu đen cho các bảng mạch chủ cao cấp hơn. Nhiều công ty sản xuất bảng mạch khác cũng chọn màu đen để đại diện cho dòng sản phẩm cao cấp hơn của mình.

Bản mạch của Apple TV sử dụng chip Apple A5.

Không chỉ vì màu sắc, một phần lý do của việc bảng mạch màu đen được xem như cao cấp hơn nằm ở việc đục lỗ trên các bảng mạch in thường khó hơn, vì vậy, chúng có năng suất thấp hơn, cũng như có giá thành cao hơn so với bảng mạch với các màu khác.

Tuy nhiên, việc bảng mạch đen bắt đầu trở thành biểu tượng cho các sản phẩm cao cấp từ khi chúng được Apple sử dụng trong các bảng mạch cho máy tính MacBook cũng như các thiết bị khác của mình. Dưới tác động của Apple, các bảng mạch màu đen cũng ngày càng được sử dụng phổ biến bởi các nhà sản xuất khác.

Mạch điều khiển nhiệt độ dùng 555

Cảm biến nhiệt độ

thachdt tháng 7 12, 2019 0

Bạn có thể xây dựng một mạch điều khiển nhiệt độ với 555 IC cùng với một bộ chia điện trở nhiệt điện trở. Lợi thế là một nguồn cung cấp năng lượng điều chỉnh tốt là không cần thiết.Mạng phân chia bao gồm điện trở điều chỉnh R3, điện trở nhiệt R4 và R5.

Mạch điều khiển nhiệt độ Schematic

NGUY HIỂM: Cẩn thận điện giật vì mạch này có kết nối trực tiếp với áp 220V

Nguyên lí hoạt động của mạch điều khiển nhiệt độ :

Khi nhiệt độ thấp hơn giá trị nhiệt độ đã cà đặt thì điện áp tại chân 2 của ic timer 555 giảm xuống dưới 1/3 Vcc. Điều này sẽ bật bộ điều khiển bằng bộ điều khiển tam giác và cũng bắt đầu chu kỳ thời gian.

Nếu nhiệt độ nhiệt độ tăng lên trên điểm đặt trước khi kết thúc chu trình thời gian, bộ phận làm nóng sẽ tắt khi kết thúc khoảng thời gian. Nếu không thì lò sưởi vẫn tiếp tục.

Nhiệt độ ngưỡng tác động được cài đặt bằng cách chỉnh biến trở R3

Mạch điều khiển relay giao tiếp qua USB

USB RELAY

thachdt tháng 7 05, 2019 0

Mạch này thachdt chia sẻ toàn bộ file layout pcb vẽ trên proteus và phần mềm được viết trên C#

Chức năng :

+ Điều khiển bật tắt 10 kênh relay bằng phần mềm

+ Giao tiếp USB

+ Tự động nhận driver

+ Hổ trợ trên hệ điều hành WINDOWN 7 trở lên , 32bit hoặc 64bit

Giao diện phần mềm như sau :

Phần mềm có thể thay đổi được tên các nút nhấn cho dễ nhớ hơn bằng cách vào menu cài đặt chọn mục đổi tên nút , một cửa sổ đổi tên nút sẽ hiện ra như hình sau, sau đó đổi tên và nhấn lưu cài đặt

Đ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/

HOT

Post Top Ad

Thứ Tư, 7 tháng 8, 2019

Tại sao hầu hết bảng mạch in lại có màu xanh lá cây trong khi của Apple lại màu đen

Dù các bảng mạch màu xanh lá cây giúp việc kiểm tra bản mạch hiệu quả hơn, nhưng khi quá trình này được tự động hóa cao hơn, màu sắc của nó trở nên không còn quá quan trọng nữa.

Thứ Sáu, 12 tháng 7, 2019

Mạch điều khiển nhiệt độ dùng 555

Mạch điều khiển nhiệt độ Schematic

Thứ Sáu, 5 tháng 7, 2019

Mạch điều khiển relay giao tiếp qua USB

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

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