Czym jest V-USB?
V-USB jest to biblioteka napisana z myślą o procesorach ATMEL umożliwiająca oprogramowanie komunikacji poprzez interfejs USB. Wprawny programista może spróbować przerobić bibliotekę pod inne procesory. Bibliotekę można ściągnąć ze strony projektu http://www.obdev.at/products/vusb/index.html. W tym miejscu dowiesz się jak obsługiwać USB od strony projektu opartego na procesorze ATMEL oraz od strony środowiska systemu operacyjnego Twojego PC.
Schematy podłączeń
Zgodnie z zaleceniami końcówki D+ i D- powinny być podłączone do nóżek odpowiedzialnych za przerwania procesora (INT0, INT1) aczkolwiek łącze D+ interfejsu podłączone być powinno zawsze do nóżki INT0 natomiast D- może być podłączone gdzie chcemy. Dodatkowo ważnym jest aby napięcie wychodzące z łączy D+ i D- było na poziomie 3.6V co można uzyskać na kilka sposobów (patrz schematy poniżej). Zaleca się też podłączenie rezystora pull-up 1.5k do D- oraz pull-up lub pull-down 1M do D+ żeby uniknąć interferencji kiedy USB nie jest podłączone.
Jako, że USB zasilane jest napięciem 5V do jego obniżenia można użyć diody Zenera
Podłączenie 1
Podłączenie 2
Podłączenie 3
Rys 1. Sposoby obniżenia napięcia na wyjściu USB
Rys 2. Schemat wtyczki
Przygotowanie do pracy
Zanim zaczniemy należy przygotować stanowisko pracy. Nie piszę już o samym układzie ale bardziej mam na myśli przygotowanie środowiska programistycznego tj. ściągnięcie biblioteki i przygotowanie jej do pracy z naszym programem.
Po ściągnięciu biblioteki rozpakowujemy ją do wybranego katalogu. Należy też ściągnąć sterowniki USB dla ©MS WINDOWS, dzięki którym będziemy mogli "rozmawiać" z naszym układem. Można to zrobić ze strony projektu libusb-win32. Moduł ten umożliwi nam skompilowanie sterowników dedykowanych dla naszego układu. Ale o tym później.
Kopiujemy folder usbdrv do naszego katalogu projektu. Wchodzimy do katalogu i tworzymy kopię pliku usbconfig_prototype.h jako usbconfig.h. Lokalizujemy linie definiującą porty IO oraz taktowanie zegara i jeśli to potrzebne uaktualniamy je do odpowiednich danych. W tym miejscu chciałbym zaznaczyć, że nasz procesor MUSI byś taktowany jedną z wartości: 12 MHz, 15 MHz, 16 MHz oraz 20 MHz lub 12.8 MHz w ostateczności 16.5 MHz +/- 1%. Inne wartości taktowania spowodują, że nie będzie możliwości używania naszego urządzenia.
Dlatego należy używać zewnętrznych kwarców i oczywiście odpowiednio obliczyć i ustawić FUSE BITy. (ja ustawiam low = AF high = DF ext. = 01)
[syntax=c]#ifndef __usbconfig_h_included__
#define __usbconfig_h_included__[/syntax]
Wstawiamy:
[syntax=c]#define F_CPU 12000000
#define USB_CFG_IOPORTNAME D
#define USB_CFG_DMINUS_BIT 3
#define USB_CFG_DPLUS_BIT 2
#define USB_CFG_CLOCK_KHZ 12000[/syntax]
Powinniśmy też skonfigurować nazwę naszego urządzenia oraz numer, przez który będzie nas rozpoznawać nasz sterownik WINDOWS.
[syntax=c]#define USB_CFG_DEVICE_ID 0x66, 0x0E /* ustawiamy ID urządzenia */
#define USB_CFG_VENDOR_NAME 'e', '-', 'w', 'o', 'o', 'd', 'y', '.', 'i', 'n', 'f', 'o' /* Nazwa producenta */
#define USB_CFG_VENDOR_NAME_LEN 12 /* Długość nazwy producenta */
#define USB_CFG_DEVICE_NAME 'W', 'O', 'O', 'D', 'U', 'S', 'B' /* Nazwa urządzenia */
#define USB_CFG_DEVICE_NAME_LEN 7 /* Długość nazwy urządzenia *//[/syntax]
Przydaje się także informacja o tym czy nasze urządzenie korzysta z zasilania USB czy nie
[syntax=c]#define USB_CFG_IS_SELF_POWERED 0
#define USB_CFG_MAX_BUS_POWER 50[/syntax]
Tak naprawdę plik usbconfig.h jest na tyle dobrze opisany, że można samemu zaglądnąć do środka i zorientować się co jeszcze można ustawić. Zapraszam do lektury.
Czas na main.c
Poniżej mamy podstawowy szkielet programu dla μprocesora obsługującego protokół i łącze USB
[syntax=c]#include<avr/io.h>
#include<avr/interrupt.h>
#include<avr/wdt.h>
#include"usbdrv.h"
#define F_CPU 12000000L
#include<util/delay.h>
USB_PUBLIC uchar usbFunctionSetup(uchar data[8]){
return0;// Narazie nic nie rób
}
int main(){
uchar i;
wdt_enable(WDTO_1S);// uaktywnij jednosekundowy watchdog
usbInit();
usbDeviceDisconnect();// Wymuś przenumerowanie
for(i =0; i<250; i++){// Odczekaj około 500 ms
wdt_reset();// Poinformuj watchdog, ze procesor działa
_delay_ms(2);
}
usbDeviceConnect();
sei();// Aktywuj przerwania po renumeracji
while(1){
wdt_reset();// wiadomo, jak wyżej
usbPoll();
}
return0;
}[/syntax]
Co tu mamy? Jak to działa? Małe wytłumaczenie
Zaimplementujmy funkcję usbFunctionSetup() obsługującą wywołania USB (co i jak opiszę później)
W częsci głównej programu ustawiamy watchdog na 1 s, która zresetuje procesor jeśli coś pójdzie nie tak i nie zostanie wywołana funkcja wdt_reset() w czasie 1000 ms. To zabezpiecza program przed jakimiś nietypowymi zachowaniami i pozwala uniknąć użytkownikowi odłączania i ponownego przyłączania urządzenia jeśli stanie się coś dziwnego.
Wywołajmy usbInit() - funkcję inicjującą działąnie biblioteki V-USB.
Wymuśmy przenumerowanie USB poprzez użycie usbDeviceDisconnect(), a następnie po 500ms usbDeviceConnect(). Na wypadek resetu Watchdog.
Włączamy przerwania
Na sam koniec nieskończona pętla resetująca watchdog i wywołująca funkcję obsługi USB usbPool().
Jak dotąd wszystko wygląda chyba prosto. Zatem wypadałoby napisać jak urządzenie ma odpowiadać na zewnętrzne wywołanie.
Aby lepiej zrozumieć w jaki sposób procesor odpowiada na zewnętrzne wywołania USB należy przybliżyć działanie trzech podstawowych funkcji. Ale to w następnej części
------------------------ [ Dodano po: 16 minutach ]
Dwie funkcje
Jak wspominałem w części poprzedniej aby zacząć pisanie programów do komunikacji USB należy poznać dwie, no może trzy podstawowe funkcje służące do komunikacji URZĄDZENIE-KOMPUTER.
Pierwszą funkcją, która musi być zawsze zdefiniowana jest usbFunctionSetup(uchar dane[8]). Wywołując wezwanie USB z poziomu komputera uruchamiana jest zawsze ta funkcja. Jej wywołanie z poziomu procesora jest następujące:
[syntax=c]USB_PUBLIC uchar usbFunctionSetup(uchar data[8])
{
usbRequest_t *rq = (void *)data; // zamiana data na właściwy typ
switch(rq->bRequest)
{[/syntax]
usbRequest jest zdefiniowany następująco
[syntax=c]typedef struct usbRequest{
uchar bmRequestType;
uchar bRequest;
usbWord_ twValue;
usbWord_ twIndex;
usbWord_ twLength;
}usbRequest_t;[/syntax]
Wszystkie dane są przekazywane od strony komputera poprzez funkcje wywołującą działanie programu poprzez USB ale co i jak napiszę w kolejnej części. W tej chwili zajmiemy się tylko funkcjami usbFunctionSetup, usbFunctionRead oraz usbFunctionWrite.
bmRequestType - informuje sterownik o tym czy chcemy dane przesyłać z czy do urządzenia
bRequest - rodzaj wywołania (zazwyczaj ustalane przez programiste)
twValue - wartość przesyłana do urządzenia
twIndex - index (w rzeczywistości kolejna wartość wysyłana przez programistę)
twLength - ilość danych
Funckie usbFunctionSetup możemy wykorzystać do wysyłania danych statycznych. Jeśli chcemy przesyłać dane odczytywane "w locie" winnismy użyć funkcji usbFunctionRead.
Przyszedł zatem czas na napisanie przykładowego programu służącego do zapalenia i gaszenia diody i przy okazji przesłania jakiegoś krótkiego tekstu np nazwy urządzenia. Ponieważ już wiadomo jak skonfigurować sterownik (patrz USB - AVR - biblioteka VUSB - część I) więc ten etap pominę.
[syntax=c]/*
* USBmain.c
*
* Created: 2014-02-13 00:22:21
* Author: Dr inż. W.K.
*/
#define F_CPU 12000000L
#include<avr/io.h>
#include<avr/interrupt.h>
#include<avr/wdt.h>
#include<util/delay.h>
#include"usbdrv.h"
/definiujemy stałe opisujące konkretne wywołania
#define USB_TEST 0 //test USB, który w odpowiedzi zwraca np nazwę urządzenia
#define USB_LED_OFF 1 //Zgaś diodę
#define USB_LED_ON 2 //zapal diodę
#define LED_DDR DDRC
#define LED_PORT PORTC
#define LED_PIN (1<<PC0)
USB_PUBLIC uchar usbFunctionSetup(uchar data[8])
{
usbRequest_t *rq = (void *)data; // cast data to correct type
switch(rq->bRequest)
{
case USB_TEST:
{
usbMsgPtr="USBTest"; //usbMsgPtr słuzy do przekazywania łańcucha znaków do programu wywołującego
return 7; //return zawsze powinno zwracać liczbę znaków jaką przekazujemy na zewnątrz (w tym wypadku 7)
}
case USB_LED_ON:
{
LED_PORT|= LED_PIN; // turn LED on
usbMsgPtr="ON"; //Przekaż ciąg znaków o treści ON
return 2;//Zwracamy dwa znaki (ON)
}
case USB_LED_OFF:
{
LED_PORT&=~LED_PIN
usbMsgPtr = "OFF" //Przekaż ciąg znaków o treści OFF
return 3; //zwracamy trzy znaki (OFF)
}
}
return 0;//Na wszelki wypadek zwróćmy zero (jakby została wywołana jakaś nieobsługiwana funkcja)
}
int main(){
LED_DDR=LED_PIN;
wdt_enable(WDTO_2S);// uaktywnij dwusekundowy watchdog
usbInit();
usbDeviceDisconnect();// Wymuś przenumerowanie
for(i =0; i<250; i++)// Odczekaj około 500 ms
{
wdt_reset();// Poinformuj watchdog, ze procesor działa
_delay_ms(2);
}
usbDeviceConnect();
sei();// Aktywuj przerwania po renumeracji
while(1)
{
wdt_reset();// wiadomo, jak wyżej
usbPoll();
}
return;
}[/syntax]
Mam nadzieję, że choć trochę rozjaśniłem sposoby komunikacji URZĄDZENIE<-->KOMPUTER poprzez USB. W następnej części wytłumaczę jak można przekazywać większą ilość danych niż 8 znaków (w dwie strony) oraz jak porozumiewać się z naszym procesorem z poziomu komputera (WIN/LINUX). Napiszę też trochę informacji na temat numerowania VENDOR/DEVICE aby pozostać legalnym.Statystyki: Napisane przez WoodPaker — 25 lut 2014, o 01:11
]]>
) J.