Alterar apenas um bit de um byte, como?

neto_e_khelen · 16 de janeiro de 2010

Estou montando um circuito com os cis 74hc595 e 74ls165 para expandir as portas ios do pic. Mas estou com um dúvida aqui:

Inicio uma variável int32 da seguinte maneira:

int32 saidas=0b00000000000000000000000000000000;

A dúvida é? como faço para mudar o estado de um bit sem alterar o restante??

Por exemplo, mudar o estado do 8ª bit da direita para a esquerda sem alterar os outros 32 bits??? estou usando o ccs.

Lokasso · 16 de janeiro de 2010

Não costumo programar em C, geralmente uso assembly, então pode ser que haja algo mais simples (ou rápido) do que o seguinte modo:

Para mudar o estado do oitavo bit da esquerda para a direita, ou seja, o bit 24, para setá-lo faça um OR entre a variável a ser alterada e o valor 0B00000001000000000000000000000000 (apenas o bit que você quer setado) ou para zerá-lo faça um AND entre a variável e o valor 0B11111110111111111111111111111111 (apenas o bit que você quer zerado).

neto_e_khelen · 17 de janeiro de 2010

Aprendi a usar a função: bit_set(saidas,0);

Só que ele seta o bit da saida que eu quero mais logo já volta a 0...COmo setar e continuar assim??

neto_e_khelen · 19 de janeiro de 2010

Vou explicar melhor: O que eu preciso é que, quando o pic receber um caracter via serial ele acenda ou apaga uma lampada de minha casa. Por exemplo: recebeu letra 'a' = acender lampada do comodo 1. Recebeu letra 'b' = apagar lampara do comodo 1. Até ai tudo bem, o problema é que no meu código, quando ligo a lampada do comodo 1 e vou ligar a lampada do como 2 ele liga, porém desliga a do comodo 1. Entendeu?? Ta ai o código que estou usando, acho que eu preciso é sempre estar atualizando o valor da minha variavel, tentei assim: saidas=saidas; mas mesmo assim não da certo. Por favor me ajudem!! sei que tem gente aqui que entende muito!!!

#include <16F877.h>
#include <74595.c>
#include <74165.c>
//#device adc=8

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES RC                       //Resistor/Capacitor Osc with CLKOUT
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES BROWNOUT                 //Reset when brownout detected
#FUSES LVP                      //Low Voltage Programming on B3(PIC16) or B5(PIC18)
#FUSES NOCPD                    //No EE protection
#FUSES NOWRT                    //Program memory not write protected
#FUSES NODEBUG                  //No Debug mode for ICD

#use delay(clock=20000000)
#use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
int32 saidas=0b11111111111111111111111111111111;
int32 saida_atual=0b00000000000000000000000000000000;
comodo1_lig();comodo2_lig();comodo3_lig();comodo4_lig();comodo5_lig();comodo6_lig();comodo7_lig();comodo8_lig();comodo9_lig();comodo10_lig();
comodo1_des();comodo2_des();comodo3_des();comodo4_des();comodo5_des();comodo6_des();comodo7_des();comodo8_des();comodo9_des();comodo10_des();
  char x;
  short vlr_b0_ant = 1, vlr_b1_ant = 1, vlr_b2_ant = 1, vlr_b3_ant = 1, vlr_b4_ant = 1, vlr_b5_ant = 1, vlr_b6_ant = 1, vlr_b7_ant = 1, vlr_c0_ant = 1, vlr_c1_ant = 1;
