-
Thread
AVR TWI Master und Slave Funtionen in C
Der TWI Bus kann dann nicht gestartet werden. Ich habe übrigens nirgendwo im Code gefunden, wo das Bit TWGCE des TWAR gesetzt wird. Wenn ich aber es explizit in TWI_Init der Slaves setze, bleibt das ganze System hängen. Weisst ihr vielleicht, woran das liegt? Vielen Dank im Voraus!
PORTC |= (_BV(PC4) | _BV(PC5)); // Port C Pin4+5 Pullups aktiviert TWBR = 22; // Setzen der TWBR Bits = 22 TWSR = 0; // Prescaler = 1 TWCR |= (_BV(TWEN)); // TWI Enable sei(); // Erlauben aller IRQ's } int main() { i2c_init(); while (1
-
Thread
Atmega8 16Mhz Quarz Fusebits setzen
) [code] #!/bin/sh prg="adude" # help() { echo "prg_fusebit_uc -- read and write fuse bits of the atmega8" echo "" echo "Usage: prg_fusebit_uc [-hu] -r|-w Freq" echo "" echo "OPTIONS: -h this help" echo " -r read fuse bytes" echo " -u use uisp instead of
hier ein Häkchen machen muss bzw. ein Häkchen rausnehmen muss bzw. dass im FuseByte dieses und jenes Bit gesetzt sein muss.
-
Thread
Brownout beim flashen setzen
Hallo, kann man beim flashen den Brownout einschalten? Atmega128 in C Es sind bei der Produktion einige Platinen mit nicht gesetztem Brownout entdeckt worden. Kann man das in der firmware intgrieren dass das Bit gesetzt wird? Es soll via Bootloader geflasht werden ohne ISP-Programmer, ist das möglich?
-
Thread
Problem mit Interupts
0b00000001 | ( 1 << PB4 ); [/C] oder aber, wie zb [C] PORTB |= (1<<PB0); [/C] nur das Bit 0 im Port B setzt und alle anderen Bits in Ruhe lässt. Viele Wege führen nach Rom.
dann am nächsten Tag eine neue einzuschrauben. Auch wenn das im Prinzip funktionieren würde. Bits unabhängig von anderen Bits setzen und löschen zu können ist eine der Grundfertigkeiten in der µC Programmierung.
-
Thread
16bit Timer [MEGA8]
************************/ ISR(TIMER1_OVF_vect) { i++; // Zaehler erneut auf Startwert setzen TCNT1 = 0xF000; } [/C]
halten und stattdessen die eigentliche Arbeit in der Haupt > // Zaehler erneut auf Startwert setzen > TCNT1 = 0xF000; Das machst du ganz am Schluß. Damit verlierst du unter Umständen Timer-Ticks.
-
Thread
Einzelne Bits eines Bytes ändern
Bit sepperat programmieren. A = 1 B = 0 C = 1 ....usw (Das dieser Programmtext nicht funktioniert, weiß ich, ich habe ihn nur zur Veranschaulichung meines Problems gewählt.) Bestimmt gibt
Hallo Geht in Bascom genuso wie Port Pins setzen daten.0 = 1 setzen von Bit 0 in daten daten.0 = 0 löschen von Bit 0 in daten Geht auch schön mit Variblen a = 5 daten.a = 1 Gruß Dieter
-
Thread
Probleme mit "rjmp 0000" und "CLI" (ASSEMBLER) ATmega8
einfach den Codeanfang zu zeigen führt zwangsläuftig zu Problemen. Ich empfehle den Watchdog-Reset. (Bit3 im WDTCR setzen und einfach in eine Endlosschleife treten).
@Niels >Ich empfehle den Watchdog-Reset. (Bit3 im WDTCR setzen und einfach in >eine Endlosschleife treten). Gute Idee, aber dann dann bleibt das (Bit3-WDTCR im MCUCSR gesetzt) und das MCUCSR-Register soll bei Programmstart nicht glöscht
-
Thread
C18 einzelnen Pin setzen/löschen
{ // Shifter shifts reverse 0 1 2 3 4 ... 14 15 Delay10KTCYx(t); SR_CLK = 1; // Shift the bit if (SR_SER == 1) bitset(Forth,i); // Output high set bit high else bitclr(Forth,i); // Output low set bit low Delay10KTCYx(t); SR_CLK = 0; (die for Schleife wiederholt
LATCH PORTS mache, alle anderen nicht verwendeten PORTApins auf Eingang (high oder low) oder Ausgang setze oder mehr Zeit gebe. NiX?! Hat jemand Rat? Viele Grüße Chris
-
Thread
Ab wann lohnt sich ein 32bit Controller? Compilerkosten?
arbeitet. Auswertung von Sensordaten, desto schneller desto besser. Da dachte ich mir long (32Bit?), könnte ich nicht 30-40% an Leistung gewinnen wenn ich auf 32 Bit setzen würde. Aktuell habe ich einen Atmega64 mit 16Mhz. Da geht die Geschwindigkeit schon merklich runter, beim großen Addieren
Askan S. wrote: > Da dachte ich mir long (32Bit?), könnte ich nicht 30-40% an Leistung > gewinnen wenn ich auf 32 Bit setzen würde. Einen Leistungsgewinn kann man erst ermitteln, wenn man die bisherige CPU-Auslastung kennt. Also, wie oft müssen
-
Thread
SRAM mit RESET Eingang gesucht
schon einen Wolf gesucht. Daher hier. Ich suche ein SRAM mit folgende Eigenschaften: - mind. 16kBit - es MUSS einen RESET Eingang besitzen, um die ganze Speichermatrix in < 5µs in einen definierten Zustand (alle Bits = 1 oder alle Bits = 0) zu setzen - Vcc 5V oder 3,3V - Organisation x1, x4, x8
doch im Eingangstext: "... um die ganze Speichermatrix in < 5µs in einen definierten Zustand (alle Bits = 1 oder alle Bits = 0) zu setzen" Die eigentliche Anwendung ist für die Frage nicht relevant und führt in diesem Forum erfahrungsgemäß zu unerwünschten Diskussionen.
-
Thread
ST26 16MBit Flash <.> XMEGA256A3BU
Linke mal das DB vom SPI Flash , hat das ein WREN Bit das du vor dem Schreiben setzen musst ? Der SS vom SPID ist auch ein Ausgang ? Kannst du eine ganze Page lesen ? Gruß JackFrost
im Status und Configuration Reg. nötig. > A. B. schrieb im Beitrag #5041559: >> Das Setzen ist aber nirgends zu sehen. > > Wo kann ich dieses Bit bitte setzen? "The Write Enable (WREN) instruction sets the Write- Enable-Latch bit in the Status register to ‘1, ..." Ist ja vielleicht
-
Thread
Port setzen mit PORTB.1 oder ähnlichem möglich ?
Hallo, kann man mit C und bei einem AVR einen Port direkt setzen, also PORTB1 = 1; oder geht das immer nur über PORTB = 0x01; ??? Gruß popi
Codevision oder Bascom geht es. Sonst gibt es auch so schöne Konstrukte wie PORTB |= (1<<0); zum Setzen und PORTB &= ~(1<<0); zum Löschen eines Bits.
-
Thread
PWM Servo Schieberegister
Bernhard Mayer schrieb: > Du hängst an jedes bit des Schieberegisters ein Servo. > Dann schiebst du ein einzelnes 1-bit durch das ganze register, d.h. es > ist immer nur ein ausgangsbit des rigisters auf 1. > Du schiebst also dieses bit ins erste
der Ablauf so aussehen: Timer initialisieren (allgemeine Einstellungen: Modus und Taktfrequenz setzen) Schleife: Schieberegister auswählen, dessen Servos ihren Impuls erhalten sollen (Index). Compare-Wert des ersten Servos ins Vergleichsregister eintragen Timer starten Warten, bis 8-Bit-Sequenz
-
Thread
Ansteuern eines LCD über ATmega16
Datenbyte an das LCD void lcd_data( uint8_t data ) { SET_PORT |= (1<<LCD_RS); // RS auf 1 setzen lcd_out( data ); // zuerst die oberen, lcd_out( data<<4 ); // dann die unteren 4 Bit senden _delay_us( LCD_WRITEDATA_US ); } void lcd_string( const char *data
); // Enable auf 0 setzen _delay_ms(2000); //Function Set 3 PORTD |= (1<<PD7); // Enable auf 1 setzen PORTA = 0x30; //Set PA4 und PA5 high PORTD &= ~(1<<PD7
-
Thread
LCD Initialisierung
>lcd_enable: >... >sbi PORTC, 0 ;Enable-Bit setzen >... >cbi PORTC, 0 ;Enable-Bit rücksetzen was soll das?
;Register wieder herstellen pop temp1 ret ;Rücksprung ; 5.3 LCD -> Enable-Bit setzen lcd_enable: push r18 ;Register sichern ser r18 out DDRC, r18 ;PortC als Ausgang sbi PORTC, 0 ;Enable-Bit setzen nop ;warten nop ;warten
-
Thread
AVR-C Analog Read
gemacht hast, und in Theorie und Praxis (vor allen Dingen Praxis) gelernt hast, wie man einzelne Bits auf 1 bzw. auf 0 setzt, bzw. dass man 0 Bits nicht explizit setzen muss, wenn man sowieso dem Register als ganzes etwas zuweist.
Martin Fischer schrieb im Beitrag #3432066: > Ja, mit auf 0 setzen meine ich sie gar nicht setzen. Ein Bit ist entweder 1 oder 0. Fangen wir jetzt bei Adam und Eva an? > Wenn ich sie von 1 > zu 0 setzen mag, muss ich sie ja nur löschen, oder? Ja > Und
-
Thread
SPI gibt lediglich 4 Bits aus!
es auch, das SPCR komplett zu setzen, also SPCR = bitX | bitY | bitZ; statt alle Bits einzeln abzuklappern.
OK, also ich habe eben nochmal die Interruptabfrage weggelassen und softwaremäßig das Setzen den SPIF festgestellt. Danach hat er alle 8 Bits einwandfrei ausgegeben. Allerdings ist er danach nicht mehr aus der Schleife herausgesprungen. Desweiteren habe ich ja keine Möglichkeit den SPIF
-
Thread
Ansteuerung EA DIP203-LCD
extended Function set" [/c] ist doch wirklich nicht so schwer. Und danach würde ich das RE Bit mit einem weiteren Function Set Kommando wieder auf 0 setzen.
Bit auf 1 setzen * dann den 4-Zeilen Modus ausschalten * dann mit der 'unteren' Interpretation das RE Bit wieder auf 0 setzen (momentan steht es ja noch auf 1) * und erst dann gilt wieder die eingekringelte
-
Thread
avr-libc alternativen
< (size * bit)); } int main () { // Setze Bits 7-9 vom Register auf 5. setBits (someHardwareRegister, 7, 3, 5); }[/c]So kann man im User-Code recht praktisch einzelne Bits von Registern setzen, unabhängig
| (val << (size * bit)); > } > > int main () { > // Setze Bits 7-9 vom Register auf 5. > setBits (someHardwareRegister, 7, 3, 5); > }So kann man im User-Code recht praktisch einzelne Bits von Registern > setzen
-
Thread
PIC 18 in und aus Sleep modus mit UART Interrupt
einer ISR. In Hauptprogramm Puffer für String reservieren Zeiger auf das erste Zeichen setzen In der ISR Empfagenes Zeichen in den Puffer schreiben Puffer voll? -> Flag setzen Ende-Kenung gekommen? -> Flag setzen Zeiger auf nächsten Pufferplatz setzen ISR verlassen
zum Auto Wake Up des PICs zu halten (S.276). [c] void main(void) { while(1) { ... BAUDCON1bits.WUE = 1; // Setze dieses Bit bevor PIC in SLEEP Modus to enter Auto Wake Up putcUSART(0x00); // Sende Break Sequenz, dieses Byte wird verworfen Sleep(); // versetzte
-
Thread
STM32 SPI zu viele Clocks
Traubensaft .. schrieb im Beitrag #4900953: doch noch ein Versuch: Setz mal hinter das bsy-wait noch ein delay von ca. 100us. Dann hat der Sensor genug Zeit, die gesendeten 16bit zu verarbeiten. Wenn das klappt, das delay reduzieren.
Zeitintervall aufgezogen. In der Timer CB Funktion dann 2 Phasen. Phase 1: HAL_SPI_Receive_IT() mit 16bit Betrieb, -> Phase 2 Phase 2: SPI Enable auf 0 setzen, -> Phase 1 Aber das SPI enable bit Hardcoremaessig auf 0 zu setzen wenn man eigentlich streng nur den ungepatchten HAL nutzen will ist auch
-
Thread
PWM - Breite von 0
Kommentar steht. Der Hintergrund: "TF2" ist *kein* Byte, dem du einen Wert zuweisen kannst. Es ist ein Bit im Register "IRCON", das du in diesem Falle rücksetzen mußt. Und das passiert mit IRCON &= ~(1<<TF2); Wenn du ein Bit in einem Register setzen willst, machst du das zum Beispiel mit T2CON |= (1<<
O-Pin für eine Blink-LED. Die Software konnte ihn immerhin direkt setzen oder löschen. Das ist aber nur ein einziger Pin am ganzen Prozessor. Der 8048 war der erste 8-bit Single-Chip-µC der Welt. Ich baute vor ein paar Jahren auch mal einen auf Lochraster auf, einfach aus
-
Thread
Problem bei Temp-Messung Rasp. Pi Pico & Pt1000
Stefan schrieb im Beitrag #7008312: > return raw << (16 - bits) | raw >> (2 * bits - 16); Verstehe ich das richtig, wenn ich meine, dass die 12 bits erst mal um die fehlenden bits (also 4) nach links geschoben werden sowie um 2 * bits - 16 (also 8), nach rechts
So macht es der Pico: raw << (16 - bits) | raw >> (2 * bits - 16) mit bits=12
-
Thread
Spannung an Ausgangsports zu niedrig
du dann sicher auch die kleinen Pulse sehen die dein Controller ausgibt. -> Also: Schau nach dem Bit-Setz-Problem
Felix schrieb im Beitrag #1873854: > -> Also: Schau nach dem Bit-Setz-Problem Hallo nochmal, das mit dem Bit-Setz-Problem stimmte. Aber da ich euch noch den Quellcode schuldig bin: #include <inttypes.h> #include <avr/io.h> #include <avr/interrupt.h>
-
Thread
Probleme bei Programm (Assembler)
set bit 0b010000000 ... damit hast du ja aber kein ziel gesagt, in welchem register das bit eigentlich gesetzt werden soll. Außerdem ist 0b01000000 eine Byteangabe, nämlich bit 6, das du jetzt setzen willst
high-aktiv... sollten die Taster nun low-aktiv sein.. müsste ich ja nur bei dem CPI die letzten beiden Bits auf 1 setzen richtig?
-
Thread
EA DOGL - Befehlsaufbau
: [c] //DOGL - Graphic LCD (Software SPI) #use spi(MASTER, DI=PIN_D7, DO=PIN_D8, CLK=PIN_D6, BITS=8, stream=dogl) . . . . output_bit (a0_glcd,0); output_bit (cs_glcd,0); delay_us (5); //Initialisierung spi_xfer (dogl,0x40,8); spi_xfer (dogl,0xA1,8); spi_xfer (dogl,0xC0,8); spi_xfer
); //8 Pixel langer Strich (als Test) spi_xfer (dogl,0x40,8); spi_xfer (dogl,0xB0,8); output_bit (a0_glcd,1); spi_xfer (dogl,0xFF,8); output_bit (a0_glcd,0); //Slave deaktivieren output_bit (cs_glcd,1); [/c] Wo könnte hier der Fehler liegen? Die Pins sind sicher richtig gemappt beim
-
Thread
Atmega328P Frequenzerzeugung
der Pin auf Ausgang konfiguriert ist, kann man in einem Taktzyklus den Pin toggeln, in dem man das Bit für den Input Port setzt. Jedes erneute setzen des Bits toggelt den Pin. Genaueres kann man im Manual nachlesen.
Veit D. schrieb im Beitrag #6488793: > den Pin toggeln, in dem man das Bit für den Input Port setzt. Jedes > erneute setzen des Bits toggelt den Pin. Genaueres kann man im Manual > nachlesen. Ach... da war was. Aber das Datenblatt spricht vom PINx-Register: [code]However
-
Thread
MSP430x169 und TIMERA compare register
Zu der Timer-Geschichte: Durch das Capture hast Du in CCR0 den Wert der Bit-Time... gut! Diesen Wert erstmal in eine Variable sichern, da wir CCR0 ändern müssen! Jetzt willst Du 1/2Bit-Time Verzögerung, also: - CCR0 auf 1/2 Wert setzen - keinen Interrupt verwenden, sondern
while(!(TACTL & TAIFG)); // warten bis Timer = CCR0, // d.h. 1/2Bit-Time ist um. [/c] - CCR0 wieder auf volle Bit-Time setzen - Timer_A Interrupt verwenden ( *nur* den!) [c] TACTL |= TACLR; // Timer nullen TACTL &= ~TAIFG; //
-
Thread
SPI Bus Pin setzen
Hi Ich will über spi bus mein CAN Controller ansprechen. Dafür muss ich den Chipselect auf low setzen in meinem C-code.Wie man ein bit setzt oder löscht weiss ich,aber wie mache ich es in einer Nios Umgebung? Der Pin Name in meinem VHDL kann ich nicht einfach so benutzen,oder? Danke.
sorry dass ich mich jetzt melde.war auf Reise. Den Chipselect konnte ich noch auf Low oder High setzen. Bei xps spi controller gibt Befehle dafür.Leider kann ich noch nicht dem CAN Controller ansprechen.Ich bekomme immer FF's zurück. Mal schauen... Gruß. JR
-
Thread
ATTiny85 - Software UART Probleme
Baudraten zu kommen und bin da etwas vom Datenblatt verwirrt. Im TCCR1-Register muss ich das CTC1-Bit setzen, um den Compare-Match zu aktivieren. Nun steht in der Bit-Beschreibung: "When the CTC1 control bit is set (one), Timer/Counter1 is reset to $00 in the CPU clock cycle after a compare match
zurück nachdem ich mal wieder etwas Zeit gefunden habe. DocMartin schrieb im Beitrag #4749924: > Setze doch mal den Autobaud-Marker und lasse die Baudrate bestimmen. Hab ich, es wird eine Baudrate von *73619* erkannt. Wenn ich die 13 Pause-Bits weglasse, wird eine Baudrate von *34833* erkannt, so
-
Thread
Sinus Referenz 100 kHz
einmal getestet und da war das Rauschen recht hoch, weiß aber nix genaues mehr. Aber wäre denn ein 14 Bit DAC überhaupt geeignet einen 16 Bit ADC zu testen?
Gatter. Einen schnellen Zähler gibt es, ich könnte also auf < 4 prüfen indem ich prüfe ob die höheren Bits alle 0 sind. Auf größer 4 zu prüfen wird etwas schwieriger. Daher dachte ich für das SCK_Enable eben an ein RS FF. Das setze ich wenn der Zähler den Wert 5 hat und resette es wenn der Zähler zurückgesetzt
-
Thread
Modulation IR Signal - Interrupt oder Warteschleife?
Normal-Zähl-Modus (Pause) Nein, immer PWM. Die kann man ja zu Pin hin abschalten, mit den COMxy Bits. Der Zähler läuft immer durch, dadurch hat man eine Zeitbasis. > und setze den Compare auf die jeweilige >Anzahl der Flanken (nennt man das so?)? Nein. Du zählst in der ISR die Anzahl Pulse,
für Pulsphase, an unbenutzten Pin für Pausephase --> Variable für gewünschte Gesamtzahl der Pulse setzen --> in ISR Anzahl der Pulse hochzählen --> In Hauptprogramm warten, bis Anzahl Pulse = gewünchte Gesamtzahl --> nächstes (Halb)Bit senden Anmerkung: Während Senden müssen keine sonstigen Programmaktivitäten
-
Thread
LCD Busy Flag Abfrage im 8 Bit Modus - die zweite
Schleife verlassen wenn BF = 0 ist hast du BF mit 7 definiert, das Busy Flag ist jedoch auf Bit 7, und dieser Wert ist als Bit-Maske oder Wert 0x80 und nicht 7.
PORTD, RS sbi PORTD, RW br1: sbi PORTB, E nop in R16,PIND ;load the upper 4 bits cbi PORTB, E nop sbi PORTB, E nop ;no need to load the lower 4 bits cbi PORTB, E bst R16,7 ;load bit7 into T flag brts br1 ;wait until Busy flag is high
-
Thread
Tasten-Matrix entprellen
/Tastenmatrix.htm Ist in Tastenmatrix.c nicht noch ein Fehler drin? Ohne Dioden nur das DDRx Bit setzen dessen Reihe ausgewertet werden soll. [c] //uint8_t ROW[] = { 0x01, 0x02, 0x04 }; // low active uint8_t ROW[] = { KEYPAD_ROW_0, KEYPAD_ROW_1, KEYPAD_ROW_2 }; // low active
("nop"); column = KEYPAD_COL_PIN; // read column [/c] Mit Dioden alle PORTx Bit's setzen bis auf das Bit welches augewertet werden soll. [c] //uint8_t ROW[] = { ~0x01, ~0x02, ~0x04 }; // low active uint8_t ROW[] = { ~KEYPAD_ROW_0, ~KEYPAD_ROW_1, ~KEYPAD_ROW_2 };
-
Thread
I2C ACK wann wieder zurück setzen
Hallo Ein ACK beruht laut µC Artikel auf setzen SDA auf Low im 9.Zyk Wann wird/muss dieses Bit vom ACK Versender (8bit Daten-Empfänger) wieder zurück gesetzt werden damit der SDA Pin als Eingang "open-drain" wieder fungiert? Bei mehrfachen Slaves
Stefan U. schrieb im Beitrag #4558054: >> Wann wird/muss dieses Bit vom ACK Versender wieder zurück > gesetzt werden > > Unmittelbar nach dem Ende des Taktimpulses. Also so in etwa? [c] SendACK (void) { while (!SCL); // Takt ist noch LOW, bit wird gesetzt
-
Thread
LED Treiber gesucht
und kommen trotzdem mit der WS2811-kompatiblen Übertragung von 8-Bit-Werten aus, weil sie direkt eine Gamma-Korrektur mit eingebaut haben. Diese mappt die 8-Bit-Werte auf entsprechende 12-Bit-PWM-Werte - unter Berücksichtigung der Helligemnpfindlichkeit des menschlichen
könnte sein, dass immer der volle Strom fließt, egal wie die LEDs leuchten. Und die Nutzung von 8 Bit Daten zur Steuerung der LED-Helligkeit über eine 12 Bit Kennlinie hat doch etwas.
-
Thread
CGA und Byteaufteilung in der Darstellung mit Farben.
-------------------------------------------- #include <dos.h> int adr; char byte; void setze() { pokeb(0xb800,adr,byte); } void cga() { asm{ mov ax,04h int 10h } } main() { cga(); adr=32; byte=255; setze(); adr=8031; byte=255; setze(
wenn schon dann schon int main() und bitte keine globalen void setze(int adr, char byte) { pokeb(0xb800,adr,byte); } und dann setze(32, 255); setze(8031, 255); und zur besseren Lesbarkeit ax splitten void cga() { asm{ mov ah,0 mov al,4 /
-
Thread
mehrer Bits verschieben
Hallo, hab eine einfache Frage, komme aber gerade nicht selber drauf. Ich möchte die ersten 4 Bit eines 8 Bitsignales um 4 nach links verschieben. Einzelne Bits in C kann man ja wie folgt verschieben: Signal[0] << 4; // 1.Bit um 4 nach links verschoben Nun möchte ich aber die 4.Bit mit
weiterhin etwas genauer ausdrücken. In deinem letzten Post schreibst du: Denn nachdem ich die ersten 4 Bit verschoben habe, muss ich sie wieder mit den letzten 4.Bit addieren. 2 Sachen: a) "den letzten 4. bit" gibt es nicht. der Punkt hinter der 4 bedeuted VIERTES Bit und bezieht sich somit auf 1 Bit
-
Thread
Verilog for Schleife
Du kannst nicht einfach ein Bit setzen, wenn die Schleife fertig ist. Die Schleife wird zu kombinatorischer Logik. Die ist irgendwann fertig. Dann sagt dir dein Timing Analyzer später ob es in einen Taktzyklus passt (wenn du die richtigen
>ich möchte max 300 Werte durchsuchen beo 150Mhz Wieviele Bits hat ein Wert?
-
Thread
Audio-Projekt
initialisierung mache ich meist so : - codec resetten (register 15) - device als master - clk divider setzen - audio routing setzen (zum testen das bypass-bit setzen) - den rest (power off/lautstärken/usw). dann schaue ich nach ob der quarz schwingt und ob BCLK und LRCLK anliegen und ob an DOUT etwas
ein guter 1-Wandler bauen lassen, oder ? Bei 50MHz hätte man immerhin 1100 Stufen je 44kH also 10 Bit. Da man mit 15kHz filtern könnte, wären es schon 12 Bit. Brauchst halt nen guten Filter.
-
Thread
STM32F4 GPIO port masking
. schrieb im Beitrag #3431346: > GPIOx->BSRR = 0xFF << (16+N) | value << N; Blödsinn Um ein Bit zu setzen reicht es, dies in die unteren 16 Bit des BSRR Registers zu schreiben. GPIOx->BSRR = (1 << N) Setzt das nte Bit und lässt alle anderen Bits unangetastet. usw.
Steel schrieb im Beitrag #3431363: > Um ein Bit zu setzen reicht es, dies in die unteren 16 Bit des BSRR > Registers zu schreiben. Es geht aber darum, nicht nur zu setzen, sondern auch zu löschen!
-
Thread
DMX-Empfang klappt nicht
Rate über eine Lookup-Table direkt für den 16bit-Timer generieren...) Viele Grüße, Hendrik
steht welche START-UP-TIME und ADDITIONAL-DELAY er hat. Hier geht es um das CKSEL0 und die SUT Bits
-
Thread
Spi 11 bit
, da dass der AVR automatisch macht, sobald das SPDR Register vollständig geshiftet ist, sprich 8 Bits gesendet (und empfangen) wurden. Nach Punkt 6 einfach den CS Pin wieder auf high und fertig ist das ganze. Ciao Fasti
; //Endwert wird berechnet PORTB = (1 << PB0); //SS auf high setzen return (xGes); //Endwert wird zurück gegeben
-
Thread
I2C Adresse ermitteln
7 bit und 7 bit sind 7 bit und mit 7 bit lassen sich Adressen von 0..127 abdecken. Eine Adresse 0xA? ist keine 7-bit-adresse ist keine 7-bit-adresse weil sie sich mit 7 bit nicht adressieren lässt.
deine Aussage ganz Falsch. > I2C_Adr = 0xA0 > Beim lesen ist I2C_Adr | rw_bit > Beim schreiben nicht mal das. > Und warum du die Adresse nach rechts schiebst, ist mir ganz unklar. ich schiebe nicht nach rechts, sondern (gemäß Spezifikation) nach links, und setze dann Bit
-
Thread
Bit an einem Port manipulieren
Als Anfänger würde ich jetzt noch in dieser Variable durch Bitmanipulation PB0 und PB7 auf 1 setzen und dann auf den Port komplett zurückschreiben. Oder wie macht man das am geschicktesten? Martin
Als Anfänger würde ich jetzt noch in dieser Variable durch > Bitmanipulation PB0 und PB7 auf 1 setzen und dann auf den Port komplett > zurückschreiben. dann nein, es ist ein wenig was anderes. Es erhält den aktuellen Zustand von PB0 und PB7 und setzt sie nicht auf 1.
-
Thread
AVR Problem mit 16 Bit Timer
Hi und hallo, ich versuche gerade einen 16 Bit Timer ans Laufen zu bekommen. Dabei soll eben ein Interrupt kommen, wenn der Timer abgelaufen ist. Das passiert aber leider nicht. Den 8 Bit Timer habe ich am Laufen. Bei dem 16 Bit Timer hänge ich
ein. Der Compiler kann das selbst entscheiden. [C] OCR1A = OCR_ONE; // TOP für OCIE1A setzen TCNT1 = TCNT_ONE; // Timerzähler1 setzen [/C]
-
Thread
Video Streaming STM32 -> Z80
Hi Sean Goff, der Z80 hat ASM Befehle zum abfragen von einem einzelnen Bit (ob gesetzt oder nicht) und zum setzen von einem einzelnen Bit abfrage : BIT b,r (8 Takte) setzen : SET b,r (12 Takte) dazwischen brauchst du noch einen Jump (if Zero) der braucht 10 Takte
Uwe B. schrieb im Beitrag #3562085: > der Z80 hat ASM Befehle zum abfragen von einem einzelnen Bit > (ob gesetzt oder nicht) und zum setzen von einem einzelnen Bit Danke, jetzt wo dus sagst sehe ich es auch. Dann werde ich es wohl mit 8 BIT abfragen mit Jump machen. Uwe B. schrieb im Beitrag
-
Thread
Kombinatorik für Fortgeschrittene?
erst mal eine zufällige Zahl zwischen 1 und > 64 generieren und dann entsprechend viele zufällige Bits auf 1 setzen. > Danach kannst Du schauen, ob die beiden ersten Bits gesetzt sind. inwieweit würde sich das vom pseudocode unterscheiden?
for (int i = 0; i < anzahl_gezogen; i++) { position = rand_zwischen(0, 63); while (bit_ist_gesetzt(bitfeld, position)) { // Bit ist schon gesetzt, nimm nächste Position position = (position + 1) % 64; } setze_bit(bitfeld, position); } if (bit_ist_gesetzt
-
Thread
Daten für Drucker abfangen
Danke für die Antworten erstmal, Ich versteh das jetzt so: 1. Ich bekomme 8Bit auf dem Parellel Port und direkt danach das strobe Signal vom PC. 2. Ich setze sofort Busy auf High. 3. Ich verarbeite die 8 Bit. 4. Ich setzte busy wieder auf Low und warte auf die nächsten
bouni) >Hab ich das jetzt so richtig verstanden ? Fast. Auf Strobe=1 warten Busy auf 1 setzen Daten lesen und an den UART ausgeben Busy auf 0 setzen MfG Falk MFG Falk
-
Thread
ATMEL billiger und leistungsfähiger als PIC
Pins gleichzeitg toggeln. Da streichen > dann die 8Bitter wiederum die Segel. Bei den ATXMegas (8 Bit) hat jeder Port sogar jeweils ein Register zum Setzen, Löschen und Togglen von Pins. Und bei neueren AVRs bewirkt ein Schreiben einer 1 auf ein, oder mehrere, Bit(s) auf das bei *allen* AVRs vorhandene
spess53 schrieb im Beitrag #2286463: > Schreiben einer 1 auf ein, oder mehrere, Bit(s) auf das bei *allen* AVRs > vorhandene PIN-Register ein Togglen der angesprochenen PINs. Da werden > eher Segel gehisst. Es gibt neben dem Setzen, Löschen und Toggeln einzelner Bits eine weitere