Fórum sobre desenvolvimento de sistemas embarcados: Hardware e Software, Tecnologias: Eletrônica digital e analógica, Microcontroladoras, Microprocessadores, Sistemas *NIX (Linux, BSD), Software embarcado Baremetal. Sem fins lucrativos.

Pular para o conteúdo

MAKROS PARA INICIANTES.

Software e Hardware para uC PIC

Moderadores: andre_luis, 51, guest2003, Renie

Responder

MAKROS PARA INICIANTES.

Mensagempor fabim » 27 Mar 2009 21:37

Por várias vezes eu vi iniciantes, apanhando por causa de coisas bobas em C ANSI, como testar um bit de uma variavel >8 bits, como setar um bit de uma variavel >8 bits.
Como unir 4 bytes a uma variavel de 32 bit´s, ou de 16 bits.

Por este motivo, resolvi compartilhar estas makros que eu fiz pra brincar, e ajudar os novatos.
Aplica-se a qualquer compilador que não seja sistematico e aceite C ANSI.

Código: Selecionar todos
////////////////////////////////////////////////////////////////////////////////
// FUNÇÃO        : pega partes de uma variavel de 16/32 bits
// PROCEDIMENTO  : diretivas de compilador
// PARÃMETRO     : variavel tipo 16 ou 32 bits
// RETORNO       : 1 byte respectivo
// ULTIMA EDIÇÃO :
// OBS           :
////////////////////////////////////////////////////////////////////////////////
#define lo(param)      ((short *)&param)[0]
#define hi(param)      ((short *)&param)[1]
#define higher(param)  ((short *)&param)[2]
#define highest(param) ((short *)&param)[3]



////////////////////////////////////////////////////////////////////////////////
// FUNÇÃO        : união de variaveis de 8 bits a uma de 16 ou 32 bits
// PROCEDIMENTO  : seta valor de bytes 0...4 com valor passado
// PARÃMETRO     : var 1 = 16/32 bits, var 2 = 8 bits
// RETORNO       : nenhum
// ULTIMA EDIÇÃO :
// OBS           :
////////////////////////////////////////////////////////////////////////////////
#define  unilo(param,param2)      ((short *)&param)[0] = ((short *)&param2)[0]
#define  unihi(param,param2)       ((short *)&param)[1] = ((short *)&param2)[0]
#define  unihigh(param, param2)    ((short *)&param)[2] = ((short *)&param2)[0]
#define  unihiguest(param, param2) ((short *)&param)[3] = ((short *)&param2)[0]

////////////////////////////////////////////////////////////////////////////////
// FUNÇÃO        : seta bit de parametro sem uso de struct
// PROCEDIMENTO  : seta bit de byte respectivo 0..3
// PARÃMETRO     : variavel de 8 a 32 bits
// RETORNO       :
// ULTIMA EDIÇÃO :
// OBS           :
////////////////////////////////////////////////////////////////////////////////

#define  setbit0(param)     ((short *)&param)[0] |= 0b00000001
#define  setbit1(param)     ((short *)&param)[0] |= 0b00000010
#define  setbit2(param)     ((short *)&param)[0] |= 0b00000100
#define  setbit3(param)     ((short *)&param)[0] |= 0b00001000
#define  setbit4(param)     ((short *)&param)[0] |= 0b00010000
#define  setbit5(param)     ((short *)&param)[0] |= 0b00100000
#define  setbit6(param)     ((short *)&param)[0] |= 0b01000000
#define  setbit7(param)     ((short *)&param)[0] |= 0b10000000

#define  setbit8(param)     ((short *)&param)[1] |= 0b00000001
#define  setbit9(param)     ((short *)&param)[1] |= 0b00000010
#define  setbit10(param)    ((short *)&param)[1] |= 0b00000100
#define  setbit11(param)    ((short *)&param)[1] |= 0b00001000
#define  setbit12(param)    ((short *)&param)[1] |= 0b00010000
#define  setbit13(param)    ((short *)&param)[1] |= 0b00100000
#define  setbit14(param)    ((short *)&param)[1] |= 0b01000000
#define  setbit15(param)    ((short *)&param)[1] |= 0b10000000

