Anonymní profil Mol – Programujte.com
 x   TIP: Přetáhni ikonu na hlavní panel pro připnutí webu
Reklama

Anonymní profil Mol – Programujte.comAnonymní profil Mol – Programujte.com

 

Příspěvky odeslané z IP adresy 89.102.186.–

Mikrokontroléry › DS1302
13. 4. 2015   #201352

No jak píšu, prostě nemůžu ty data z té funkce dostat. Asi něco dělám špatně i když sem si komentáře přečetl.  

int main(void)

 {  char h,m,s;

     rtc_init();               

     while(1)

        {
            get_date_time();

           m=dt.minute; 

        }

}

Mikrokontroléry › DS1302
11. 4. 2015   #201249

Zdravím

dostal sem od kolegy kód k DS1302, ale prostě nemůžu přijít na to jak do těch funkcí narvat a získat ty argumenty data a času. Neuměl by mi prosím někdo znalý pohledem na kód poradit? 

/*-------------------------
  ds1302.h
 -------------------------*/
#ifndef RTC_H
#define RTC_H
 
//Data type to hold calendar/clock data
typedef struct
{
    uint8_t second;
    uint8_t minute;
    uint8_t hour;
    uint8_t date;
    uint8_t month;
    uint8_t day;
    uint8_t year;
} dateTime;
 
/*******************************************************************
  Interface function to initialize RTC: 1. Disable Clock Halt
                                        2. Set to 24 hour mode
                                        3. Disable Write Protection
  No Calendar/Clock will be changed
********************************************************************/
void rtc_init(void);
 
//Interface function to read Calendar/Clock value
dateTime get_date_time(void);
 
//Interface function to set Calendar/Clock value
void set_date_time(dateTime dt);
 
#endif


/*-------------------------
   ds1302.c
 -------------------------/

/* SCLK - PC0
    I/O - PC1
   REST - PC2   */



#define F_CPU 8000000UL //8.000MHz
  
#include <avr/io.h>
#include <stdint.h>
#include <util/delay.h>
#include "rtc.h"
 
//Strobe "pin" on "port" high
#define IO_PIN_STROBE_HIGH(port, pin)   \
        __asm__ __volatile__ (          \
        "sbi %0, %1"                    \
        : /* no output */               \
        : "I" (_SFR_IO_ADDR(port)),     \
          "I" (pin))
 
//Strobe "pin" on "port" low
#define IO_PIN_STROBE_LOW(port, pin)    \
        __asm__ __volatile__ (          \
        "cbi %0, %1"                    \
        : /* no output */               \
        : "I" (_SFR_IO_ADDR(port)),     \
          "I" (pin))
 
//Timing requirement between data output and clock strobe high
#define DATA_TO_CLK_SETUP()     \
        __asm__ __volatile__ (  \
        "nop\n\t"               \
        "nop\n\t"               \
        ::)
 
//Strobe CE pin of DS1302 high and low
#define CE_STROBE_HIGH() IO_PIN_STROBE_HIGH(PORTC, 5) 
#define CE_STROBE_LOW() IO_PIN_STROBE_LOW(PORTC, 5)
 
//Strobe SCLK pin of DS1302 high and low
#define SCLK_STROBE_HIGH() IO_PIN_STROBE_HIGH(PORTC, 6)
#define SCLK_STROBE_LOW() IO_PIN_STROBE_LOW(PORTC, 6)
 
//Strobe IO pin of DS1302 high and low
#define IO_STROBE_HIGH() IO_PIN_STROBE_HIGH(PORTC, 7)
#define IO_STROBE_LOW() IO_PIN_STROBE_LOW(PORTC, 7)
 
//Calendar/Clock burst read and write command
#define DT_BURST_READ 0xbf
#define DT_BURST_WRITE 0xbe
 
//RTC register seconds byte read and write command
#define DT_SECONDS_READ 0x81
#define DT_SECONDS_WRITE 0x80
 
//RTC register hours byte read and write command
#define DT_HOURS_READ 0x85
#define DT_HOURS_WRITE 0x84
 
//RTC register WP write
#define DT_WP_WRITE 0x8e
 
