Kênh Tên Miền chuyên cung cấp tên miền đẹp, giá rẻ! Hãy liên hệ kỹ thuật: 0914205579 - Kinh doanh: 0912191357 để được tư vấn, hướng dẫn miễn phí, Cảm ơn quý khách đã ủng hộ trong thời gian qua!
Sunday, February 16, 2014


Chào các bạn hôm nay mình xin gới thiệu 1 hệ thống giám sát nhiệt độ bằng phần mềm chạy trên hệ điều hành


Phần mềm được lập trình bằng LabView 

+  Phần mềm bao gồm 1 biểu đồ nhiệt độ và 1 đồng hồ đo nhiệt độ hiện tại tương ứng với mỗi kênh , 2 nút   điều chỉnh nhiệt độ min, max
 + Phần cứng bao gồm PIC18F2455 có cổng USB kết nối với máy tính, LM35 để đo nhiệt độ 0°C - 150°C và UlN2003 điều khiển 4 ROLE .
       kênh 1 điều khiển RL3 và RL4 trong sơ đồ mạch ở hình dưới
       kênh 2 điều khiển RL1 và RL2 trong sơ đồ mạch ở hình dưới
Nguyên lí hoạt động:
  + Đường nhiệt độ max là đường màu đỏ trên biểu đồ , đường màu xanh lá cây là đường nhiệt độ min trên biểu đồ , còn đường màu trắng là đường biểu diễn nhiệt độ đo được theo thời gian  , 2 đường này được điều chỉnh bằng 2 nút xoay tròn tương ứng từ 0°C đến 150°C , giá trị mặc định max là 130°C và min là 30°C , thời gian lấy mẫu nhiệt độ là 100ms
  Khi nhiệt độ đo được vượt quá giá tri max thì phần mềm sẽ báo quá nhiệt và ROLE quá nhiệt sẽ đóng của kênh tương ứng
  Khi nhiệt độ đo được thấp hơn giá trị min thì phần mềm sẽ báo dưới nhiệt ( nhiệt độ thấp)  và ROLE dưới nhiệt sẽ đóng
Khi nhiệt độ đo được bình thường tức là nằm giữa min và max thì cả 2 ROLE đều cắt

Vì LM35 chỉ đo được khoảng nhiệt độ từ 0°C - 150°C nên giới hạn nhiệt độ giám sát của phần mềm là 0°C - 150°C tương ứng

Link download phần mềm ,code ,file mô phỏng tại đây :
http://www.mediafire.com/download/z6a9qlh9ibq3a4y/He_Thong_Giam_Sat_Nhiet_Do_2_Kenh.rar

Yêu cầu LABVIEW phiên bản 10 trở lên mới mở được

Phần mềm giao tiếp với phần cứng USB thông qua chuẩn HID vì mình chỉ truyền và nhận 2 bytes dữ liệu ,không cần dùng đến BULK..... hay các chuẩn khác gì cho phí tài nguyên.

Hình của phần mềm khi chạy:







Đây là sơ đồ code của phần mềm trong LABVIEW :




Sơ đồ mạch của phần cứng :


Trong mạch còn có 1 LED để báo hiệu kết nối còn LED kia sẽ nháy sáng báo hiệu dữ liệu đang được truyền qua USB

Code C lập trình cho PIC18F2455:

#include "18F2455.h"
#device adc=10
#FUSES NOWDT                 
#FUSES WDT128                 
#FUSES XT                     
#FUSES NOPROTECT              
#FUSES NOBROWNOUT           
#FUSES BORV20                 
#FUSES NOPUT                
#FUSES NOCPD              
#FUSES STVREN                 
#FUSES NODEBUG                
#FUSES NOLVP                 
#FUSES NOWRT               
#FUSES NOWRTD               
#FUSES IESO                 
#FUSES FCMEN                
#FUSES PBADEN                
#FUSES NOWRTC              
#FUSES NOWRTB             
#FUSES NOEBTR             
#FUSES NOEBTRB            
#FUSES NOCPB              
#FUSES LPT1OSC              
#FUSES MCLR                   
#FUSES NOXINST               
#FUSES PLL12                 
#FUSES USBDIV           
#FUSES CPUDIV4               
#FUSES VREGEN                 
#use delay(clock=12000000)
#include <pic18_usb.h>
#include <usb_desc_hid.h>
#include <usb.c>
void main()
{
   long t1,t2;
   char temp_1=0,temp_2=0,temp_max=0,temp_min=0;
   char data_in[2],data_out[2];
   set_tris_b(0xFF);
   output_b(0x00);
   setup_adc(ADC_CLOCK_INTERNAL);
   SETUP_ADC_PORTS(AN0_TO_AN1|VSS_VDD);
   usb_init();                                         
   usb_task();                                           
   usb_wait_for_enumeration();
   output_high(PIN_B0);
 while(true)
  {
  set_adc_channel(0);
  t1=read_adc();
  delay_us(20);
  set_adc_channel(1);
  t2=read_adc();
  delay_us(20);
  temp_1=t1*0.4883;
  temp_2=t2*0.4883;
  switch(usb_enumerated())
   {
   case 0:break;
   case 1:
      {
      switch(usb_kbhit(1))
        {
        case 0:break;
        case 1:
           {
           output_toggle(PIN_B1);
           usb_get_packet(1,data_in,2);
           temp_max=data_in[0];
           temp_min=data_in[1];        
           data_out[0]=temp_1;
           data_out[1]=temp_2;
           usb_put_packet(1,data_out,2,USB_DTS_TOGGLE);
           break;
           }
        }
      break;
      }
   }
  if(temp_1>temp_max)output_high(PIN_B4);
  else output_low(PIN_B4);
  if(temp_1<temp_min)output_high(PIN_B5);
  else output_low(PIN_B5);
  if(temp_2>temp_max)output_high(PIN_B6);
  else output_low(PIN_B6);
  if(temp_2<temp_min)output_high(PIN_B7);
  else output_low(PIN_B7);  
  }
}


Code của thư viện usb_desc_hid :

#IFNDEF __USB_DESCRIPTORS__
#DEFINE __USB_DESCRIPTORS__

#ifndef USB_CONFIG_PID
   #define USB_CONFIG_PID  0x0032
#endif

#ifndef USB_CONFIG_VID
   #define  USB_CONFIG_VID 0x1121
#endif

#ifndef USB_CONFIG_BUS_POWER
   //valid range is 0..500
   #define  USB_CONFIG_BUS_POWER 100   //100mA
#endif

#ifndef USB_CONFIG_VERSION
   //version number that is stored into descriptor, in bcd.
   //range is 00.00 to 99.99
   #define  USB_CONFIG_VERSION   0x0100      //01.00
#endif

#ifndef USB_CONFIG_HID_TX_SIZE
   //valid range is 0-255
   #define USB_CONFIG_HID_TX_SIZE   2     //compatible with hiddemo.exe
#endif

#ifndef USB_CONFIG_HID_RX_SIZE
   //valid range is 0-255
   #define USB_CONFIG_HID_RX_SIZE   2     //compatible with hiddemo.exe
#endif

#ifndef USB_CONFIG_HID_TX_POLL
   // for full speed devices, valid range is 1-255
   // for slow speed devices, valid range is 10-255
   #define USB_CONFIG_HID_TX_POLL   10
#endif

#ifndef USB_CONFIG_HID_RX_POLL
   // for full speed devices, valid range is 1-255
   // for slow speed devices, valid range is 10-255
   #define USB_CONFIG_HID_RX_POLL   10
#endif

//Tells the CCS PIC USB firmware to include HID handling code.
#ifdef USB_HID_DEVICE
#undef USB_HID_DEVICE
#endif

#DEFINE USB_HID_DEVICE  TRUE

//the following defines needed for the CCS USB PIC driver to enable the TX endpoint 1
// and allocate buffer space on the peripheral
#ifdef USB_EP1_TX_ENABLE
#undef USB_EP1_TX_ENABLE
#endif
#define USB_EP1_TX_ENABLE  USB_ENABLE_INTERRUPT   //turn on EP1 for IN bulk/interrupt transfers