#define  setbit16(param)    ((short *)&param)[2] |= 0b00000001
#define  setbit17(param)    ((short *)&param)[2] |= 0b00000010
#define  setbit18(param)    ((short *)&param)[2] |= 0b00000100
#define  setbit19(param)    ((short *)&param)[2] |= 0b00001000
#define  setbit20(param)    ((short *)&param)[2] |= 0b00010000
#define  setbit21(param)    ((short *)&param)[2] |= 0b00100000
#define  setbit22(param)    ((short *)&param)[2] |= 0b01000000
#define  setbit23(param)    ((short *)&param)[2] |= 0b10000000

#define  setbit24(param)    ((short *)&param)[3] |= 0b00000001
#define  setbit25(param)    ((short *)&param)[3] |= 0b00000010
#define  setbit26(param)    ((short *)&param)[3] |= 0b00000100
#define  setbit27(param)    ((short *)&param)[3] |= 0b00001000
#define  setbit28(param)    ((short *)&param)[3] |= 0b00010000
#define  setbit29(param)    ((short *)&param)[3] |= 0b00100000
#define  setbit30(param)    ((short *)&param)[3] |= 0b01000000
#define  setbit31(param)    ((short *)&param)[3] |= 0b10000000

////////////////////////////////////////////////////////////////////////////////
// FUNÇÃO        : zera bit parametro sem uso de struct
// PROCEDIMENTO  : zera bit de parametro com uso de AND
// PARÃMETRO     : variavel de 8 a 32 bits
// RETORNO       :
// ULTIMA EDIÇÃO :
// OBS           :
////////////////////////////////////////////////////////////////////////////////
#define  clrbit0(param)     ((short *)&param)[0] &= ~0b00000001
#define  clrbit1(param)     ((short *)&param)[0] &= ~0b00000010
#define  clrbit2(param)     ((short *)&param)[0] &= ~0b00000100
#define  clrbit3(param)     ((short *)&param)[0] &= ~0b00001000
#define  clrbit4(param)     ((short *)&param)[0] &= ~0b00010000
#define  clrbit5(param)     ((short *)&param)[0] &= ~0b00100000
#define  clrbit6(param)     ((short *)&param)[0] &= ~0b01000000
#define  clrbit7(param)     ((short *)&param)[0] &= ~0b10000000

#define  clrbit8(param)     ((short *)&param)[1] &= ~0b00000001
#define  clrbit9(param)     ((short *)&param)[1] &= ~0b00000010
#define  clrbit10(param)    ((short *)&param)[1] &= ~0b00000100
#define  clrbit11(param)    ((short *)&param)[1] &= ~0b00001000
#define  clrbit12(param)    ((short *)&param)[1] &= ~0b00010000
#define  clrbit13(param)    ((short *)&param)[1] &= ~0b00100000
#define  clrbit14(param)    ((short *)&param)[1] &= ~0b01000000
#define  clrbit15(param)    ((short *)&param)[1] &= ~0b10000000

#define  clrbit16(param)    ((short *)&param)[2] &= ~0b00000001
#define  clrbit17(param)    ((short *)&param)[2] &= ~0b00000010
#define  clrbit18(param)    ((short *)&param)[2] &= ~0b00000100
#define  clrbit19(param)    ((short *)&param)[2] &= ~0b00001000
#define  clrbit20(param)    ((short *)&param)[2] &= ~0b00010000
#define  clrbit21(param)    ((short *)&param)[2] &= ~0b00100000
#define  clrbit22(param)    ((short *)&param)[2] &= ~0b01000000
#define  clrbit23(param)    ((short *)&param)[2] &= ~0b10000000

#define  clrbit24(param)    ((short *)&param)[3] &= ~0b00000001
#define  clrbit25(param)    ((short *)&param)[3] &= ~0b00000010
#define  clrbit26(param)    ((short *)&param)[3] &= ~0b00000100
#define  clrbit27(param)    ((short *)&param)[3] &= ~0b00001000
#define  clrbit28(param)    ((short *)&param)[3] &= ~0b00010000
#define  clrbit29(param)    ((short *)&param)[3] &= ~0b00100000
#define  clrbit30(param)    ((short *)&param)[3] &= ~0b01000000
#define  clrbit31(param)    ((short *)&param)[3] &= ~0b10000000

