MCUserver: AVR = USB osciloskop chudé bastlířky

Název článku je za prvé snahou o genderovou vyváženost a za druhé pokračováním předchozího textu AVR = USB klávesnice. A mezi námi děvčaty, proč si nepostavit za 5 EUR USB dvoukanálový osciloskop?

Zdrojový článek:
S plným textem a všemi zdroji je zde.

Upozornění:
Případné zájemkyně o stavbu raději upozorňuji na to, že na 4 pinu, který slouží jako vstupní pro osciloskop je vyvedeno i 5V z USB zásuvky bez jakékoliv ochrany proti zkratování. Většina USB portů na PC má ochranu 5V napájení pomocí polysiliconové pojistky, ale jako správný paranoik jsem přesvědčen že opatrnosti není nikdy dost. Mcu server nepřejímá žádnou zodpovědnost za stav vašeho hardware!

Popis zařízení:
Jde o zařízení založené na AVR ATtiny45, které je připojeno k USB přes ochranné odpory a zenerovy diody na přizpůsobení napěťových úrovní (ano, má to své mouchy, ale v naprosté většině případů to funguje). Přesnost vnitřního oscilátoru umožnila neosazovat externí krystal. Zařízení má dva analogové vstupy, z nichž jeden lze omezit pomocí trimru (tedy zvýšit rozsah vstupních napětí), druhý má napěťový rozsah 0-5V. na další dva piny (celkem 4-pinového vstupu) je vyvedeno 5V a GND, čímž je umožněno napájení cílové aplikace na pokusné desce. Firmware pro Tiny45 je napsáno v C a přeložen pomocí Winavr, pro USB bylo bylo využito obdev. Neočekávejte něco jako digitální osciloskop s 1Gs. Jedná se o velmi jednoduché zařízení, ale má 10-bit A/D převod. Zařízení využívá HID, tedy na PC není nutné instalovat jakýkoliv speciální driver.

Video s hotovým zařízením:

Schéma zapojení:

Celé zařízení:

Odkaz na YouTube

Zdrojový kód:

 
/* Name: main.c
 * Project: Data input based on AVR USB driver with TINY45
 * V3: 2 inputs ADC2/PB4 ADC3/PB3, pas de switch, led sur PB1 (on=0)
 * Author: Jacques Lepot
 * Creation Date: 2008-04-19
 * Copyright: (c) 2008 by Jacques LEpot
 * License: Proprietary, free under certain conditions. 
 
 */
 
#include <avr/io.h>#include <avr/wdt.h>#include <avr/eeprom.h>#include <avr/interrupt.h>#include <avr/pgmspace.h>#include <util/delay.h>#include "usbdrv.h"
#include "oddebug.h"
 
/*
Pin assignment:
PB4 = analog input (ADC2)
PB3 = analog input (ADC3)
PB1 = LED output (active low)
 
PB0, PB2 = USB data lines
*/
 
#define BIT_LED 1
#define BIT_KEY 4
 
 
#define UTIL_BIN4(x)        (uchar)((0##x & 01000)/64 + (0##x & 0100)/16 + (0##x & 010)/4 + (0##x & 1))
#define UTIL_BIN8(hi, lo)   (uchar)(UTIL_BIN4(hi) * 16 + UTIL_BIN4(lo))
 
#ifndef NULL
#define NULL    ((void *)0)
#endif
 
/* ------------------------------------------------------------------------- */
 
static uchar    reportBuffer[5];    /* buffer for HID reports, type game cntrler*/
static uchar    idleRate;           /* in 4 ms units */
 
static uchar    adcPending;
static uchar    isRecording;
static uchar    adchanel;
static int              adcval1;
static int              adcval2;
 
/* ------------------------------------------------------------------------- */
 
