USB Deneme kartı (Bitti)

[baran123]

Aslında tam deneme kartı değil ama LCD,LED,sıcaklık ve D portunu kontrol edebileceğiniz bir devre yapmıştım bir ara.Belki birinin işine yarar.Eski bir proje saçma bir şey yapmış olabilirim.

main.h

/*****************************************************************************/
/*
/* Project          : main.c
/*
/* Description      : Home Automation
/*
/* Author           : Baran Ekrem
/*
/*****************************************************************************/
#IFNDEF __MAIN_H__
#DEFINE __MAIN_H__

#INCLUDE <18F4550.h>
#DEVICE ADC = 10

#FUSES NOWDT                 
#FUSES WDT128  
#FUSES NOLVP                   
#FUSES NOPROTECT
#FUSES HSPLL                   
#FUSES NOPROTECT               
#FUSES BROWNOUT_NOSL           
#FUSES BROWNOUT              
#FUSES PUT                  
#FUSES NOCPD                   
#FUSES STVREN               
#FUSES NODEBUG                
#FUSES NOLVP                   
#FUSES NOWRT                 
#FUSES NOWRTD                   
#FUSES NOIESO                
#FUSES NOFCMEN                 
#FUSES NOPBADEN               
#FUSES NOWRTC           
#FUSES NOWRTB      
#FUSES NOEBTR             
#FUSES NOEBTRB               
#FUSES NOCPB              
#FUSES NOMCLR                 
#FUSES LPT1OSC      
#FUSES NOXINST
#FUSES PLL5                  
#FUSES CPUDIV1 
#FUSES USBDIV 
#FUSES VREGEN

#USE DELAY(CLOCK = 48MHz, CRYSTAL = 20MHz, USB_FULL)

#DEFINE USB_HID_DEVICE     TRUE             
#DEFINE USB_EP1_TX_ENABLE  USB_ENABLE_INTERRUPT  
#DEFINE USB_EP1_RX_ENABLE  USB_ENABLE_INTERRUPT    
#DEFINE USB_EP1_TX_SIZE    64  
#DEFINE USB_EP1_RX_SIZE    64   

#INCLUDE "Ds18b20.c"
#INCLUDE "Flex_Lcd.c"
#INCLUDE "USB_Konfigurasyon.h"
#INCLUDE <pic18_usb.h>     
#INCLUDE <usb.c>    

#USE FAST_IO(B)
#USE FAST_IO(D)

#DEFINE UcNokta1      1 
#DEFINE signal        gelen_paket[0]
#DEFINE control       gelen_paket[1]
#DEFINE count         gelen_paket[2]
#DEFINE byteData      gelen_paket[3]

#ENDIF

main.c

/*****************************************************************************/
/*
/* Project          : main.c
/*
/* Description      : Home Automation
/*
/* Author           : Baran Ekrem
/*
/*****************************************************************************/
#include "main.h"

static int8 gelen_paket[64];
static int8 giden_paket[32];
static int8 x,tam,onda;
static int16 term;
static float sicaklik;

static void McuInit(void);
static void Outputs(void);
static void SendTemp(void);
static void LcdOperations(char);
static void LedStateChange(char);
static void ProgramConnected(char);

/***********************************************************/
/* Function Name  : main
/* Description    : Main Program
/* Input          : None
/* Return         : None
/**********************************************************/
void main(void)
{     
   McuInit();
   
   for (;;)
   { 
      while(usb_enumerated())
      {  
         SendTemp();
         
         if(usb_kbhit(1))         
         {         
            usb_get_packet(UcNokta1, gelen_paket, 64);
            
            if(signal == 'A')
            {
               switch(control)   
               {
                  case 'a': ProgramConnected(control); break;
                  case 'b': ProgramConnected(control); break; 
                  case 'c': LcdOperations(control);    break;
                  case 'd': LcdOperations(control);    break;
                  case 'e': ProgramConnected(control); break;     
                  case 'f': Outputs();                 break;   
                  case '0': LedStateChange(control);   break;
                  case '1': LedStateChange(control);   break; 
               }
            }
         }
      }
   } 
}