//Configure port pin directions for read and write DS1302
#define WRITE_MODE() (DDRC |= 0xe0)
#define READ_MODE() (DDRC = (DDRC|0xe0)&0xbf)
//Disable io pull-up in read mode
#define DISABLE_IO_PULLUP() (PORTC &= 0xbf) 
//Read i/o value from DS1302
#define IO_READ() (PINC & 0x40)


 
//Prepare CE and SCLK for new operation
static void reset(void)
{
    //Pull both CE and SCLK low to start with   
    SCLK_STROBE_LOW();
    CE_STROBE_LOW();
 
    //Comms. begin with CE stobe high
    CE_STROBE_HIGH();
}
 
//Read one byte of Calendar/Clock data
static uint8_t read_byte(void)
{
    uint8_t byte = 0;
    uint8_t i;
 
    //Port pins in read mode for data read
    READ_MODE();
    //Disable internal I/O pull-up
    DISABLE_IO_PULLUP();
 
    //Read one byte of Calendar/Clock data
    for(i = 0; i != 8; ++i)
    {
        //Strobe SCLK low to read I/O
        SCLK_STROBE_LOW();
        _delay_us(1);
 
        if(IO_READ() != 0)
        {
            byte |= 1<<i;
        }
        //Strobe SCLK high for next I/O read
        SCLK_STROBE_HIGH();
        _delay_us(1);
    }
 
    return byte;
}
 
//Write one byte of control or Calendar/Clock data
static void write_byte(uint8_t byte)
{
    uint8_t i;
 
    //Port pins in write mode
    WRITE_MODE();
 
    //Write one byte of control or Calendar/Clock data
    for(i = 0; i != 8; ++i)
    {
        //Start clock cycle with SCLK low
        SCLK_STROBE_LOW();
        _delay_us(1);
 
        //Write bit value to I/O pin of DS1302          
        if(((1<<i)&byte) == 0)
        {
            IO_STROBE_LOW();
        }
        else
        {
            IO_STROBE_HIGH();
        }
 
        DATA_TO_CLK_SETUP(); //Data to clock setup
 
        //End clock cycle with SCLK high
        SCLK_STROBE_HIGH();
        _delay_us(1);       
    }
     
}
 
//Read 7 bytes of Calendar/Clock data
static dateTime read_dt_block(void)
{
    uint8_t dt_byte;
    uint8_t byte_pos;
    dateTime dt = {0};
 
    //Always do a reset before a new operation
    reset();
 
    //Write the clock burst read command into DS1302
    write_byte(DT_BURST_READ);
 
    //Read each of the 7 Calendar/Clock bytes from DS1302
    for(byte_pos = 0; byte_pos != 7; ++byte_pos)
    {
        //Read one byte of calendar/clock data
        dt_byte = read_byte();
         
        //Copy the read byte to the right place
        switch(byte_pos)
        {
            case 0:
                        dt.second = dt_byte;
                        break;
            case 1:
                        dt.minute = dt_byte;
                        break;
            case 2:
                        dt.hour = dt_byte;
                        break;
            case 3:
                        dt.date = dt_byte;
                        break;
            case 4:
                        dt.month = dt_byte;
                        break;
            case 5:
                        dt.day = dt_byte;
                        break;
            case 6:
                        dt.year = dt_byte;
                        break;
        }
    }
 
    //Always end an operation with a reset
    reset();
    return dt;
}
 
//Write 8 bytes of Calendar/Clock data
static void write_dt_block(dateTime dt)
{
    uint8_t dt_byte;
    uint8_t byte_pos;
 
    //Always do a reset before a new operation
    reset();
 
    //Write burst write command byte to DS1302
    write_byte(DT_BURST_WRITE);
 
    //Write each of the 7 Calendar/Clock byte to DS1302
    for(byte_pos = 0; byte_pos != 7; ++byte_pos)
    {
        //Copy the right byte to write
        switch(byte_pos)
        {
            case 0:
                        dt_byte = dt.second;
                        break;
            case 1:
                        dt_byte = dt.minute;
                        break;
            case 2:
                        dt_byte = dt.hour;
                        break;
            case 3:
                        dt_byte = dt.date;
                        break;
            case 4:
                        dt_byte = dt.month;
                        break;
            case 5:
                        dt_byte = dt.day;
                        break;
            case 6:
                        dt_byte = dt.year;
                        break;
        }
 
        //Write one byte of Calendar/Clock data
        write_byte(dt_byte);
    }
 
    //Must write the 8th byte of the Calendar/Clock register
    write_byte(0);
 
    //Always end an operation with a reset
    reset();
}
 
