Можно:
1) Передать в функцию указатель на заполняемый массив и его там заполнять.
2) Создать глобальный массив. Он будет доступен везде.
3) Создать в функции локальный статический массив, заполнять его и возвращать на него указатель.
На мой взгляд, первый вариант самый правильный.
Вопросы по С/С++ (СИ)
Re: Вопросы по С/С++ (СИ)
Аlex Спасибо!, осталось теперь разобраться как это написать 
!
!Re: Вопросы по С/С++ (СИ)
Попробуйте так:RoTToR писал(а):Аlex Спасибо!, осталось теперь разобраться как это написать
Код: Выделить всё
void MyFunc( char* );
char MyArray[8];
char* Pointer = MyArray;
void MyFunc( char* array ){
char i;
for( i = 0; i < 8; i++ ) *array = i;
}
int main(void) {
MyFunc( Pointer );
// .............
Передав указатель на массив в функцию, результатом ее выполнения уже и будет модифицированный массив.
Следовательно, функция может быть и void.
При вызове функции можно и не создавать отдельный указатель, достаточно в нее передать адрес первого элемента массива
Код: Выделить всё
MyFunc( &MyArray[0] );что равноценно.
Много раз упоминавшиеся Керниган и Ричи плюс внимательное чтение их книги.
С уважением,
Виктор.
Виктор.
Re: Вопросы по С/С++ (СИ)
signum писал(а):Вопрос на засыпку как поставить bit флаги, пример bit fl_rg, и подобные не используя "bit", bit работает но флаги ставит в по умолчанию GPIOx.x, компилятор CVAVR, контроллер XMEGA128A1
"PRT SC" в приложении.
Никто не в курсе?
Ладно я Сделал так:
Код: Выделить всё
...
register unsigned char Flag_Reg1 @12, Flag_Reg2 @13;
...
#define START_EXO_TRUE Flag_Reg1 |= 0b00000100
#define RTC_TIMER_TRUE Flag_Reg1 |= 0b00001000
#define in_7sg_TRUE Flag_Reg1 |= 0b00010000
...
#define FL_KEY_0_FALSE Flag_Reg2 &= ~0b00000010
#define FL_KEY_1_FALSE Flag_Reg2 &= ~0b00000100
#define FL_KEY_2_FALSE Flag_Reg2 &= ~0b00001000
...
#define FL_KEY_3_TST if((Flag_Reg2 & 0b00010000) != FALSE)
#define FL_KEY_4_TST if((Flag_Reg2 & 0b00100000) != FALSE)
#define FL_KEY_5_TST if((Flag_Reg2 & 0b01000000) != FALSE)
#define MainTimerFlag_TST if((Flag_Reg2 & 0b10000000) != FALSE)
Но вопрос остаеться открытым.
bit Флаги в GPIOx.x ? какого хрена они там.
-
ibiza11
- Поставщик валерьянки для Кота
- Сообщения: 1900
- Зарегистрирован: Сб фев 21, 2009 13:11:40
- Откуда: Москва
Re: Вопросы по С/С++ (СИ)
честно говоря и первый раз не понял Ваш вопрос.signum писал(а):Но вопрос остаеться открытым.
bit Флаги в GPIOx.x ? какого хрена они там.
Если хотите использовать в качестве флагов однобитные переменные, то предлагаю следующий вариант:
Код: Выделить всё
struct
{
unsigned long AddrSet :1,//флаг того, что в предыдущем цикле был установлен адрес,а теперь нужно вывести данные
bit1 :1,
bit2 :1,
bit3 :1,
bit4 :1;
}Flag;
Flag.bit1 = TRUE;
if(Flag.bit1)
Последний раз редактировалось ibiza11 Чт ноя 29, 2012 10:11:02, всего редактировалось 1 раз.
Ставим плюсы: )
Re: Вопросы по С/С++ (СИ)
Меня в данный момент интересует не реализация флагов, а то что например если в коде делаеш
компилятор делает так:
Листинг этого кода(Используеться SBI "Установить бит в порту")
А вот правильный пример:
Вот в моем случае(Вариант который использую я):
Впорос в том почему флаги ставяться по умолчанию в флаг->GPIOx.x ну или флаг->GPIORx.x , а не допустим в gh->R2.0; ?
Код: Выделить всё
bit d,f,c;компилятор делает так:
Код: Выделить всё
d->GPIO0.0
f->GPIO0.1
c->GPIO0.2
Листинг этого кода(Используеться SBI "Установить бит в порту")
Код: Выделить всё
; 0000 01D2 d = f = c = 1;
SBI 0x0,2
SBI 0x0,1
SBI 0x0,0
А вот правильный пример:
Код: Выделить всё
; 0000 0094 gh =1;
SET
BLD R2,0
; 0000 0095 gh = 0;
CLT
BLD R2,0
Вот в моем случае(Вариант который использую я):
Код: Выделить всё
; 0000 0097 h |= 0b00011000;
LDI R30,LOW(24)
OR R5,R30
; 0000 0098 h &= ~ 0b00010000;
LDI R30,LOW(239)
AND R5,R30
Впорос в том почему флаги ставяться по умолчанию в флаг->GPIOx.x ну или флаг->GPIORx.x , а не допустим в gh->R2.0; ?
Последний раз редактировалось signum Ср ноя 28, 2012 21:08:45, всего редактировалось 1 раз.
Re: Вопросы по С/С++ (СИ)
Спойлер
ibiza11 писал(а):честно говоря и первый раз не понял Ваш вопрос.signum писал(а):Но вопрос остаеться открытым.
bit Флаги в GPIOx.x ? какого хрена они там.
Если хотите использовать в качестве флагов однобитные переменные, то предлагаю следующий вариант:Код: Выделить всё
struct
{
unsigned long AddrSet :1,//флаг того, что в предыдущем цикле был установлен адрес,а теперь нужно вывести данные
NeedLedRefresh :1,//нужно обновить регистры светодиодов
RangePushed :1,//нажата кнопка Зона действия
RangeLong :1,//долго нажата кнопка Зона действия
SoundPushed :1,//нажата кнопка Звуковая сигнализация
SoundLong :1,//долго нажата кнопка Звуковая сигнализация
RangeAndSoundPushed :1,//нажаты обе кнопки Звуковая сигнализация и Зона действия
PacketTout :1,//пришел пакет данных UART
PacketToutEn :1,//включение таймаута приема пакета
CommTout :1,//таймаут связи
CommToutEn :1,//включение счета таймаута связи
SystemTimerEnable :1,//включение отчета времени (секунды, минуты, часы)
SysTimerOverflow :1,//переполнение отчета времени (секунды, минуты, часы)
PerSecond :1,//прошла одна секунда, должен быть обработан и сброшен
HeaderTout :1,//таймаут таймера транспаранта
HeaderEn :1,//включение таймера транспаранта
ForwBufFull :1,//заполнился интервал 1 минута
BckwBufFull :1,//заполнился интервал 1 минута
ForwLong :1,//переполнился интевал 10 минут
BckwLong :1,//переполнился интевал 10 минут
DownCommErr :1,//ошибка межблочной связи
UpCommErr :1,//ошибка межблочной связи
ForwClr :1,//очищен результат вероятности ошибки прямого канала
BckwClr :1,//очищен результат вероятности ошибки обратного канала
CtrlPrev :1,//предыдущий бит "КОНТРОЛЬ"
ModeEn :1,//влючение таймера режима
ModeTout :1,//таймаут таймера режима
ClrReg :1,
SynchrFail :1,//срыв синхронизации по любому из каналов в течение обсчета вероятности ошибки во втором режиме
bit28 :1,
bit29 :1,
bit30 :1,
bit31 :1;
}Flag;
Flag.NeedLedRefresh = TRUE;
if(Flag.NeedLedRefresh)
спас, проверил Вашу реализацию.
Код: Выделить всё
; 0000 005F Flag.bit28 = TRUE;
LDS R30,_Flag
ORI R30,2
STS _Flag,R30
; 0000 0060 if(Flag.bit28){Flag.bit28 = FALSE;}
ANDI R30,LOW(0x2)
BREQ _0xD3
LDS R30,_Flag
ANDI R30,0xFD
STS _Flag,R30
Re: Вопросы по С/С++ (СИ)
как это работает(#include <avr/pgmspace.h>)
непонятны эти дефайны
похоже на асемблерные вставки... только как это пременить и для чего эта либа? как она работаеи О_о
Спойлер
Код: Выделить всё
/* Copyright (c) 2002-2007 Marek Michalkiewicz
Copyright (c) 2006, Carlos Lamas
Copyright (c) 2009-2010, Jan Waclawek
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
* Neither the name of the copyright holders nor the names of
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE. */
/* $Id: pgmspace.h 2241 2011-05-11 12:59:48Z joerg_wunsch $ */
/*
pgmspace.h
Contributors:
Created by Marek Michalkiewicz <marekm@linux.org.pl>
Eric B. Weddington <eric@ecentral.com>
Wolfgang Haidinger <wh@vmars.tuwien.ac.at> (pgm_read_dword())
Ivanov Anton <anton@arc.com.ru> (pgm_read_float())
*/
/** \file */
/** \defgroup avr_pgmspace <avr/pgmspace.h>: Program Space Utilities
\code
#include <avr/io.h>
#include <avr/pgmspace.h>
\endcode
The functions in this module provide interfaces for a program to access
data stored in program space (flash memory) of the device. In order to
use these functions, the target device must support either the \c LPM or
\c ELPM instructions.
\note These functions are an attempt to provide some compatibility with
header files that come with IAR C, to make porting applications between
different compilers easier. This is not 100% compatibility though (GCC
does not have full support for multiple address spaces yet).
\note If you are working with strings which are completely based in ram,
use the standard string functions described in \ref avr_string.
\note If possible, put your constant tables in the lower 64 KB and use
pgm_read_byte_near() or pgm_read_word_near() instead of
pgm_read_byte_far() or pgm_read_word_far() since it is more efficient that
way, and you can still use the upper 64K for executable code.
All functions that are suffixed with a \c _P \e require their
arguments to be in the lower 64 KB of the flash ROM, as they do
not use ELPM instructions. This is normally not a big concern as
the linker setup arranges any program space constants declared
using the macros from this header file so they are placed right after
the interrupt vectors, and in front of any executable code. However,
it can become a problem if there are too many of these constants, or
for bootloaders on devices with more than 64 KB of ROM.
<em>All these functions will not work in that situation.</em>
\note For <b>Xmega</b> devices, make sure the NVM controller
command register (\c NVM.CMD or \c NVM_CMD) is set to 0x00 (NOP)
before using any of these functions.
*/
#ifndef __PGMSPACE_H_
#define __PGMSPACE_H_ 1
#define __need_size_t
#include <inttypes.h>
#include <stddef.h>
#include <avr/io.h>
#ifndef __ATTR_CONST__
#define __ATTR_CONST__ __attribute__((__const__))
#endif
#ifndef __ATTR_PROGMEM__
#define __ATTR_PROGMEM__ __attribute__((__progmem__))
#endif
#ifndef __ATTR_PURE__
#define __ATTR_PURE__ __attribute__((__pure__))
#endif
/**
\ingroup avr_pgmspace
\def PROGMEM
Attribute to use in order to declare an object being located in
flash ROM.
*/
#define PROGMEM __ATTR_PROGMEM__
#ifdef __cplusplus
extern "C" {
#endif
#if defined(__DOXYGEN__)
/*
* Doxygen doesn't grok the appended attribute syntax of
* GCC, and confuses the typedefs with function decls, so
* supply a doxygen-friendly view.
*/
/**
\ingroup avr_pgmspace
\typedef prog_void
Type of a "void" object located in flash ROM. Does not make much
sense by itself, but can be used to declare a "void *" object in
flash ROM.
*/
typedef void PROGMEM prog_void;
/**
\ingroup avr_pgmspace
\typedef prog_char
Type of a "char" object located in flash ROM.
*/
typedef char PROGMEM prog_char;
/**
\ingroup avr_pgmspace
\typedef prog_uchar
Type of an "unsigned char" object located in flash ROM.
*/
typedef unsigned char PROGMEM prog_uchar;
/**
\ingroup avr_pgmspace
\typedef prog_int8_t
Type of an "int8_t" object located in flash ROM.
*/
typedef int8_t PROGMEM prog_int8_t;
/**
\ingroup avr_pgmspace
\typedef prog_uint8_t
Type of an "uint8_t" object located in flash ROM.
*/
typedef uint8_t PROGMEM prog_uint8_t;
/**
\ingroup avr_pgmspace
\typedef prog_int16_t
Type of an "int16_t" object located in flash ROM.
*/
typedef int16_t PROGMEM prog_int16_t;
/**
\ingroup avr_pgmspace
\typedef prog_uint16_t
Type of an "uint16_t" object located in flash ROM.
*/
typedef uint16_t PROGMEM prog_uint16_t;
/**
\ingroup avr_pgmspace
\typedef prog_int32_t
Type of an "int32_t" object located in flash ROM.
*/
typedef int32_t PROGMEM prog_int32_t;
/**
\ingroup avr_pgmspace
\typedef prog_uint32_t
Type of an "uint32_t" object located in flash ROM.
*/
typedef uint32_t PROGMEM prog_uint32_t;
/**
\ingroup avr_pgmspace
\typedef prog_int64_t
Type of an "int64_t" object located in flash ROM.
\note This type is not available when the compiler
option -mint8 is in effect.
*/
typedef int64_t PROGMEM prog_int64_t;
/**
\ingroup avr_pgmspace
\typedef prog_uint64_t
Type of an "uint64_t" object located in flash ROM.
\note This type is not available when the compiler
option -mint8 is in effect.
*/
typedef uint64_t PROGMEM prog_uint64_t;
#else /* !DOXYGEN */
typedef void prog_void PROGMEM;
typedef char prog_char PROGMEM;
typedef unsigned char prog_uchar PROGMEM;
typedef int8_t prog_int8_t PROGMEM;
typedef uint8_t prog_uint8_t PROGMEM;
typedef int16_t prog_int16_t PROGMEM;
typedef uint16_t prog_uint16_t PROGMEM;
typedef int32_t prog_int32_t PROGMEM;
typedef uint32_t prog_uint32_t PROGMEM;
#if !__USING_MINT8
typedef int64_t prog_int64_t PROGMEM;
typedef uint64_t prog_uint64_t PROGMEM;
#endif
#endif /* defined(__DOXYGEN__) */
/* Although in C, we can get away with just using __c, it does not work in
C++. We need to use &__c[0] to avoid the compiler puking. Dave Hylands
explaned it thusly,
Let's suppose that we use PSTR("Test"). In this case, the type returned
by __c is a prog_char[5] and not a prog_char *. While these are
compatible, they aren't the same thing (especially in C++). The type
returned by &__c[0] is a prog_char *, which explains why it works
fine. */
#if defined(__DOXYGEN__)
/*
* The #define below is just a dummy that serves documentation
* purposes only.
*/
/** \ingroup avr_pgmspace
\def PSTR(s)
Used to declare a static pointer to a string in program space. */
# define PSTR(s) ((const PROGMEM char *)(s))
#else /* !DOXYGEN */
/* The real thing. */
# define PSTR(s) (__extension__({static const char __c[] PROGMEM = (s); &__c[0];}))
#endif /* DOXYGEN */
#define __LPM_classic__(addr) \
(__extension__({ \
uint16_t __addr16 = (uint16_t)(addr); \
uint8_t __result; \
__asm__ \
( \
"lpm" "\n\t" \
"mov %0, r0" "\n\t" \
: "=r" (__result) \
: "z" (__addr16) \
: "r0" \
); \
__result; \
}))
#define __LPM_enhanced__(addr) \
(__extension__({ \
uint16_t __addr16 = (uint16_t)(addr); \
uint8_t __result; \
__asm__ \
( \
"lpm %0, Z" "\n\t" \
: "=r" (__result) \
: "z" (__addr16) \
); \
__result; \
}))
#define __LPM_word_classic__(addr) \
(__extension__({ \
uint16_t __addr16 = (uint16_t)(addr); \
uint16_t __result; \
__asm__ \
( \
"lpm" "\n\t" \
"mov %A0, r0" "\n\t" \
"adiw r30, 1" "\n\t" \
"lpm" "\n\t" \
"mov %B0, r0" "\n\t" \
: "=r" (__result), "=z" (__addr16) \
: "1" (__addr16) \
: "r0" \
); \
__result; \
}))
#define __LPM_word_enhanced__(addr) \
(__extension__({ \
uint16_t __addr16 = (uint16_t)(addr); \
uint16_t __result; \
__asm__ \
( \
"lpm %A0, Z+" "\n\t" \
"lpm %B0, Z" "\n\t" \
: "=r" (__result), "=z" (__addr16) \
: "1" (__addr16) \
); \
__result; \
}))
#define __LPM_dword_classic__(addr) \
(__extension__({ \
uint16_t __addr16 = (uint16_t)(addr); \
uint32_t __result; \
__asm__ \
( \
"lpm" "\n\t" \
"mov %A0, r0" "\n\t" \
"adiw r30, 1" "\n\t" \
"lpm" "\n\t" \
"mov %B0, r0" "\n\t" \
"adiw r30, 1" "\n\t" \
"lpm" "\n\t" \
"mov %C0, r0" "\n\t" \
"adiw r30, 1" "\n\t" \
"lpm" "\n\t" \
"mov %D0, r0" "\n\t" \
: "=r" (__result), "=z" (__addr16) \
: "1" (__addr16) \
: "r0" \
); \
__result; \
}))
#define __LPM_dword_enhanced__(addr) \
(__extension__({ \
uint16_t __addr16 = (uint16_t)(addr); \
uint32_t __result; \
__asm__ \
( \
"lpm %A0, Z+" "\n\t" \
"lpm %B0, Z+" "\n\t" \
"lpm %C0, Z+" "\n\t" \
"lpm %D0, Z" "\n\t" \
: "=r" (__result), "=z" (__addr16) \
: "1" (__addr16) \
); \
__result; \
}))
#define __LPM_float_classic__(addr) \
(__extension__({ \
uint16_t __addr16 = (uint16_t)(addr); \
float __result; \
__asm__ \
( \
"lpm" "\n\t" \
"mov %A0, r0" "\n\t" \
"adiw r30, 1" "\n\t" \
"lpm" "\n\t" \
"mov %B0, r0" "\n\t" \
"adiw r30, 1" "\n\t" \
"lpm" "\n\t" \
"mov %C0, r0" "\n\t" \
"adiw r30, 1" "\n\t" \
"lpm" "\n\t" \
"mov %D0, r0" "\n\t" \
: "=r" (__result), "=z" (__addr16) \
: "1" (__addr16) \
: "r0" \
); \
__result; \
}))
#define __LPM_float_enhanced__(addr) \
(__extension__({ \
uint16_t __addr16 = (uint16_t)(addr); \
float __result; \
__asm__ \
( \
"lpm %A0, Z+" "\n\t" \
"lpm %B0, Z+" "\n\t" \
"lpm %C0, Z+" "\n\t" \
"lpm %D0, Z" "\n\t" \
: "=r" (__result), "=z" (__addr16) \
: "1" (__addr16) \
); \
__result; \
}))
#if defined (__AVR_HAVE_LPMX__)
#define __LPM(addr) __LPM_enhanced__(addr)
#define __LPM_word(addr) __LPM_word_enhanced__(addr)
#define __LPM_dword(addr) __LPM_dword_enhanced__(addr)
#define __LPM_float(addr) __LPM_float_enhanced__(addr)
#else
#define __LPM(addr) __LPM_classic__(addr)
#define __LPM_word(addr) __LPM_word_classic__(addr)
#define __LPM_dword(addr) __LPM_dword_classic__(addr)
#define __LPM_float(addr) __LPM_float_classic__(addr)
#endif
/** \ingroup avr_pgmspace
\def pgm_read_byte_near(address_short)
Read a byte from the program space with a 16-bit (near) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_byte_near(address_short) __LPM((uint16_t)(address_short))
/** \ingroup avr_pgmspace
\def pgm_read_word_near(address_short)
Read a word from the program space with a 16-bit (near) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_word_near(address_short) __LPM_word((uint16_t)(address_short))
/** \ingroup avr_pgmspace
\def pgm_read_dword_near(address_short)
Read a double word from the program space with a 16-bit (near) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_dword_near(address_short) \
__LPM_dword((uint16_t)(address_short))
/** \ingroup avr_pgmspace
\def pgm_read_float_near(address_short)
Read a float from the program space with a 16-bit (near) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_float_near(address_short) \
__LPM_float((uint16_t)(address_short))
#if defined(RAMPZ) || defined(__DOXYGEN__)
/* Only for devices with more than 64K of program memory.
RAMPZ must be defined (see iom103.h, iom128.h).
*/
/* The classic functions are needed for ATmega103. */
#define __ELPM_classic__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint8_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"mov r31, %B1" "\n\t" \
"mov r30, %A1" "\n\t" \
"elpm" "\n\t" \
"mov %0, r0" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r0", "r30", "r31" \
); \
__result; \
}))
#define __ELPM_enhanced__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint8_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %0, Z+" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_xmega__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint8_t __result; \
__asm__ \
( \
"in __tmp_reg__, %2" "\n\t" \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %0, Z+" "\n\t" \
"out %2, __tmp_reg__" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_word_classic__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint16_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"mov r31, %B1" "\n\t" \
"mov r30, %A1" "\n\t" \
"elpm" "\n\t" \
"mov %A0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %B0, r0" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r0", "r30", "r31" \
); \
__result; \
}))
#define __ELPM_word_enhanced__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint16_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_word_xmega__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint16_t __result; \
__asm__ \
( \
"in __tmp_reg__, %2" "\n\t" \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z" "\n\t" \
"out %2, __tmp_reg__" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_dword_classic__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint32_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"mov r31, %B1" "\n\t" \
"mov r30, %A1" "\n\t" \
"elpm" "\n\t" \
"mov %A0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %B0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %C0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %D0, r0" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r0", "r30", "r31" \
); \
__result; \
}))
#define __ELPM_dword_enhanced__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint32_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z+" "\n\t" \
"elpm %C0, Z+" "\n\t" \
"elpm %D0, Z" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_dword_xmega__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint32_t __result; \
__asm__ \
( \
"in __tmp_reg__, %2" "\n\t" \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z+" "\n\t" \
"elpm %C0, Z+" "\n\t" \
"elpm %D0, Z" "\n\t" \
"out %2, __tmp_reg__" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_float_classic__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
float __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"mov r31, %B1" "\n\t" \
"mov r30, %A1" "\n\t" \
"elpm" "\n\t" \
"mov %A0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %B0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %C0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %D0, r0" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r0", "r30", "r31" \
); \
__result; \
}))
#define __ELPM_float_enhanced__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
float __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z+" "\n\t" \
"elpm %C0, Z+" "\n\t" \
"elpm %D0, Z" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_float_xmega__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
float __result; \
__asm__ \
( \
"in __tmp_reg__, %2" "\n\t" \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z+" "\n\t" \
"elpm %C0, Z+" "\n\t" \
"elpm %D0, Z" "\n\t" \
"out %2, __tmp_reg__" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
/*
Check for architectures that implement RAMPD (avrxmega3, avrxmega5,
avrxmega7) as they need to save/restore RAMPZ for ELPM macros so it does
not interfere with data accesses.
*/
#if defined (__AVR_HAVE_RAMPD__)
#define __ELPM(addr) __ELPM_xmega__(addr)
#define __ELPM_word(addr) __ELPM_word_xmega__(addr)
#define __ELPM_dword(addr) __ELPM_dword_xmega__(addr)
#define __ELPM_float(addr) __ELPM_float_xmega__(addr)
#else
#if defined (__AVR_HAVE_LPMX__)
#define __ELPM(addr) __ELPM_enhanced__(addr)
#define __ELPM_word(addr) __ELPM_word_enhanced__(addr)
#define __ELPM_dword(addr) __ELPM_dword_enhanced__(addr)
#define __ELPM_float(addr) __ELPM_float_enhanced__(addr)
#else
#define __ELPM(addr) __ELPM_classic__(addr)
#define __ELPM_word(addr) __ELPM_word_classic__(addr)
#define __ELPM_dword(addr) __ELPM_dword_classic__(addr)
#define __ELPM_float(addr) __ELPM_float_classic__(addr)
#endif /* __AVR_HAVE_LPMX__ */
#endif /* __AVR_HAVE_RAMPD__ */
/** \ingroup avr_pgmspace
\def pgm_read_byte_far(address_long)
Read a byte from the program space with a 32-bit (far) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_byte_far(address_long) __ELPM((uint32_t)(address_long))
/** \ingroup avr_pgmspace
\def pgm_read_word_far(address_long)
Read a word from the program space with a 32-bit (far) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_word_far(address_long) __ELPM_word((uint32_t)(address_long))
/** \ingroup avr_pgmspace
\def pgm_read_dword_far(address_long)
Read a double word from the program space with a 32-bit (far) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_dword_far(address_long) __ELPM_dword((uint32_t)(address_long))
/** \ingroup avr_pgmspace
\def pgm_read_float_far(address_long)
Read a float from the program space with a 32-bit (far) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_float_far(address_long) __ELPM_float((uint32_t)(address_long))
#endif /* RAMPZ or __DOXYGEN__ */
/** \ingroup avr_pgmspace
\def pgm_read_byte(address_short)
Read a byte from the program space with a 16-bit (near) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_byte(address_short) pgm_read_byte_near(address_short)
/** \ingroup avr_pgmspace
\def pgm_read_word(address_short)
Read a word from the program space with a 16-bit (near) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_word(address_short) pgm_read_word_near(address_short)
/** \ingroup avr_pgmspace
\def pgm_read_dword(address_short)
Read a double word from the program space with a 16-bit (near) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_dword(address_short) pgm_read_dword_near(address_short)
/** \ingroup avr_pgmspace
\def pgm_read_float(address_short)
Read a float from the program space with a 16-bit (near) address.
\note The address is a byte address.
The address is in the program space. */
#define pgm_read_float(address_short) pgm_read_float_near(address_short)
/** \ingroup avr_pgmspace
\def PGM_P
Used to declare a variable that is a pointer to a string in program
space. */
#ifndef PGM_P
#define PGM_P const prog_char *
#endif
/** \ingroup avr_pgmspace
\def PGM_VOID_P
Used to declare a generic pointer to an object in program space. */
#ifndef PGM_VOID_P
#define PGM_VOID_P const prog_void *
#endif
/* pgm_get_far_address() macro
This macro facilitates the obtention of a 32 bit "far" pointer (only 24 bits
used) to data even passed the 64KB limit for the 16 bit ordinary pointer. It
is similar to the '&' operator, with some limitations.
Comments:
- The overhead is minimal and it's mainly due to the 32 bit size operation.
- 24 bit sizes guarantees the code compatibility for use in future devices.
- hh8() is an undocumented feature but seems to give the third significant byte
of a 32 bit data and accepts symbols, complementing the functionality of hi8()
and lo8(). There is not an equivalent assembler function to get the high
significant byte.
- 'var' has to be resolved at linking time as an existing symbol, i.e, a simple
type variable name, an array name (not an indexed element of the array, if the
index is a constant the compiler does not complain but fails to get the address
if optimization is enabled), a struct name or a struct field name, a function
identifier, a linker defined identifier,...
- The returned value is the identifier's VMA (virtual memory address) determined
by the linker and falls in the corresponding memory region. The AVR Harvard
architecture requires non overlapping VMA areas for the multiple address spaces
in the processor: Flash ROM, RAM, and EEPROM. Typical offset for this are
0x00000000, 0x00800xx0, and 0x00810000 respectively, derived from the linker
script used and linker options. The value returned can be seen then as a
universal pointer.
*/
#define pgm_get_far_address(var) \
({ \
uint_farptr_t tmp; \
\
__asm__ __volatile__( \
\
"ldi %A0, lo8(%1)" "\n\t" \
"ldi %B0, hi8(%1)" "\n\t" \
"ldi %C0, hh8(%1)" "\n\t" \
"clr %D0" "\n\t" \
: \
"=d" (tmp) \
: \
"p" (&(var)) \
); \
tmp; \
})
extern PGM_VOID_P memchr_P(PGM_VOID_P, int __val, size_t __len) __ATTR_CONST__;
extern int memcmp_P(const void *, PGM_VOID_P, size_t) __ATTR_PURE__;
extern void *memccpy_P(void *, PGM_VOID_P, int __val, size_t);
extern void *memcpy_P(void *, PGM_VOID_P, size_t);
extern void *memmem_P(const void *, size_t, PGM_VOID_P, size_t) __ATTR_PURE__;
extern PGM_VOID_P memrchr_P(PGM_VOID_P, int __val, size_t __len) __ATTR_CONST__;
extern char *strcat_P(char *, PGM_P);
extern PGM_P strchr_P(PGM_P, int __val) __ATTR_CONST__;
extern PGM_P strchrnul_P(PGM_P, int __val) __ATTR_CONST__;
extern int strcmp_P(const char *, PGM_P) __ATTR_PURE__;
extern char *strcpy_P(char *, PGM_P);
extern int strcasecmp_P(const char *, PGM_P) __ATTR_PURE__;
extern char *strcasestr_P(const char *, PGM_P) __ATTR_PURE__;
extern size_t strcspn_P(const char *__s, PGM_P __reject) __ATTR_PURE__;
extern size_t strlcat_P (char *, PGM_P, size_t );
extern size_t strlcpy_P (char *, PGM_P, size_t );
extern size_t __strlen_P(PGM_P) __ATTR_CONST__; /* program memory can't change */
extern size_t strnlen_P(PGM_P, size_t) __ATTR_CONST__; /* program memory can't change */
extern int strncmp_P(const char *, PGM_P, size_t) __ATTR_PURE__;
extern int strncasecmp_P(const char *, PGM_P, size_t) __ATTR_PURE__;
extern char *strncat_P(char *, PGM_P, size_t);
extern char *strncpy_P(char *, PGM_P, size_t);
extern char *strpbrk_P(const char *__s, PGM_P __accept) __ATTR_PURE__;
extern PGM_P strrchr_P(PGM_P, int __val) __ATTR_CONST__;
extern char *strsep_P(char **__sp, PGM_P __delim);
extern size_t strspn_P(const char *__s, PGM_P __accept) __ATTR_PURE__;
extern char *strstr_P(const char *, PGM_P) __ATTR_PURE__;
extern char *strtok_P(char *__s, PGM_P __delim);
extern char *strtok_rP(char *__s, PGM_P __delim, char **__last);
extern size_t strlen_PF (uint_farptr_t src) __ATTR_CONST__; /* program memory can't change */
extern size_t strnlen_PF (uint_farptr_t src, size_t len) __ATTR_CONST__; /* program memory can't change */
extern void *memcpy_PF (void *dest, uint_farptr_t src, size_t len);
extern char *strcpy_PF (char *dest, uint_farptr_t src);
extern char *strncpy_PF (char *dest, uint_farptr_t src, size_t len);
extern char *strcat_PF (char *dest, uint_farptr_t src);
extern size_t strlcat_PF (char *dst, uint_farptr_t src, size_t siz);
extern char *strncat_PF (char *dest, uint_farptr_t src, size_t len);
extern int strcmp_PF (const char *s1, uint_farptr_t s2) __ATTR_PURE__;
extern int strncmp_PF (const char *s1, uint_farptr_t s2, size_t n) __ATTR_PURE__;
extern int strcasecmp_PF (const char *s1, uint_farptr_t s2) __ATTR_PURE__;
extern int strncasecmp_PF (const char *s1, uint_farptr_t s2, size_t n) __ATTR_PURE__;
extern char *strstr_PF (const char *s1, uint_farptr_t s2);
extern size_t strlcpy_PF (char *dst, uint_farptr_t src, size_t siz);
extern int memcmp_PF(const void *, uint_farptr_t, size_t) __ATTR_PURE__;
__attribute__((__always_inline__)) static inline size_t strlen_P(PGM_P s);
static inline size_t strlen_P(PGM_P s) {
return __builtin_constant_p(__builtin_strlen(s))
? __builtin_strlen(s) : __strlen_P(s);
}
#ifdef __cplusplus
}
#endif
#endif /* __PGMSPACE_H_ */
непонятны эти дефайны
Спойлер
Код: Выделить всё
#define __ELPM_classic__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint8_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"mov r31, %B1" "\n\t" \
"mov r30, %A1" "\n\t" \
"elpm" "\n\t" \
"mov %0, r0" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r0", "r30", "r31" \
); \
__result; \
}))
#define __ELPM_enhanced__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint8_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %0, Z+" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_xmega__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint8_t __result; \
__asm__ \
( \
"in __tmp_reg__, %2" "\n\t" \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %0, Z+" "\n\t" \
"out %2, __tmp_reg__" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_word_classic__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint16_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"mov r31, %B1" "\n\t" \
"mov r30, %A1" "\n\t" \
"elpm" "\n\t" \
"mov %A0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %B0, r0" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r0", "r30", "r31" \
); \
__result; \
}))
#define __ELPM_word_enhanced__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint16_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_word_xmega__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint16_t __result; \
__asm__ \
( \
"in __tmp_reg__, %2" "\n\t" \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z" "\n\t" \
"out %2, __tmp_reg__" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_dword_classic__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint32_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"mov r31, %B1" "\n\t" \
"mov r30, %A1" "\n\t" \
"elpm" "\n\t" \
"mov %A0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %B0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %C0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %D0, r0" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r0", "r30", "r31" \
); \
__result; \
}))
#define __ELPM_dword_enhanced__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint32_t __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z+" "\n\t" \
"elpm %C0, Z+" "\n\t" \
"elpm %D0, Z" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_dword_xmega__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
uint32_t __result; \
__asm__ \
( \
"in __tmp_reg__, %2" "\n\t" \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z+" "\n\t" \
"elpm %C0, Z+" "\n\t" \
"elpm %D0, Z" "\n\t" \
"out %2, __tmp_reg__" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_float_classic__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
float __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"mov r31, %B1" "\n\t" \
"mov r30, %A1" "\n\t" \
"elpm" "\n\t" \
"mov %A0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %B0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %C0, r0" "\n\t" \
"in r0, %2" "\n\t" \
"adiw r30, 1" "\n\t" \
"adc r0, __zero_reg__" "\n\t" \
"out %2, r0" "\n\t" \
"elpm" "\n\t" \
"mov %D0, r0" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r0", "r30", "r31" \
); \
__result; \
}))
#define __ELPM_float_enhanced__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
float __result; \
__asm__ \
( \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z+" "\n\t" \
"elpm %C0, Z+" "\n\t" \
"elpm %D0, Z" "\n\t" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
}))
#define __ELPM_float_xmega__(addr) \
(__extension__({ \
uint32_t __addr32 = (uint32_t)(addr); \
float __result; \
__asm__ \
( \
"in __tmp_reg__, %2" "\n\t" \
"out %2, %C1" "\n\t" \
"movw r30, %1" "\n\t" \
"elpm %A0, Z+" "\n\t" \
"elpm %B0, Z+" "\n\t" \
"elpm %C0, Z+" "\n\t" \
"elpm %D0, Z" "\n\t" \
"out %2, __tmp_reg__" \
: "=r" (__result) \
: "r" (__addr32), \
"I" (_SFR_IO_ADDR(RAMPZ)) \
: "r30", "r31" \
); \
__result; \
})) похоже на асемблерные вставки... только как это пременить и для чего эта либа? как она работаеи О_о
Re: Вопросы по С/С++ (СИ)
mastech, с английским туго или ещё что? 
Почти в самом верху файла из первого спойлера:
data stored in program space (flash memory) of the device. In order to
use these functions, the target device must support either the LPM or
ELPM instructions. Дальше читать описание системы команд 8-bit AVR на тему LPM и ELPM.
Почти в самом верху файла из первого спойлера:
Спойлер
The functions in this module provide interfaces for a program to accessdata stored in program space (flash memory) of the device. In order to
use these functions, the target device must support either the LPM or
ELPM instructions.
Когда уже ничего не помогает - прочтите, наконец, инструкцию.
Лучший оптимизатор находится у вас между ушей. (Майкл Абраш, программист Quake и QuakeII)
Избыток информации ведёт к оскудению души - Леонтьев А. (сказано в 1965 г.)
Лучший оптимизатор находится у вас между ушей. (Майкл Абраш, программист Quake и QuakeII)
Избыток информации ведёт к оскудению души - Леонтьев А. (сказано в 1965 г.)
Re: Вопросы по С/С++ (СИ)
Kavka Спасибо за пинок под зад Буду внимательней)
Буду внимательней)Re: Вопросы по С/С++ (СИ)
Ребят, кто может помочь с USART на си ?
-
Goldsmith
- Опытный кот
- Сообщения: 736
- Зарегистрирован: Пн янв 10, 2011 03:06:36
- Откуда: Ростов-на-Дону
- Контактная информация:
Re: Вопросы по С/С++ (СИ)
Datasheet.
Любой дурак может писать код. Настоящий профессионал - это тот, кто способен постоянно создавать продукт высокого качества, укладываясь при этом в бюджет.
J. Ganssle
J. Ganssle
-
vitalik_1984
- Поставщик валерьянки для Кота
- Сообщения: 2482
- Зарегистрирован: Пт авг 27, 2010 05:57:06
- Откуда: Тюмень
- Контактная информация:
Re: Вопросы по С/С++ (СИ)
drac0Sha писал(а):Ребят, кто может помочь с USART на си ?
Много кто может помочь, только мало у кого есть желание. Слишком размытый вопрос, нужно как минимум знать камень, далее неплохо бы каким компилятором собирается программа.
Как то так.И еще не все, при полном сознании двух этих параметров так же нужно убедить присутствующих, что объяснения на пальцах не будут как об стенку горох. Для этого нужно предоставить публике начало работы хотя бы по просмотру того же datasheet, что непонятно всегда подскажут.
Re: Вопросы по С/С++ (СИ)
Поясните плиз, код из даташита для тини13: EECR=(0<<EEPM1)|(0>>EEPM0);// Set program mode
Первое - cbi(EECR,EEPM1). Второе - непонятно. cbi(EECR,EEPM0)???
То есть аналогичная запись получается просто EECR=0?
Или тут присутствуют какие-то подводные камни?
Первое - cbi(EECR,EEPM1). Второе - непонятно. cbi(EECR,EEPM0)???
То есть аналогичная запись получается просто EECR=0?
Или тут присутствуют какие-то подводные камни?
Re: Вопросы по С/С++ (СИ)
Это просто опечатка...
Должно быть...
Должно быть...
Код: Выделить всё
/* Set Programming mode */
EECR = (0<<EEPM1)|(0<<EEPM0)
"Я не даю готовых решений, я заставляю думать!"(С)
Re: Вопросы по С/С++ (СИ)
Да нет, не опечатка, у меня прога именно с таким кодом отлично работает. Проверенно в протеусе. Мне непонятно что именно этот код делает. Разобрался, просто EECR=0b00000000.
//Подпрограмма записи байта в энергонезависимую память
////////////////////////////////////////////////////////////////////////////////////////////
static void EEPROM_write( BYTE ucAdr, BYTE ucData){
while (EECR & (1<<EEPE));// Wait previous write
EECR=(0<<EEPM1)|(0>>EEPM0);// Set program mode
EEARL=ucAdr;
EEDR=ucData;
BYTE cSREG=SREG;//store interrupts state
cli();//disable interrupts
sbi(EECR,EEMPE);// write 1 to EEMPE
sbi(EECR,EEPE);// start EEPROM write by setting EEPE
SREG=cSREG;//restore interrupts state
}
Дизасемблерная часть:
static void EEPROM_write( BYTE ucAdr, BYTE ucData){
while (EECR & (1<<EEPE));// Wait previous write
258: e1 99 sbic 0x1c, 1 ; 28
25a: fe cf rjmp .-4 ; 0x258 <main+0xba>
EECR=(0<<EEPM1)|(0>>EEPM0);// Set program mode
25c: 1c ba out 0x1c, r1 ; 28
EEARL=ucAdr;
25e: 1e ba out 0x1e, r1 ; 30
EEDR=ucData;
260: 6d bb out 0x1d, r22 ; 29
BYTE cSREG=SREG;//store interrupts state
262: 8f b7 in r24, 0x3f ; 63
cli();//disable interrupts
264: f8 94 cli
sbi(EECR,EEMPE);// write 1 to EEMPE
266: e2 9a sbi 0x1c, 2 ; 28
sbi(EECR,EEPE);// start EEPROM write by setting EEPE
268: e1 9a sbi 0x1c, 1 ; 28
SREG=cSREG;//restore interrupts state
26a: 8f bf out 0x3f, r24 ; 63
26c: 3f ef ldi r19, 0xFF ; 255
Тут мне многое непонятно, похоже компилятор как-то оптимизирует этот участок кода, тк EEPROM_write я вызываю всего 2 раза.
EEPROM_write(0,pwm1); //Записываем значение скважности ШИМ ДХО в энергонезависимую память
EEPROM_write(1,plafon_pwm_linear);//Записываем значение линейности затухания в энергонезависимую память
Видно что регистр r1 записыватся и в EECR и в EEARL. Но в EEARL передается адрес сначала 0, потом 1. Получается что и в EECR тоже то 0 то 1. При этом прошивка получается абсолютно рабочая. Готовое реальное устройство записывает и читает еепром нормально.
Непонятно.
Регистр EECR по даташиту:
0x1C EECR – – EEPM1 EEPM0 EERIE EEMWE EEWE EERE
Наверно winavr оптимизировал код так, что когда передается адрес=0х01, в EECR выствляется бит в EERE, что не мешает вести опецию записи в еепром...
УПС... Тут оказывается еще 2 участок кода присутствует
////////////////////////////////////////////////////////////////////////////////////////////
//Подпрограмма записи байта в энергонезависимую память
////////////////////////////////////////////////////////////////////////////////////////////
static void EEPROM_write( BYTE ucAdr, BYTE ucData){
while (EECR & (1<<EEPE));// Wait previous write
2c0: e1 99 sbic 0x1c, 1 ; 28
2c2: fe cf rjmp .-4 ; 0x2c0 <main+0x122>
EECR=(0<<EEPM1)|(0>>EEPM0);// Set program mode
2c4: 1c ba out 0x1c, r1 ; 28
EEARL=ucAdr;
2c6: be bb out 0x1e, r27 ; 30
EEDR=ucData;
2c8: 8d bb out 0x1d, r24 ; 29
BYTE cSREG=SREG;//store interrupts state
2ca: 8f b7 in r24, 0x3f ; 63
cli();//disable interrupts
2cc: f8 94 cli
sbi(EECR,EEMPE);// write 1 to EEMPE
2ce: e2 9a sbi 0x1c, 2 ; 28
sbi(EECR,EEPE);// start EEPROM write by setting EEPE
2d0: e1 9a sbi 0x1c, 1 ; 28
SREG=cSREG;//restore interrupts state
2d2: 8f bf out 0x3f, r24 ; 63
Теперь всё понял. в EECR всегда пишется 0.
Спойлер
//////////////////////////////////////////////////////////////////////////////////////////////Подпрограмма записи байта в энергонезависимую память
////////////////////////////////////////////////////////////////////////////////////////////
static void EEPROM_write( BYTE ucAdr, BYTE ucData){
while (EECR & (1<<EEPE));// Wait previous write
EECR=(0<<EEPM1)|(0>>EEPM0);// Set program mode
EEARL=ucAdr;
EEDR=ucData;
BYTE cSREG=SREG;//store interrupts state
cli();//disable interrupts
sbi(EECR,EEMPE);// write 1 to EEMPE
sbi(EECR,EEPE);// start EEPROM write by setting EEPE
SREG=cSREG;//restore interrupts state
}
Дизасемблерная часть:
static void EEPROM_write( BYTE ucAdr, BYTE ucData){
while (EECR & (1<<EEPE));// Wait previous write
258: e1 99 sbic 0x1c, 1 ; 28
25a: fe cf rjmp .-4 ; 0x258 <main+0xba>
EECR=(0<<EEPM1)|(0>>EEPM0);// Set program mode
25c: 1c ba out 0x1c, r1 ; 28
EEARL=ucAdr;
25e: 1e ba out 0x1e, r1 ; 30
EEDR=ucData;
260: 6d bb out 0x1d, r22 ; 29
BYTE cSREG=SREG;//store interrupts state
262: 8f b7 in r24, 0x3f ; 63
cli();//disable interrupts
264: f8 94 cli
sbi(EECR,EEMPE);// write 1 to EEMPE
266: e2 9a sbi 0x1c, 2 ; 28
sbi(EECR,EEPE);// start EEPROM write by setting EEPE
268: e1 9a sbi 0x1c, 1 ; 28
SREG=cSREG;//restore interrupts state
26a: 8f bf out 0x3f, r24 ; 63
26c: 3f ef ldi r19, 0xFF ; 255
Тут мне многое непонятно, похоже компилятор как-то оптимизирует этот участок кода, тк EEPROM_write я вызываю всего 2 раза.
EEPROM_write(0,pwm1); //Записываем значение скважности ШИМ ДХО в энергонезависимую память
EEPROM_write(1,plafon_pwm_linear);//Записываем значение линейности затухания в энергонезависимую память
Видно что регистр r1 записыватся и в EECR и в EEARL. Но в EEARL передается адрес сначала 0, потом 1. Получается что и в EECR тоже то 0 то 1. При этом прошивка получается абсолютно рабочая. Готовое реальное устройство записывает и читает еепром нормально.
Непонятно.
Регистр EECR по даташиту:
0x1C EECR – – EEPM1 EEPM0 EERIE EEMWE EEWE EERE
Наверно winavr оптимизировал код так, что когда передается адрес=0х01, в EECR выствляется бит в EERE, что не мешает вести опецию записи в еепром...
УПС... Тут оказывается еще 2 участок кода присутствует
////////////////////////////////////////////////////////////////////////////////////////////
//Подпрограмма записи байта в энергонезависимую память
////////////////////////////////////////////////////////////////////////////////////////////
static void EEPROM_write( BYTE ucAdr, BYTE ucData){
while (EECR & (1<<EEPE));// Wait previous write
2c0: e1 99 sbic 0x1c, 1 ; 28
2c2: fe cf rjmp .-4 ; 0x2c0 <main+0x122>
EECR=(0<<EEPM1)|(0>>EEPM0);// Set program mode
2c4: 1c ba out 0x1c, r1 ; 28
EEARL=ucAdr;
2c6: be bb out 0x1e, r27 ; 30
EEDR=ucData;
2c8: 8d bb out 0x1d, r24 ; 29
BYTE cSREG=SREG;//store interrupts state
2ca: 8f b7 in r24, 0x3f ; 63
cli();//disable interrupts
2cc: f8 94 cli
sbi(EECR,EEMPE);// write 1 to EEMPE
2ce: e2 9a sbi 0x1c, 2 ; 28
sbi(EECR,EEPE);// start EEPROM write by setting EEPE
2d0: e1 9a sbi 0x1c, 1 ; 28
SREG=cSREG;//restore interrupts state
2d2: 8f bf out 0x3f, r24 ; 63
Теперь всё понял. в EECR всегда пишется 0.
Последний раз редактировалось _SIL_ Чт дек 06, 2012 22:40:30, всего редактировалось 2 раза.
-
Аlex
- Модератор
- Сообщения: 4614
- Зарегистрирован: Чт мар 18, 2010 23:09:57
- Откуда: Планета Земля
- Контактная информация:
Re: Вопросы по С/С++ (СИ)
То, что у Вас работает, это не значит, что там не опечатка. Т.к. (0>>EEPM0) эквивалентно (0<<EEPM0). А вот если Вы захотите сменить нолик на единичку (установить бит EEPM0), то "быть беде" 
Re: Вопросы по С/С++ (СИ)
Разобрался. Предыдущем посте всё написал.
Re: Вопросы по С/С++ (СИ)
Ребят, помогите, пожалуйста разобраться с USARTOM.
у меня такое задание:
Разработать программу, реализующую генератор изменяемой частоты. Начальная частота – 0.5 Гц, т.е. желтый индикатор 1 с горит, 1 с не горит и т.д. Нажатие кнопки 1 приводит к увеличению частоты на 40%, нажатие кнопки 2 уменьшает частоту на 40%. Для облегчения замера частот использовать красный и зеленый индикаторы: красный должен мигать с частотой в 10 раз большей основной частоты (желтого индикатора), а зеленый должен мигать с частотой в 10 раз меньше основной. Одновременное нажатие обеих кнопок должно возвращать генератор в исходное состояние – 0.5 Гц.
Должны обеспечиваться следующие форматы сообщений как от ПК к узлу, так и от узла к ПК:
SOF len message CS
SOF – Start of Frame, признак начала сообщения, 1 байт, 0x7E;
len – длина сообщения в байтах, 1 байт;
message – сообщение, len байт;
CS – контрольная сумма, 1 байт
Контрольная сумма CS должна вычисляться сложением байтов поля message при помощи операции «ИСКЛЮЧАЮЩЕЕ ИЛИ».
При передаче 8-битных байтов использовать проверку четности и 1 стоповый бит. Постараться организовать взаимодействие на максимально возможной скорости.
Что нужно сделать
o Запрос состояния (query). В ответ на этот запрос узел должен сообщить номер своего состояния, оставшееся время нахождения в нем (в единицах таймера) и состояние индикаторов.
o Установка состояния (set). Узел должен немедленно установить запрошенное состояние и оповестить ПК об успешном выполнении команды.
o Еще 2-3 команды по усмотрению.
Вот код:
Тестирую в протеусе : подключил к собранной схеме virtual terminal. Нажимаю на кнопку 3 ( ASCII код 33) - должна поидее уменьшится частота, но мне в ответ приходит такое сообщение :
7E 02 20 33 13 и частота не уменьшается..
7E - начало сообщения (правильно), дальше должна идти длина сообщения (1 байт), тут почему то выдает 02, далее само сообщение (20 - неизвестная команда) , 33 код кнопки (ASCII) и 13 - контрольная сумма.
Подскажите, пожалуйста, может я не так ввожу команду или что-то неправильно в коде ?
у меня такое задание:
Разработать программу, реализующую генератор изменяемой частоты. Начальная частота – 0.5 Гц, т.е. желтый индикатор 1 с горит, 1 с не горит и т.д. Нажатие кнопки 1 приводит к увеличению частоты на 40%, нажатие кнопки 2 уменьшает частоту на 40%. Для облегчения замера частот использовать красный и зеленый индикаторы: красный должен мигать с частотой в 10 раз большей основной частоты (желтого индикатора), а зеленый должен мигать с частотой в 10 раз меньше основной. Одновременное нажатие обеих кнопок должно возвращать генератор в исходное состояние – 0.5 Гц.
Должны обеспечиваться следующие форматы сообщений как от ПК к узлу, так и от узла к ПК:
SOF len message CS
SOF – Start of Frame, признак начала сообщения, 1 байт, 0x7E;
len – длина сообщения в байтах, 1 байт;
message – сообщение, len байт;
CS – контрольная сумма, 1 байт
Контрольная сумма CS должна вычисляться сложением байтов поля message при помощи операции «ИСКЛЮЧАЮЩЕЕ ИЛИ».
При передаче 8-битных байтов использовать проверку четности и 1 стоповый бит. Постараться организовать взаимодействие на максимально возможной скорости.
Что нужно сделать
o Запрос состояния (query). В ответ на этот запрос узел должен сообщить номер своего состояния, оставшееся время нахождения в нем (в единицах таймера) и состояние индикаторов.
o Установка состояния (set). Узел должен немедленно установить запрошенное состояние и оповестить ПК об успешном выполнении команды.
o Еще 2-3 команды по усмотрению.
Вот код:
Спойлер
Код: Выделить всё
#define F_CPU 8000000UL // указываем частоту в герцах
#include <stdlib.h>
#include <avr/io.h> // регистры ввода/вывода
#include <avr/interrupt.h> // обработка прерываний
#include <avr/delay.h> //задержка
unsigned int next_frequency = 0; // признак смены частоты
unsigned int current_message = 0; // текущее сообщение
unsigned int length_of_get_message = 0; // длина полчаемого сообщения
unsigned int data_message[100]; // получаемое сообщение
unsigned int control_summ; // контрольная сумма
volatile unsigned int Step; // общий шаг частоты
volatile unsigned int Step_inc; //шаг увеличения частоты
volatile unsigned int Step_dec; //шаг уменьшения частоты
volatile unsigned int Count_time_seconds; // счетчик для мигания зеленого
volatile unsigned int button; // признак нажатия кнопки
volatile unsigned int Frequency; // время таймера
volatile unsigned int Frequency_yellow; // частота желтого
volatile unsigned int Count_time_seconds_red; //счетчик для мигания красного
volatile unsigned int Frequency_yellow_temp;
#define Size_of_queue 150
#define SOF 0x7E
unsigned char Queue[Size_of_queue]; //очередь запросов
unsigned char* first_byte = Queue; //первый запрос в очереди
unsigned char* last_byte = Queue; //последний запрос в очереди
unsigned char queue_is_free = 1; //очередь пуста
//==================
//==================
/// запросы
enum Types_of_inquiry
{
Get_status = 0x31, //получить статус
Set_status = 0x32, // установить статус
Decrease_status = 0x33, // уменьшаем частоту
Increase_status = 0x34, // увеличиваем частоту
Reset_control = 0x35, // перезапуск
Control_was_restarted = 0x10, //факт рестарта
Frequency_decrease = 0x11, // переход на уменьшение частоты
Frequency_increase = 0x12, // переход на увеличение частоты
Status_was_getting = 0x13, // статус был получен
Status_was_setting = 0x14, // статус был установлен
UNDEFINED_COMMAND = 0x20, // неизвестная команда
Next_step_by_timer = 0x16, // переход на след частоту по таймеру
Button_was_pressed= 0x17, //нажали кнопку
Control_summ_is_bad = 0x18 // неверная контрольная сумма
};
//==================
// добавление байта в очередь
void Add_byte_to_queue(unsigned char byte)
{
if (last_byte != first_byte || queue_is_free == 1){
*last_byte = byte;
last_byte++;
if (last_byte == Queue + Size_of_queue){
last_byte = Queue;
}
queue_is_free = 0;
}
}
//==================
// получение байта из очереди
unsigned char Get_byte_from_queue()
{
unsigned char byte = *first_byte;
first_byte++;
if (first_byte == Queue + Size_of_queue){
first_byte = Queue;
}
if (first_byte == last_byte){
queue_is_free = 1;
}
return byte;
}
//==================
// отсылка байта через USART
void USART1_send_byte(unsigned char message)
{
//Ждем пока данные передаются
while ( !(UCSR1A & (1<<UDRE1)) );
UDR1 = message;
}
//==================
// отсылка сообщения через USART
void USART1_send_message (unsigned char *message, unsigned char length)
{
// посылаем признак начала сообщения
USART1_send_byte(SOF);
// длина сообщения
USART1_send_byte(length);
unsigned char control_Summ = 0;
// посылаем сообщение
for(unsigned char i = 0; i < length; i++)
{
USART1_send_byte(message[i]);
control_Summ ^= message[i];
}
// контрольная сумма
USART1_send_byte(control_Summ);
}
//==================
/*Функция уменьшения частоты */
void DecreaseFrequency()
{
if (Frequency_yellow < (65535/1.4)) {
Frequency_yellow = Frequency_yellow*1.4;
}
}
//==================
/* Функция увеличения частоту */
void IncreasedFrequency()
{
if (Frequency_yellow > 1) {
Frequency_yellow =Frequency_yellow*0.6;
}
}
//==================
// ФУНКЦИЯ 3 установить состояние
void Set_status_function (unsigned int *data){
// номер шага, соответственно, частота
PORTB = data[1];
PORTE = data[2];
// поличуть текущее время на единичном интервале
TCNT1 = data[3];
TCNT1 = data[4]>>8;
}
//==================
// ФУНКЦИЯ 4 restart
void Restart_Controller()
{
Frequency_yellow = 0.1*8000000/64;
}
//==================
// полное состояние контроллера
void Full_Status_Controller (unsigned int *data, unsigned int length,unsigned char _SOF )
{
// тип сообщени
data[0] = _SOF;
// номер шага, соответственно, частота
data[1] = PORTB;
data[2] = PORTE;
// текущее время на данном шаге в единицах таймера
data[3] = TCNT1>>8;
data[4] = TCNT1;
length = 5;
}
//==================
// передача полного сообщения
void Send_Status(unsigned char _SOF)
{
unsigned char length = 10;
unsigned char data[100];
Full_Status_Controller(data, length,_SOF);
USART1_send_message(data, length);
}
//==================
// разбор USART сообщегия
void USART_work (unsigned int *data){
switch (data[0]){
case Get_status: // если поличуть статус
Send_Status (Status_was_getting); // сообщили
break;
case Set_status: // установить статус
Set_status_function(data); // выполнить нужное действие
Send_Status (Status_was_setting); // сообщить об этом
break;
case Decrease_status:
DecreaseFrequency ();
Send_Status (Frequency_decrease);
break;
case Increase_status:
IncreasedFrequency();
Send_Status (Frequency_increase);
break;
case Reset_control:
Restart_Controller();
Send_Status (Control_was_restarted);
break;
default: // ошибка
Send_Status (UNDEFINED_COMMAND);
break;
}
}
//==================
// обработка комманды в очереди
void Work_command(){
unsigned char answer_message[2]; // отправляемое сообщение об ошибке
while (!queue_is_free){
unsigned char byte = Get_byte_from_queue(); // взяли байт из очереди
switch (current_message){
case 0: // начинается сообщение
if (byte == SOF){ // если первое это признак начала
data_message[current_message] = byte; // взяли его
current_message++; // след шаг
}
else{
answer_message[0] = UNDEFINED_COMMAND;//если не признак начала - ошибка
answer_message[1] = byte;
USART1_send_message(answer_message, 2); // сообщили
}
break;
case 1: // если уже послали признак начала сообщения
data_message[current_message] = byte;// формируем сообщение
current_message++; // след шаг
length_of_get_message = byte; // взяли длинку, тк это следующрий элемент
control_summ = 0;
break;
default: // идет сам текст сообщения
data_message[current_message] = byte; // взяли элемент
current_message++; // слудующий
if (length_of_get_message > 0){ // на каждом шаге считаем контрольную сумму
length_of_get_message--; // ум длину
control_summ ^= byte; // собственно, контрольная сумма
}else{ // когда дошли до конца сообщения
if (control_summ == byte){ // если реальная сумма равно теоретической
USART_work(data_message); // передать на USART
}else{ // если контрольная сумма не совпадает
data_message[0] = Control_summ_is_bad; // ошибка
USART1_send_message(data_message, data_message[1]);
}
current_message = 0;
}
break;
}
}
}
//==================
//==================
// инициализация
//==================
//==================
void Ititual(){
// красная лампочка
DDRE = (1<<PE1)|(1<<PE2)|(1<<PE3);
PORTE = (1<<PE1)|(1<<PE2)|(1<<PE3);
// кнопка
DDRB = (0<<PB5)|(0<<PB6);
PORTB = (1<<PB5)|(1<<PB6);
// предделитель наймера 64
TCCR1B = (0<<CS12)|(1<<CS11)|(1<<CS10);
// разрешаем прерывание от таймера 1.
TIMSK = (1<<TOIE1);
TCNT1 = 65536 - 0.1*8000000/64;
Frequency_yellow = 0.1*8000000/64;
sei();
//задаем скорость обмена, устанавливаем USART в нужный режим работы
UBRR1H = 0;
UBRR1L = 51;
//разрешаем прием-передачу
UCSR1B = (1<<RXEN1)|(1<<TXEN1)|(1<<RXCIE1)|(0<<TXCIE1);
//устанавливаем асинхронный режим работы и формат посылки: 8 бит, 1 стопповый бит
UCSR1C = (0<<USBS1)|(1<<UCSZ10)|(1<<UCSZ11)|(0<<UCSZ12)|(0 << UMSEL1)|(0<<UPM10)|(0<<UPM11);
}
//==================
SIGNAL(SIG_OVERFLOW1){
TCNT1 = 65536 - Frequency_yellow ;
PORTE = PINE^(1<<PE3);
if (Count_time_seconds == 10) {
PORTE = PINE^(1<<PE2);
Count_time_seconds = 0;
Count_time_seconds_red++;
if (Count_time_seconds_red == 10) {
PORTE = PINE^(1<<PE1);
Count_time_seconds_red=0;
}
}
Count_time_seconds++;
//==================
}
// прерывание при получении данных по USART
SIGNAL (SIG_USART1_RECV)
{
Add_byte_to_queue(UDR1);
}
//==================
//==================
// главная программа
int main()
{
Ititual(); // инициализация
while (1){ // бесконечный цикл
_delay_ms(500); // формируем задержку 0.5с
/*проверяем одновременное нажатие двух кнопок */
if ((PINB & (1<<PB6 | 1<<PB5))==0) {
Frequency_yellow = 0.1*8000000/64;
}
else{
/* если обе кнопки не нажаты, то перейдем к проверке нажатия одной из кнопок*/
// проверяем нажатие кнопки уменьшения частоты
if ((PINB & (1<<PB6)) == 0){ // проверяем нажатие кнопки
if (Frequency_yellow < (65535/1.4)) {
Frequency_yellow = Frequency_yellow*1.4;
}
}
// проверяем нажатие кнопки увеличения частоты
if ((PINB & (1<<PB5)) == 0){ // проверяем нажатие кнопки
if (Frequency_yellow > 1) {
Frequency_yellow =Frequency_yellow*0.6;
}
}
}
Work_command();
}
return 0;
}
//==================
//==================
Тестирую в протеусе : подключил к собранной схеме virtual terminal. Нажимаю на кнопку 3 ( ASCII код 33) - должна поидее уменьшится частота, но мне в ответ приходит такое сообщение :
7E 02 20 33 13 и частота не уменьшается..
7E - начало сообщения (правильно), дальше должна идти длина сообщения (1 байт), тут почему то выдает 02, далее само сообщение (20 - неизвестная команда) , 33 код кнопки (ASCII) и 13 - контрольная сумма.
Подскажите, пожалуйста, может я не так ввожу команду или что-то неправильно в коде ?
-
vitalik_1984
- Поставщик валерьянки для Кота
- Сообщения: 2482
- Зарегистрирован: Пт авг 27, 2010 05:57:06
- Откуда: Тюмень
- Контактная информация:
Re: Вопросы по С/С++ (СИ)
Вообще получается, что протокол передачи работает правильно, тем более что код посланной клавиши совпадает с ответом.
Я думаю лучше присмотреться к функциям обработки принятых байт.
Я думаю лучше присмотреться к функциям обработки принятых байт.