/***********************************************************/
/* Function Name  : sendTemp
/* Description    : Read temp and send
/* Input          : None
/* Return         : None
/**********************************************************/
static void SendTemp(void)
{
   sicaklik = ds1820_read();
   
   term = sicaklik * 10;
   tam = term / 10;
   onda = term % 10;
   
   giden_paket[0] = tam;
   giden_paket[1] = onda;
   
   usb_put_packet(UcNokta1, giden_paket, 64, USB_DTS_TOGGLE);
}

/***********************************************************/
/* Function Name  : ProgramConnected
/* Description    : Determining the Program Connection State
/* Input          : char ConState (a, b)
/* Return         : None
/**********************************************************/
static void ProgramConnected(char ConState)
{
   if(ConState == 'a')
   {
      printf(lcd_putc,"\fPC Connected");
   }
   
   if(ConState == 'b')
   {
      printf(lcd_putc,"\fPC Disconnected");
   }
}

/***********************************************************/
/* Function Name  : LedStateChange
/* Description    : Changing the Status LED
/* Input          : char state (0, 1)
/* Return         : None
/**********************************************************/
static void LedStateChange(char state)
{
   if(state == '1') 
   {
      output_high(pin_b6); 
      printf(lcd_putc,"\fLED On");
   }
   
   if(state == '0') 
   {
      output_low(pin_b6);
      printf(lcd_putc,"\fLED Off");
   }
}

/***********************************************************/
/* Function Name  : LcdOperations
/* Description    : Text is Sending to the Lcd
/* Input          : char Info (c, d, e)
/* Return         : None
/**********************************************************/
static void LcdOperations(char Info)
{
   if(Info == 'c')
   {
      lcd_gotoxy(1,1);
      for(x = 3; x <= count; x++)
      { 
         printf(lcd_putc,"%c",gelen_paket[x]);
      }
   }
   
   if(Info == 'd')
   {
      lcd_gotoxy(1,2);
      for(x = 3; x <= count; x++)
      { 
         printf(lcd_putc,"%c",gelen_paket[x]);
      }
   }
   
   if(Info == 'e')
   {
      printf(lcd_putc,"\f");
   }
}

/***********************************************************/
/* Function Name  : Outputs
/* Description    : Control the Port D
/* Input          : None
/* Return         : None
/**********************************************************/
static void Outputs(void)
{
   output_d(byteData);  
}

/***********************************************************/
/* Function Name  : McuInit
/* Description    : MCU is Preparing
/* Input          : None
/* Return         : None
/**********************************************************/
static void McuInit(void)
{
   setup_timer_0(RTCC_INTERNAL);
   setup_timer_1(T1_DISABLED);   
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC); 
   setup_psp(PSP_DISABLED);    
   setup_spi(SPI_SS_DISABLED); 
   setup_adc_ports(NO_ANALOGS);    
   setup_adc(ADC_OFF); 
   setup_CCP1(CCP_OFF);        
   setup_CCP2(CCP_OFF); 
   setup_vref(FALSE);
   
   set_tris_b(0x00);
   set_tris_d(0x00);
   output_b(0x00);
   output_d(0x00);
   
   lcd_init();
   usb_init();  
   usb_task();
   
   output_high(pin_b7);
   printf(lcd_putc,"\fUSB Connecting.."); 

   usb_wait_for_enumeration();     
   
   if(usb_enumerated())  
   {
      printf(lcd_putc,"\fUSB Connected");
   }
}

usb_konfigurasyon

                                                      

#IFNDEF __USB_DESCRIPTORS__
#DEFINE __USB_DESCRIPTORS__