PROGMEM char usbHidReportDescriptor[USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH] = { /* USB report descriptor */
    0x05, 0x01,        // USAGE_PAGE (Generic Desktop = 01)
        0x09, 0x05,        // USAGE (Game Pad = 05)
        0xa1, 0x01,        // COLLECTION (Application)
        0x09, 0x01,        //   USAGE (Pointer)
        0xa1, 0x00,        //   COLLECTION (Physical)
        0x09, 0x30,        //     USAGE (X)
        0x09, 0x31,        //     USAGE (Y)
        0x15, 0x00,        //   LOGICAL_MINIMUM (0)
        0x26, 0xff, 0x00,  //     LOGICAL_MAXIMUM (255)
        0x75, 0x08,        //   REPORT_SIZE (8bits)
        0x95, 0x04,        //   REPORT_COUNT (2)
        0x81, 0x02,        //   INPUT (Data,Var,Abs)
        0xc0,              // END_COLLECTION
        
        0x05, 0x09,        // USAGE_PAGE (Button)
        0x19, 0x01,        //   USAGE_MINIMUM (Button 1)
        0x29, 0x08,        //   USAGE_MAXIMUM (Button 8)
        0x15, 0x00,        //   LOGICAL_MINIMUM (0)
        0x25, 0x01,        //   LOGICAL_MAXIMUM (1)
        0x75, 0x01,        // REPORT_SIZE (1bit)
        0x95, 0x08,        // REPORT_COUNT (8)
        0x81, 0x02,        // INPUT (Data,Var,Abs)
        0xc0               // END_COLLECTION
};
 
/* ------------------------------------------------------------------------- */
 
static void buildReport(void)
{
 
        reportBuffer[0] = adcval1>>8;
        reportBuffer[1] = adcval1;
        reportBuffer[2] = adcval2>>8;
        reportBuffer[3] = adcval2;
        reportBuffer[4] = 0x01;
 
}
 
/* ------------------------------------------------------------------------- */
 
static void setIsRecording(uchar newValue)
{
    isRecording = newValue;
    if(isRecording){
        PORTB &= ~(1 << BIT_LED);      /* LED on */
    }else{
                PORTB |= 1 << BIT_LED;    /* LED off */
    }
}
 
/* ------------------------------------------------------------------------- */
 
static void adcPoll(void)
{int value;
    if( !(ADCSRA & (1 << ADSC))){           //adcPending &&
       // adcPending = 0;
        value=ADC;
                if(adchanel){
                        adcval1 = value + value + (value >> 1);  /*  value * 2.5 for output in mV */
                        ADMUX = UTIL_BIN8(1001, 0011);
                        }
                else{
                        adcval2 = value + value + (value >> 1);
                        ADMUX = UTIL_BIN8(1001, 0010);
                }
                adchanel=!adchanel;
                ADCSRA |= (1 << ADSC);  /* start next conversion */
    }
}
 
static void timerPoll(void)
{
static uchar timerCnt;
 
    if(TIFR & (1 << TOV1)){
        TIFR = (1 << TOV1); /* clear overflow */
        if(adcPending == 0){
                adcPending = 1;
                ADCSRA |= (1 << ADSC);  /* start next conversion */
        }
 
    }
}
 
/* ------------------------------------------------------------------------- */
 
static void timerInit(void)
{
    TCCR1 = 0x0b;           /* select clock: 16.5M/1k -> overflow rate = 16.5M/256k = 62.94 Hz */
}
 
static void adcInit(void)
{
    ADMUX = UTIL_BIN8(1001, 0011);  /* Vref=2.56V, measure ADC0-  REFS1 REFS0 ADLAR REFS2 , MUX3 MUX2 MUX1 MUX0 -> ADC2=0010, ADC3=0011, ADC2-ADC3=0110, (ADC2-ADC3)*20=0111*/
    ADCSRA = UTIL_BIN8(1000, 0111); /* enable ADC, not free running, interrupt disable, rate = 1/128 = 129khz*/
}
 
/* ------------------------------------------------------------------------- */
/* ------------------------ interface to USB driver ------------------------ */
/* ------------------------------------------------------------------------- */
 
uchar   usbFunctionSetup(uchar data[8])
{
usbRequest_t    *rq = (void *)data;
 
    usbMsgPtr = reportBuffer;
    if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){    /* class request type */
        if(rq->bRequest == USBRQ_HID_GET_REPORT){  /* wValue: ReportType (highbyte), ReportID (lowbyte) */
                                                                                                   /* we only have one report type, so don't look at wValue */
            buildReport();
            return sizeof(reportBuffer);
        }else if(rq->bRequest == USBRQ_HID_GET_IDLE){
            usbMsgPtr = &idleRate;
            return 1;
        }else if(rq->bRequest == USBRQ_HID_SET_IDLE){
            idleRate = rq->wValue.bytes[1];
        }
    }else{
        /* no vendor specific requests implemented */
    }
        return 0;
}
 