void main()
{

   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_OFF);
   setup_psp(PSP_DISABLED);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);


    while(1)
 {
      if (kbhit())          // se houver caractere no buffer de entrada da serial ...
     {
         x = getchar();   // busca caractere da serial
         switch(x)  // escolhe x
           {
           case 'a' :
           {
           comodo1_lig();
           break;
           }
           case 'b' :
           {
           comodo1_des();
           break;
           }
           case 'c' :
           {
           comodo2_lig();
           break;
           }
           case 'd' :
           {
           comodo2_des();
           break;
           }

     }
 }
}
comodo1_lig()
{
putc('a');
bit_set(saidas,0);
write_expanded_outputs(&saidas);
delay_ms(50);
output_high(PIN_B6);
delay_ms(50);
output_low(PIN_B6);
saidas=saidas;
}
comodo1_des()
{
putc('b');
bit_clear(saidas,0);
write_expanded_outputs(&saidas);
delay_ms(50);
output_high(PIN_B6);
delay_ms(50);
output_low(PIN_B6);
saidas=saidas;
}
comodo2_lig()
{
putc('c');
bit_set(saidas,1);
write_expanded_outputs(&saidas);
delay_ms(50);
output_high(PIN_B6);
delay_ms(50);
output_low(PIN_B6);
saidas=saidas;
}
comodo2_des()
{
putc('d');
bit_clear(saidas,1);
write_expanded_outputs(&saidas);
delay_ms(50);
output_high(PIN_B6);
delay_ms(50);
output_low(PIN_B6);
saidas=saidas;
}

Lokasso · 19 de janeiro de 2010

Isto está certo ? ->

write_expanded_outputs(&saidas)

Não deveria ser assim ? ->

write_expanded_outputs(saidas)

Pelo que me lembro de C quando você passa o nome da variável para uma função, o que você está realmente passando é uma cópia de seu valor. Já quando você passa &variável para outra função, o que você passa é o endereço desta variável.

Mesmo assim ainda há algo estranho. Se o que eu falei estiver certo não era para nada ter funcionado no seu código, e não só quando se muda o estado de "outro cômodo".

neto_e_khelen · 19 de janeiro de 2010

Isto está certo ? ->
write_expanded_outputs(&saidas)

Não deveria ser assim ? ->

write_expanded_outputs(saidas)

Pelo que me lembro de C quando você passa o nome da variável para uma função, o que você está realmente passando é uma cópia de seu valor. Já quando você passa &variável para outra função, o que você passa é o endereço desta variável.

Mesmo assim ainda há algo estranho. Se o que eu falei estiver certo não era para nada ter funcionado no seu código, e não só quando se muda o estado de "outro cômodo".

Achei um exemplo na net que usa a função dessa maneira. O pior é que tirei o & e ai que o programa não funciona é nada!

Segue o código da biblioteca <74595.c> :

///////////////////////////////////////////////////////////////////////////
////   Library for a 74595 Expanded Output Chip                        ////
////                                                                   ////
////   Any number of these chips may be connected in serise to get     ////
////   8 additional outputs per chip.  The cost is 3 I/O pins for      ////
////   any number of chips.                                            ////
////                                                                   ////
////   write_expanded_outputs(eo);  Writes the array eo to the chips   ////
////                                                                   ////
///////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,2003 Custom Computer Services           ////
//// This source code may only be used by licensed users of the CCS C  ////
//// compiler.  This source code may only be distributed to other      ////
//// licensed users of the CCS C compiler.  No other use, reproduction ////
//// or distribution is permitted without written permission.          ////
//// Derivative programs created using this software in object code    ////
//// form are not restricted in any way.                               ////
///////////////////////////////////////////////////////////////////////////

#IFNDEF EXP_OUT_ENABLE

#define EXP_OUT_ENABLE  PIN_B0
#define EXP_OUT_CLOCK   PIN_B1
#define EXP_OUT_DO      PIN_B2
#define NUMBER_OF_74595 4

#ENDIF


void write_expanded_outputs(byte* eo) {
byte i;

output_low(EXP_OUT_CLOCK);
output_low(EXP_OUT_ENABLE);

for(i=1;i<=NUMBER_OF_74595*8;++i) { // Clock out bits from the eo array
if((*(eo+(NUMBER_OF_74595-1))&0x80)==0)
output_low(EXP_OUT_DO);
else
output_high(EXP_OUT_DO);
shift_left(eo,NUMBER_OF_74595,0);
output_high(EXP_OUT_CLOCK);
output_low(EXP_OUT_CLOCK);
}
output_high(EXP_OUT_ENABLE);
}