/*******************************************************************
  Interface function to initialize RTC: 1. Disable Clock Halt
                                        2. Set to 24 hour mode
                                        3. Disable Write Protection
  No Calendar/Clock will be changed
********************************************************************/
void rtc_init(void)
{
    uint8_t byte_second;
    uint8_t byte_hour;
 
    //Disable Clock Halt
    reset();
    write_byte(DT_SECONDS_READ);
    byte_second = read_byte();
    reset();
    write_byte(DT_SECONDS_WRITE);
    write_byte(byte_second & 0x7f);
    reset();
 
    //Set to 24 hour mode
    write_byte(DT_HOURS_READ);
    byte_hour = read_byte();
    reset();
    write_byte(DT_HOURS_WRITE);
    write_byte(byte_hour & 0x7f);
    reset();
 
    //Disable Write Protection
    write_byte(DT_WP_WRITE);
    write_byte(0);
    reset(); 
}
 
//Interface function to read Calendar/Clock value
dateTime get_date_time(void)
{
    dateTime dt;
     
    //Read raw calendar/clock block from DS1302
    dt = read_dt_block();
 
    /*************************************************************
     Convert from the raw BCD Calendar/Clock data to normal decimal
     values. Hour is treated differently in 24 and AM/PM mode.
     Also the day of week is left as is.
    **************************************************************/
    dt.second = (((dt.second&0x70)>>4)*10) + (dt.second&0x0f);
    dt.minute = (((dt.minute&0x70)>>4)*10) + (dt.minute&0x0f);
    if((dt.hour&0x80) == 0)
    {
        dt.hour = (((dt.hour&0x30)>>4)*10) + (dt.hour&0x0f);
    }   
    dt.date = (((dt.date&0x30)>>4)*10) + (dt.date&0x0f);
    dt.month = (((dt.month&0x10)>>4)*10) + (dt.month&0x0f);
    dt.year = (((dt.year&0xf0)>>4)*10) + (dt.year&0x0f);
 
    return dt;
}
 
//Interface function to set Calendar/Clock value
void set_date_time(dateTime dt)
{
    /**************************************************************
     Convert from normal decimal Calendar/Clock value to BCD. Hour
     is treated differently in 24 and AM/PM mode. Also the day of
     week is left as is.
    ***************************************************************/   
    dt.second = ((dt.second/10)<<4) | (dt.second%10);
    dt.minute = ((dt.minute/10)<<4) | (dt.minute%10);
    if((dt.hour&0x80) == 0)
    {
        dt.hour = ((dt.hour/10)<<4) | (dt.hour%10);
    }
    dt.date = ((dt.date/10)<<4) | (dt.date%10);
    dt.month = ((dt.month/10)<<4) | (dt.month%10);
    dt.year = ((dt.year/10)<<4) | (dt.year%10);
 
    write_dt_block(dt);
}
Mikrokontroléry › kompilace kódu v Atmel Studi…
21. 3. 2014   #188505

Díky, tohle se zdá, že bude v pořádku, sem už žádná chyba neodkazuje. Teď sice hází chybu  Error  9  ld returned 1 exit status   collect2.exe   0   0 ale to s tím asi nemá nic společného a asi by to bylo na jinou kapitolu. Každopádně díky všem za rady.

Mikrokontroléry › kompilace kódu v Atmel Studi…
20. 3. 2014   #188482

Díky za rady, dal sem mu const unsigned char *logo PROGMEM a bohužel pořád hlásí Error  1 variable 'logo' must be const in order to be put into read-only section by means of '__attribute__((progmem))'   a k tomu asi 1000 hlášek  Warning  5  (near initialization for 'logo') [enabled by default]  a Warning  596    excess elements in scalar initializer [enabled by default]    

Mikrokontroléry › kompilace kódu v Atmel Studi…
20. 3. 2014   #188473

Zdravím, mám takový problém, při kompilaci v Atmel Studiu 6 mi pořád vybíhá tahle hláška a nevím co s tím, ještě sem se s ní nesetkal, v AVR Studiu 4 to prý funguje normálně. díky za každou radu