////////////////////////////////////////////////////////////////////////////////
// FUNÇÃO        : testa bit parametro sem uso de struct
// PROCEDIMENTO  : testa bit de parametro com uso de AND
// PARÃMETRO     : variavel de 8 a 32 bits
// RETORNO       :
// ULTIMA EDIÇÃO :
// OBS           :
////////////////////////////////////////////////////////////////////////////////

#define  tstbit0(param)     ((short *)&param)[0] & 0b00000001
#define  tstbit1(param)     ((short *)&param)[0] & 0b00000010
#define  tstbit2(param)     ((short *)&param)[0] & 0b00000100
#define  tstbit3(param)     ((short *)&param)[0] & 0b00001000
#define  tstbit4(param)     ((short *)&param)[0] & 0b00010000
#define  tstbit5(param)     ((short *)&param)[0] & 0b00100000
#define  tstbit6(param)     ((short *)&param)[0] & 0b01000000
#define  tstbit7(param)     ((short *)&param)[0] & 0b10000000

#define  tstbit8(param)     ((short *)&param)[1] & 0b00000001
#define  tstbit9(param)     ((short *)&param)[1] & 0b00000010
#define  tstbit10(param)    ((short *)&param)[1] & 0b00000100
#define  tstbit11(param)    ((short *)&param)[1] & 0b00001000
#define  tstbit12(param)    ((short *)&param)[1] & 0b00010000
#define  tstbit13(param)    ((short *)&param)[1] & 0b00100000
#define  tstbit14(param)    ((short *)&param)[1] & 0b01000000
#define  tstbit15(param)    ((short *)&param)[1] & 0b10000000
#define  tstbit16(param)    ((short *)&param)[2] & 0b00000001
#define  tstbit17(param)    ((short *)&param)[2] & 0b00000010
#define  tstbit18(param)    ((short *)&param)[2] & 0b00000100
#define  tstbit19(param)    ((short *)&param)[2] & 0b00001000
#define  tstbit20(param)    ((short *)&param)[2] & 0b00010000
#define  tstbit21(param)    ((short *)&param)[2] & 0b00100000
#define  tstbit22(param)    ((short *)&param)[2] & 0b01000000
#define  tstbit23(param)    ((short *)&param)[2] & 0b10000000

#define  tstbit24(param)    ((short *)&param)[3] & 0b00000001
#define  tstbit25(param)    ((short *)&param)[3] & 0b00000010
#define  tstbit26(param)    ((short *)&param)[3] & 0b00000100
#define  tstbit27(param)    ((short *)&param)[3] & 0b00001000
#define  tstbit28(param)    ((short *)&param)[3] & 0b00010000
#define  tstbit29(param)    ((short *)&param)[3] & 0b00100000
#define  tstbit30(param)    ((short *)&param)[3] & 0b01000000
#define  tstbit31(param)    ((short *)&param)[3] & 0b10000000
Mano, ve só.
Sou responsável pelo que escrevo!!! E não pelo que você entende !!!
fabim
Dword
 
Mensagens: 5001
Registrado em: 16 Out 2006 10:18
Localização: aqui uái!!!?
Voltar ao topo

Mensagempor ze » 30 Mar 2009 09:59

macros+=algumas;
vi no forum cbe. (perdi o link)
Código: Selecionar todos
#define BCD2BYTE( b ) ( ( ( ( ( b ) >> 4 ) & 0x0f ) * 10 ) + ( ( b ) & 0x0f ) )
#define BYTE2BCD( b ) ( ( ( ( b ) / 10 ) << 4 ) + ( ( b ) % 10 ) )

do hitech-c
Código: Selecionar todos
#define setbit(var,bitno) ((var) |= 1 << (bitno))
#define clrbit(var,bitno) ((var) &= ~(1 << (bitno)))
#define xorbit(var,bitno) ((var) ^= 1 << (bitno))