neto_e_khelen · 19 de janeiro de 2010

Ninguem??? Eu só quero aprender a usar o 74hc595...Estou usando quatro deles por isso minha variavel é int32.

Felipe Electronic · 19 de janeiro de 2010

porque não faz uma int comum para cada shift?

abs.

neto_e_khelen · 19 de janeiro de 2010

porque não faz uma int comum para cada shift?
abs.

Tentei agora. Só que acontece o mesmo problema, se, no mesmo 74595 eu mudar o estado de algum outro bit o restante altera também...Será que o problema é no meu hardware: segue anexo o link do arquivo zipado com a simulação do proteus e o código pra vocês baixarem e analisarem melhor.

Código e simulação.zip

Felipe Electronic · 19 de janeiro de 2010

rode assembly embarcado no seu codigo em C e poderá mexer em qualquer bit, exemplo:



int valor

#asm //setando um bit qualquer da int valor
  bsf   valor,x (onde x é o numero do bit que você quer mexer sendo de 0 a 7 para int e 0 a 31para int 32)
#endasm 

#asm //limpando um bit qualquer da variavel valor
   bcf  valor,x (onde x é o numero do bit que você quer mexer)
#endasm

abs.

neto_e_khelen · 19 de janeiro de 2010

rode assembly embarcado no seu codigo em C e poderá mexer em qualquer bit, exemplo:



int valor

#asm //setando um bit qualquer da int valor
  bsf   valor,x (onde x é o numero do bit que você quer mexer sendo de 0 a 7 para int e 0 a 31para int 32)
#endasm 

#asm //limpando um bit qualquer da variavel valor
   bcf  valor,x (onde x é o numero do bit que você quer mexer)
#endasm

abs.

Funcionou beleza esse código, só que com o mesmo problema, quando seto o bit0 da variavel e vou setar o bit1 da mesma variavel o bit0 volta a zerar...

Felipe Electronic · 19 de janeiro de 2010

Opa quando for so pra setar deves usar so

#asm

bsf valor,x

#endasm

sera que nao tem algum loop no seu codigo que esta zerando a variavel?

abs.

neto_e_khelen · 19 de janeiro de 2010

Opa quando for so pra setar deves usar so
#asm

bsf valor,x

#endasm

sera que nao tem algum loop no seu codigo que esta zerando a variavel?

abs.

Pior que não...Pelo menos eu acho...Depois dê uma olhada no código....Se puder, claro....

vtrx · 19 de janeiro de 2010

Provavelmente voce esta reutilizando esta variável sem notar.

neto_e_khelen · 20 de janeiro de 2010

Pior que não, veja o código:

int32 saidas;
char x;
comodo1_lig();comodo1_des();comodo2_lig();comodo2_des();
void main()
{

   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_OFF);
   setup_psp(PSP_DISABLED);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);


    while(1)
 {
      if (kbhit())          // se houver caractere no buffer de entrada da serial ...
     {
         x = getchar();   // busca caractere da serial
         switch(x)  // escolhe x
           {
           case 'a' :
           {
           comodo1_lig();
           break;
           }
           case 'b' :
           {
           comodo1_des();
           break;
           }
           case 'c' :
           {
           comodo2_lig();
           break;
           }
           case 'd' :
           {
           comodo2_des();
           break;
           }
           default:break;
           }
     }
 }
}
comodo1_lig()
{
putc('a');
bit_set(saidas,0);
write_expanded_outputs(&saidas);
delay_ms(50);
output_high(PIN_B6);
delay_ms(50);
output_low(PIN_B6);
}
comodo1_des()
{
putc('b');
bit_clear(saidas,0);
write_expanded_outputs(&saidas);
delay_ms(50);
output_high(PIN_B6);
delay_ms(50);
output_low(PIN_B6);
}
comodo2_lig()
{
putc('c');
bit_set(saidas,1);
write_expanded_outputs(&saidas);
delay_ms(50);
output_high(PIN_B6);
delay_ms(50);
output_low(PIN_B6);
}
comodo2_des()
{
putc('d');
bit_clear(saidas,1);
write_expanded_outputs(&saidas);
delay_ms(50);
output_high(PIN_B6);
delay_ms(50);
output_low(PIN_B6);
}