Error  1   variable 'urel_logo' must be const in order to be put into read-only section by means of '__attribute__((progmem))'    

 Na chybu to konktrétně odkazuje na tento .h soubor

char logo[] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xF8, 0xF8, 0x08, 0x08, 0x18, 0xF8, 0xE0, 0x00, 0xE8, 0xE8, 0x00, 0xC0, 0xE0, 0x60,
0x60, 0xE0, 0xE0, 0x00, 0xE8, 0xE8, 0x00, 0x20, 0xF8, 0xF8, 0x20, 0x00, 0x40, 0x60, 0x28, 0x2C,
0xE4, 0xC0, 0x00, 0xF8, 0xF8, 0x00, 0xE0, 0xE0, 0x60, 0x20, 0xE0, 0xC0, 0x00, 0xE8, 0xEC, 0x04,
0x00, 0x00, 0x00, 0x00, 0x60, 0xE0, 0x80, 0x80, 0xE0, 0x60, 0x00, 0xC0, 0xE0, 0x60, 0x60, 0xE0,
0xC0, 0x00, 0xC0, 0xE0, 0x20, 0x60, 0xF8, 0xF8, 0x00, 0xC0, 0xE0, 0x60, 0x60, 0xE0, 0xC0, 0x00,
0x60, 0xE0, 0x80, 0x80, 0xE0, 0x60, 0x00, 0x40, 0x60, 0x28, 0x2C, 0xE4, 0xC0, 0x00, 0xF8, 0xF8,
0x60, 0x20, 0xE0, 0xC0, 0x00, 0x40, 0x60, 0x20, 0x20, 0xE0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0F, 0x0F, 0x08, 0x08, 0x0C, 0x0F, 0x03, 0x00, 0x0F, 0x0F, 0x00, 0x27, 0x2F, 0x2C,
0x2C, 0x3F, 0x1F, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x0F, 0x0F, 0x08, 0x00, 0x06, 0x0F, 0x09, 0x0D,
0x0F, 0x0F, 0x00, 0x0F, 0x0F, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x0F, 0x0F, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0F, 0x0F, 0x03, 0x00, 0x00, 0x07, 0x0F, 0x0C, 0x0C, 0x0F,
0x07, 0x00, 0x07, 0x0F, 0x0C, 0x08, 0x0F, 0x0F, 0x00, 0x07, 0x0F, 0x0C, 0x0C, 0x0F, 0x07, 0x00,
0x00, 0x03, 0x0F, 0x0F, 0x03, 0x00, 0x00, 0x06, 0x0F, 0x09, 0x0D, 0x0F, 0x0F, 0x80, 0x8F, 0x8F,
0x80, 0x80, 0x8F, 0x0F, 0x00, 0x06, 0x0F, 0x09, 0x8D, 0x8F, 0x8F, 0x80, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
0xC0, 0xC0, 0xE0, 0xE0, 0x70, 0x70, 0x30, 0x38, 0x38, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
0x18, 0x18, 0x18, 0x10, 0x30, 0x30, 0x30, 0x20, 0x20, 0x40, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x08,
0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0xC1, 0xE0, 0xB8, 0x9F, 0x87, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0xF0, 0xF8, 0x3C, 0x1E, 0x0F, 0x07,
0xC3, 0xC1, 0xE0, 0xF0, 0x30, 0x38, 0x1C, 0x1C, 0x0C, 0x0E, 0x06, 0x87, 0x83, 0xC3, 0xC3, 0xC3,
0xC3, 0xC3, 0xC3, 0xC3, 0xC2, 0xC2, 0xC6, 0x84, 0x8C, 0x08, 0x08, 0x10, 0x21, 0x02, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x60, 0x20,
0x20, 0xE0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xF0, 0x10, 0x10, 0xF0, 0xE0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFE, 0x1F, 0x07, 0x01, 0x00, 0xE0, 0xF8, 0x3E, 0x1F,
0x07, 0x03, 0x80, 0xC0, 0xF0, 0x78, 0x1C, 0x0C, 0x06, 0x83, 0xC3, 0x61, 0x61, 0x30, 0x30, 0x18,
0x18, 0x18, 0x08, 0x08, 0x08, 0x08, 0x08, 0x18, 0x18, 0x11, 0x11, 0x22, 0x40, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0F, 0x09,
0x0D, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x1F, 0x10, 0x10, 0x1F, 0x0F, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0x03, 0x00, 0x00,
0x00, 0xF8, 0x1F, 0x07, 0x00, 0x00, 0xF0, 0xF8, 0x0E, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0xF8,
0xF8, 0xF8, 0xF8, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xF8, 0xF8, 0xF8, 0x00, 0x00, 0xF8, 0xF8, 0xF8,
0xF8, 0x78, 0x78, 0x78, 0x78, 0xF8, 0xF0, 0xF0, 0xE0, 0x00, 0x00, 0xF8, 0xF8, 0xF8, 0xF8, 0x78,
0x78, 0x78, 0x78, 0x78, 0x78, 0x00, 0x00, 0xF8, 0xF8, 0xF8, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0x02, 0xFE,
0xFE, 0x06, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0x01, 0x01, 0xFF, 0xFE, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x38, 0x60, 0x00, 0x01, 0x0F, 0x3C, 0xC0, 0x00,
0x00, 0x07, 0x78, 0xE0, 0x00, 0x00, 0x1F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0x38, 0x38, 0x38, 0x78, 0xFF, 0xFF, 0xFF, 0xC7, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x38,
0x38, 0x38, 0x38, 0x38, 0x38, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
0xF8, 0xF8, 0x28, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xF1, 0x11, 0x11, 0xF1, 0xE0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x04, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
0x3F, 0x3F, 0x3F, 0x38, 0x38, 0x38, 0x38, 0x3F, 0x3F, 0x1F, 0x0F, 0x00, 0x00, 0x3F, 0x3F, 0x3F,
0x3F, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x3F, 0x3F, 0x3F, 0x30, 0x00, 0x3F, 0x3F, 0x3F, 0x3F, 0x3C,
0x3C, 0x3C, 0x3C, 0x3C, 0x3C, 0x00, 0x00, 0x3F, 0x3F, 0x3F, 0x3F, 0x3C, 0x3C, 0x3C, 0x3C, 0x3C,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x1B, 0x12, 0x1B, 0x1F, 0x07, 0x00, 0x00, 0x00
};
Mikrokontroléry › Počítání v long
5. 1. 2014   #185985