/* ------------------------------------------------------------------------- */
/* ------------------------ Oscillator Calibration ------------------------- */
/* ------------------------------------------------------------------------- */
 
/* Calibrate the RC oscillator to 8.25 MHz. The core clock of 16.5 MHz is
 * derived from the 66 MHz peripheral clock by dividing. Our timing reference
 * is the Start Of Frame signal (a single SE0 bit) available immediately after
 * a USB RESET. We first do a binary search for the OSCCAL value and then
 * optimize this value with a neighboorhod search.
 * This algorithm may also be used to calibrate the RC oscillator directly to
 * 12 MHz (no PLL involved, can therefore be used on almost ALL AVRs), but this
 * is wide outside the spec for the OSCCAL value and the required precision for
 * the 12 MHz clock! Use the RC oscillator calibrated to 12 MHz for
 * experimental purposes only!
 */
static void calibrateOscillator(void)
{
uchar       step = 128;
uchar       trialValue = 0, optimumValue;
int         x, optimumDev, targetValue = (unsigned)(1499 * (double)F_CPU / 10.5e6 + 0.5);
 
    /* do a binary search: */
    do{
        OSCCAL = trialValue + step;
        x = usbMeasureFrameLength();    /* proportional to current real frequency */
        if(x < targetValue)             /* frequency still too low */
            trialValue += step;
        step >>= 1;
    }while(step > 0);
    /* We have a precision of +/- 1 for optimum OSCCAL here */
    /* now do a neighborhood search for optimum value */
    optimumValue = trialValue;
    optimumDev = x; /* this is certainly far away from optimum */
    for(OSCCAL = trialValue - 1; OSCCAL <= trialValue + 1; OSCCAL++){
        x = usbMeasureFrameLength() - targetValue;
        if(x < 0)
            x = -x;
        if(x < optimumDev){
            optimumDev = x;
            optimumValue = OSCCAL;
        }
    }
    OSCCAL = optimumValue;
}
/*
Note: This calibration algorithm may try OSCCAL values of up to 192 even if
the optimum value is far below 192. It may therefore exceed the allowed clock
frequency of the CPU in low voltage designs!
You may replace this search algorithm with any other algorithm you like if
you have additional constraints such as a maximum CPU clock.
For version 5.x RC oscillators (those with a split range of 2x128 steps, e.g.
ATTiny25, ATTiny45, ATTiny85), it may be useful to search for the optimum in
both regions.
*/
 
void    usbEventResetReady(void)
{
    calibrateOscillator();
    eeprom_write_byte(0, OSCCAL);   /* store the calibrated value in EEPROM */
}
 
/* ------------------------------------------------------------------------- */
/* --------------------------------- main ---------------------------------- */
/* ------------------------------------------------------------------------- */
 
int main(void)
{
uchar   i;
uchar   calibrationValue;
 
    calibrationValue = eeprom_read_byte(0); /* calibration value from last time */
    if(calibrationValue != 0xff){
        OSCCAL = calibrationValue;
    }
    odDebugInit();
    usbDeviceDisconnect();
    for(i=0;i<20;i++){  /* 300 ms disconnect */
        _delay_ms(15);
    }
    usbDeviceConnect();
    DDRB |= 1 << BIT_LED;   /* output for LED */
    //PORTB |= 1 << BIT_KEY;  /* pull-up on key input */
    wdt_enable(WDTO_1S);
    //timerInit();
    adcInit();
    usbInit();
    sei();
        setIsRecording(1);
    for(;;){    /* main event loop */
        wdt_reset();
        usbPoll();
        if(usbInterruptIsReady() ){ /* we can send a report */
            buildReport();
            usbSetInterrupt(reportBuffer, sizeof(reportBuffer));
 
        }
        //timerPoll();
        adcPoll();
    }
    return 0;
} 
 

Starší články

Novější články