ricardospimentel · 7 de março de 2011

Eu sei o que você quer (Se ainda quer, pois há quase um ano que ninguém responde a isto aqui), você quer alterar uma saída sem que as outras se alterem.

Sabendo como os shifts funcionam, acho que isso desta forma é bem difícil de se fazer, já que pra se alterar uma de suas saídas, você terá que refazer também todas as outras saídas a não ser que você, antes de modificar aquela saída, envie uma nova informação ao shift já com a informação de todas as portas em alto ou baixo estado e naquele momento. Isto seria meio complicado.

Isto é bem fácil de se fazer utilizando Dois Shifts, um de entrada e outro de saída como um 74xx165 e um 74xx595. Nas bibliotecas do CCS já tem este exemplo o "EX_EXPIO.C" aí você pode colocar, como um exemplo, o teclas no 74xx165 e o LEDs no 74xx595, aí você verá que só aquela saída se alterará. Agora, como programar esta função diretamente nas portas do uC, já não sei, mas sei que isto é possível com um Multiplex como um 74xx151 ou 74xx251.

neto_e_khelen · 8 de março de 2011

Olá ricardospimentel, obrigado por responder! Eu acabei desistindo, pois não consegui fazer isso que queria...Mas não entendi direito o que você quis dizer...

ricardospimentel · 8 de março de 2011

Oi caro "neto_e_khelen".

Eu há pouco estava atrás desta mesma solução, a de se utilizar Shift-Registers para ampliar as portas de saída de um pic em vez de um mux que me é mais complexo, pois no meomento estou estudando os shift-registers e os muxs estudarei mais adiante com um pic.

Sabe como os Shift-Registers com entrada serial e saída paralela funcionam? Eles recebem os dados em sua entrada "data" em fila e para cada bit devemos ter uma transição no pino clock do nivel "1" para o nível "0", ou seja, um shift-register trabalha na base do empurrãozinho e para cada 8 bits que entram em seu pino "data", serão necessários 16 bits no pino "clock". Após feito tudo isso e com o nosso shift tendo os dados armazenados em seus flip-flops, enviamos aquela transição de nivel "1" e depois so nível "0" no pino "enable" e assim temos as saídas de nosso Shift fazendo o que queremos. Ele pode ou não possuir o latch em suas saídas, no caso do 74595 ou 4094, sim, já possuem.

Cara, é uma grande pena ter desistido disso. Qual foi a sua alternativa??

Cheguei ao código que eu tanto queria chegar. El está meio primitivo ainda (e originalmente é do usuário "lucasi"), mas o alterei com o uso de alguns operadores e consegui alterar apenas a saída que desejava e também sei que já é o suficiente para material de estudo para outros.

Segue o código em CCS.

#FUSES NOWDT
#FUSES INTRC_IO
#FUSES NOPROTECT //Código não protegido contra leitura.
//#FUSES NOLVP //Sem low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O

#USE delay (clock=4000000)

//#INCLUDE <Driver_LCD_com_shift_register.h>

#define EXP_OUT_ENABLE PIN_B2 //RCK - Pino 12 do 74HC595(1) & Pino 12 do 74HC595(2)
#define EXP_OUT_CLOCK PIN_B0 //SCK - Pino 11 do 74HC595(1) & Pino 11 do 74HC595(2)
#define EXP_OUT_DO PIN_B1 //SER - Pino 14 do 74HC595(1)
///////////////////////////////////////////////////////////////////////////
//// O DS do 74HC595(2) é alimentado pelo Q7' do 74HC595(1) ////
//// ////

#ZERO_RAM

