-
Thread
einzelnes bit in c abfragen
Hi Leute, wie ist es in C möglich einzelne Bits einer selbstdefinierten Variable (int oder char) an meinem PIC abzufragen? Gruß Gerhard
gereicht hat, hier nochmal: [[Bitmanipulation]] http://www.mikrocontroller.net/search?query=einzelnes+bit+in+c+abfragen Du hättest auch einfach nur deinen Threadtitel in die Suche eintippen können, oder ein C-Buch in die Hand nehmen, oder ein Tutorial ansehen, oder einen anderen C-Quelltext, oder
-
Thread
Einzelne Bit's abfragen mit C
Guten Morgen Ich mache meine berufsausbildung zum Elektroniker in der Schweiz. In meiner Region ist es üblich, dass man in den ersten zwei Jahren nur Assembler Programmiert, was ich mittlerweile auch fast im Schlaf beherrsche. Eigentlich fangen wir mit C erst in ein paar Monaten an, aber mich reizt es schon jetzt ein bisschen damit anzufangen. Nun, gestern habe ich mir mal ein Buch geholt und gemerkt, dass es doch irgendwo eine Gewisse ähnlichkeit hat. Ich besitze ein Board mit einem PIC16F887, zum Programmieren verwende ich den MikroC PRO for PIC. Auf dem Board sind 8 Schalter (PORTA
-
Thread
Port einzeln abfragen
PD3 auf high PORTD &= ~(0 << PD2); //PD2 auf low PORTD &= ~(1 << PD1); //PD1 auf high einzelne Ports setzten, aber wie kann ich einen vereinzelten Port abfragen ? ich kenn das bisher nur mit if(PORTA == 0xFE)..... bzw. if(PORTA == 0b11111110)..... habe es schon mit if(PORTA |= ~(1 << PA0
binaer 00000001 //if(PIND.0 == 1) Hier wird ganz einfach geprueft ob das Bit 0 im PIND eine 1 ist. Im Grunde ist das ganz genau dieselbe Abfrage wie PIND & (1 << PD0). Auch hier wird geprueft ob Bit 0 eine 1 enthaelt. Ueber die Maske werden alle anderen Bits definitiv
-
Thread
Einzelne Bits in C setzen
muss, kann man das mit einem Makro, inline-Funktionen oder mit der struct Variante auch mit Standard-C abbilden. Meine Meinung: Die Möglichkeit bei einigen Compilern mit einer speziellen Syntax Bits einzeln ansprechen zu können, wird bei weitem überschätzt. Ist ungefähr so wichtig wie es beim Auto
DATA=1 und i=DATA sind dort legitime Anweisungen, ohne dass auf Lesen umgeschalten werden muss.) C für µC ist schon sehr hardwarenah. Nur Standardfunktionen können portiert werden. Alles, was auf die Hardware zugreift, und dazu zählt oftmals auch das setzen eines einzelnen Bits, ist sowieso schlecht
-
Thread
Binärzahlen und Abfrage einzelner Bits in C /
Hallo zusammen, als C-Anfänger habe ich folgende, für die meisten von euch wahrscheinlich ziemlich leicht zu beantwortende Fragen: 1. Wie kann ich einzelne Bits eines Zeichens abfragen? Es geht um eine Manchestercodierung
0bx gehört leider nicht zum C-Sprachumfang. Da es aber manchmal sehr nützlich ist, unterstützen es einige Compiler. Zur Abfrage einzelner Bits: dafür gibts mehrere Möglichkeiten. Hier mal eine: if (temp&0x80) // testet Bitstelle
-
Thread
Einzelne Bit in Bitfeld in for Schleife ansprechen
Rick M. schrieb im Beitrag #7741920: > C hat anscheinend keine vernünftigen "Werkzeuge" um einzelne Bit zu > adressieren. Natürlich nicht! Aber dein C++ kann das! z.B. durch überladen des [] Operators. Die Arduino EEPROM Lib tut ähnliches
Merker zu verwenden. Ja, das ist einfach und schnell. Rick M. schrieb im Beitrag #7741920: > C hat anscheinend keine vernünftigen "Werkzeuge" um einzelne Bit zu > adressieren. Überhaupt kein Problem. [c] (a >> i) & 1 [/c]
-
Thread
[AVR] Zwischen einzelnen PCINT-Quellen unterscheiden
Note schrieb im Beitrag #4614635: [c] > ISR(PCINT1_vect) > { > // Vergleich alter/neuer Portzustand > uint8_t changedBits; > > changedBits = PINB^portOldState; > portOldState = PINB; [/c] Du hast definitiv das PCINT-Problem
besser? ISR(PCINT1_vect) { // Vergleich alter/neuer Portzustand uint8_t changedBits; uint8_t changedBitsBuffer; changedBitsBuffer = PINB; changedBits = changedBitsBuffer^portHistory; portHistory = changedBitsBuffer; // die restlichen Abfragen }
-
Thread
Einzelne Port-Pins abfragen
) bekomme ich das richtige Ergebnis. Kann man gezielt einzelne Pins überhaupt abfragen? Danke
'sbis'/sbic' kann man auch den Port einlesen und das Bit abfragen: [avrasm] in r16,PINB andi r16, 1<<PINB0 breq abc ; wenn Bit Null oder brne abc ; wenn Bit <> Null [/avrasm] MfG Spess
-
Thread
AVR: Bit-Abfragen und -Zuweisungen an einzelnem Port
einzelnen Eingang ABFRAGEN? Kann man nur ein ganzes Byte abfragen ( [...] if(PORTB == 0b00000010){ ... } [...] ) oder ist auch ein einzelnes Bit möglich? Beim Googeln habe ich leider keine Lösung für
Sepp schrieb im Beitrag #2955822: > Einzelne Bits kann man nicht lesen, nur die ganzen 8 Bit des Ports B. Man kann z.B. auf Assembler-Ebene zumindest mit den SKIP-Befehlen auch einzelne Bits abfragen, aber scheint hier wohl um C zu gehen
-
Thread
8 bit auslesen
Darth V. schrieb im Beitrag #7261218: > Cch brauche die einzelne bits um je nach Stellung Musik abzuspielen. :) > Und es wäre zu viel Arbeit von 8 bit jede Stellung zu erfassen und als > if Abfrage abzufragen... ???-{ .... Sieht scheiße aus, wa? Probiers
doch mal, warum du das so machen willst. Was ist das > eigentliche Problem? Warum willst du da einzelne Bits "auslesen"? > Ich bekomme 128 verschiedene Zustände reingeschickt die per Expander über den I2c auf den uC(ATMega328P) geschickt werden. Dass wird per Uart auf den RPI geschickt. Jetzt will
-
Thread
Hilfe, Interrupt flags lassen sich mit 'typedef union' nicht einzeln löschen
Neue CAN Nachricht im FIFO 0 Buffer-Array abgelegt uint32_t RF1N:1; //Bit 11: Neue CAN Nachricht im FIFO 1 Buffer-Array abgelegt … } bit; uint32_t reg; } CAN_IR_Type canIrType; [/c] Auf diese weiße kann man einfach einzelne Bits mit [c]if(canIrType.RF0N
bits, die bereits auf 1 sind werden wieder auf 1 gesetzt. } } [/c] . . . Kann mir irgendjemand erklären, wieso dem so ist? Wieso wird nicht einfach das einzelne Bit mit [c]canIrType.RF0N =
-
Thread
Abfage auf einzelne Bits einer Variable
Guten Morgen. Habe eine Frage zu einer if Abfrage. #define Bit0 0x01 #define Bit1 0x02 #define Bit2 0x04 ... #define Bit7 0x40 extern unsigned char test; if(test & Bit1) {...} if(test & Bit2) {...} if(test & Bit3) {...} Zur Erklärung:In der Variable Test stehen Informationen in den einzelnen Bits. Ich möchte nun die einzelnen Infos wie oben beschrieben abfragen. Ist diese Umsetzung so möglich? Gibt es einfachere oder bessere Möglichkeiten? Dank für eure Unterstützung. MfG Josef
-
Thread
Abfrage effizienter gestallten
Hallo liebe Community ich habe derzeit folgende Code Zeilen [c] if(!strcmp(ucTemp,"version")) main_token.befehl = VERSION; //Erster Befehl entschlüsseln und sichern if(!strcmp(ucTemp,"output_on")) main_token.befehl = OUTPUTON; //Erster Befehl entschlüsseln und sichern if(!strcmp(ucTemp,"output_off")) main_token.befehl = OUTPUTOFF; //Erster Befehl entschlüsseln und sichern if(!strcmp(ucTemp,"pause")) main_token.befehl = PAUSE; //Erster Befehl entschlüsseln und sichern if(!strcmp(ucTemp,"end")) main_token.befehl = END; //Erster Befehl entschlüsseln und sichern
-
Thread
Wie kann man in C einzelne Bits einer Variable prüfen ?
µC eine einzelne Variable für verschiedene Dinge nehmen könnte. Gruß Andreas
@Josef: Du betrachtest beide Bits gemeinsam, er möchte aber wissen ob bit 3 ODER bit 1 null ist. Das geht nur durch eine bitweise ODER-Abfrage.
-
Thread
ATmega32 einzelne Pins setzen und abfragen
geeigneter Bitmanipulation (siehe https://www.mikrocontroller.net/articles/Bitmanipulation) problemlos einzelne Bits abfragen, setzen bzw. löschen. Colin v.H. schrieb im Beitrag #2731202: > Port-A ist als Eingang geschaltet. Nun läuft im µC eine Schleife ab, die > nur unterbrochen werden soll, wenn Pin
Bitmanipulation (siehe > https://www.mikrocontroller.net/articles/Bitmanipulation) problemlos > einzelne Bits abfragen, setzen bzw. löschen. ist das nicht ein wiederspruch in sich? der atmel kann sowohl einen Port als auch ein Bit eines Ports ändern.
-
Thread
wie komme ich an die einzelnen Bits? ( C )
Pin schreiben usw. Eine Funktion die mir das Timing macht habe ich, diese funktioniert auch. [c] write_one(); write_zero(); [/c] Wenn ich jetzt das Byte 0 habe dann entspricht das ganze folgendem [c] write_zero(); //Bit 1 write_zero(); //Bit 2 write_zero(); //Bit 3 write_zero();
per RS232 eine Zahl zwischen 0 und 255 und den rest macht der Code. Der zerlegt das Byte dann in einzelne Bits und macht für jedes Bit dann eine if abfrage wenn eine 0 dann write_zero() und wenn eine 1 dann write_one(). Also, 1. Wie kriege ich aus dem Byte acht Bits? 2. Wie kriege ich zugriff auf
-
Thread
Schieberegister: Abfrage von mehreren Tastern
Schieberegister, das macht der P/S Eingang. Nachdem dann die Werte im Schieberegister sind, wandern die einzelnen Bits im Gänsemarsch aus dem Q8 Ausgang raus. Eines nach dem anderen und jeweils um 1 Schritt weiter, wenn du einmal auf C drückst.
) { Result <<= 1; if( IS_SET( SR_PIN, SR_DATA ) ) Result |= 0x01; SET_BIT( SR_PORT, SR_C ); CLR_BIT( SR_PORT, SR_C ); } return Result; } int main(void) { uint8_t Byte; SR_DDR |= (1<<SR_PS) | (1<<SR_C); DDRD |= (1<<PD5) | (1<<PD6) | (1<<PD7);
-
Thread
Bit als Variable definieren in C (STM32)
Na gut, noch ein Versuch zum ursprünglichen Thema zu kommen : einzelne Bits kann man in C innerhalb von Strukturen anordnen : [c] struct { unsigned int buhl:1; } lieblingsvariable; [/c]
schrieb im Beitrag #5525196: > Na gut, noch ein Versuch zum ursprünglichen Thema zu kommen : > einzelne Bits kann man in C innerhalb von Strukturen anordnen : > > [c] > struct { > unsigned int buhl:1; > } lieblingsvariable; > [/c] Wobei die struct ganze Bytes belegt, man also nur bei Verwendung
-
Thread
einzene Bits prüfen ( if (bit) {.} )
[c] char _var; // die variable in der du ein einzelnes bit abfragen willst if ((_var & 0b00001000) >= 1) /* die 1 gibt das bit an welches du abfragen willst.*/ { x=y; // was auch immer dann halt
Thomas Müller wrote: > [c] > char _var; // die variable in der du ein einzelnes bit abfragen willst > > if ((_var & 0b00001000) >= 1) /* die 1 gibt das bit an welches du > abfragen willst.*/ > { > x=y; // was auch immer
-
Thread
"Memory Barrier" in C99
krachen. Das kann es nur, wenn die Hardwareregister breiter sind als die native Busbreite des µC - wenn das also z.B. ein 16-Bit-Register ist, und das auf einem 8-Bit-AVR angesteuert werden soll. Darin unterscheidet sich das Register in keiner Weise von einer Variablen, die größer ist als die
Zugriff sowieso atomar. Nö. Ein Read Modify Write Zugriff, welcher eben NICHT sbi/cbi nutzt, um einzelne Bits zu ändern, ist es auch nicht! Nur komplette, einfache Bytezugriffe beim Lesen oder Schreiben!
-
Thread
PIC18F1220 (C-Code) Port (einzelnen Pin) abfragen
Hi! Seit etwa einer Woche beschäftige ich mich mit PICs, z.Z. eigentlich nur mit dem 18F1220 (weil ich lieber in C schreiben möchte). Ich benutze MPLAB X und PICkit3. Soweit so gut! Bis jetzt habe ich es geschafft Ports ein und auzuschalten (LED blinken lassen), den Wert eines Potis mit ADC zu bestimmen und ein LCD zu initialisieren (mehr oder weniger gut). Nun wollte ich wegen dem LCD die Busy-Flag abfragen können und da viel mir auf, dass ich bis dahin noch nie ein High-Low Signal an einem Pin abgefragt habe. Doch genau das bekomm ich einfach nicht gebacken und weiß nun einfach nicht mehr weiter
-
Thread
Übertragung von High- und Low-Signalen zwischen zwei AVR
Das ist doch C++ Code in einer Umgebung verpackt. Oder irre ich mich? Denn in C++ ist das hier [c] if ((pinD.bit2 == 0) & (pinD.bit3 == 0) & (pinD.bit4 == 0)){ [/c] an dieser Stelle nicht richtig. Ein
selten, weil man da tatsächlich eher wenig mit einzelnen Bits rummacht. Aber auf einem µC ist das anders: Da sind die Bitoperationen dein Lebenselexier, weil sich 80% der ganze Programmierung nur mit der Manipulation von einzelnen Bits bzw. Bitfolgen beschäftigt
-
Thread
ADC-Kanäle sukzessive abfragen
// start bit for (uint8_t i = 9 + STOP_BITS; i; i--) // start + data + stop bits { _delay_us(1e6 / BAUD); // bit duration if (c & 1) STXD = MARK; else STXD = !MARK; // = Space c >>= 1; // next bits or stop bit(s) } } [/c]
-
Thread
Abfrage von ca. 130 Tasten
wohl doch recht? c-hater schrieb im Beitrag #4878262: > Kein Problem bei der Abfrage per Matrix. Geht genauso, als hätte man > zwei einzelne Taster. Man muss halt bloß dafür sorgen, dass alle > Mittelkontakte einheitlich
der in der digitalen Welt magischen Grenze von 128 liegt. Dann brauchst du vier (bis 256 Tasten) 8-Bit Schieberegistern. Bei 128 kämest du mit dreien aus. Bei Einzel-IO-Abfrage bräuchtest du für 130 Taster ganze 17 Schieberegister mit 8 Bit.
-
Thread
einzelne bits lesen / setzen
Hallie hallo allerseits! bin gerade dabei mein fertiges Prograemmchen zu optimieren und hab da ein Problem gefunden, dem ich nicht Herr werde. hoffe, hier kann mir vielleicht jemand weiter helfen: und zwar sollen im Programm verschiedene Bausteine und Funktionen ueber UART (Hyperterminal/Labview) ein und aus geschaltet werden. das habe ich bis Dato mit einem ganzen Byte gemacht, in das ich eine 1 oder 0 geschrieben hab und im Programm dieses Byte auch auf 1 oder !1 abgefragt hab. Funktioniert, aber da werden bisl Ressourcen verballert, denk ich. nun wuerd ich gerne ein Byte nehmen und
-
Thread
Tasten entprellen
passiert im wesentlichen: > return key_mask; Nö. Die wichtigste Operation hast Du unterschlagen: [c] key_mask &= key_press; // read key(s) [/c] Das ist die Maskierung des Dich interessierenden Bits. Du brauchst erstmal ein Verständnis, wie man in C einzelne Bits behandelt. C prüft bei Bedingungen
sind. Soviel Lebenszeit will keiner verschwenden. > aber beileibe nicht bei der Portierung von 8Bit-Code auf > 32Bit, Portierung von "8Bit-Code"? 8-Bit-Code in C? Was soll das denn sein? Gabs noch nicht mal auf der PDP-11, der C-Ur-Maschine. 8-Bit-Code-C-Compiler sind keine C-Compiler, sondern
-
Thread
Interrupts in Assembler und C
falsche operatoren - Setzen von Bits mit "oder" [c]EICRA |= ( (1<<ISC00) | (1<<ISC01) ); EIMSK |= (1<<INT0); // Interrupt zulassen! [/c]
// Tu was... Zaehler = 0; // ABER auch hier koennte der Interrupt die if-Abfrage unterbrechen :-( } } [/c]
-
Thread
Auf Bit array zugreifen
@ Peter Zz (bastelboy) >Ich benötige für einen Ringbuffer in C ein 1024 Bit langes Bitarray. >Die Abfrage, Setzen, Löschen müssen sehr schnell sein. Du hast mal sicher NICHT 1024 einzelne Statusbist, sondern eher ein Array mti Daten für LEDs etc., die schnell
); } void writeOne() { buffer[writeIndex] |= bitMask; incrementToNextBit(); } [/C]
-
Thread
Abfragen
Schleifendurchlauf wiederholen. 6) Für Deine Zukunft als Programmierer: Du solltest versuchen, Dich mehr in den µC reinzuversetzen und nachzuvollziehen, was er bei den einzelnen Befehlen macht, statt munter drauf los diverse Ideen bunt zu mischen und nach dem Try and error Prinzip Deine Programme zu entwickeln.
Hi Ihr lieben, ich habe die abfrage hinbekommen mit der Version von Jen. Danke nun habe ich eine andere Frage. Wie kann ich an einem Pin ohne Interrupt einen Flankenwechsel abfragen? Muss nämlich nachschaun, wenn da Signale sind,
-
Thread
EleLa - Elektronik Lagerverwaltung Entwicklung V3.0
bekam nur Unmengen von unveränderlichen "<Neuer Eintrag>". Meine Umgebung: Client: Windows 7, 64 Bit, tagesaktuell gepatcht, mysql-connector-c-6.1.5-win32 Server: MySQL V5.5.33 unter Linux
die DLL "libmysql.dll" Homepage von MySQL geladen werden: "http://dev.mysql.com/downloads/connector/c/" Falls der Link nicht mehr funktioniert: "http://dev.mysql.com/" >> Downloads >> Community >> MySQL Connectors >> Connector/C (libmysqlclient) Hier kann das Windows ZIP Archiv für 32 oder 64 Bit
-
Thread
C String einlesen, wieso geht das?!
Abfrage(); return 0; }[/c]
() { Abfrage(); return 0; } [/c] [pre] $ gcc s.c && ./a.out s.c: In function ‘Abfrage’: s.c:8:11: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘char (*)[1]’ [-Wformat
-
Thread
if-Abfragen verpönt?
A. K. schrieb im Beitrag #2889430: > Beispiel: GCC für ARM(e) macht aus einer if-Abfrage > cmp r0, #99 > movgt r0, #0 Und das ist besser als eine einzelne AND-Instruktion? Abgesehen davon, dass das egal ist, weil man auch auf 'nem µC heutzutage normalerweise
> Sind if-Abfragen so verpönt? Nein, überhaupt nicht, zumindest nicht in C. [c] if (buffer_write_index >= buffer_size) buffer_write_index = 0; [/c] Das ist für mich etwas holprig zu lesen, funktioniert
-
Thread
Wie mach ich das am schlausten? Lochstreifen einlesen mit ATmega16
LS1 rjmp bit1_1_1 ;wenn LS1 gesetzt, dann zu bit1_1_1 springen sbis PIND,2 ;Abfrage LS2 rjmp bit2 ;inzwischen gesetzt? dann weiter zu bit2 rjmp bit1_1 ;nicht gesetzt dann weiter abfragen bit1_
trotzdem etwas ändert, sollte man auch das geänderte Prog posten. > Das Blech steht jetzt bei c0 auf dem bild. Müsste ich jetzt nicht erst > sbis Licht,clock abfragen um dann das erste Bit einzulesen? Nein, denn dein Blech steht jetzt nicht bei c0, sondern bei b0. > Was der > Befehl "ror
-
Thread
Frage zur Tasterabfrage
Code wird der ganze PORT D Überprüft/ausgewertet/abgefragt. Ich würde gern wissen wie man ein einzelnes Bit aus PORT D überprüft/auswertet/abfragt. P.S. Wenn man den µC weg lässt wie du schreibst, nimmt man da vorzugsweise Leiterbahn oder eher Draht ?
Pull-up-Widerstände von etwa 20 kOhm nach High. Wenn die Taster geöffnet sind, erhält man so eine Eins, sind einzelne Taster geschlossen erhält man für diese eine Null. Das steht im Datenblatt des ATMega328 Prozessors. Statt den ganzen Port abzufragen, kann man auch einzelne Bits abfragen. Dazu einfach eine Beschreibung
-
Thread
Auslastung/Rechenleistung eines µC
übernehmen" soll, wie er > berechnen kann. Und zwar berechnen, ohne dass die Ergebnisse der > einzelnen Aufgaben nicht länger als eine bestimmte Zeit brauchen. Also > deterministisch sind. [math] \sum_{i=1}^m { C_i \over P_i } \le 1 [/math] i = Periodisches Ereignis m = Anzahl der periodischen
Zeit den Zustand des µCs kennen! > > Klaus Diese Aussage ist schlicht weg falsch!!! Der uC ist deterministisches System. Mann muss nichtmal den ganzen Zustand kennen (den man aber sehr wohl auf grund Determinismus fast vollständig kennen kann), sondern nur die Zustände/Bits von denen Sprünge
-
Thread
Bit-Manipulation in C (schnellere Formulierung?)
Hallo ! ich habe eine Frage zum Thema Bit-Manipulation in C http://www.mikrocontroller.net/articles/Bitmanipulation#Standard_C_4 Abfrage 1 (verstanden und akzeptiert) [c]// prüfe ob Bit 4 in der Variable tmp gesetzt ist if (tmp & 0x10
Boolschen Wert wirken (anstatt die einzelnen Bits des "tmp & 0x11" zu negieren): geänderte Abfrage 2 [c]// prüfe ob Bit 0 und Bit 4 in der Variable tmp gelöscht sind // die Klammer ist wichtig! if (!(tmp & 0x11)) { // hier die
-
Thread
I2C und STM8
(uint8_t)result; I2C->CCRH = (uint8_t)result & 0x0F; //first 4 bits of CCR-value I2C->OARL = 0xA0; //own Address I2C->OARH = 0x40; //6th bit must be set by software I2C->CR1 = 0x01; //enable peripheral [/
[/c] "Entscheident" hier war die Abfrage, ob der I2C-Bus die Startaktion schon erkannt hat !! while (!(I2C_SR1 & I2C_SR1_SB));
-
Thread
Eingänge abfragen
Nimm an, Du würdest einen Port mit 8 Eingängen abfragen und ignoriere die Bits die auf Ausgang geschaltet sind.
im Prinzip wie Guru schon schrieb, benutze Bit-Masken für jeden einzelnen Eingang
-
Thread
Art der if-Auswahl nur Geschmackssache?
ist bei c = 0x81 der Fall. Also richtig. Wenn du abfragen willst ob Bit7 und Bit0 gesetzt ist, geht das so: if ((c1 & 0x81)==0x81)... Deinen Mangel an Kenntnissen von Bitoperationen kannst du nicht
zu aufwändig um. Für a32 = b16 x c16 muss zwingend b und c auf 32 Bit erweitert werden und eine 32 Bit Multiplikation ausgeführt werden. Mit einer 16 Bit Multiplikation ist a auch nur 16 Bit. In Assembler kann ich aber b16 und c16
-
Thread
C-Code verstehen
> Bits kann man nicht direkt abfragen. nana, so kann man das nicht stehen lassen. Man kann Bits schon direkt abfragen - das Problem ist, dass C keine Bit-Datentyp kennt. Deshalb dieses Konstrukt. Jeder
und meiner Meinung nach verständlicher) schreiben: while(EECR & EEW); Die Aussage, dass man Bits nicht direkt abfragen kann, bezog sich auf Ansi-C.
-
Thread
Denkfehler mit PCA9536 (Problem)
Gerhard > sorry, das verstehe ich nicht so richtig mit dem stop. Ich muss doch die > Taster abfragen und das bit entsprechend setzen. Wie soll ich das kürzer > machen bzw dichter dran? Seh Dir mal meine kleine Änderung an. So meinte ich das: [c] while(1) { // Hauptschleife
// 0x03 abfrage oberes Temp if (ret == 0) // 0x02 abfrage unetre Temp { // Wenn LM75 ein OK sendet... i2c_start(lm75_r); msb_temp = i2c_readAck();
-
Thread
µC mit 3 oder 4 UARTs
Alleskönnerlösung mit viel Firepower zu erzwingen, sollte man vielleicht mal drüber nachdenken, ob man die einzelnen Module vielleicht NACHEINANDER abfragen kann. Dann reicht ein simpler Multiplexer für 20 Cent und ein kleiner AVR. MFG Falk
einmal liest. Grundsätzlich obliegt es aber dort dem Software Entwickler, ob er ein mehrfaches Abfragen benötigt. Bei nem Einsatz in EMV unkritischen Umgebungen und bei 4800 bis 9600 Baud sollte ein einzelnes Abfragen keine Probleme bereiten. mfg Emperor_L0ser
-
Thread
Frage zum Case Switch, bzw suche Konstrukt das nach bits schaltet
: break; } [/c] ich möchte also, dass jedes Bit der Flags für einen Case steht. So geht das aber nich, meckert der Compiler. Also hab ich das erstmal so gelöst: [c] #define Blah 1 #define Blub 2 uint8
{ printf("Funktion 3 wurde aufgerufen\n"); } int main() { uint16_t flags = 0x3; do_ifBitIsSet(flags, 1, print1); do_ifBitIsSet(flags, 2, print2); do_ifBitIsSet(flags, 3, print3); } [/c]
-
Thread
8-Bit Display Ansteuerung
programmieren. Die sieht nämlich etwas >anders aus ... Bei mir besteht die ganze Initialisierung für 8-Bit-Mode aus genau *vier* Kommandos: 40ms Warten 0x38 Functionset: 8Bit/2line/5x8 Zeichen 8ms Warten 0x0c Disp on/Cursor off/no blink 0x01 Display löschen 0x06 Entry Mode: Cursor inc/Cursor
Wertes fällig. Die einzelnen Nibble können ohne Verzögerung direkt nacheinander geschrieben werden. Noch einmal zur Betonung: das Busy-Flag (BF) immer vor einer neuen Ausgabe abfragen. Im Idealfall entsteht dann keine zusätzliche
-
Thread
Pin als In oder Out konfigurieren, abhängig von einzelnem B
werden 1:1 ausgegeben) Datenregiser = 11110000 Richtungsregister = 11100000 (erste 3 Bit Eingang, rest Ausgang) Signale an den Pins = ZZZ10000 Nun ist die Frage, wie man das macht. Ich könnte natürlich jedes einzelne Bit der entsprechenden Signale abfragen und "von Hand" den Pin auf
natürlich jedes >einzelne Bit der entsprechenden Signale abfragen und "von Hand" den Pin >auf Z oder 1 oder 0 setzen. Wie könnte man es einfacher lösen? Mit einer Schleife. [vhdl] -- Datenumschaltung per Registerbits
-
Thread
Viele Kippwaagen, wie zählen?
Eingänge der SRs (beispielsweise CMOS4021) parallel in die Register einliest, die dann seriell vom µC ausgelesen werden. Nach dem Auslesen aller Taster sind in 10 Bytes im µC Bit für Bit insgesamt die Zustände aller 80 Taster abgespeichert. Die kann man bequem auswerten: Byte für Byte. Das ist eigentlich
von der Rückflanke des Strobeimpulses zurück gesetzt. Ein weiterer Nachteil dieser sequentiellen Abfrage ist, daß diese systembedingt nur funktioniert solange der µC auch läuft. Also sollte der µC oder der auch der Bus aus irgend einem Grund ausfallen gehen die Daten währen dieses Zeitraumes natürlich
-
Thread
Keil C51 auf SDCC portieren -> optimieren
Schleife in der ich die PWM-Kanäle durchlaufe, sondern der Inhalt, wobei das eigentlich nur if-Abfragen sind, in denen in Abhängigkeit der Einstellungen für die Kanäle eben das entsprechende Bit gesetzt wird. @Matthias K.: > SDCC kann mit C51 Keil weder in Codegröße noch in Geschwindigkeit > mithalten
dort die Bits entsprechend dem was man sonst im Code an Portbits setzt, oder man beisst in den sauren Apfel und testet halt die einzelnen Bits der fertigen PWM Bytes und setzt/löscht dann die Portbits entsprechend
-
Thread
Drehgeber auslesen
case (BIT6): // 01 -> 00, left mc_c_gc_cM; break; case (BIT7): // 10 -> 11 mc_c_gc_cM; break; case (BIT6 | BIT7):
P2IES & (BIT6 | BIT7)) { case 0: // 00 -> 10 mc_c_gc_cM; break; case (BIT6): // 01 -> 11 mc_c_gc_cP; break
-
Thread
I2C Bus schalten - Verhalten ?
abbildest. Und damit Du nicht die drei anderen LEDs beeinflusst, wenn Du den Zustand einer einzelnen änderst, merkst Du Dir immer den Zustand aller LEDs, manipulierst diesen Zustand und sendest den an den LED-Portexpander. Ein Bit setzt man am anschaulichsten z.B. mit [c]var |= 1 << 6[/c] var sei ein uint8_t, 6 ist Bit 6. Bits fängt man bei 0 an zu bezeichen, also Bit 0 bis 7 eines Bytes. Ein Bit löscht man z.B. mit [c]var &= ~(1 << 0)[/c] Hier wird Bit 0 von var gelöscht. Ob ein Bit gesetzt ist, prüft man
-
Thread
Programmierung eines 80C552 mit Assembler
;get adc result / upper 8 BIT mov b,#00h ;clear B clr c ;clear carry rlc a ;move BIT 10 into carry jnc no_bit_10 ;If there is a BIT 10 then setb b.1 ;store into B b.1 clr c ;clear carry no_bit_10: rlc a ;else move BIT 9 into carry jnc no_bit