#6 hlucheucho
Díky za vyčerpávající odpověď, už to jede, ten problém byl v tom, že sem neměl obojí přetypovaný zvlášť jak to uvádíš, to unsigned mě pak taky napadlo, ale to už tu ten příspěvek byl. Každopádně díky za řešení. Jinak je to externí 16bit ADC čtené po SPI.

Mikrokontroléry › Počítání v long
3. 1. 2014   #185898

Mám Atmegu16, takže ta by 32bit na long umět měla. Nicméně sem narazil na jeden zajímavý problém a tím bude zřejmně to dělení, protože, když zadám výpočet

ADH=3;
ADL=251; //AD=1019
vysledek = (long) ((ADH<<8|ADL)*50);

tak vysledek je 50950 proti čemuž se nedá nic namítnout, ale..
pokud to na závěr vydělím, třeba desítkou tj. vysledek = (long) ((ADH<<8|ADL)*50)/10;

vysledek je již 64078 což je naprosto zcesné a to nepřekročím ani 16 bitů.

Mikrokontroléry › Počítání v long
2. 1. 2014   #185872

Čau, potřebuju na osmibitovém up počítat poměrně velká čísla, ale bohužel výsledkem je nula i přesto, že po přetypování do long by se vejít měl, protože nejvyšší hodnota, která může při výpočtu nastat je 32768E4 což je 29 bitů, ale zdá se, že se přes ty hausnumera v mezivýpočtech nedokáže překlenout.  Na vstupu mám 16-bit číslo, to vynásobit konstantou 5000 a vydělit 65536. Je to externí A/D převodník. Nevěděl by někdo nějaký algoritmus jak na to? díky 

ADH=179; // hornich 8 bitu
ADL=87; // spodnich 8 bitu

vysledek = (long) ((256*ADH+ADL)*5000)/65536;