Byte data1 = 0b00000011;
Byte data2 = 0b10101011;

//------ 74HC595 serial chip --------------
void outSerial(int8 chip1,int8 chip2)
{
int8 i;
int16 data;

data = chip2;
data = data<<8;
data = data | chip1;

// Output to serial line
for(i=0; i<16; i++)
{
if(data & 0x8000)
{output_high(EXP_OUT_DO);}
else
{output_low(EXP_OUT_DO);}

data = data<<1;

output_low(EXP_OUT_CLOCK); //Shift data
output_high(EXP_OUT_CLOCK);
}

output_low(EXP_OUT_ENABLE); //Output on pins
output_high(EXP_OUT_ENABLE);
}

void main(){

setup_counters(RTCC_INTERNAL,RTCC_DIV_2); //configuração TMR0 DEFAULT
setup_timer_1(T1_DISABLED); // desabilitarmos o TMR1
setup_timer_2(T2_DISABLED,0,1); // desabilitamos o TMR2
setup_comparator(NC_NC_NC_NC); // desabilitamos os comparadores
setup_vref(FALSE); // desabilitamos a tens?o de referencia

outSerial(data1,data2);
delay_ms(500);
while(true){
data1 |= 0b00000100;
outSerial(data1,data2);
delay_ms(500);

// 76543210
data1 ^= 0b00000100;
outSerial(data1,data2);
delay_ms(500);

data1 |= 0b00001000;
outSerial(data1,data2);
delay_ms(500);

// 76543210
data1 ^= 0b00001000;
outSerial(data1,data2);
delay_ms(500);

data2 |= 0b01000000;
outSerial(data1,data2);
delay_ms(500);

// 76543210
data2 ^= 0b01000000;
outSerial(data1,data2);
delay_ms(500);

}
}
#INCLUDE <16f628a.H>

Neste código, estão habilitados 2 74595 e consegui alterar apenas o bit daquela saída daquele CI sem alterar os outros. Vejam:

(Perdão, pois não consegui ainda fazer gift animado, pois minha net da net está triste de lenta)

Vejam a imagem n°2, agora dom o quarto led aceso e o restante intocável;

..agora o nosso quarto led se apagou e o sétimo led do segundo Shift se acendeu. Reparem que os outros nem viram quem passou atrás deles;

..e agora, todos em seu estado original.

.if · 9 de março de 2011

...
Isto é bem fácil de se fazer utilizando Dois Shifts, um de entrada e outro de saída como um 74xx165 e um 74xx595....

olá. perdão se não entendi direito mas creio eu que seria mais conveniente fazer uma variável espelho das saídas e fazer a operação nela antes de externá-la, não?

Também pode-se considerar o uso do ci PCF8575 que é um i2c i/o expander.

De toda a forma grato pela contribuição!

ricardospimentel · 10 de março de 2011

E aí "josedasilva0", tudo bem?

Humildemente perguntando, como você usaria essas variáveis espelho para essa aplicação?

Eu vou fazer uns testes aqui para poder explicar melhor isso que escrevi, ou até mesmo corrigir.

Atenciosamente,

Ricardo Pikmentel, Até +!

E aí, caro José da Silva 0!!

Mais baseado nesta pergunta:

Estou montando um circuito com os cis 74hc595 e 74ls165 para expandir as portas ios do pic. Mas estou com um dúvida aqui:

Inicio uma variável int32 da seguinte maneira:

int32 saidas=0b00000000000000000000000000000000;

A dúvida é? como faço para mudar o estado de um bit sem alterar o restante??

Por exemplo, mudar o estado do 8ª bit da direita para a esquerda sem alterar os outros 32 bits??? estou usando o ccs.

..do nosso caro amigo "neto_e_khelen" (acho ser um casal) que respondi isso:

Isto é bem fácil de se fazer utilizando Dois Shifts, um de entrada e outro de saída como um 74xx165 e um 74xx595. Nas bibliotecas do CCS já tem este exemplo o "EX_EXPIO.C" aí você pode colocar, como um exemplo, o teclas no 74xx165 e o LEDs no 74xx595, aí você ....