#include <usb.h>

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

      0x15, 0x00,        // Logical minimum (-128)
      0x25, 0xFF,        // Logical maximum (127)

      0x75, 8,        // Report size = 8 (bits)
      0x95, 64,        // Report count = 16 bits (2 bytes)
      0x81, 2,        // Input (Data, Var, Abs)
      0x19, 0,        // Usage minimum
      0x29, 800,        // Usage maximum
      0x75, 8,        // Report size = 8 (bits)
      0x95, 64,        // 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
         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
         50, //maximum bus power required (maximum milliamperes/2)  (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
         0x11,0x01, //hid class release number (1.0) (try 1.10)      ==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
         0x03, //transfer type supported (0x03 is interrupt)         ==31
         USB_EP1_TX_SIZE,0x00, //maximum packet size supported                  ==32,33
         10,  //polling interval, in ms.  (cant be smaller than 10)      ==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
         0x03, //transfer type supported (0x03 is interrupt)         ==38
         USB_EP1_RX_SIZE,0x00, //maximum packet size supported                  ==39,40
         10 //polling interval, in ms.  (cant be smaller than 10)    ==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
         0x00,0x02, //usb version in bcd 
         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
         0x11,0x11, //vendor id (0x04D8 is Microchip, or is it 0x0461 ??)
         0x11,0x11, //product id   ==11,12  //don't use ffff says usb-by-example guy.  oops
         0x00,0x01, //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};

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)
         'B',0,
         'E',0,
   //string 2
         58,                   //length of string index
         USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
         ' ',0,
         'B',0,
         'A',0,
         'R',0,
         'A',0,
         'N',0,
         ' ',0,
         'E',0,
         'K',0,
         'R',0,
         'E',0,
         'M',0,
         ' ',0
};

#ENDIF

flex_lcd.c

#define LCD_DB4   PIN_B0 
#define LCD_DB5   PIN_B1
#define LCD_DB6   PIN_B2 
#define LCD_DB7   PIN_B3 

#define LCD_E     PIN_B5
#define LCD_RS    PIN_B4 

#define lcd_type 2   
#define lcd_line_two 0x40 

int8 const LCD_INIT_STRING[4] = { 0x20 | (lcd_type << 2), 0xc, 1, 6 }; 
                              
void lcd_send_nibble(int8 nibble) 
{ 
   output_bit(LCD_DB4, !!(nibble & 1)); 
   output_bit(LCD_DB5, !!(nibble & 2));  
   output_bit(LCD_DB6, !!(nibble & 4));    
   output_bit(LCD_DB7, !!(nibble & 8));    
   
   delay_cycles(1); 
   output_high(LCD_E); 
   delay_us(2); 
   output_low(LCD_E); 
} 

#ifdef USE_LCD_RW 
int8 lcd_read_nibble(void) 
{ 
   int8 retval; 

   #bit retval_0 = retval.0 
   #bit retval_1 = retval.1 
   #bit retval_2 = retval.2 
   #bit retval_3 = retval.3 
   
   retval = 0; 
       
   output_high(LCD_E); 
   delay_cycles(1); 
   
   retval_0 = input(LCD_DB4); 
   retval_1 = input(LCD_DB5); 
   retval_2 = input(LCD_DB6); 
   retval_3 = input(LCD_DB7); 
     
   output_low(LCD_E); 
       
   return(retval);    
}    
#endif 

#ifdef USE_LCD_RW 
int8 lcd_read_byte(void) 
{ 
   int8 low, high; 
   
   output_high(LCD_RW); 
   delay_cycles(1); 
   
   high = lcd_read_nibble(); 
   
   low = lcd_read_nibble(); 
   
   return( (high<<4) | low); 
} 
#endif 

void lcd_send_byte(int8 address, int8 n) 
{ 
   output_low(LCD_RS); 
   
   #ifdef USE_LCD_RW 
   while(bit_test(lcd_read_byte(),7)) ; 
   #else 
   delay_us(60);  
   #endif 
   
   if(address) 
      output_high(LCD_RS); 
   else 
      output_low(LCD_RS); 
         
    delay_cycles(1); 
   
   #ifdef USE_LCD_RW 
      output_low(LCD_RW); 
      delay_cycles(1); 
   #endif 
   
   output_low(LCD_E); 
   
   lcd_send_nibble(n >> 4); 
   lcd_send_nibble(n & 0xf); 
} 