Mikrokontroléry › Jak používat A/D převodník
30. 11. 2013   #184597

Může mi někdo prosím popsat co znamená tento zápis? díky

ADCSRA |= (1 << ADEN) | (1 << ADSC) | (1 << ADFR) | (1 << ADIE) | (1 <<ADPS2) | (1 <<ADPS1)  | (1 <<ADPS0); 
Mikrokontroléry › Mega8 a podmínka if
29. 11. 2013   #184533

čau, potřebuji kontrolovat výstupy ze snímačů a tím že smí být aktivní nanejvýš jeden a udělal sem si v Atmel studiu funkci pro čtení a zpracování logických úrovní, když je na portu A víc než jedna jednička, else má spustit TIMER1, kde je generátor obdélníku pro rozdrnčení piezoměniče + otočit výstupy PB0/1. Bohužel však jak je vidět ze simulace, tak i přesto, že na portu A je přítomna jedna vysoká úroveň což odpovídá podmínce if, bylo to vyhodnoceno jako nesplnění a na výstup se dostal obsah else což mi hlava nebere. Neměl by prosím někdo typ co by za tím mohlo být? Přikládám program a simulaci 

Připojen obrázek.

Připojen obrázek.

Palkic.89
Mikrokontroléry › ATmega a smyčka while
24. 11. 2013   #184348

#4 KIIV
Režim CTC razantně odmítám, je složitý na nastavování a nikdy se mi ho nepovedlo rozběhnout podle představ. Overflow je jednoduchý.

Palkic.89
Mikrokontroléry › ATmega a smyčka while
24. 11. 2013   #184346

#3 KIIV
Díky, to je přesně ono. :wink:

Palkic.89
Mikrokontroléry › ATmega a smyčka while
24. 11. 2013   #184302

#1 Palkic.89
if (i>9999) i=0;  sorry za překlep
 

Palkic.89
Mikrokontroléry › ATmega a smyčka while
24. 11. 2013   #184301

Zdary, potřeboval bych poradit, mám atmegu16 a nedaří se mi rozchodit tuto děličku 1000 pomocí while, čítač TIMER0 běží na 1000 tikách za sekundu a while by měl dekrementovat z 1000 do 0 a pak inkrementovat proměnnou i čímž frekvence i bude 1 sekunda, avšak dekrementace z 1000 do 0 proběhne po restartu jen jednou a na hodnotě nula zůstane a již neběží odznova a mě by zajímalo proč už se znova nerozběhne. Podle kolegy je ten kód v pořádku...

unsigned int cekej, i=0;  

void main(void)    
  {  
        asm("sei");

        while (1)
          {  cekej=1000;
             while(cekej>0)
             i++;
             if(T>9999) i=0;   }
  }


ISR(TIMER0_OVF_vect) 
{
      if (cekej)
          cekej--;

      TCNT0=131;  // 1 kHz
}
Mikrokontroléry › Zalomení v HT
20. 4. 2013   #175266

je to opravdu jak píšete :) ale je nevýhoda, že jsou to dva znaky zvlášť \r a \n, takže při větší rychlosti to může být problém s datovým tokem. Jelikož HT stejně neudrží moc hodnot a ty první se začnou přepisovat, tak se stejně poohlédnu po něčem jiném. Termite 2.9 se zdá jako celkem solidní. :)

Mikrokontroléry › Zalomení v HT
19. 4. 2013   #175240

Nevíte jak se dělá zalomení na nový řádek v Hyperterminálu? Na uart_putc(13) což je ascii enter nereaguje, a na uart_putc('\n') vypisuje do diagonály...

C / C++ › Zaokrouhlení na desitky
12. 4. 2013   #174908

Ano, před vstupem ADC mám sumátor, kde přičítám polovinu reference a následně jí v programu odečítám, takže mohu přivádět i záporné signály. Možná bude problém v tom, že to nezkouším v reálu, ale pouze simulačně v PSpicu, takže možná by mohl být zádrhel zde. Reálně bych pak chtěl krystal 14,745 MHz, USART na 115200 Baudů a data posílat rychlostí 600-800 vzorků za vteřinu přes FT232RL na terminál. Ale abych se vrátil k tématu, kdyby byl nějaký problém s těmi desetinými místy, tak to prostě nechám nezaokrouhlené i když je otázka jak to vlastně potom zjistím.