#ifndef USB_EP1_TX_SIZE
 #if (USB_CONFIG_HID_TX_SIZE >= 64)
   // interrupt endpoint max packet size is 64.
   #define USB_EP1_TX_SIZE    64
 #else
   // by making EP packet size larger than message size, we can send message in one packet.
   #define USB_EP1_TX_SIZE    (USB_CONFIG_HID_TX_SIZE+1)
 #endif
#endif

#ifdef USB_EP1_RX_ENABLE
#undef USB_EP1_RX_ENABLE
#endif
#define USB_EP1_RX_ENABLE  USB_ENABLE_INTERRUPT   //turn on EP1 for OUT bulk/interrupt transfers

#ifndef USB_EP1_RX_SIZE
 #if (USB_CONFIG_HID_RX_SIZE >= 64)
   // interrupt endpoint max packet size is 64.
   #define USB_EP1_RX_SIZE    64
 #else
   // by making EP packet size larger than message size, we can send message in one packet.
   #define USB_EP1_RX_SIZE    (USB_CONFIG_HID_RX_SIZE+1)
 #endif
#endif

#include <usb.h>

   //////////////////////////////////////////////////////////////////
   ///
   ///  HID Report.  Tells HID driver how to handle and deal with
   ///  received data.  HID Reports can be extremely complex,
   ///  see HID specifcation for help on writing your own.
   ///
   ///  CCS example uses a vendor specified usage, that sends and
   ///  receives 2 absolute bytes ranging from 0 to 0xFF.
   ///
   //////////////////////////////////////////////////////////////////

   const char USB_CLASS_SPECIFIC_DESC[] =
   {
      6, 0, 255,        // Usage Page = Vendor Defined
      9, 1,             // Usage = IO device
      0xa1, 1,          // Collection = Application
      0x19, 1,          // Usage minimum
      0x29, 8,          // Usage maximum

      0x15, 0x80,       // Logical minimum (-128)
      0x25, 0x7F,       // Logical maximum (127)

      0x75, 8,          // Report size = 8 (bits)
      0x95, USB_CONFIG_HID_RX_SIZE,        // Report count = 16 bits (2 bytes)
      0x81, 2,          // Input (Data, Var, Abs)
      0x19, 1,          // Usage minimum
      0x29, 8,          // Usage maximum
      0x75, 8,          // Report size = 8 (bits)
      0x95, USB_CONFIG_HID_TX_SIZE,        // Report count = 16 bits (2 bytes)
      0x91, 2,          // Output (Data, Var, Abs)
      0xc0              // End Collection
   };

   //if a class has an extra descriptor not part of the config descriptor,
   // this lookup table defines where to look for it in the const
   // USB_CLASS_SPECIFIC_DESC[] array.
   //first element is the config number (if your device has more than one config)
   //second element is which interface number
   //set element to 0xFFFF if this config/interface combo doesn't exist
   const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP[USB_NUM_CONFIGURATIONS][1] =
   {
   //config 1
      //interface 0
         0
   };

   //if a class has an extra descriptor not part of the config descriptor,
   // this lookup table defines the size of that descriptor.
   //first element is the config number (if your device has more than one config)
   //second element is which interface number
   //set element to 0xFFFF if this config/interface combo doesn't exist
   const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP_SIZE[USB_NUM_CONFIGURATIONS][1] =
   {
   //config 1
      //interface 0
         32
   };


