Hallo,

Ben redelijk nieuw in C en doe voornamelijk kennis op via het www.
Volgende:
Ik maak een quiz-afdruk-knop-indicatie-met-led's systeem
Heb een port met daaraan drukknoppen naar massa en externe + interne pull up. De bedoeling is om iets te doen vanaf er één knop ingedrukt is.

if (~BUTTON_PINS) Werkt niet

if (!(BUTTON_PINS==0xFF)) werkt wel

Ik verwacht dat beiden identiek zijn maar werken toch anders.
Bovenstaande wordt continue doorlopen ook al worden er geen
knoppen ingedrukt. Als ik BUTTON_PINS uitlees is alles hoog.

Iemand een verklaring?

het verschil tussen ! en ~ is:
not (uitroepteken) -> inverteer boolean
not (tilde) -> inverteer bitmask

(a==b) is een vergelijking die een boolean oplevert. die kun je met "!" inverteren. je kunt ook herschrijven !(a==b) --> (a!=b)

~a levert geen boolean op. dus kun je ook niet gebruiken in een if statement. je zou kunnen zeggen: (~a==0x00), maar dan is (a!=0xff) netter. (denk ik)

http://stackoverflow.com/a/7207403/1590309

Een if statement werkt ook prima op niet booleans. Hij test of het gelijk of ongelijk aan nul is. Maar als de compiler integer promotion gebruikt (of hoe het dan ook heet) dan is ~FF gelijk aan FF00 en dan werkt het niet. [volgens het Witte K&R boekje, kan best aangepast zijn in de tussentijd]

Op 15 mei 2013 10:19:23 schreef JoWi:
Een if statement werkt ook prima op niet booleans.

Dat was ook mijn redenering.
BUTTON_PINS = 0xFF indien er niets ingedrukt is.
met ~ maak is 0x00 en triggert de IF niet.
Vanaf er 1 is ingedrukt -> triggert de IF.

Blijkbaar gebruikt de compiler (Gcc c en c++) dan integer promotion.
Ik google er verder op.
Bedankt!

*Edit -> Confused
Het register is 8bits en wordt dit dan ook als een 8bit waarde ingelezen? of worden er bits aan toegevoegd om er een 16bit integer
van te maken? Waardoor het 0x00FF inleest in plaats van 0xFF.
Bij inverteren wordt dit dan 0xFF00 en niet 0x00.

Iemand die men kaars oplicht?

[Bericht gewijzigd door Kwally op (29%)]

Volgende de C taaldefinitie vindt er een integer promotie plaatst op het resultaat van de + en - unary operators, de ~ bitwise complement en de beide shift operators.

Je register met de waarde van de IO poort mag dan wel 8 bit breed zijn, deze waarde wordt naar een integer omgezet voordat de ~ operator uitgevoerd wordt. In C is een integer minstens net zo groot als een short en een short is minstens net zo groot als een char (byte). In jouw geval is een integer groter dan een byte en worden er dus 0 waardes aan je 8 bit register waarde toegevoegd die dan door de bitwise complement op 1 gezet worden. In sommige architecturen is een integer net zo groot als een byte en daar werkt je constructie wel omdat een integer promotie geen 0 bits toevoegd.

Deze integer promotion binnen C (en C++) is een fout die vaak gemaakt wordt.

Dus van een char (8bit) maken ze een inter (16-bit)
als je +,-,~,<< en >> gebruikt.
De uitkomst is 16-bits?

Op 15 mei 2013 11:38:13 schreef Hewlett:
In sommige architecturen is een integer net zo groot als een byte en daar werkt je constructie wel omdat een integer promotie geen 0 bits toevoegd.

Ik maak gebruik van de ATMEGA644 (8-Bit). Dus in principe zou het
wel moeten werken?

*Slow student @ Work

Het feit dat je op een 8 bit micro werkt wil dan niet zeggen dat een integer ook 8 bit is.

Het resultaat van een operatie met een inpliciete integer promotie is afhankelijk van waar dat resultaat aan toegekend wordt. In jouw geval binnen binnen een if statement als conditie variabele is dat een integer.

[Bericht gewijzigd door Henry S. op (35%)]

int is in C altijd minimaal 16 bits.