pro ukázku celý program

C / C++ › Zaokrouhlení na desitky
12. 4. 2013   #174902

Díky, to dělení odzadu mě nenapadlo. Zkusil sem to opravit, ale když dám vypsat jen tři čísla, tak se výsledky pořád záhadně mění. Vypadá to, že se při výpisu bez tisícin někde integruje nějaká chyba...

C / C++ › Zaokrouhlení na desitky
12. 4. 2013   #174889

CPU obluhuje pouze tento ISR, je nastaven po 0,1 sekundách a UART běží na 57600 Baud, s jakou rezervou ISR stíhá to bohužel nevím kde zjistit.

C / C++ › Zaokrouhlení na desitky
12. 4. 2013   #174886

Uvedu jen tu část přerušení, kde dochází k výpočtu a výpisu abych to tu netapetoval, celý kód kdyžtak později.


signed short int u, jednotky, desetiny, setiny, tisiciny;
unsigned long int counter=0;  // 0 - 99999
volatile unsigned short int adc;

ISR(TIMER1_OVF_vect)
{
counter++;
uart_putc('0'+counter/100);
uart_putc('0'+counter%100/10);
uart_putc('0'+counter%10);
uart_putc(';');  // format csv

 u = ((long)adc*4096/1024)+5; 

 if (u>=0) {jednotky=u/1000;}
      else {jednotky=(u*(-1))/1000;}

if (u>=0) {desetiny=(u%1000)/100;}
   else {desetiny=((u*(-1))%1000)/100;}  

if (u>=0) {setiny=((u%1000)%100)/10;}
   else {setiny=(((u*(-1))%1000)%100)/10;}
   
  if (u>=0) {tisiciny=((u%1000)%100)%10;}
       else {tisiciny=(((u*(-1))%1000)%100)%10;}
                
if (u>=0) {uart_putc('+');}
   else {uart_putc('-');}
   
      uart_putc('0'+jednotky);
      uart_putc(',');
      uart_putc('0'+desetiny);
      uart_putc('0'+setiny);
       // uart_putc('0'+tisiciny);
    
      uart_putc(';'); // format csv
      uart_putc(';'); // format csv
      uart_putc(13); //carriage return

C / C++ › Zaokrouhlení na desitky
12. 4. 2013   #174874

Ale teď sem narazil na zajímavý problém související v tím výše, udělal jsem si výpis několika hodnot pomocí seriové linky a zjistil sem, že výsledky se kupodivu neshodují, výpis viz odkaz http://www.imgway.cz/di-J66W.jpg

První sloupec je čas, druhý sloupec jsou původní hodnoty s tisícinama, ve třetím jsem pouze přičetl 5 což odpovídá a ve čtvrtém jsem pouze nevypsal tisíciny toho třetího, avšak hodnoty se místy záhadně odchylují, přitom rozdíl mezi třetím a čtvrtým slupcem je pouze v tom, že jsem zakomentoval výpis tisícin  -  // uart_putc('0'+tisiciny); 

C / C++ › Zaokrouhlení na desitky
12. 4. 2013   #174873

#9 KIIV
Máte pravdu, tu pětku mohu přičíst ke všemu a na výsledek to nemá vliv, takže ten if netřeba, to me nenapadlo, zřejmně sem to měl v hlavě z nějakého jiného případu. Nicméně ten zápis v prvním příspěvku je stejně záhadně nefunkční.

C / C++ › Zaokrouhlení na desitky
11. 4. 2013   #174817

#4 crazy
Nikoliv, má to zaokrouhlovat nahoru i dolu, schválně to rozepíšu ať je to názornější jak jsem to myslel, pro příklad dám hodnoty od 3420-3429, z toho to snad bude pochopitelnější

3420 - jednotky nejsou >=5, nech bejt >>> 3420 >>> 3,42
...

3424 - jednotky nejsou >=5, nech bejt >>> 3424 >>> 3,42
3425 - jednotky jsou >=5, přičti 5 >>> 3430 >>> 3,43
...

3429 - jednotky jsou >=5, přičti 5 >>> 3434 >>> 3,43
3430 - jednotky nejsou >=5, nech bejt >>> 3430 >>> 3,43

a přeformátuju to tak, že přes modulo to rozsekám na cifry a vypíšu to znak po znaku s tím, že mezi stovky a tísíce vložim čárku viz první příspěvek dole. 

C / C++ › Zaokrouhlení na desitky
11. 4. 2013   #174800

   Ahoj, potřebuju čtyřciferné celé číslo zaokrouhlit na tříciferné (ve skutečnosti tisíciny na setiny), vymyslel jsem tento algoritnus, avšak po sobě jdoucí čísla 3422, 3426 dávají najevo, že je něco špatně, logicky bych očekával 3422, 3431. Věděl by někdo co s tím? Díky       

          U=((long)adc*5000/1024);                          // adc=<0;1023>
              if ( (((u%1000)%100)%10) >= 5)  {u+5;}  // otestuj jednotky zda jsou >= 5, případně přičti 5 k U
                 else {U+0;}                                       // v případě < 5 nech původní U

         tisice=U/1000;   //
          // desetina carka
         stovky=(U%1000)/100; //
         desitky=((U%1000)%100)/10; //
            //  jednotky=((U%1000)%100)%10; // potlačeny !

Palkic.89
Mikrokontroléry › Atmega8 - výpočet v ADC
3. 4. 2013   #174369

To znamená, že když nastane Uin=Uref, tak se výstup zarazí o předposlední úroveň, protože je to posunuté do nuly?

Palkic.89
Mikrokontroléry › Atmega8 - výpočet v ADC
3. 4. 2013   #174330

Jak je to prosím s výpočtem výstupní hodnoty z A/D převodníku? Z jedné učebncie elektroniky sem se dočetl, že je to Uin*(2^n-1)/Uref  to by znamenalo, že při 10 bitech by to mělo být 1023, avšak v datasheetu je uvedeno 1024 což se mi zdá divné, protože když nastane Uin=Uref, pak dojde k překročení 10 bitů ne?

Konkrétně: mám referenci 4,096V, jaká bin.hodnota bude na výstupu při vstupu 0V; 2,148V; 4,096V ?

Děkuji za vysvětení.

Mol
Mikrokontroléry › Atmega8 a FT230X
31. 3. 2013   #174186

Dostal jsem ochuzenou verzi známého obvodu FT232RL UART/USB, avšak FT230X pracuje pouze se 3.3V, zatímco Atmega na 5V (nemohu níže kvůli 16MHz), bude tomu FTDIčku TTL vadit nebo je lepší ve směru z megy udělat odporový dělič a srazit ten TXD na cca 3.3V?  Díky

Palkic.89
Mikrokontroléry › Potřebná rychlost USART
2. 1. 2013   #169689

Zdravím potřeboval bych posílat z MEGY8 do PC data ve formátu ±0,00V o rychlosti 1000 hodnot/sec. Dle mých teoretických úvah by to mělo být 6 znaků+carriage return čili 7*(8+startbit+stopbit) takže 70 bitů na řádek*1000 řádků takže 70000 Bd a použil by se 32 násobek základní rychlosti tj. 76800.  Je to tak?  Díky

Palkic.89
Mikrokontroléry › čas za který nastane přeruše…
30. 12. 2012   #169595

Ahoj, potřebuju udělat časování po 1 sec na ATmega8 a použil jsem návod z knížky od V. Váni - Mikrokontroléry AVR programování. Ovšem délka jedné periody není 1 sec jak bych předpokládal, ale 2,9 sec. Mohl by mi někdo kvalifikovaný říct jestli je to opravdu správně? Děkuji :)

TCCR1A=0;
TCCR1B=0b00000100;  // clk/256 (XTAL 8MHz)
TCNT1= 34286;            // 2^16-8000000/256 = 65536-31250 = 34286  
OCR1A=0;
OCR1B=0;
GIMSK=0;
MCUCR=0;
TIMSK=0b00000100;  //  Bit 2 - Overflow Interrupt Enable

ISR(TIMER1_OVF_vect)
{  sec++;  };

 

 

Hostujeme u Českého hostingu       ISSN 1801-1586       ⇡ Nahoru Webtea.cz logo © 20032018 Programujte.com
Zasadilo a pěstuje Webtea.cz, šéfredaktor Lukáš Churý