//////////////////////////////////////////////////////////////////
///
///   start config descriptor
///   right now we only support one configuration descriptor.
///   the config, interface, class, and endpoint goes into this array.
///
//////////////////////////////////////////////////////////////////

   #DEFINE USB_TOTAL_CONFIG_LEN      41  //config+interface+class+endpoint+endpoint (2 endpoints)

   const char USB_CONFIG_DESC[] = {
   //IN ORDER TO COMPLY WITH WINDOWS HOSTS, THE ORDER OF THIS ARRAY MUST BE:
      //    config(s)
      //    interface(s)
      //    class(es)
      //    endpoint(s)

   //config_descriptor for config index 1
         USB_DESC_CONFIG_LEN, //length of descriptor size          ==1
         USB_DESC_CONFIG_TYPE, //constant CONFIGURATION (CONFIGURATION 0x02)     ==2
         USB_TOTAL_CONFIG_LEN,0, //size of all data returned for this config      ==3,4
         1, //number of interfaces this device supports       ==5
         0x01, //identifier for this configuration.  (IF we had more than one configurations)      ==6
         0x00, //index of string descriptor for this configuration      ==7
        #if USB_CONFIG_BUS_POWER
         0xC0, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 unused and bit7=1         ==8
        #else
         0x80, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 unused and bit7=1         ==8
        #endif
         USB_CONFIG_BUS_POWER/2, //maximum bus power required (maximum milliamperes/2)  (0x32 = 100mA)

   //interface descriptor 1
         USB_DESC_INTERFACE_LEN, //length of descriptor      =10
         USB_DESC_INTERFACE_TYPE, //constant INTERFACE (INTERFACE 0x04)       =11
         0x00, //number defining this interface (IF we had more than one interface)    ==12
         0x00, //alternate setting     ==13
         2, //number of endpoins, except 0 (pic167xx has 3, but we dont have to use all).       ==14
         0x03, //class code, 03 = HID     ==15
         0x00, //subclass code //boot     ==16
         0x00, //protocol code      ==17
         0x00, //index of string descriptor for interface      ==18

   //class descriptor 1  (HID)
         USB_DESC_CLASS_LEN, //length of descriptor    ==19
         USB_DESC_CLASS_TYPE, //dscriptor type (0x21 == HID)      ==20
         0x00,0x01, //hid class release number (1.0)      ==21,22
         0x00, //localized country code (0 = none)       ==23
         0x01, //number of hid class descrptors that follow (1)      ==24
         0x22, //report descriptor type (0x22 == HID)                ==25
         USB_CLASS_SPECIFIC_DESC_LOOKUP_SIZE[0][0], 0x00, //length of report descriptor            ==26,27

   //endpoint descriptor
         USB_DESC_ENDPOINT_LEN, //length of descriptor                   ==28
         USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05)          ==29
         0x81, //endpoint number and direction (0x81 = EP1 IN)       ==30
         USB_EP1_TX_ENABLE, //transfer type supported (0x03 is interrupt)         ==31
         USB_EP1_TX_SIZE,0x00, //maximum packet size supported                  ==32,33
         USB_CONFIG_HID_TX_POLL,  //polling interval, in ms.  (cant be smaller than 10 for slow speed)      ==34

   //endpoint descriptor
         USB_DESC_ENDPOINT_LEN, //length of descriptor                   ==35
         USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05)          ==36
         0x01, //endpoint number and direction (0x01 = EP1 OUT)      ==37
         USB_EP1_RX_ENABLE, //transfer type supported (0x03 is interrupt)         ==38
         USB_EP1_RX_SIZE,0x00, //maximum packet size supported                  ==39,40
         USB_CONFIG_HID_RX_POLL //polling interval, in ms.  (cant be smaller than 10 for slow speed)    ==41
   };

   //****** BEGIN CONFIG DESCRIPTOR LOOKUP TABLES ********
   //since we can't make pointers to constants in certain pic16s, this is an offset table to find
   //  a specific descriptor in the above table.

   //NOTE: DO TO A LIMITATION OF THE CCS CODE, ALL HID INTERFACES MUST START AT 0 AND BE SEQUENTIAL
   //      FOR EXAMPLE, IF YOU HAVE 2 HID INTERFACES THEY MUST BE INTERFACE 0 AND INTERFACE 1
   #define USB_NUM_HID_INTERFACES   1

   //the maximum number of interfaces seen on any config
   //for example, if config 1 has 1 interface and config 2 has 2 interfaces you must define this as 2
   #define USB_MAX_NUM_INTERFACES   1

   //define how many interfaces there are per config.  [0] is the first config, etc.
   const char USB_NUM_INTERFACES[USB_NUM_CONFIGURATIONS]={1};

   //define where to find class descriptors
   //first dimension is the config number
   //second dimension specifies which interface
   //last dimension specifies which class in this interface to get, but most will only have 1 class per interface
   //if a class descriptor is not valid, set the value to 0xFFFF
   const int16 USB_CLASS_DESCRIPTORS[USB_NUM_CONFIGURATIONS][1][1]=
   {
   //config 1
      //interface 0
         //class 1
         18
   };

   #if (sizeof(USB_CONFIG_DESC) != USB_TOTAL_CONFIG_LEN)
      #error USB_TOTAL_CONFIG_LEN not defined correctly
   #endif