Tenzij je je compiler kunt vertellen schijt te hebben aan de standaard. Zo kun je avr-gcc de opdracht geven 8-bits ints te gebruiken. Waarschijnlijk maak je daarmee op termijn meer stuk dan je lief is, maar ja, als je jezelf in de voeten wil schieten moet je dat vooral doen :-)

Btw, short is altijd minstens 16 bits. long altijd minstens 32. int hoort het default type van de CPU te zijn, maar minimaal 16 bits:

Ok bedankt allemaal. Mijn probleem is klaar en duidelijk

Ik maak ook geregeld gebruik van
uint8_t = een 8 bit integer.
Waarom maak ik daarmee meer stuk dan me lief is?
Das toch het ideale voor deze AVR (8-bit'er) ?

Nee, dat bedoel ik niet. uint8_t is prima, en zelfs beter dan omwegen als 'unsigned char'

Wat is bedoel is dat bij operators als '+', '<<' en '-' in C niet intergers opgewaardeerd worden tot int's. En ints zijn minimaal 16 bit.

Er is een optie voor avr-gcc (-mint8) waarmee int's 8 bit worden. Dat mag niet volgens de C-spec, en als je het wel doed kan er een hoop stuk gaan.

Maar uint8_t gebruiken is gewoon goed en verstandig.

edit: @kwally hieronder: ja.

Alweer iets bijgeleerd.

Ter bevestiging en om zeker te zijn dat ik het goed heb...

stel:

uint8_t input = 0xFF;
uint16_t uitkomst;

in de code doe je dan
uitkomst = ~input;

Naar mijn gevoel is uitkomst dan 0xFF00 ?

In dit soort gevallen van twijfel is het heel handig om de assembly listing erbij te hebben. Dan check je even wat die if precies test en je weet het.
Misschien staat er in dit geval wel 1 van de poort inputs op een andere waarde. Inverteren levert dan nog steeds !=00 op.

Dag Kwally,

Op 15 mei 2013 13:27:11 schreef Kwally: Naar mijn gevoel is uitkomst dan 0xFF00 ?

Ja, tenminste als uint16_t ook 2 bytes breed is. Misschien kan je dit eens proberen om het verschil te beter te begrijpen


unsigned char inputI = 0xFF;
char inputII = 0xFF;

int  uitkomstI, uitkomstII;
 
uitkomstI = ~inputI;
uitkomstII = ~inputII;

Ik weet niet of dit echt duidelijk was, maar C kent enkel de volgende types, alle andere types zijn gewoon andere namen voor dezelfde types:


char
unsigned char 
short 
unsigned short
int 
unsigned int
long 
unsigned long  
float 
double
//En voor de puristen :)
enum 

//C++ voegt daaraan toe
bool

uint8_t is bijvoorbeeld een unsigned char (zo vermoed ik toch) wat je ergens een of andere header kan terug vinden.

Als je wil weten hoeveel bytes een type omvat kan je ook sizeof gebruiken. Als je code schrijft voor meerdere platformen (portable code) heb je trouwens dikwijls geen andere keuze.

Voorbeeld:

 
//Zelfgemaakt type 
typedef struct 
 {
  char* string;
  union {
	  int intGetal;
	  float reeelGetal;
  	};
 } tMystruct;  

int testI =  sizeof(int);
int testII =  sizeof(tMystruct);

Groetjes

Bedankt allemaal.
Alweer iets meer kennis van C

@YokoTsuno:

Je verhaal klopt voor K&R C, maar niet voor recentere versies van de standaard.

C99 (uit 2000) voegt (o.a.) de uint8_t en uint16_t types toe, en die zijn gedefinieerd als EXACT 8 resp. 16 bits.

Hoe de compiler ervoor zorgt dat een uint8_t 8 bits breed is mag de compiler zelf weten. Dus het kan best zijn dat avr-gcc dit doet door uint8_t onder water te definieren als unsigned char, maar daar mag je niet van uit gaan.

Gaaf, hier heb ik ook weer iets geleerd wat ik tot voorheen niet begreep. Ik had nog nooit gehoord van 'integer promotion'.

Overigens, van de vele manieren om dit op te lossen zou je dan ook nog dit kunnen schrijven:

if(0x00FF & ~BUTTON_PINS)

Daarbij gebruik je alsnog de tilde.
Maar dan is de optie die je zelf aangaf wel veel 'leesbaarder':


if(!(BUTTON_PINS == 0xFF)

//of nog duidelijker:

if(BUTTON_PINS != 0xFF)

Ik kan me ook voorstellen dat deze twee efficiëntere code opleveren dan de eerste...

Dag Blurp,

Op 16 mei 2013 09:32:12 schreef blurp: C99 (uit 2000) voegt (o.a.) de uint8_t en uint16_t types toe, en die zijn gedefinieerd als EXACT 8 resp. 16 bits.

Klopt, maar je moet dit toch wat nuanceren denk ik.

Heel wat compilers ondersteunen deze C99 niet of enkel gedeeltelijk en bij diegenen die dat wel doen gebeurt dit bij mijn weten meestal via macros in een header file (<stdint.h> bijvoorbeeld) zodat dit uiteindelijk weer op hetzelfde neerkomt, namelijk indirect gebruik van "echte" C types. Welk voordeel heeft dit dan?

Sommige compilers hebben ook nog een aantal andere types voor getallen van diverse bitbreedtes (__int16, __int64,...) en zelfs 16-bit
karakters (Om een oplossing te bieden aan Chinees of andere niet-Westerse talen) welke echt in de compiler gedefinieerd zijn. Dit zijn zelfs types die in geen enkele standaard voorkomen.

Als je altijd met eenzelfde compiler werkt is het gebruik van C99 of andere types inderdaad geen probleem. Bij meerdere compilers ligt dit wat moeilijker volgens mij.

Groetjes

De originele standaard stelt iets van char <= short <= int <= long. Maar soms wil je zeker weten een 32-bit variabele gebruiken.

Om een voorbeeld te noemen. Op de avr (gcc-avr) is een int 16-bits. De standaard zegt dat de processor daar efficient mee om moet kunnen gaan. Nou dat lukt dus niet: het is een heel gedoe om met 16-bits te werken op de AVR. Anyway, als je iets schrijft wat van AVR tot x86-64 moet werken (*), heb je anders een probleem als je een 32-bit type wilt hebben. Dat zou dus iets als de uint32_t moeten zijn.

Dat het dan uiteindelijk toch een header is die een #define doet, maakt niet uit. Als de standaard voorschrijft dat iets moet werken, maakt het niet uit hoe dat geregeld wordt. (als de standaard zegt dat ik zonder #include de types moet kunnen gebruiken dan moet de compiler uit zichzelf dat include file regelen).

(*) Stel bijvoorbeeld dat ik een binary structure op de AVR naar SD kaart schrijf en weer uitlees/presenteer op een PC. Dan is er een library component/definitie wat shared is tussen die twee programmas.

Op 16 mei 2013 19:22:05 schreef rew:
Om een voorbeeld te noemen. Op de avr (gcc-avr) is een int 16-bits. De standaard zegt dat de processor daar efficient mee om moet kunnen gaan.

mode=standaardneuken:

Inderdaad moet int de breedte hebben waarmee de processor efficient kan werken, MAAR int moet minimaal 16 bits breed zijn.

Daarom is int op avr-gcc netjes 16 bit, ookal is dat veel meer werk voor de processor.

mode standaardneuken uit.

Wat wel weer leuk is is dat gcc heel vaak die promoties naar 16 bit in de uiteindelijke output weghaald, omdat die extra 8 bits nooit gebruikt worden. Dus uiteindelijk hou je toch efficiente machinecode over

@Yoko: Welke (relevante) compiler ondersteund C99's stdint niet? Bij mijn weten alleen MS Visual C, maar wie gebruikt dat voor iets anders dan windows?

Dan speelt er ook nog het stukje leesbaarheid en portabiliteit.

if(~BUTTON && 0xff)

Is minder leesbaar als bijvoorbeeld

boolean buttonPressed = (BUTTON & 0xff);
if(!buttonPressed) ...

Daarnaast is het verstandig geen aannames te nemen over de gebruikte compiler, uint conversie of processor. Aannames zijn de bron van onverklaarbare bugs. Derde voordeel is debugging: je kunt de waarde van de boolean mooi tracen of step trough debuggen. Een extra regeltje code kan geen kwaad vind ik hier.

Ps. Ik weet dat beide regeltje code niet hetzelfde doen, maar het gaat om de stijl.

Ik ga er effe vanuit dat het een tikfout is dat in je eerste voorbeeld && staat, en in de tweede &.

Als dat zo is zal iedere fatsoenlijke compiler (iig avr-gcc) er dezelfde machinecode van maken.

Edit:
@RobvdVeer hieronder: Ik vind je tweede voorbeeld een stuk duidelijker!
Inderdaad moet je in eerste instantie leesbare code schrijven, optimaliseren is vaak maar heel plaatselijk nodig, als het uberhaupt wel moet.

"Premature optimization is the root of all evil"

Op 17 mei 2013 14:46:14 schreef blurp:
Ik ga er effe vanuit dat het een tikfout is dat in je eerste voorbeeld && staat, en in de tweede &.

Als dat zo is zal iedere fatsoenlijke compiler (iig avr-gcc) er dezelfde machinecode van maken.

Dat weet ik, daarom staat de ps. voetnoot.

Dat het resultaat hetzelfde zal zijn, garandeerd niet dat de lezer/programmeur snel doorheeft wat er moet staan of wat het ding doet. Anders kunnen we zo terug naar assembly. Ik zie teveel software met

int x,y,a.b;
/* don't touch */
x = (int)a/b % y; while(zz++) y /= 3; if (a) break; 

Ok ok, dit is overdreven, maar compilers kunnen tegenwoordig prima omgaan met langere variabelenamen, de optimizer maakt er wel wat moois van. Punt is, zorg dat je je code over een jaar nog begrijpt, of beter: dat een ander hem begrijpt.

Als je een register waarde uitlest uit de AVR is dit
een sidned char of een signed int8_t.

Want met het gebruik van "~" voegt hij '1' toe.
Mocht het een unsigned zijn zou hij '0' toevoegen.

*Ik hoor het wel als dit mis is.

Waarschijnlijk geen van beiden. Maar het hangt af van je compiler.

Ergens in de include files staat PORTD gedefinieerd. Pluis die deinitie uit, en je zult zien wat het is.

Maar op avr-gcc is alles gedefineerd als unsigned, dus uint8_t voor 8 bit registers.

Sowieso ken ik geen enkel register bij AVR waar een signed interpretatie zin heeft.

Op 16 mei 2013 21:43:30 schreef blurp: Welke (relevante) compiler ondersteund C99's stdint niet?

Wat is er verkeerd aan een bredere kennis van C/C++? Je weet nooit of de TS met een ander platform in aanraking komt.

Op 17 mei 2013 15:23:45 schreef Kwally: Als je een register waarde uitlest uit de AVR is dit een sidned char of een signed int8_t.

Voor gcc-avr is signed char gedefinieerd als:

 typedef signed char int8_t 

in een meegeleverde include file. Beide zijn dus een en hetzelfde type. Hetzelfde geldt voor alle andere types.

PORTx is enkel een macro voor het werkelijke HW adres van de poort. Zoiets als 0x0015001344. Zoals Blurp al zei wordt de waarde in dit register geinterpreteerd als unsigned char. Ook gedefinieerd in een meegeleverde header.

Er is trouwens nog een alternatief voor jouw typeconversieprobleem in de vorm van een union/struct. Deze methode laat eveneens toe om direct een bit te adresseren zonder dat je telkens een masker nodig hebt. Alhoewel dit op het eerste zicht anders lijkt is deze structuur slechts 16 bits groot voor jouw platform, hetzelfde als een unsigned int.


main()
	{
		
int portValInInt;
unsigned int portValInUInt;

typedef union 
	{
        struct  {	
                      unsigned int port: 8; /* 8-bits port*/
                     };
		/*Optioneel vanaf hier*/
        struct  { 	
                       unsigned int IO0: 1; /* Input 0*/
                       unsigned int IO1: 1; /* Input 1*/     
                       unsigned int IO2: 1; /* Input 2*/
                       unsigned int IO3: 1; /* Input 3*/       
                       unsigned int IO4: 1; /* Input 4*/
                       unsigned int IO5: 1; /* Input 5*/
                       unsigned int IO6: 1; /* Input 6*/
                       unsigned int IO7: 1; /* Input 7*/
                      };	
		/*tot hier*/
        int value;
	} t_port;
 
t_port digitalIO = {0};

digitalIO.port = ~BUTTON_PINS

portValInInt = digitalIO.value;           
portValInUInt = digitalIO.value;           

/*Een enkele bit adresseren kan zo*/
if (digitalIO.IO1) { /*Doe iets*/ }	

return;

}

Groetjes