pra alguns pic´s com eeprom
Código: Selecionar todos
#define   EEPROM_WRITE(addr, value) \
   while(WR)continue;EEADR=(addr);EEDATA=(value); \
   EECON1&=0x7F;CARRY=0;if(GIE)CARRY=1;GIE=0; \
   WREN=1;EECON2=0x55;EECON2=0xAA;WR=1;WREN=0; \
   if(CARRY)GIE=1

#define   EEPROM_READ(addr) ((EEADR=(addr)),(EECON1&=0x7F),(RD=1),EEDATA)

e agora a mais fudida de todas muito utilizada pelos iniciante no hello world. É tão complexa que foi tese de meu doutorado
Código: Selecionar todos
#define led RB0

até a próxima semana
abs
Avatar do usuário
ze
Dword
 
Mensagens: 1655
Registrado em: 05 Jun 2007 14:32
Voltar ao topo

Mensagempor barboza » 30 Mar 2009 11:25

Só tomem cuidado com o uso de macros extensas, pois dependendo do compilador valem mais a pena criar funções, pois podem alocar vários espaço de código para fazerem a mesma coisa.
Os homens mentiriam muito menos se as mulheres fizessem menos perguntas.
Avatar do usuário
barboza
Word
 
Mensagens: 948
Registrado em: 17 Out 2006 13:42
Localização: Longe de onde gostaria de estar
Voltar ao topo

Mensagempor fabim » 30 Mar 2009 11:37

Opa, então meu querido!!
Quando a coisa é longa, não se usa makros.
Usa-se rotinas...

Mais valeu pelo aviso!!

Escutaram newbies ?

fabim
Mano, ve só.
Sou responsável pelo que escrevo!!! E não pelo que você entende !!!
fabim
Dword
 
Mensagens: 5001
Registrado em: 16 Out 2006 10:18
Localização: aqui uái!!!?
Voltar ao topo

Mensagempor rodrigoadachi » 16 Ago 2009 09:06

Disgraçados, esculacharão os pobre iniciantes assim como eu .. kkkkkk

Mas valew...

kkkkkkkkkkkkkkkk

:lol:
rodrigoadachi
Nibble
 
Mensagens: 70
Registrado em: 15 Out 2007 12:19
Localização: Bahia - Brazil
Voltar ao topo

Mensagempor barboza » 16 Ago 2009 17:24

fabim escreveu:Opa, então meu querido!!
Quando a coisa é longa, não se usa makros.
Usa-se rotinas...

Mais valeu pelo aviso!!

Escutaram newbies ?

fabim



Este é um exemplo, no meu ponto de vista!!!

lellis escreveu:
pra alguns pic´s com eeprom
Código: Selecionar todos
#define   EEPROM_WRITE(addr, value) \
   while(WR)continue;EEADR=(addr);EEDATA=(value); \
   EECON1&=0x7F;CARRY=0;if(GIE)CARRY=1;GIE=0; \
   WREN=1;EECON2=0x55;EECON2=0xAA;WR=1;WREN=0; \
   if(CARRY)GIE=1

Os homens mentiriam muito menos se as mulheres fizessem menos perguntas.
Avatar do usuário
barboza
Word
 
Mensagens: 948
Registrado em: 17 Out 2006 13:42
Localização: Longe de onde gostaria de estar
Voltar ao topo

Mensagempor Jorge_Francisco » 16 Ago 2009 20:33

Já ia comentar o setbit enorme do fabim, mas vi que o lellis colocou a forma reduzida.

Vlw
Avatar do usuário
Jorge_Francisco
Dword
 
Mensagens: 1009
Registrado em: 12 Out 2006 09:53
Localização: Rio de Janeiro
Voltar ao topo

Mensagempor fabim » 16 Ago 2009 20:45

Jorge_Francisco escreveu:Já ia comentar o setbit enorme do fabim, mas vi que o lellis colocou a forma reduzida.

Vlw


hehe, para iniciantes...
é que ao meu ver, um iniciante entende bem melhor o que acontece.
Eu por exemplo, não costumo usar dessa forma....