Este é aquele exemplo do CCS que usa um 74165 e um 74595 que ajuda a compreender como se ampliar as portas de E/S do uC se utilizando de Shift-Registers, CIs baratíssimos na faixa de $0,50 a $1,00. Neste sample do CCS você aperta uma tecla na entrada do 165 e acende um led na saída do 595. Pra falar a verdade se dentro do code você apenas utilizar:

...

read_expanded_inputs(variável); \\Sacanagem, né? Colocar acento numa variável!! Só eu mesmo.

write_expanded_inputs(variável);

...

Isto aí acima, claro que tendo os devidos drivers carregados no código, já faz o que eu acho que o nosso colega queria fazer, mas ele desistiu.

Quanto ao PCF8575, não fiz uma pesquisa tão intensa, mas não me parece assim tão fácil de encontrar e acho que se eu encontrar, o valor dele não será tão bom quanto o dos Shifts.

Agora quanto às variáveis espelho, ainda estou refletindo sobre isso.

Até +.

Ricardo S Pimentel.

.if · 10 de março de 2011

olá ricardo. gostei do trocadilho do 'refletindo'.

vejamos...

vamos considerar uma variável unsigned long int L de 4 bytes (32 bits) deva ser varrida por 4 74hc595 em série sem usar sua lib de seu compilador. (sim...saiba que isso é possível! o [micro]mundo não se resume ao ccs).

uma função:

#define clock RB0 //voce pode expandir para outros MC´s tipo PTA0, P0.0 etc

#define data RB1

#define enable RB2

outlong(unsigned long int li)

{

unsigned char i;

enable=0;

for (i=0;i<32;i++)

{

data=li;//dado

clock=1;clock=0;//pulso para deslocamento

li>>=1;//próximo bit por favor (não me lembro se variável tipo long permite esta operação)

}

enable=1;enable=0;//pulso para segurar os bits na saída

}

teoricamente deve dar conta do recado e serve pra todos compiladores e microcontroladores (o [micro]mundo não se resume ao pic)

agora faça o que quiser da variável espelho L antes de chutá-la pra fora

p.ex. algo assim responderia à pergunta do casal:

#define setbit(var,bitno) ((var) |= 1 << (bitno))

#define clrbit(var,bitno) ((var) &= ~(1 << (bitno)))

L=0b00011110101001011111000010100101;

clrbit(L,26);//zerar o bit 26

outlong(L);

Apesar do quesito custo não estar em pauta, é válida sua observação. Mesmo sendo baratíssimo, podemos ecomizar o 74165. Se isto for pra matriz de leds, com + 1 entrada do MC pode-se ler 32 teclas fazendo uma varredura de 0´s. Mas isso é outra estória

Bom, se 1 dia tiver tempo, faço uma simulação desta pra ver pois defequei isto sem teste prático

abç & sucessos!

ricardospimentel · 10 de março de 2011

E aí José? Tudo bem?

Já sei como funciona um Shift com ou sem o Latch e por isso sei que eles funcionam mesmo sem um uC por perto, dá até pra fazê-lo funcionar só com a mão (..essa eu nunca testei, mas sabendo como ele funciona, é só testar na protoboard. Um louco aí se aventura?), e estou elaborando o meu próprio driver com algumas diretivas para facilitar o meu próprio uso, portanto não utilizo mais o driver do CCS.

Eu utilizo o CCS no momento e você deve estar utilizando o MikroC. Estou em fase de aprendendizado e o CCS tem um material de pesquisa bem grande na web, só uma pena ele não ser cem porcento ANSI, mas mais adiante pretendo utilizar ou o Hitech-C ou mesmo o SDCC que é muito famoso no mundo dos 8051.

Agora entendi o que você quis dizer com a variável espelho. Tendo o protótipo de função já prontinho para receber as nossas queridas variáveis, é só fazer o seguinte:

-usar essa variávelzinha com um nome bem bacana do tipo int, char, o que quiser;

-utilizar um operador adequado (COMPARAR, IGUALAR, NOT, AND, XANDY,OR, XOR, THOR);

-escolher o portão do 595, e pronto! Agora é só carregar essa função com essa variável, agora carregada com o nosso a suado byte, enviar para o Xifti e pronto. Aquela porta estárá em HIGH.

Acho que você está acostumado a utilizar chips de 16bits, aqui eu estou trabalhando com um simplezinho de 8bits, então uma int para ele, equivale a 8 bits e uma long int, 16bits. Caso eu queira usar 4bytes, en tenho que ou usar 4x8bits ou 2x16bits. Acho mais prático usar 4x8bits.

Bacana é isso, trocarmos nossos conhecimentos com humildade, paciência e boa vontade.

Valeu.

Ricardo da Silva Pimentel.

Sink00 · 10 de março de 2011

Bom na verdade um int NUNCA deveria ter 8 bits não importa a arquitetura.. Isso é definido no ANSI C... Mas de qualquer forma.. por que voce nao tenta os compiladores da Microchip.. eles sao MUITO bons, eficientes... de graça.. e agora o novo MPLABX que é baseado no NetBeans.. ta muito bom. Ele so fica grifando tudo falando que esta errado.. mas até ai..... hehehe.. Mas eu juro que não entendi toda essa discussao de vocês.. a duvida inicial nao poderia ser respondida apenas com bitwise?

Abs

.if · 10 de março de 2011

sim se não tivesse hw envolvido

o IAR C pros arms 32 bits considera char como .... 32 bits

os compiladores microchip não devem ser considerados 100% free. Considere o sdcc

abç

ricardospimentel · 10 de março de 2011

sim se não tivesse hw envolvido

o IAR C pros arms 32 bits considera char como .... 32 bits

os compiladores microchip não devem ser considerados 100% free. Considere o sdcc

abç

Ok então seu José. Então o tamnho de uma int depende então das configurações de cada compilador para cada uC, pelo o que entendi. Certo? (Ainda estou novinho, vou tropeçando e logo me erguendo mas tomando o cuidado de não tropicar de novo)

Valeu, até+!!

Bom na verdade um int NUNCA deveria ter 8 bits não importa a arquitetura.. Isso é definido no ANSI C... Mas de qualquer forma.. por que voce nao tenta os compiladores da Microchip.. eles são MUITO bons, eficientes... de graça.. e agora o novo MPLABX que é baseado no NetBeans.. ta muito bom. Ele so fica grifando tudo falando que esta errado.. mas até ai..... hehehe.. Mas eu juro que não entendi toda essa discussao de vocês.. a duvida inicial nao poderia ser respondida apenas com bitwise?

Abs

Aonde c tava este tempo todo?? Gostaria de saber sobre o "bitwise". Como você o aplicaria neste caso??

Eu tentei resolver a dúvida do nosso casal amigo e acabei entrando também na dúvida. Estou aqui, justamente tentando num projetinho meu, no Proteus ainda, Fazer uma portinha do 595 alternar piscando um led sem interferir e sem ser interferido por outros comandos, ou seja, quero acender um led na Q7', deixá-lo aceso. Enquanto isso fazer outras coisas como comandar um LCD nas outras portas, e a nossa portela Q7' ainda acesa sem se apagar.

Achei que eu tivesse conseguido com o código que expus acima, mas quando a aplicação é mais intensa, ou quando uso em conjunto com timer0, não dá certo.

Parece estranho, mas é que essa minha dúvida surgiu quase agora e achei que eu tinha achado a solução.

Sobre os compiladores, vou atrás do MPLABX para experimentar e concordo com o José Luís que os compiladores da Microchip não são 100% FREE, mas acho que utilizando os uC dela me dêem o direito de usar o sW deles. Acho que é assim.

Valeu a cooperação.

()s.

Ricardo da Silva Pimentel