//////////////////////////////////////////////////////////////////
///
///   start device descriptors
///
//////////////////////////////////////////////////////////////////

   const char USB_DEVICE_DESC[USB_DESC_DEVICE_LEN] ={
      //starts of with device configuration. only one possible
         USB_DESC_DEVICE_LEN, //the length of this report   ==1
         0x01, //the constant DEVICE (DEVICE 0x01)  ==2
         0x10,0x01, //usb version in bcd ==3,4
         0x00, //class code ==5
         0x00, //subclass code ==6
         0x00, //protocol code ==7
         USB_MAX_EP0_PACKET_LENGTH, //max packet size for endpoint 0. (SLOW SPEED SPECIFIES 8) ==8
         USB_CONFIG_VID & 0xFF, ((USB_CONFIG_VID >> 8) & 0xFF), //vendor id       ==9, 10
         USB_CONFIG_PID & 0xFF, ((USB_CONFIG_PID >> 8) & 0xFF), //product id, don't use 0xffff       ==11, 12
         USB_CONFIG_VERSION & 0xFF, ((USB_CONFIG_VERSION >> 8) & 0xFF), //device release number  ==13,14
         0x01, //index of string description of manufacturer. therefore we point to string_1 array (see below)  ==15
         0x02, //index of string descriptor of the product  ==16
         0x00, //index of string descriptor of serial number  ==17
         USB_NUM_CONFIGURATIONS  //number of possible configurations  ==18
   };


//////////////////////////////////////////////////////////////////
///
///   start string descriptors
///   String 0 is a special language string, and must be defined.  People in U.S.A. can leave this alone.
///
///   You must define the length else get_next_string_character() will not see the string
///   Current code only supports 10 strings (0 thru 9)
///
//////////////////////////////////////////////////////////////////

//the offset of the starting location of each string.  offset[0] is the start of string 0, offset[1] is the start of string 1, etc.
char USB_STRING_DESC_OFFSET[]={0,4,12};

// Here is where the "CCS" Manufacturer string and "CCS HID Demo" are stored.
// Strings are saved as unicode.
// These strings are mostly only displayed during the add hardware wizard.
// Once the operating system drivers have been installed it will usually display
// the name from the drivers .INF.
char const USB_STRING_DESC[]={
   //string 0
         4, //length of string index
         USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
         0x09,0x04,   //Microsoft Defined for US-English
   //string 1
         8, //length of string index
         USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
         'P',0,
         'H',0,
         'T',0,
   //string 2
         36, //length of string index
         USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
         'P',0,
         'h',0,
         'a',0,
         'n',0,
         ' ',0,
         'H',0,
         'o',0,
         'a',0,
         'n',0,
         'g',0,
         ' ',0,
         'T',0
         'h',0
         'a',0
         'c',0
         'h',0
};

#ENDIF



Cám ơn các bạn đã đọc...............


Mình đã nghiên cứu và thực hiên thành công hệ thống giám sát nhiệt độ ,độ ẩm từ xa bằng sóng vô tuyến 315MHz và 433MHz khoảng cách giám sát là 800m , nhiệt độ giám sát từ 0°C đến 800°C và có thể tăng lên 128 kênh , phần mềm có giao diện tiếng Việt.

                                               Nguồn : http://phanhoangthach.blogspot.com/

0 comments:

Post a Comment

domain, domain name, premium domain name for sales

Popular Posts