-
Thread
Probleme Tachosignal Auswertung
Aktivieren der externen Referencspannung //*/ [/c] Dann habe ich noch eine Frage mit dem setzten der Bits im Register: Wenn ich jetzt z.B. den AD - Wandler starten möchte, muss ich doch das BIT ADSC im ADCSRA-Register setzen. Jetzt möchte ich aber erst später im Programm dieses BIT setzen und schreibe
Schreibweise so ok??? Grundsätzlich: ja. > Jetzt möchte ich aber erst später im Programm dieses BIT setzen und > schreibe an die entsprechende stelle im Programm; > > [c] > ADCSRA = _BV ( ADSC ); //Starte AD - Messung > [/c] Damit löscht du aber die Anderen Bits wieder. Um 1 Bit zu setzen
-
Thread
USB RFID Tag Leser
Hallo, hier gibt's einen RFID Tag Leser, der 64 Bit 125 kHz Tags ausliest und die darin gespeicherten Daten (40 Bit "netto") über die USB Schnittstelle ausgibt. - Auf der Platine integrierte PCB Antenne - RFID Reader Chip EM 4095 - µC ATMega 16,
ATA5570 schreiben kann. Eine kurze Frage noch: Gibt es einen besonders wichtigen Grund, warum 40 bits empfangen werden? EM4102 liefert z.B. 64 bits an Daten. War Dein Ziel nur Customer ID (8bits) + Data (32 bits) = 40bits zu empfangen? MfG
-
Thread
Xmega Soundcheck
> würde toggeln. Z.B. 32000 (16Bit) resampled nach 12Bit ergibt: 4062.5. > Ausgegeben mit 12 Bit: 4062 4063 4062 4063 ... (bis 16) Ups. Richtig heißen muss es: Z.B. 33000 (16Bit) resampled nach 12Bit ergibt: 2062.5. Ausgegeben mit 12 Bit: 2062 2063 2062 2063 ... (bis 16) Noch ein Bsp.: 65110(16Bit) -> 12Bit: 4069.375 -> Lsb's: 0110 -> 6. D.h. Korrekturwert 6 muss auf 16 12 Bit Werte aufgeteilt (offsetted) werden.
-
Thread
LCD Routine Funktioniert nicht
am Port ausgeben D7 D6 D5 D4 0 0 1 1 0 0 1 1 und der Controller ist im 8 Bit Modus, dann wertet er das als 2 Konfigurationsanweisungen, die ihn 2 mal in den 8 Bit Modus setzen würden (für N und F saugt er sich jeweils etwas aus den Fingern) Ist der Controller aber im 4 Bit
Ausgabe von 0 0 1 1 0 0 1 1 als 1 Konfigurationsanweisung, mit der er in den 8 Bit MOdus schaltet und er ein N und ein F von jeweils 0 setzen soll Aber auf N und F kommt es hier nicht an. Wichtig ist, dass der Controller nach diesen beiden Ausgaben auf jeden Fall im 8 Bit Modus
-
Thread
ATmega Bootloader Lock Bits
verifizieren, ob der Code richtig aufgespielt wurde. (höchstens noch beim ersten Mal, wenn ich die BootLockBits nach dem verifizieren setze) Theoretisch müßte man die BootLockBits zusammen mit dem Code löschen können, um sie nach dem verifizieren wieder zu setzen. Aber so viel ich weiß, kann das dazu erforderliche
Hey, welche Lock-Bits genau muss ich denn setzen, damit das Auslesen des Programmes verhindert wird? Beim Atmega 2561 würd ich jetzt nach Datenblatt LB-Mode 3 setzen. "Further programming and verification is disabled
-
Thread
Verzweigungen
, 1 rjmp MotorZW3 ;################################################## ;Setze Bits in Byte für die Linienerkennung######## LinksGroesser: sbr Linienerkennung, 1 rjmp MessungZW05 LinksKleiner: cbr Linienerkennung, 1 rjmp MessungZW1 MitteGroesser: sbr Linienerkennung
zwangsläufig kleiner. Da es keine dritte Möglichkeit gibt, ist der zweite Vergleich überflüssig. >;Setze Bits in Byte für die Linienerkennung######## >.... Warum macht du das nicht sofort nach dem Vergleich. Das Herumgespringe ist unübersichtlich. MfG Spess
-
Thread
Tasterabfrage
& MASKE; wird die LEDs wohl löschen. Warum muss da aber DDRA dabei sein?? Dann schreibe ich die Bits für die Datenrichtung in tmp und schreibe dies dann wiederrum in DDRA. Das letzte ist dann dass ich PORTA3 auf high setze. Nur den Anfang verstehe ich dabei eben nicht. Zu dem mit do … while(0) habe
wird die > LEDs wohl löschen. > Warum muss da aber DDRA dabei sein?? Dann schreibe > ich die Bits für die Datenrichtung in tmp und schreibe dies dann > wiederrum in DDRA. Das letzte ist dann dass ich PORTA3 auf high setze. > Nur den Anfang verstehe ich dabei eben nicht. Noch nicht. Nachlesen
-
Thread
Einfaches Assemblerprogramm
;Bank 1 setzen movlw B'11111111' ;Port B alle Eingänge movwf TRISB bcf STATUS, RP0 ;Bank 0 setzen main clrw movfw PORTB ;Auslesen
auch mit den anderen Pins was vor. Aber ich dachte jeden kann man einzeln ansteuern. Da ich das Bit sozusagen auf den Pin setze und nicht auf das ganze Register. Und eine grundlegende Frage hätte ich noch. Wenn der Taster betätigt wurde, kann mann das dann so machen das die LED leuchtet auch wenn
-
Thread
ir senden mit tiny2313
wenigstens das Senden ausserhalb der INTx ISRs im Hauptprogramm gemacht. Also im INTx Fall Flag setzen "taste wurde gedrückt" und weitere INTx sperren. Dann in der Hauptschleife Flag prüfen, Senden, Pause, INTx freigeben. Im RC5-Protokoll ist auch ein sog. *Togglebit* vorgesehen (3. Bit im Datenwort
habe nur auf den Sender mit Fabians Code reagiert hat, weil bei beide tiny2313 habe ich die fuse-bits gleich gesetzt. Ich werde dan mal die fuses so setzen: http://www.engbedded.com/cgi-bin/fc.cgi?P_PREV=ATtiny2313&P=ATtiny2313&V_LOW=CD&V_HIGH=DF&V_EXTENDED=FF&M_LOW_0x3F=0x1C&M_HIGH_0x0E=0x0E&M_HIGH
-
Thread
Prinzip grafische darstellung/diagramme etc
Das macht man dann abwe nich mit nem 8 bit microcontroller :D
.0,0,0,0} {0,0,0,0,0,0,0.........0,0,0,0}} [/c] Je nachdem ob ein Pixel gesetzt wird oder nicht, setze ich eine 0 oder eine 1 in die jeweilige Array Position. Sollte man eig. einen anderen Datentyp nehmen? int reserviert doch mehr Speicher als nur 1 Bit? Oder wie läuft das ganze ab? Weil rechnerisch
-
Thread
Kupferdrahtdurchmesser bei Spulen
Grund dieser Logik entfällt die aufwendige PWM-Helligkeitssteuerung durch den Prozessor. Auf den 6Bit Port wird nun 1 Pixelbyte ausgegeben und durch den MUX selektiert man jeweils 3Bit dieses Ports. Das Pixelbyte enthält also kodiert xxRRGGBB jeweils 2Bit pro Farbe. Die RRGGBB Bits gehen an den 6 Bit
. Man lädt einfach die Pixelbytes einer Displayzeile aus dem RAM und gibt sie nacheinander an den 6Bit Port aus. Dies macht man insgesamt 3 mal nacheinander pro Pixelzeile. Beim erstenmal setzt man den MUX auf Bit 0 einer Farbe, dann Bit 1 und dann nochmal Bit 0. Ein Display mit 512 Spalten wird also
-
Thread
uint64_t und Bits 33-64 lesen bzw. setzen
Hallo, ich habe ein Problem mit dem uint64_t Datentyp. Mein Testprogramm sieht so aus: [code] #include <inttypes.> #include <stdio.h> #define SET_BIT64(port, bit) ((port) = (uint64_t)((uint64_t)(port) | (uint64_t)(1ULL << (bit)))) #define IS_BIT_SET64(port, bit) ((uint64_t)((uint64_t)(port) & (uint64_t)(1ULL << (bit))) ? 1 : 0) void dbg(unsigned long long b) { for (int i = 0; i < 64; ++i) { if (IS_BIT_SET64(b, i)) { printf("X"); } else { printf("."); } } printf("\n"); } void test() { unsigned long long test; for (int i = 0;
-
Thread
Funktionsrumpf für Interrupt und neu setzen von Interrupt Vectoren
... Ich benutze diese Technik in CFC ebenfalls 'B_' für BOOL 'P_' für Puls, 'PW_' für gepulste Bits in einem Datenword...
Flash, RAM und Taktzyklen kostet. Bernd ich hab's mir schon vor ein bis zwei Wochen überlegt. Ich setze erst einmal das gesamtpacket um und versuche dabei nicht gleich ein Baustelle nach dem anderen zu hinterlassen. Wenn ich das alles so flexibel wie möglich aufziehen möchte muss ich eben mit gewissen
-
Thread
Tasten entprellen
betätigt wird, ädert sich die Anzeige. Hier der geäderte Code. MAIN: CLI CBR key_press, 1 ;Bit0 in key_press löschen CBR key_press, 2 ;Bit1 in key_press löschen CBR key_press, 4 ;Bit2 in key_press löschen CBR key_press, 8 ;Bit3 in key_press löschen CBR key_press, 128 ;Bit7 in
so sehen die Unterprogramme aus: ST100_0: ;Ziffer 0 CBI PORTB, PB3 ;A auf 0 setzen CBI PORTB, PB0 ;B auf 0 setzen CBI PORTB, PB1 ;C auf 0 setzen CBI PORTB, PB2 ;D auf 0 setzen RET Wo ist der logische Fehler? Julien
-
Thread
SPS-Programmierung / uC Programmierung in C
aber nichts mit der Frage zu tun. Hier noch mein Senf zum Thema: Bei einer SPS bedeutet: Setzen => Ein Bit auf TRUE setzen, egal wie sein Zustand vorher war Das Bit ist hinterher auf jeden Fall TRUE Rücksetzen => Ein Bit auf FALSE setzen, egal wie sein Zustand vorher war Das Bit ist hinterher auf jeden Fall FALSE Wert zuweisen => Ein Bit gleich setzen zu einem anderen Wert Das Bit kann hinterher TRUE oder auch FALSE sein, je nach dem wie der Wert seiner "Mutter" ist. Das wurde hier schon angedeutet: Autor: Dennis Heynlein (c-logic
-
Thread
security bits im PIC nicht zurücksetzbar
z.B. 0x3FB9 lädt, so ergibt ein Auslesen des Configuration Words nach der Sequenz 0x02B9 (d.h. alle Bits ausser die Codeprotection Bits werden gesetzt). Weiterhin: Die Bits in den ID Locations lassen sich von 1 auf 0 setzen (beim Versuch das Configuration Memory zu programmieren gemäss Figure 3-4 in
bits via ICSP." Hat jemand bei sich Erfolg mit dem Setzen und Zurücksetzen der Security Bits beim PIC16F628 per Do-It-Your-Self-Brenner? Wenn ja, welchen Brenner und welche Software verwendet Ihr?
-
Thread
AVR: zwei ISR's blockieren sich
wurde aufgerufen. Kann mir vielleicht jemand erklären, warum das mit einer 64 Bit-Variablen nicht funktioniert? Dann noch eine allgemeine Frage an m.n. :Was macht es eigentlich für einen Sinn in einer ISR das sei() zu setzen. Man muss doch eigentlich immer in der main-Funktion das sei() setzen, damit man überhaupt in einer ISR eintreten kann, oder?
-
Thread
Alternative zu PORTB.0
eigentlich kennen...) EDIT: Sehe grad, dass Du offensichtlich doch was anderes meinst. Einzelne Bits werden mit & bzw. | (UND mit dem Komplement der Bitmaske zum löschen, ODER mit der Bitmaske zum setzen) verändert. Siehe dazu auch [[Bitmanipulation]]. Sehr empfehlenswerter Artikel. [[AVR-GCC-Tutorial
>> Sehe grad, dass Du offensichtlich doch was anderes meinst. Einzelne Bits werden mit & bzw. | (UND mit dem Komplement der Bitmaske zum löschen, ODER mit der Bitmaske zum setzen) verändert. Siehe dazu auch Bitmanipulation. Sehr empfehlenswerter Artikel. AVR-GCC-Tutorial
-
Thread
[ AVR ] Probleme mit LCD-Display (KS0066)
; setzen BIT E nop ; kein Operation (warten) nop nop cbi portc,E ; lösche BIT E ret ; **** Zeitschleifen **** wait50us: ldi tim1, (F_CPU * 50 / 3 / 1000000
(KS0066) initialisieren ------------------ void lcd_ini () //void lcd_set204B_4bit () { delay_ms(40); // Warten > 30 ms //------------ Function set ------------------------ lcd_port_ini (); // setze Portrichtung (1 = Ausgang): 0011 1111 PORTC = 0x02;
-
Thread
Serielle Schnittstelle
data output (readable) |7|6|5|4|3|2|1|0| ports 278, 378, 3BC | | | | | | | `---- data bit 0, hardware pin 2 | | | | | | `----- data bit 1, hardware pin 3 | | | | | `------ data bit 2, hardware pin 4 | | | | `------- data bit 3, hardware pin 5 | | | `-------- data bit 4, hardware pin 6 | | `--------- data bit 5, hardware pin 7 | `---------- data bit 6, hardware pin 8 `----------- data bit 7, hardware pin 9 Port 379 printer status register (Parallel Printer Port) |7|6|5|4|3|2|1|0|
-
Thread
LCD Anzeige macht Probleme
Web rum, die fehlerhaft sind. An einer entscheidenden Stelle fehlt das Delay oder es werden zu früh 8Bit-Befehle statt 4Bit-Nibble gesendet. Manche Controller tolerieren das, manche aber nicht.
ausgedrückt: Die Daten werden bei E 'High' die ganze Zeit ins interne Register eingelesen. Warbei mir 8-Bit Modus, aber ich denke das gilt identisch auch für den 4-Bit Mode.
-
Thread
AVR DB - oder doch ein Compiler-Fehler?
Dein tick ist 16bit und dein ms_counter 32bit. Beim Draufspeichern schmeißt du die oberen Bits weg. Mach mal testweise eine 32bit tick Variable und schau obs noch vorkommt.
diese stets gültige Werte annehmen und sich dabei eine Häh? d.H. in deiner Welt darf man nur 8-Bit-Variablen verwenden, wenn man auf einem 8-Bit-AVR unterwegs ist? Es ist nunmal eine Hardware-Limitierung, dass der AVR nur 8 Bit auf einmal schreiben kann. Völlig egal, ob du den in ASM, in C++, oder
-
Thread
Umwandlung Wert in 4 Byte Gleitkommazahl (KNX)
= KNX_VORZEICHEN_MINUS; // Merker setzen } else ucVorzeichen = KNX_VORZEICHEN_PLUS; // Merker setzen if(ucVorzeichen == KNX_VORZEICHEN_MINUS) // Vorzeichen negativ? uiReturnvalue = 0b1000000000000000; // Negativ-Bit setzen else uiReturnvalue = 0b0000000000000000; // Negativ-Bit löschen uiReturnvalue = uiReturnvalue | (uiExponent << 11); // Exponent-Bits setzen uiReturnvalue = uiReturnvalue +iMantisse;
-
Thread
MMC/SD ansteuern mit AVR
Codevision Compiler anzupassen... jedoch weiß ich bei diesen 2 zeilen nicht so recht weiter: if (bit_is_set(MMC_Read,SPI_DI) > 0) //Lesen des Pegels von MMC_DI und if (bit_is_set(Byte,(a-1))>0) //Ist Bit a in Byte gesetzt bit_is_set scheint ein makro zu sein, cvr unterstützt dies aber nicht
@Marcel Ich weiß nicht, ob Du es inzwischen schon herausgefunden hast: loop_until_bit_is_set => while(!(REGISTER&(1<<BIT))){} loop_until_bit_is_clear => while(REGISTER&(1<<BIT)){} Du musst nur darauf achten, dass Du das verwendete BIT oben im Programm mit #define
-
Thread
INT0, nach wieviel takten startet die ISR?
es höchstens dort wieder manuell setzen. Ist aber >nicht gerade zu empfehlen. Warum nicht? Wenn ich meine Takte abgezählt habe und genau weiß, dass die ISR nicht unendlich tief schachteln? aber ok, das I-Flag setzen wäre dann 1-Takt
> wann willst du es denn setzen, du kannst es ja nur setzen nach dem du in > der ISR bist, aber da sind ja schon wieder ein paar takte vergangen. Es dürften ja Takte vergehen, ich möchte nur wissen wieviele. 6? 7? 8? Damit ich
-
Thread
Takteinstellung ATtiny84A
wirklich daran, dass der ADC im FreeRunningModus läuft... wenn ich in der ISR vom ADC einen breakpoint setze, komm ich gar nicht mehr raus... Ich bin gerade dabei, den ADC auf den Timer0(8bit) zu triggern. das erreiche ich, wenn ich das ADTS2 Bit im ADCSRB register setze. Den Timer 0 hab ich aber für PWM
machen Nein. >oder wandelt der danns chon jedes mal, wenn Timer0 überläuft? Ja. >(das ADSC bit im ADSCRA ist gesetzt)... Brauchst du nicht setzen. Das wird bei Free Running nur zum Starten gebraucht. MfG Spess
-
Thread
OC0A & OC0B gleichzeitig toggeln?
invertiertes. Ich wollte das ja realisieren indem ich einen Ausgang initial high und den anderen low setze. Kann es sein, dass dadurch: "If one or both of the COM0A1:0 bits are set, the OC0A output overrides the normal port functionality of the I/O pin it is connected to". - meine high/low Initialisierung
invertiertes. Ich wollte das ja > realisieren indem ich einen Ausgang initial high und den anderen low > setze. Ne, im PWM-Mode ist das Ausgangsregister wirkungslos. Du kannst aber einen PWM-Ausgang auf invertiert setzen, das geht in allen PWM-Modi.
-
Thread
USB IR Remote Receiver (V-USB + IRMP)
Byte], Month[Byte], Year[Word]) HidD_SetFeature (schicke Daten zum AVR): ID4: (1 Byte, Boolean) setze PowerOn Funktion aktiv/inaktiv. ID5: (6 Bytes) setze/loesche trainierten IR-Code im EEProm. ID6: (1 Word) setze IR-Polling Frequenz.[/c] Um an die aktuellen IR-Code zu kommen muss das Feature
programmieren. ich habe die anleitung von portisch schritt für schritt befolgt. beim auslesen der fuse-bits schon das erste prob: anfangs hat er immer "missing device" gemeldet; nach ein paar mal "retry" hat er aber die bits ausgelesen. ich habe die bits richtig gesetzt und dann "write" geklickt. das hat
-
Thread
PIC16F84 heftige Probleme, kein Oscillator schwingt an MPLAB, MPSIM.etc.bin Neuling!
Mike wrote: > Hast Du die Oszillator Selection Bits FOSC0 und FOSC1 richtig gesetzt? Wo kann ich diese Bits denn setzen? Oder wie mache ich das? Doch nicht in der .inc oder? Soll ich die bei der Initialisierung im ASM file setzen? SCHONMAL HERZLICHEN
René Manjavi wrote: > Mike wrote: >> Hast Du die Oszillator Selection Bits FOSC0 und FOSC1 richtig gesetzt? > > Wo kann ich diese Bits denn setzen? Oder wie mache ich das? Doch nicht > in der .inc oder? Soll ich die bei der Initialisierung im ASM file > setzen? in
-
Thread
Sinustest des vs1011
SCI_PORT &= ~(1<<SCI_PIN); //SCI aktivieren SPSR = 0 << SPI2X; //SPI Auf halbe geschwindigkeit setzen (nur notwendig wenn Quarz-frq. <24.576MHz) loop_until_bit_is_set(PIND, PD5); //Auf DREQ warten vs1011_SCI_write(SCI_MODE, MODE_TESTS); //SM_SDINEW |(für SM_TESTS 5. Bit von 0-15 setzen) vs1011_SCI_write(SCI_CLOCKF, 0x1800+0x8000); //12288000 / 2000 + doublespeed bit SCI_PORT |= 1<<SCI_PORT; //SCI deaktivieren SDI_PORT &= ~(1<<SDI_PIN); //SDI aktivieren
-
Thread
USB des STM32 F103C8T6 nutzen
getaktet wird. Im Reset-Zustand ist der Teiler für den USB-Takt schon auf 1,5 eingestellt (USBPRE Bit im RCC_CFGR == 0), d.h. mit 72MHz Systemtakt läuft der USB automatisch mit 48MHz. Ansonsten muss man das System ebenfalls mit 48MHz takten und das USBPRE Bit setzen, dann ist USB-Takt gleich Systemtakt
Wie installiert man die Nuvoton *.inf Datei unter Windows 7 32bit?
-
Thread
PC-Tastatur mit AVR ersetzen
---------------------------- bitweiter: dec temp2 ; Anzahl der ausgegebenen Bits runterzählen brne Schiebe_1 ; Wenn noch keine 8 Bits ausgegeben -> Schleife bilden pop temp2 parity_bit: ;---------------------- cpi parity, 0 breq null rcall send_eins rjmp
Operation Verwendung für --------------------------------------- ODER Bit setzen UND Bit löschen; Bit zum Abfragen ausmaskieren XOR Bit toggeln (aus 0 mach 1 und umgekehrt)
-
Thread
Fusebits beim AT-Mega 8
da eine Frage und bitte nicht schlagen wenn sie hier falsch ist: Wie muss ich die Fuse- und Lock-Bits beim AT-Mega8 setzen damit das Programm nicht ausgelesen werden kann? Hintergrund, ich habe ein kleines Programm für eine Steuerung geschrieben das ich im Atmega8 zum testen an ein paar Bekannte weiter
nachgefragt, aus dem engl. Text werde ich nicht ganz schlau weil es wohl mehrere Möglichkeiten gibt die Bits zu setzen. Ich dachte hier wäre einer der schon mal die Lockbits benutzt hat und mir sagen kann wie die sein müssen und wo die sich befinden wenn ich z.B. mit Bascom arbeite. Sind die Lockbits z.
-
Thread
Versuch einer Millis Funktion für AVR
Ben S. schrieb im Beitrag #7940601: > 64bit in Mikrosekunden 64 Bit in Mikrosekunden... auf einem AVR? Oder bin ich hier im falschen Thread?
, nicht 16 Bit Variablen (im RAM).
-
Thread
Variable Portzuweisung PXOUT
Der Port wird ja über ein Register angesprochen. Das Register besteht aus einzelnen Bits. Die Nummer des Ports ist das entsprechende Bit. Willst du Port POUT.0 auf 1 setzen, dann sieht das so aus: 00000001 Bei POUT.1: 00000010 Natürlich kannst du die Bitvektoren beliebig angeben.
PORT7 &= 0xf3; // löscht Bit 2 und 3 PORT7 |= VAR1; // setzt die Bits aus VAR1 Port 8 entsprechend. Anmerkung: Als Port werden iA die gesamten 8 Bit bezeichnet. Du möchtest einzelne Portbits setzen.
-
Thread
Laufwerksbuschstaben zuweisen?
Hans schrieb im Beitrag #7783310: > - lade Dir die 32Bit Variante herunter und installiere sie. Damit die > 64Bit Variante erhalten bleibt in ein anderes Verzeichnis. Ich habe die 32/64-Bit-Variante vom TC installiert. Ich habe die 32 Bit.exe vom TC
Peter N. schrieb im Beitrag #7783481: > Ich habe die 32/64-Bit-Variante vom TC installiert. Ich habe die reine 32Bit Variante installiert und über diese dann auch das 32Bit Plugin installiert. Hast Du den TC im Verzeichnis "Program Files" oder "Program Files
-
Thread
Laufschrift Denkanstöße
0x04,0x32,0x21,0x43,0x43}; > glcdSetPixel(x,y); > Nun kann Ich ja mit "glcdSetPixel()" einen beliebigen Pixel setzen. > Die Anzahl von Pixel vom Buchstaben "A" müssten 5Bytes(8Bits) * 8 = 320 > Pixel sein. > Wie setze ich jetzt von jedem Byte von "A" gezielt die Pixel, wenn ich > bei der "glcdSetPixel()"
0x04,0x32,0x21,0x43,0x43}; >> glcdSetPixel(x,y); >> Nun kann Ich ja mit "glcdSetPixel()" einen beliebigen Pixel setzen. >> Die Anzahl von Pixel vom Buchstaben "A" müssten 5Bytes(8Bits) * 8 = 320 >> Pixel sein. >> Wie setze ich jetzt von jedem Byte von "A" gezielt die Pixel, wenn ich >> bei der "glcdSetPixel()
-
Thread
AVR Synthesizer mit ATxmega128A1
weniger Verzerrungen. Sinuston (12Bit und 8Bit) auf einem ATxmega128A1 mit internem 12Bit DAC http://soundcloud.com/rolfdegen/sinus_12bit_8bit Gruß Rolf
fFineByte) ) >> 8 + ( fPitch2 * (fFineByte) ) >> 8; [/code] Ich glaube C/C++ rechnet hier in 24bit, die Multiplikation aus 24bit mit 8bit ergibt allerdings 32bit und der Compiler convertiert das runter indem er die höheren (wichtigeren) 8bit weglässt. Das müsste irgendwie mit Typecasting lösbar sein
-
Thread
Hausbus
mitlerweile hab ich mir erstmal ein telegramm zusammengestellt: extendetFrame: Stand. Identifier-> 8Bit Ziel; 3Bit Nachrichtenart (E/A Analog, Zeit etc.. dienst nur der Vorauswahl) ext. Identifier-> 8Bit Absender; 10Bit BroadcastID (jeder wert der als Broadcast rausgeht hat eine unverwechselbare ID)
. :-) Bit28 ist das MSB. Bit0 ist das LSB. Damit wird _zuerst_ Bit28 gesendet... > wird beim gleichzeitigen senden die nachricht als wichtig erkann > (höhere priorität) die wärend des telegrammes als erstes
-
Thread
Atmega 2560 startet Program nicht
ganzen Klumpen [c] //++++++++++++++++++ TEST ++++++++++++++++++// PORTB |= (1<<PB6); //Bit setzen PORTB |= (1<<PB7); //Bit setzen PORTA |= (1<<PB0); //Bit setzen PORTA |= (1<<PB1); //Bit setzen PORTA |= (1<<PB2); //Bit setzen PORTA |= (1<<PB3); //Bit setzen PORTA |= (1<<PB4); //Bit setzen PORTA |= (1<<PB5); //Bit setzen PORTA |= (1<<PB6); //Bit setzen PORTA |= (1<<PB7); //Bit setzen _delay_ms(5000); // warten PORTB &= ~(1<<PB7); // Bit loeschen
-
Thread
24 bit Rechtgenerator mit feiner Auflösung
Beispiel für einen 16-bit Zähler auf einem µC: Ein wenig pseudocode nenne ich es mal ;) Für deine Zahl, nehmen wir mal 200.000. uint32_t max = 200000; jetzt teilen wir die Zahl auf und setzen das Compare-Register des
Was ist denn mit einem AVR Xmega? der Kann z.B. 2 16-Bit Timer hardwareseitig zu einem 32 Bit Timer/counter zusammenschalten. Und die Auflösung ist auch kein Problem
-
Thread
ADC 24 Bit äußere Beschaltung.
Ein weiterer Punkt wäre das Auslesen des ADCs. Ich verwerfe das LSB des 24-Bit ADC (dies ist ja das Status Bit) und lass mir die 23 Bit als Integer anzeigen. Dies müßte korrekt sein. gel? Also hat der 24 Bit ADC im Prinzip nur eine Auflösung von 23 bit?
Beitrag #3890687: > Habe leider die Schaltung hier nur auf dem Steckbrett. Autsch, und das bei 23 bit…das wird ja schon bei 16 bit nix damit da nix zappelt und du willst es auf 23 bit bringen? Also ich fände ja jetzt interessant wofür du 23 bit brauchst. However, auf dem Steckbrett kannst du locker
-
Thread
AVR - SHT11 liefert zu große Werte
(1<<8); //Schreibe 1 in Bit 9 von MSB } _delay_ms(EINPEGELN); //ACK zwischen den beiden 8- Bit- Feldern SHT_DATA_DDR = SHT_DATA_DDR | (1<<SHT_DATA_PIN); //Datenpin als Ausgang setzen (ACK) _delay_ms(EINPEGELN
(1<<0); //Schreibe 1 in Bit 1 von MSB } _delay_ms(EINPEGELN); SHT_DATA_DDR = SHT_DATA_DDR | (1<<SHT_DATA_PIN); //Datenpin als Ausgang setzen (ACK) _delay_ms(EINPEGELN); SHT_DATA_PORT = SHT_DATA_PORT | (1<
-
Thread
Anfängerfrage: Temperaturgesteuerter Heizer
Übertragungsfrequenzen ansetzt. uint8_t w1_reset( void ); // löst am DS1820 einen Reset aus uint8_t w1_bit_io( uint8_t b ); // schreibt ein Bit in den IC, gleichzeitig wird ein Bit // vom IC empfangen uint8_t w1_byte_wr( uint8_t b ); // benutzt w1_bit_io um nacheinander 8 Bit zum IC zu schicken
if(t >= 10) { p |= (1<<4); t -= 10; } //Pin4 für 10°C setzen if(t >= 8) { p |= (1<<3); t -= 8; } //Pin3 für 8°C setzen if(t >= 4) { p |= (1<<2); t -= 4; } //Pin2 für 4°C setzen if(t >= 2) { p |= (1<<1); t -= 2; } //Pin1 für 2°C setzen
-
Thread
Incrementieren einer 16Bit Zahl
Hallo zusammen, ich möchte einer 16 Bit Zahl immer bis dezimal 9999 hochzählen lassen (für eine Zeitmessung mit AVR 4433). Gibt es eine kürzere Möglichkeit wie in meinen Beispielprogramm? Danke im Voraus. Norbert
.def Time1H = r25 HAUPT: ldi Time1L,low(10000) ;Counter auf 10000 (low-byte in r24) setzen ldi Time1H,high(10000) ;Counter auf 10000 (high-byte in r25) setzen ZAEHL: sbiw Time1L,1 ;16-Bit Counter um 1 verringern brne ZAEHL ;und solange widerholen solange <> 0
-
Thread
Bitte um Hilfe mit Verständnis, ISR von Timer usw.
oben demonstrierten Probleme beim Lesezugriff. Mmh. Auf dem ATMega1284 *sind* Zugriffe auf die 16-bit TCNTn-Register atomar: "16.3 Each 16-bit timer has a single 8-bit register for temporary storing of the high byte of the 16-bit access. [...] When the low byte of a 16-bit register is read by the CPU
for > temporary storing of the high byte of the 16-bit access. [...] When the > low byte of a 16-bit register is read by the CPU, the high byte of the > 16-bit register is copied into the temporary register in the same clock > cycle as the low byte
-
Thread
XP: Checkdisk beim Boot
Das Dirty-Bit kann man via "fsutil" abfragen und setzen: [code] fsutil dirty query c: [/code] [code] fsutil dirty set c: [/code] ...zeigt fsutil an dass das Dirty-Bit gesetzt ist? Falls nicht: Setz es einfach
falsch ist, so what? Beschwere dich bei der Chip. > und beharrst darauf, daß auf WinME > keine 64-Bit-Emulation unter VMware möglich ist. Auf einem 32-Bit WinMe mit einem 32-Bit Prozessor wirst du wohl schwerlich eine 64-Bit Emulation hinbekommen. Woher soll der Proz. plötzlich 64-bit breite Register
-
Thread
Arduino->WS2812B-> Arduino
blockieren. > Der Compiler wird so gut sein und die paar Befehle optimieren. Denk ich auch. Ein Bit ist 1,2us lang. Man pollt z.B. immer bis zur fallenden Flanke, wartet dann bis zur Mitte des Bits, und wertet dann den Portstatus aus. Oder man benutzt ICP1. Für ganz wenige Bits könnte man vielleicht
NeoPixel LED Rings zu sehen. Interessant dabei ist, dass die Neopixel scheinbar einen Buffer von 2 Bit haben, da das Signal am Ausgang des letzten Pixels um 2 Bit verschoben ist. [c] /* * * Sender for NeoPixel stripe * last LED is used as data container (24bit) * * 21.11.2021 chris_
-
Thread
avr asm bit-Ansteuerung
Programm in einem Register eine binäre Zahl eintragen, wo ich immer nur 1 oder 0 für das entsprechende Bit bekomme. Es handelt sich um PS2. Wie mache ich das am besten, ich hatte das so gedacht: Bit an der Stelle k setzen/löschen: sbr state, k nur ist das Problem, das es in Assembler dahinter
Martin K. schrieb: > Habt ihr da eine Idee? Am einfachsten machst du das so, dass du *immer* Bit 0 setzt und nach links verschiebst. Ergebnis = 0 für alle Bits 0 bis 7 { schiebe Ergebnis eine Stelle nach links setze Bit 0 abhängig von dem was du empfangen hast } Bsp
-
Thread
Raceboard mit Zeitanzeigen
auftritt. Ich kann es nur nochmal wiederholen: 14 Digit * (7 Segmente + DP) = 112 CLK. Bit entsprechend seinem Wert setzen bzw. löschen, 100ms warten, CLK toggle, 100ms warten, CLK toggle, 100ms warten. Wenn Byte zu Ende, Latch toggle, 100ms warten, Latch toggle, wieder 100ms warten
Code und Arduino-shiftOut ist, dass Deine Funktion mit der Logik arbeitet: - Clock-Pin auf Low - Bit-Value setzen - Clock-Pin auf High Und Arduino-shiftOut shiftet wie folgt: - Bit-Value setzen - Clock-Pin auf High - Clock-Pin auf Low Beim Arduino-shiftOut muß deshalb vor dem ersten Funktionsaufruf