-
Thread
LM3S9B96 SPI über GPIO
schreib opcode gefunden und zum lesen muss ich dann erst 3H senden und dann einfach nach daten abfragen, hab meinen code so umgestellt. bin mir nicht sicher ob es so in ordnung ist. Sind die CS richtig gesetzt oder soll alles in einem CS stattfinden. [c] SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC
:10004000FFFFFFFFFFFFAA9930A1000720003161E9 :1000500009EE33213C0F31A100C931412F0031C2DB :100060000222809330E1FFCF30C1008131810881CD :100070003201001F32C1000532E1000432A1000E3E :100080003261000032810000334118F23362000017 :10009000000030220000000030A10001506000028A
-
Thread
[Anfänger] Bitwert eines Eingangspins abfragen
Hallo, ich hab gerade mit AVR-Programmierung angefangen. Vor 5-6 Jahren hatte ich C mal im Studium, die Grundzüge sind mir also klar. PHP programmiere ich täglich, das ist ja mein Job. Also wie ein Programm "funktioniert", ist mir schon klar. Nun habe ich eine Frage, wie ich den Zustand von Ports speichersparend ablegen kann. Ich möchte gerne ein Variable haben, in der nur steht "Taster gedrückt: ja/nein". Dazu habe ich folgendes gemacht: [c] struct { uint8_t t1; uint8_t t2; uint8_t t3; } Taster; int main (void) { while(1) { DDRD = 0b11100011;
-
Thread
Attiny13A einfache Quizschaltung
Fuse nicht gesetzt ist, wird das nichts. Also nutze ich nun die Pins 0-4 und verwende wieder die "bit_is_clear" Funktion zum abfragen der Pins. Zweite Sache die mir beim rumtesten auffiel, war dann die Tasterpins nach dem Abfragen wieder auf 1 zusetzen. Damits hats schlussendlich funktioniert. Anbei
versinkst du im Chaos. Also lerne etwas über [[Bitmanipulation]] und wie man einzelne Bits gezielt abfragen oder schreiben kann. >Anbei noch mal der neue Code und was fürs Auge :) Naja . . . Beides eher hyperfluide . . .
-
Thread
STM32 GPIO setzen, löschen, abfragen
hi, als Einsteiger beschäftige ich mich gerade mit den GPIOs. Dazu habe ich folgende Frage: Um einen Pin zu setzen oder zu löschen gibts ja 3 Möglichkeiten: 1. Berechnung der Bit-Band Adresse des entsprechenden Pins und diesen direkt setzen (soll am schnellsten gehen) 2. Per Befehl GPIOx->ODR = 00001000; 3. Per BSRR Register Welche Unterschiede haben die Möglichkeiten 2 und 3....?? Beide greifen auf das ODR zu und setzen / löschen den Pin. Warum nutzt man nicht immer den Bit-Band Zugriff? Da der Compiler ja die meiste Arbeit übernimmt ist das zeit- und codemäßig die schnellste
-
Thread
Schalter einlesen Entprellen notwendig (kein Taster)
Danegger mit Timer-Verfahren auf die 4 Ports bekommen, also wie ich in get_key_press() alle 4 Ports Abfrage ob sich etwas geändert hat oder wie macht man das am Besten? http://www.mikrocontroller.net/articles/Entprellung#Komfortroutine_.28C_f.C3.BCr_AVR.29
dann die Schiebereien und Maskiererein WertPORT = WertPORT>> 2; // 2 rechts schieben // oberen 4 Bits maskieren, sodass diese gelöscht sind WertPORT= WertPORT& 0b00001111; // Variable invertieren und zwar nur die unteren 4 bits WertPORT= WertPORT^ 0b00001111; } [/c]
-
Thread
Gedanken zur Auswahl eines µ-Controllers
43,2 MHz. Uups, das ist doch ganz schön viel für > selber bauen. > > Alles vorausgesetzt für 8 Bit ADCs... bei 10 Bit Auflösung machts halt > noch ein wenig mehr Spaß. Andi Ü. schrieb im Beitrag #2405715: > Wie soll der eine bzw. die zwei ADCs vom µC das synchron hinkriegen? Das > geht nur
... Aber wie gesagt, das ist nur eine schnelle Idee. Bei einem 32Bit µC, oder aber einem 16Bit DsPic hätte man dabeit wenn möglich sogar noch die Zeit eine rudimentäte Aufbereitung/Auswertung der Daten schon im µC vorzunehmen! Gruß Carsten
-
Thread
Grafikfähiger LCD Controller für 320x240 LCD mit 4 Graustufen
Hallo Bruno, >>Die Befehlszeile ist darin 0x10, 0xAA, 0x00, >>0x00, 0x3C, 0xF0, 0x01, d.h. er hat für ein 30 Byte breites Bild xs=60 >>eingegeben. So genau habe ich mir das damals nicht angesehen. Wenn ich das richtig verstanden habe, gibt der letzte Wert die Bit pro
// Zeilenadresse laden inc XH cbi _SFR_IO_ADDR(PORTD), FLM ld r16, X+ // 320 bits ausgeben ld r16, X+ ld r16, X+ ld r16, X+ ld r16, X+ ... [/c] Etwa der hier? Was genau bedeutet diese Schreibweise hier? [c] .global TIMER1_OVF_vect [/c] >Was ist CKDIS
-
Thread
Akku Spannung für 40W LED Lampe Kontrollieren
wieder null und es fängt alles von vorn an. Ist aber mein Fehler gewesen, sorry. Wenn ich eine 10 Bit Zahl speichern möchte, dann kann ich ja keine 8 Bit Variable dafür nutzen. Ersetze das in der Main(). Mach aus dem "uint8_t" ein "uint16_t" [c] uint16_t adc_in; // Akku-Spannung uint16_t adc_poti; // Poti-Spannung [/c] Du kannst den 10Bit ADC-Wert durch 4 teilen, dann bekommst du einen 8 Bit Wert den du in das 8 Bit Timer-Register schieben kannst. [c] pwm_write(adc_poti/4); [/c] > 780 = 12,58V > 830
-
Thread
Sinustabelle für kontinuierliches Signal
. Wert der Sinus-Tabelle verwenden. und nun in fixed und hex, damit sich der µC leichter tut: 0929 * D09C = 0776E4FC (nur die oberen 16 Bits interessieren uns) 0777 (gerundet = bit 15 dazuaddiert) andiert mit 01FF (gleichbedeutend mit modulo 512)
375--> den 375. Wert der Sinus-Tabelle verwenden. > > und nun in fixed und hex, damit sich der µC leichter tut: > 0929 * D09C = 0776E4FC (nur die oberen 16 Bits interessieren uns) > 0777 (gerundet = bit 15 dazuaddiert) > andiert mit 01FF (gleichbedeutend mit modulo 512
-
Thread
Displays mit integriertem Controller + SPI - Wo?
laufen. (printf schreibt nur in einen buffer) Da kann soetwas schon etwas weh tun wenn man nicht die Bits einzeln in einem TimerIRQ rauswerfen will. Olaf
Olaf schrieb im Beitrag #4748600: > Da > kann soetwas schon etwas weh tun wenn man nicht die Bits einzeln in > einem TimerIRQ rauswerfen will. Das ist im I2C Fall unerheblich da der I2C Bus langsamer ist als der Prozessor. Im Software-Fall braucht man Delays um das Timing einzuhalten, im
-
Thread
Warum sind STM32 I/Os auf 16 Bit kastriert?
, je nach Anzahl der Pins des uC-Gehäuses. Da alle Pins am uC Mehrfachbelegungen hat macht es keinen Sinn, einen 32bit IO-Port zu definieren, da die Wahrscheinlichkeit hoch ist, das ein IO-Port dann nur noch teilweise frei ist.
es nur etwas umständlicher, wenn man wirklich toggeln will, weil man erst den aktuellen Zustand abfragen muss. drm schrieb im Beitrag #6407073: > Da alle Pins am uC Mehrfachbelegungen hat macht es keinen Sinn, einen > 32bit IO-Port zu definieren, da die Wahrscheinlichkeit hoch ist, das ein >
-
Thread
C Code Optimierung für LCD (AVR32)
Display läuft... leider braucht das Bild etwa 4-5 sek bis es aufgebaut ist. Nun möchte ich mein C-Code optimieren. die dafür nötige Code Zeile ist folgende. (Anhang) "Befehl" ist ein 18 Bit langes Wort. Die einzelnen "AVR32_PIN_PBXX" geben an an welcher stelle sich dieses Pin befindet.
verantwortliche Code ist, neben der oben schon angeführten Erkennung des > Operationsmusters, in fold-const.c:fold_single_bit_test() zu finden. Und > darin kann ich keine Abfrage auf Existenz solcher Operationen entdecken. Ich auch nicht der Ort, weil fold_single_bit_test() auf tree-Ebene operiert. >
-
Thread
RFM01/02 Basics
Init Bsp: CC00 Status lesen 8B61 +- 90kHz Bandbreite A640 434MHz D040 RATE/2 C823 4,8kbps C220 Bit Sync ein C001 Tx deaktivieren Die Übertragung eines oder mehrerer Bytes per HF erfolgt so: C039 Sender aktivieren (Bitweise übertragen -> siehe unten 0xAA
aufgrund der erhöhten baudrate. laut rfm02 data sheet gilt für 38,4kBaud das pll setting command d2c0 statt d240 >warum wird das einlesen der daten eigentlich beim senden des arrays >unterbunden? du mußt ja beim rfm02 die nutzdaten bits einzeln z.b. über den fsk-pin senden. Wenn da zu einem
-
Thread
PIC 12F683 DiSEqC Bursterkennung
ich (Anfänger) möchte auf meinem PIC 22kHz modulierte Signale erkennen. Es handelt sich um DiSEqC, d.h. moduliert wird mit einer Art On- Off-Keying. Dazu müssen Bursts mit einer Gesamtlänge von einem einzelnen Burst 1,5ms (22kHz, 0 Bit 22 Zyklen in 1ms und 0,5ms Pause, 1 Bit 11 Zyklen in 0,5ms und
innerhalb der "Ruhepause" (22kHz aus) würdest du sofort wieder (fälschlicherweise) mit einem neuen Bit anfangen. Wenn man aber weiss das man innherhalb der Ruhepause ist (Timer abfrage) kann man diese Störung erkennen.
-
Thread
Drehgeber und Schrittmotor- 2 Riesenbaustellen im Programm
t val; cli(); val = enc_delta; enc_delta = val & 3; sei(); return val >> 2; } [/c] Problem 1: bei Höchstgeschwindigkeit (1450U/min) muss die "schnelle" Abfrage (TIMER0_COMPA_vect) so oft ausgeführt werden, dass kein Impuls verschluckt werden kann; bei 25U/s und 1024Impulsen/U sind
: > val ist bei dir int, also 16 Bit, da kann man DEUTLICH langsamer > abfragen, nämlich Faktor 32768. Die Variable, die abgefragt werden muss und überzulaufen droht, ist enc_delta, also nur 8bit. Überlege gerade, was gegen eine 16bit
-
Thread
Ansteuerung eines Schrittmotors mit 2 Endschaltern
Schrittmotor läuft nicht einfach los und fährt dann bis zu einem Endschalter. Ein Schrittmotor muss jeden einzelnen Schritt gesagt bekommen und die Anzahl der Schritte bestimmt den Fahrweg. Da braucht man keinen Endschalter. Es reicht eine Referenzmarke, an der sich der µC orientieren kann. Alles andere ist Schrittzählerei
läuft nicht einfach los > und fährt dann bis zu einem Endschalter. Ein Schrittmotor muss jeden > einzelnen Schritt gesagt bekommen und die Anzahl der Schritte bestimmt > den Fahrweg. Da braucht man keinen Endschalter. Es reicht eine > Referenzmarke, an der sich der µC orientieren kann. Nunja und
-
Thread
ATMEL stellt grafische Oberfläche für 8 bit Controller vor
? Weil etwas groß ist, ist es noch lange nicht komplex und noch lange nict auf einem µC.
AchWieLustig schrieb im Beitrag #3630073: > ATMEL stellt eine grafische Programmier-Oberfläche für 8 bit ATMega's > vor, Ach... Ich hatte beim Lesen der Überschrift an ein GDI und eine Klasenbibliothek grafischer Elemente für Atmels µC gedacht ... und nun sowas. Das erinnert mich ein bissel an
-
Thread
I2C vs. UART Vor-/Nachteile
zur Sammelleitung (das Umschalten auf Tristate ist halt ein wenig gefrickel). Die Slaves werden einzeln adressiert. Ich sehe keinen Grund, so ein Gefrickel einem etablierten Standard wie I²C vorzuziehen. Wenn es "einfach" sein soll, einfach bei allen AVRs die SCL pins verbinden, außerdem alle SDA
>Beim Master braucht das MCPM-Bit überhaupt nicht gesetzt werden. Ich meinte das 9. Bit, das die Adressierung signalisiert. Hängt auch immer etwas vom verwendeten µC ab. (AVR, 8051, ...) Viel warm heute! Hoffentlich kommt der
-
Thread
Einfache CPU, einfacher Rechner, nur zum Lernen, Erfahrung?
2FManual%2F&cHash=a684a589e406751cf37b8b0374ec085d und dann hier im speziellen * https://8bit-wiki.de/fileadmin/8bit-wiki/MicroProfessor_von_MicroTech/MicroProfessor-MPF1/Manual/MPF%201%20Mikroprozessor%20Christiani.pdf
Gleitkommazahlen, für das Vorzeichen "S"); ich habs nur erraten. Also "nichts","+" oder "-". Dann steht über BITS, MSD; was heist das? Ja, für die PIO muss ich das Buch Nr. C201 besorgen. Hier gibt es nur 6 Flags. [(Bei den 64-Bit-Prozessoren hat man schon ein 32-Bit-Flagregister.) Das war nur nebenbei.]
-
Thread
Pwm von RC Empfänger mit Arduino verarbeiten
Im Prinzip ist es zwar eine, aber praktisch dann eher doch nicht. Für die Auswertung mit einem µC würde man nun nicht jeden Serversteuer- impuls an einen einzelnen Controllereingang hängen, sondern sich im Empfänger den Punkt suchen, wo das komplette Telegramm anliegt. Und das an den µC hängen. Dann
changes } /* static int tick=0; tick=getTick(); // so würde ich die Hightime vom Signal abfragen (für meinen code) */ }[/c]
-
Thread
AVR PORTE ansprechen wie genau?
kurz nocheinmal eine Frage: Wenn ich z.b. Schreibe: uint_8t data; data=PINC; und dann abfragen will ob Bit PC7 zum Zeitpunkt beim kopieren in dummy gesetzt war, geht das dann folgendermaßen? if(data & 0b10000000) Oder habe ich da irgendwo den Denkfehler? Ich vermute an der Stelle meinen
@Johannes (Gast) >und dann abfragen will ob Bit PC7 zum Zeitpunkt beim kopieren in dummy >gesetzt war, geht das dann folgendermaßen? >if(data & 0b10000000) Ja. >Oder habe ich da irgendwo den Denkfehler? Nein. >Ich
-
Thread
RAM-Bankswitching - wie am geschicktesten mit GCC auf AVR?
à 32kB vorhanden sind. Die Hardware im Detail: µC: Atmel ATmega2561 @ 16MHz Latch: 74AC573 RAM: CY7C1049CV Am Ende möchte ich gern zwei Funktionen habe, in die ich eine Addresse und einen 8Bit-Wert packe, die dann automatisch die Bank wählen, und
Stackframe ein. Liegt sie nicht. Der Compiler optimiert die union weg und greift direkt auf die einzelnen Bytes zu, daher ist das Ergebnis meist sogar besser als bei low+high<<8 oder ähnlichen 2x8 bit <-> 16bit Umwandlungen. Beim AVR + gcc funktioniert das wunderbar, bei anderen Kombinationen muss man
-
Thread
String über UART an LCD
im Nachhinein > an das LCD schicken kann. > > Aufgrund dessen, dass ich nicht jedes Zeichen einzeln verschicken > möchte, habe ich mir... Bedenke, daß ein UART eine Schnittstelle ist für asynchronen Betrieb. Dort hast du es mit einzelnen Zeichen zu tun, die du auch einzeln auswerten solltest
if C>=0xE0 then Setze Schreibzeiger auf Zeile 0, Stelle C-0xE0, exit; if C>=0xC0 then Setze Schreibzeiger auf Zeile 1, Stelle C-0xE0, exit; if C = 3 then { merke Schreibzeiger in Rettvariable
-
Thread
DS1820, DS18B20 in C
laufen bekomme habe, habe ich mir Peters Code nochmal genau angeschaut. Das Problem entsteht hier: [c] b = w1_bit_io( 1 ); // read bit if( w1_bit_io( 1 ) ){ // read complement bit[/c] Zu beginn der w1_bit_io wird der Bus auf high geschaltet. Am ende wieder of low. Durch den direkt
= w1_byte_rd(); // low byte bite3 = w1_byte_rd(); // low byte //Messwert in Grad Celsius auf LCD ausgeben //sprintf( (char*)s, "%3d.%01dC ", bite1>> 4, (bite1 << 12) / 6553 ); // 0.1øC set_cursor
-
Thread
C++ Objektorientierung ?
, wie jeder gcc, mit einem C- und einem C++ -Compiler. Der eine spricht nur vollwertiges C, der andere nur vollwertiges C++. „Kompatibel“ ist das nur in so weit, wie C und C++ gemeinsame Sprachkonstrukte haben. Oliver
zugreifen (also z.b. zwei verschiedene > Peripheriegeräte abfragen) ?? I2C ist "single master / multiple client". Also Dein AVR kann viele Clients abfragen.
-
Thread
Geschwindigkeit bei volatile-variablen
Jörg Wunsch wrote: > Wenn man mit den Dingern mehr als eine einzelne > Abfrage/Zuweisung macht, sollte man sie besser in lokalen Variablen > cachen (die dann wieder optimiert werden können). Ob das in dieser Allgemeinheit ein guter Ratschlag ist, möchte ich stark
könnte locker auf volatile verzichten. Nein, kann man nicht. Wenn man im nicht-ISR-Kontext eine Abfrage à la [c] while (!some_ISR_state) /* wait */ ; [/c] hat, kann der Compiler ohne volatile wieder schlussfolgern, dass some_ISR_state sich gar nicht mehr ändern /kann/, und die Abfrage
-
Thread
Verständnisfrage PIC-Stack
von W abziehen ; Bei Fragen bitte nachrechnen btfsc STATUS, Z ; wenn Zero-Bit nicht gesetzt, nächste Anweisung ; überspringen goto Z2 ; also nur zu Z2, wenn die Subtraktion 0 ergab btfsc STATUS, C goto Z2 ; oder wenn Carry gesetzt
movf Zahl,0 ; Zahl nach W holen addlw D'246' ; 10 abziehen btfsc STATUS, Z ; wenn Zero-Bit nicht gesetzt, nächste Anweisung ; überspringen goto Z3 ; also nur zu Z3, wenn die Subtraktion 0 ergab btfsc STATUS, C goto Z3 ; oder wenn Carry gesetzt
-
Thread
Mega8 Port.Pin Zustand abfragen wenn gegen GND vs.VCC
Hi Spess, So sind die Pins angelegt. //Definition der Port Aliase Relais1[@PortD,5] : Bit; Relais2[@PortD,6] : Bit; Relais3[@PortD,7] : Bit; Relais4[@PortB,0] : Bit; //ACHTUNG RelaisStatus muß negiert werden RelaisStatus1[@PortB,4] : Bit; RelaisStatus2[@PortB,3] : Bit
; {------------------------------------------------------------------------------} begin SetBit(Relais1,false); SetBit(Relais2,false); SetBit(Relais3,false); SetBit(Relais4,false); // SetBit(RelaisStatus1,false); // SetBit(RelaisStatus2,false); // SetBit(RelaisStatus3,false)
-
Thread
Kombination zwischen zwei Programmen
Flag-Zustand an. > > Ja genau so wollte ich das machen! > aber ich wusste nicht wie ich die Taster Abfrage machen soll, deswegen > dachte ich an den externen Interrupt... > Also wie soll ich die Abfrage machen? Einfach den µC-Pin, wo der Taster dran hängt, abfragen. Taster vom Pin gegen GND, internen
Tastenabfrage sogar ganz gut funktionieren, weil die Anzeige relativ lange dauert. Das Problem bei dieser Abfrage besteht ja im Grunde darin, dass der µC (im Tutorialsbeispiel) zu schnell ist. Wodurch das Tastenprellen durchschlägt (und genau das ist auch das Problem bei einer Lösung mit externem Interrupt)
-
Thread
uC für 0,20€ CH552 / CH554 von WCH Billig Micro mit USB Funktion, Chip vorstellung
Makros für SDCC), hier ein kleiner Zwischenstand zum Bootloader. Diie Mainfunktion des Bootloaders in C. Sie ist nicht 100% identisch zum Original sollte aber funktionsgleich sein und das Wesentliche zeigen. Thomas [c] bit bit00; // ??? bit bSoftReset; // 1 for going to reset
Das funktioniert soweit ich kann's bloss nicht abschließend testen da ich nur die Demo habe. Die einzelnen Dateien kann ich aber kompilieren. Dann hab ich mir nochmal den MicroC Pro Compiler angeschaut. Das Ding ist der Hammer die übersetzen doch tatsächlich unsigned short in einen 8Bit Typ also gleich
-
Thread
Wasserzähler Impulszählung (Batteriebetrieb)
im Beitrag #6637054: > Ein EEPROM hat 100.000 Schreibzyklen bis es den Geist aufgibt oder? Je Bit. Z.B. bei einem ATtiny85 kannst Du 4000 Bits einzeln auf 0 setzen, ehe Du wieder löschen mußt. Die restlichen 12 Bytes kannst Du dann als Zähler * 4000 nehmen. Damit hast Du 400.000.000 Schreibzyklen
Beitrag #6637054: >> Ein EEPROM hat 100.000 Schreibzyklen bis es den Geist aufgibt oder? > > Je Bit. > Z.B. bei einem ATtiny85 kannst Du 4000 Bits einzeln auf 0 setzen, ehe Du > wieder löschen mußt. Die restlichen 12 Bytes kannst Du dann als Zähler * > 4000 nehmen. > Damit hast Du 400.000.000
-
Thread
Umsetzung "kleines" Bussystem für AVR im Haus
Grundsätzlich ja, mit den Timern musst halt sehen wie du klarkommst, Kannst ja einfach einen 8-Bit Timer nehmen, den immer bis zum Overflow laufen lassen und eine Variable erhöhen (quasi das higher Byte Softwaremäßig) und dann halt abfragen, wann dieses Byte überlauft, dann hattest grob 256*256 Zyklen
Verwendung der anderen Buffer auskommentiert. Nun habe ich auch einen schönen "Gänsemarsch"! ;) [c] if (_bit_is_clear(status, 2)) { address = 0x00; //} //else if (_bit_is_clear(status, 4)) { // address = 0x02; //} //else if (_bit_is_clear(status, 6)) { // address = 0x04;
-
Thread
ATmega8 Fuses?
Hi, ja was ist noch dran... :-) PORTD 0-1:UART 2-7:Dotmatrix Display. (4bit Datenbus) PORTB 0-5:Taster nach GND 6-7:XTAL für UART... PORTC 0-1:ADC 2-3:Steuerausgänge 4-5:I2C soll nach Möglichkeit für Erweiterungen frei bleiben 6: der ominöse RESET Pin :-I 7: nicht
irgendeinem Interrupt benutzt, vor Tasterabfrage Interrupts sperren, schauen, ob E=0, dann Taster abfragen, Interrupts wieder freigeben. Ebenso ist es möglich, die Abfrage in einer ISR laufen zu lassen.
-
Thread
Interrupts mit Atmel Studio für SAM3X8E (Arduino Due)
du hier *keine* getrennten Interrupts zum senden und empfangen! Das heisst du musst in der ISR abfragen, was jetzt den IRQ ausgeloest hat. [c] void USART1_Handler(void) { uint32_t irq_status = USART1->US_CSR; if( irq_status & empfangs_interrupt_bit_maske) { } if( irq_status &
Beitrag #4105717: > Was nicht funktioniert, ist auf diese Weise eine Interruptroutine für > einen einzelnen Portpin, Das gibt es so auch nicht fuer einen einzelnen Pin. Du nimmst den Handler fuer den Port, und dann musst du abfragen welcher Pin den IRQ ausgeloest hat. [c] void PIOC_Handler(void) {
-
Thread
Verständnis zu RS-485
Stefan schrieb im Beitrag #3349007: > Wenn Du nicht mehr als 8 Bits zur Adressierung verwendest Wozu sollte man das tun? "Offiziell" sind nur 32 Teilnehmer möglich, auch inoffiziell wird es schwierig, mehr als 100 zu betreiben. Also reichen 8 Bit. Eine Möglichkeit
Teilnehmer möglich, > auch inoffiziell wird es schwierig, mehr als 100 zu betreiben. Also > reichen 8 Bit. Nö. Es gibt auch 1/8load-Transceiver. Funktioniert zuverlässig. Schon mit >200 Teilnehmern aufgebaut. Aber 8Bit-Adresse reicht trotzdem.
-
Thread
STM32 Shift operationen
doch direkt verwenden und musst nichts mehr durch die Gegend schieben (bei 10 müsstest du das). [c]if (GPIO_ReadInputData(PORT) & GPIO_Pin_10) { bit 10 gesetzt } else { bit 10 nicht gesetzt }[/c]
template <typename T> constexpr std::size_t log2 (const T& val, T bit = (std::numeric_limits<T>::digits-1)) { return val & (T { 1 } << bit) ? bit : log2 (val, bit-1); } [/c] einfach mal an den Anfang eines C++ Sourcefiles in einem vorhandenen Projekt eingefügt.
-
Thread
Timer ungleichmässig
& .. ist die Abfrage des Ports C PC5 auf 0. Was habe ich wieder falsch gemacht? achim
davon (welches nur noch von diesem Bit abhängt) logisch umdrehen !(PINC & ( 1 << PC5 )) > Wie ist es mit den Klammern. In meinem C-Buch stehen für jede if und > else abfrage ein paar Klammern {} drin
-
Thread
Pollin Display Optrex F-51154NF-FW-AA
Datenbus zwischen S1D1 und Mikrocontroller. An SV2 befinden sich die Steuerleitungen. Zu den einzelnen Bauteilen: C6,C5,C2,C1 = 100nF C16 = 10uF R10 = 10k Die Frequenz für den Quarz findest du im Datenblatt vom S1D1 :)
meine Koordinaten. So hab ich denn einen "Touch-Controller" der die Koordinaten denn per TWI zum uC der Grafikansteuerung schickt. Die Matrix hat glaub ich einen Widerstand von 2k5. Somit kannste die Pins direkt mit einem uC ansteuern bzw. abfragen. Gruß Eike
-
Thread
Unterprogramm Aufruf ohne Rücksprung
PORTB &= ~(1<<PB1); } else if (ADC<=(HoldStrom-Deadband)){ PORTB |= (1<<PB1); } } [/c]
Interrupts. Interrupts sind ja gerade dafür erfunden worden, die Pollerei zu vermeiden. Die Abfrage im Hauptprogramm ohne die Verwendung von Interrupts sieht so aus: [c] if(TIFR & 1<<OCF1A) { // Timer-Flag gesetzt? stromregel(); TIFR |= 1<<OCF1A; // Timer-Flag löschen }
-
Thread
Eingabe auf Gültigkeit prüfen
] != 'A' || > command[3] != 'B' .......)[/c] > > Ich könnte die Liste jetzt weiter fortführen, aber das ist aber ein > wenig umständlich! Erst mal: mach es korrekt und dann frag dich ob du das Vereinfachen kannst. Deine Abfrage da oben
Danke für deiene schnelle Antwort. Was ist denn an der Abfrage nicht korrekt?? Es funktioniert auf jeden Fall einwandfrei. Die Idee mit dem Array hatte ich auch schon, allerdings weiß ich nicht, wie ich das in C umsetzen kann.
-
Thread
bidirektionale RS232 Funkbrücke mit RFM12
Ich sehe gerade, da bin ich um ein Bit verrutscht: PortC0-2: Baudrate PortC3-4: Kanal PortC5: unbenutzt
// Dummy, nachschieben als Pipelineputzer NSEL = 1; SSPCON_SSPEN = 1; // SPI abschalten, Bits werden manuell geschoben // RF_CMD(RF_TX_OFF); // TX off } [/c]
-
Thread
SPI - RS-485 - CAN
er eine UART-Hardware besitzt, die bei entsprechender Einstellung > alle Bytes ohne gesetztes 9. Bit von sich aus ignoriert. wenn der µC die aber nicht hat? (TI Stellaris... :/)
ist es doch auch. Bei den AVRs wird im Multiprozessormode ein > RX-Interrupt nur bei gesetztem 9.Bit ausgelöst. Der Datenaustausch > erfolgt mit gelöschtem 9.Bit und die nicht adressierten Slaves bekommen > davon nichts mit. Ah - das ist natürlich gut. Blöd, dass das der µC hier nicht kann :/
-
Thread
Mikrocontroller mit 16-Bit-UART
Terence S. schrieb im Beitrag #7665599: > Für 16 Bit wären damit sogar 3 Pakete notwendig. Zur Synchronisation bei 16-Bit Daten per 8-Bit Übertragung kann man das Parity-Bit benutzen.
auseinandersetzen, wie man sinnvolle Datenübertragungsprotokolle gestaltet. Wenn es soweit geht, daß man einzelne Bits einer UART-Übertragung abzählt und zu vermeiden sucht, ist man zum Optimieren irgendwo sehr gründlich falsch abgebogen.
-
Thread
LON Bus Windhager mitlesen/steuern
Yeah one tick is a bit low. Thats the reason why it signals a corrupted packet. Ich hab mittlerweile die C# sourcen überarbeitet und eine GUI gebastelt. Leider erst mal hardcoded auf 192.168.1.255 als Adresse. (bis ich
dissecting the payload. The APDU really just starts with 1 or 2 bytes (depending on the first bits, see Figure 10.2) followed by the payload of that specific NV. I have a list of NVs for: WVF V 3.51 InfoWIN FW V 2.60 FireWin V 3.10 PMX v2.7 UML C1 V 3.51 VarioWin (?)
-
Thread
Modulation IR Signal - Interrupt oder Warteschleife?
Das hier [C] while (interrupt_count < countPulse); [/C] ist keine atomare Abfrage des [C] volatile long int interrupt_count; [/C] entweder du machst das atomar (d.h. interrupt_count unter Interrupt
nie irgendwas von einer Funktion sendBit im Code gesehen hat, dass diese Funktion so [C] int sendBit( int wert1, int wert2 ) { ... } [/C] aussieht. Schreibst du [C] sendBit(50000,50000); [/C] dann muss sich der Compiler
-
Thread
STM32 Locking in C
Ich löse das meist so, dass ich eine globale Variable benutze. In dieser setze ich in der ISR ein Bit (Flag) wenn neue Daten vorliegen, das ich in der main() abfrage, die entsprechende Funktion ausführe und danach das Flag zurücksetze. Die ISR selbst prüft dieses Flag und schreibt die Daten, falls das
Bit AVR mit RAM knausern. Auf 32-Bit ARM sind 32-Bit Zugriffe Atomar. Das _Atomic ersetzt aber auch auf 32-Bittern das Assembler-Speicher-Optimierungs-Barrier.
-
Thread
STM32F4 SPI Problem
(!(SPI1->SR & SPI_SR_TXE)); [/c] Nils N. schrieb im Beitrag #5325053: > Nach dem Schreiben von SPIx->DR = DATA; musst du warten, bis das RXNE > bit gesetzt ist, was bedeutet, dass Daten empfangen wurden (eben das > Byte bei 8bit
SPI_CR2_SSOE; > oSPI->CR1 |= SPI_CR1_SPE; > } > > uint8_t SPI_Send(SPI_TypeDef * oSPI, uint8_t cVal){ > oSPI->DR = cVal; > while(!(oSPI->SR & SPI_SR_RXNE)); > > return oSPI->DR; > } Konkret sieht es so aus, dass der Controller wieder bei der Abfrage hängen bleibt, ob das RXNE-Bit
-
Thread
internen RC Osci syncronisieren
gleich eingestellt sein. Moment: Das muß ich jetzt mit dem Baudratentakt machen. Nicht mit dem µC Takt. Wenn ich zum Bsp. 250kBit/s einstelle, dann dauert ein Bit 4µs, heißt aller 8µs eine positive Flanke zum zählen. Wenn ich nun soviele "0x55" hintereinander für 1ms Dauer ohne Pause rausschicken
nicht niedriger, wenn er schneller durch die ISR kommt? Kostet der Vergleich wirklich 200 Takte? [c] if ( (~reg & 0b00000100) & (1<<PINA2) ) { // prüft ob Pin Bit.2 Low Counter++; PulsCounter = Counter; } [/c] Danach habe ich die Verzögerung zum Timer stoppen verkürzt. [c] ISR(PCINT0
-
Thread
ATTiny2313 I2C - Master (Peter Fleury) / Slave (jtronics)
Verbindung return Byte0; } //############# Abfrage einzelner Bytes (8 Bits) und anschließend zusammenfügen zu einem Word (16 Bit) void read_Attiny1(void) { i2c_start_wait(Adr_AttinyI + I2C_WRITE); // Adr_AttinyI ansprechen i2c_write(0); //
(); // Byte2 lesen hig = i2c_readAck(); // Byte3 lesen word2 = uniq(low,hig); // 2x 8Bit --> 16Bit i2c_stop(); // stopt I2C Verbindung } //############# Senden einzelner Bytes (8 Bits) und anschließend senden von
-
Thread
Inkrementieren von Bits in Bitfeldern
Hallo uC-Gemeinde, ich habe ein Problem mit dem Inkrementieren eines oder mehrerer Bits in einem Bitfeld. Folgender Code inkrementiert alle Member des Bitfelds: [c] static volatile struct{ unsigned
läuft der Zugriff auch falsch ab, weil Abfragen auf Struct1 == 1 dann falsch ausgewertet werden. Mit [c] static volatile struct{ unsigned char a:3; unsigned char b:3; unsigned char c:2; }status; [/c] funktioniert das Ganze