Por exemplo, eu cansei de ver post´s de pessoas perguntando uma forma mais simples de unir dois bytes a uma int, ou 4 a uma long..
Tempão que o nego perde com..
<<<
ou
X*.....

é bem mais imples e direto..

Código: Selecionar todos
 
////////////////////////////////////////////////////////////////////////////////
// FUNÇÃO        : união de variaveis de 8 bits a uma de 16 ou 32 bits
// PROCEDIMENTO  : seta valor de bytes 0...4 com valor passado
// PARÃMETRO     : var 1 = 16/32 bits, var 2 = 8 bits
// RETORNO       : nenhum
// ULTIMA EDIÇÃO :
// OBS           :
////////////////////////////////////////////////////////////////////////////////
#define  unilo(param,param2)      ((short *)&param)[0] = ((short *)&param2)[0]
#define  unihi(param,param2)       ((short *)&param)[1] = ((short *)&param2)[0]
#define  unihigh(param, param2)    ((short *)&param)[2] = ((short *)&param2)[0]
#define  unihiguest(param, param2) ((short *)&param)[3] = ((short *)&param2)[0]


só para ter idéia, eu parei com pic nos projetos que eu estava desenvolvendo...
depois que eu me aprofundei nos ARM7 e CM3, e fiz uma comparação de preço comparando performances.....

LPC2103 -----
Para
LPC1766 -----
ou
AT91sam-----

De uma olhada nos preços..
Mais interessante, é a mesma porcaria que pic, se você programar em C e ja ter uma noção boa de hw em uC ta tranquilo.
E todas estas diretivas que eu passei, funcionam normalmente no keil para a RAM

ADIOS

Fabim
Mano, ve só.
Sou responsável pelo que escrevo!!! E não pelo que você entende !!!
fabim
Dword
 
Mensagens: 5001
Registrado em: 16 Out 2006 10:18
Localização: aqui uái!!!?
Voltar ao topo

Mensagempor ze » 17 Ago 2009 10:26

olás. um compilador pro arm que uso não tem como descrever constantes na forma 0b10101010. aí achei isto e achei legal:
http://www.velocityreviews.com/forums/t ... acros.html
hopefully it's useful to some of you as well.

Ah... e realmente a macro da eeprom fica grande. use-se função:
eepw(addr, value)
{
EEPROM_WRITE(addr, value);
}
abç
Avatar do usuário
ze
Dword
 
Mensagens: 1655
Registrado em: 05 Jun 2007 14:32
Voltar ao topo

Mensagempor fabim » 17 Ago 2009 10:45

hehe, bem observado lelis, no caso do keil.
Não utilizo constantes binarias e sim hex.
0x01;
0x02;
0x04;
0x08;
0x10;
0x20;
0x40;
0x80;

Abçs.

Fabim
Mano, ve só.
Sou responsável pelo que escrevo!!! E não pelo que você entende !!!
fabim
Dword
 
Mensagens: 5001
Registrado em: 16 Out 2006 10:18
Localização: aqui uái!!!?
Voltar ao topo

Mensagempor Djalma Toledo Rodrigues » 17 Ago 2009 12:01

Esperto o Fabim;
Não pega Bin vai de Hexa.

Somente descordo de dizer "tudo a mesma porcaria".

Vejam bem, a Alavanca não é uma coisa extraordinária ?

(O que é a Roda se não uma Sucessão de Alavancas)

Quanto mais um componente eletrônico. Quanto mais um Micro Processador.

Quanto mais ...
.
Avatar do usuário
Djalma Toledo Rodrigues
Dword
 
Mensagens: 2334
Registrado em: 03 Ago 2008 13:22
Voltar ao topo
Responder

Voltar para PIC

Quem está online

Usuários navegando neste fórum: Nenhum usuário registrado e 1 visitante

Visualizar novas mensagens desde sua última visita
Powered by phpBB® Forum Software © phpBB Group
Style by Marc Alexander ©
Traduzido por: Suporte phpBB
Time : 0.085s | 10 Queries | GZIP : Off
cron

x