void lcd_init(void) 
{ 
   int8 i; 
   
   output_low(LCD_RS); 
   
   #ifdef USE_LCD_RW 
   output_low(LCD_RW); 
   #endif 
   
   output_low(LCD_E); 
   
   delay_ms(15); 
   
   for(i=0 ;i < 3; i++) 
   { 
      lcd_send_nibble(0x03); 
      delay_ms(5); 
   } 
   
   lcd_send_nibble(0x02); 
   
   for(i=0; i < sizeof(LCD_INIT_STRING); i++) 
   { 
      lcd_send_byte(0, LCD_INIT_STRING[i]); 
      
      #ifndef USE_LCD_RW 
      delay_ms(5); 
      #endif 
   } 
   
} 

void lcd_gotoxy(int8 x, int8 y) 
{ 
   int8 address; 
   
   if(y != 1) 
      address = lcd_line_two; 
   else 
      address=0; 
   
   address += x-1; 
   lcd_send_byte(0, 0x80 | address); 
} 

void lcd_putc(char c) 
{ 
   switch(c) 
   { 
      case '\f': lcd_send_byte(0,1); delay_ms(2); break; 
      case '\n': lcd_gotoxy(1,2); break; 
      case '\b': lcd_send_byte(0,0x10); break; 
      default: lcd_send_byte(1,c); break; 
   } 
} 

#ifdef USE_LCD_RW 
char lcd_getc(int8 x, int8 y) 
{ 
   char value; 
   
   lcd_gotoxy(x,y); 
   
   while(bit_test(lcd_read_byte(),7));  
   
   output_high(LCD_RS); 
   value = lcd_read_byte(); 
   output_low(lcd_RS); 
   
   return(value); 
} 
#endif

Devre şeması : http://i.hizliresim.com/Am7qJX.png

Dosyalar : http://s5.dosya.tc/server2/lgg4i6/PIC_Kontrol.rar.html

Kolay gelsin.

[ziyaretci]

Hocam elinize sağlık, veri gönderimi ve alma kısmında kullanılan fonksiyonun asm tarafındaki bilgiye sahipseniz bilgilendirebilir misiniz?

[baran123]

Hocam sizin konuyu biliyorum.Fakat o kadar derinden bilgim maalesef yok.

[Recep METE]

Çalışman için teşekkürler, hemen indirip dosyaladım.Belki lazım olur.

[mustafa_temel]

bu devre tam olarak ne işe yarıyor acaba ??

[baran123]

USB üzerinden PIC ile iletişim kuruyorsunuz.Bilgisayar arayüzünden bilgi göndererek LCD de yazı yazdırabiliyor, ledleri yaka biliyor ve D portunu kontrol edebiliyorsunuz.Sanırım sıcaklık ölçmede vardı ama tam hatırlamıyorum.

[mustafa_temel]

USB üzerinden PIC ile iletişim kuruyorsunuz.Bilgisayar arayüzünden bilgi göndererek LCD de yazı yazdırabiliyor, ledleri yaka biliyor ve D portunu kontrol edebiliyorsunuz.Sanırım sıcaklık ölçmede vardı ama tam hatırlamıyorum.

hım anladım güzel bişey o zaman ...

[RaMu]

Hocam elinize sağlık, veri gönderimi ve alma kısmında kullanılan fonksiyonun asm tarafındaki bilgiye sahipseniz bilgilendirebilir misiniz?

  Sizin konunuzda Baran ın kodlarını mplab ide ile derletip
kolay araştırılabilir hale getirdim,
ufakda bir video hazırladım,
(sessiz videoları hiç sevmem ama)
buradanda konunun linkini vermek istedim:
https://www.picproje.org/index.php/topic,59058.msg457160.html#msg457160