-
Thread
bit invertieren
es so an > einem Port auszugeben?! > Also aus 11101010 mach 01010111 Das ist ein invertiertes BYTE... :-o Und das gabs schon oft hier im Forum. Die Suche wird dir helfen... http://www.mikrocontroller.net/search?query=Byte+spiegeln&forums[]=1&forums[]=2 EDIT: Mist, Fenster zu lang offen...
Okay, Ihr habt Recht, ich wusste nicht genau was ich wollte :D. Also ich will das Byte natürlich Spiegeln. Und das am besten in C. Es war gestern glaub einfach schon zu spät xD
-
Thread
Spiegeln eines Bits
Hallo, es wurde schon einige mal darüber geschreiben wie man ein Byte Spiegeln kann. Ich stehe gerade vor dem Problem das ich beim Layout bin und einen ganzen Bus Spiegeln müsste (was viel Platzt auf der Platiene brauchen würde). Bei mir ist aber immer nur maximal 1Bit
256 Byte im Code frei? Tabelle.
-
Thread
lookup verständnis
In ASM kann man ein Byte bitweise wunderbar spiegeln, indem man Register A 8x per 'lsl' ins Carry schiebt und per 'ror' in Register B rotiert.
Funktionen für das ganze Display sind schon fertig! Nur wenn ich da jetzt das versuchen will, ist ja das Byte immer falsch rum angelegt kann man sagen! Also muss ich das zuerst Spiegeln, sodass der Port ein Gespiegelts Byte anlegt, aber auf dem Display das dann wieder stimmt! Sagte ja es ging nicht anderst
-
Thread
Inline Assembler- Bits spiegeln
Wenn du 256 Bytes RAM frei hast, geht das mit einer Übersetzungstabelle (byte array) deutlich schneller (sowohl in C als auch in Assembler): [code] static uint8_t swap[256] = { 0x00,0x80,0x40,0xc0,0x20,0xa0,0x60,0xe0
; 1 clr ZH ; 1 clr tmp ; 1 subi ZL,Byte1(LUTNEGOFFS) ; 1 sbci ZH,Byte2(LUTNEGOFFS) ; 1 sbci tmp,Byte3(LUTNEGOFFS) ; 1 out RAMPZ,tmp ; 1 elpm R16,Z ; 3 pop tmp
-
Thread
ADC auf DAC spiegeln Problem!
Hallo uC-Freunde! Ich habe folgendes Problem, ich möchte mit einem ADC-Eingang eine Spannung einlesen und den gleichen Spannungswert am DAC-Ausgang ausgeben. Leider funktioniert dies noch nicht richtig. Ich gebe 5 V an den Eingang und erhalte am Ausgang lediglich 2,62 V. DAC und ADC lasse ich über die interne Vref 2,56 V laufen. Kann mir jemand sagen, was ich in meinem Code falsch mache?! [C] void get_adc_data(void) { while(1) { ADCSRA |=(1<<ADSC);//ADC_starting_conversation //adcl = ADCL; //adch = ADCH; //dacl = DACL; //dach = DACH; //adc = adcl
-
Thread
reihenfolge der bits in einem byte umdrehen
wirklich ist? Das letzte Mal, als ich es nachgerechnet habe, war die simple Schleife bei einem Byte, das es umzudrehen gilt, kürzer und schneller.
zugreifen: [c] PROGMEM uint8_t bit_revers_tab[256] = { 0x00, 0xF0, 0x40, 0x20, ...}; uint8_t my_revers_byte; uint8_t my_byte; my_byte = 0x01; my_revers_byte = pgm_read_byte(bit_revers_tab + my_byte;); [/c] Das ist zwar unschlagbar schnell, dafür schmerzen die 256 Tabbellenbytes vielleicht.
-
Thread
Bits umtauschen (spiegeln)
Es weihnachtet wieder einmal und ich habe mein 16x10 LED Display vorgekramt. ATmega128 es werden 2x8Bit (PortA linke hälfte, PORTC rechte hälfte)) breit pro Zeile dargestellt und das alles 10x (PORTD mit 74HCT42 0-9 decodiert)nach unten widerholt.(PORTD=10->alles aus) Seinerzeit(tm) hatte ich das mit den Fastavr-"Compiler" (ähnlich BASCOM) zusammengebastelt und ging eigentlich auch ganz gut. Durch eine damalige Unachtsamkeit beim Routing sind jedoch alle Portbits vom PORTA und PORTC vertauscht. aus PA.0->PA.7 wurde PA.7->PA.0 usw. *schnief* Ich habe das damals softwaremäßig so gelöst:
-
Thread
Bits spiegeln in Hardware oder in Software?
PD1->D6 usw. Nun hab ich zwei Möglichkeiten: Layout einfach halten, und die Bits in Software spiegeln, oder Schaltplan und Software "sauber" halten, dafür ein kleiner Alptraum beim layouten (wird einseitig). Da es ein grafisches Display ist, wird da das Spiegeln eh nicht so tragisch, da sowieso
also auch Zeichensatztabellen kann man schon zur Compilezeit durch das Macro jagen. Da kostet das Spiegeln also keine zusätzliche Laufzeit. Peter
-
Thread
NMEA - Protokoll / UBLOX SAM - LS / ATMEGA 16
Beschreibung: Funktion wird verwendet um Bytes an das Display hinauszuschreiben. *******************************************************/ void LCD_Out(char out, int reg) { out = Spiegeln(out); //Der zu sendende Charakter muss noch gespiegelt
Kommenatere unterhalb *******************************************************/ unsigned char Spiegeln (unsigned char c) { unsigned char i, back; //i = Zaehlvariable // back der gespiegelte unsigned char for (i =0; i < 8; i++) //Algorithmus zum spiegeln eines unsigned
-
Thread
EEPROM Daten wegen Zugriffszeit im RAM Spiegeln?
musst erst das EEPROM ansprecehn, dann den Lesebefehl absetzten. > Danach die Adresse und Anzahl der Byte(s) übertragen. > Diesen Protokolloverhead hast du bei EEPROM immer. > Naja man muß das auch ins RAM spiegeln, also Initialisierung laß ich mal nicht gelten. Adresse laden und und Bytes übertragen
eine Sensorkennlinie in soooo hoher Geschwindigkeit lesen muß als das es sich lohnt das ins RAM zu spiegeln...
-
Thread
Guter, günstiger, Chip für Grafikdisplay
.. der muss älter sein laut grober suche im netz kann er 8bit parallel oder seriell bild spiegeln 240x64 pixel in hart SW sind das 1920 bytes RAM also 3840 bytes im Ram für pages (greyscale 4bit *4) 4kb Ram für das LCD sollten in jedem etwas größeren µC platz sein
der muss älter sein > laut grober suche im netz kann er 8bit parallel oder seriell > > bild spiegeln > > 240x64 pixel in hart SW sind das 1920 bytes RAM > also 3840 bytes im Ram für pages > > (greyscale 4bit *4) > > 4kb Ram für das LCD sollten in jedem etwas größeren µC platz sein
-
Thread
Wie kann ich ein Port invertieren
Übrigens kann man in Bascom direkt auf Assembler umschalten und wieder Zurück. In Assembler geht das Spiegeln des Portwerts blitzschnell. Gruss allu
Ok, ok, Du hast gewonnen, geniales Programm. Selbst meine einfachste Variante braucht zum spiegeln immer noch 16 Zyklen. Und ist auch noch einen Befehl länger. Dim Zum_display As Byte ' Übergabe und Rückgabe $asm Spiegel: Loadadr Zum_display , X ld r18, X rol r18
-
Thread
Bits elegant spiegeln, wie?
Hallo, Ein Byte negiert man, in dem man es Exclusiv-Oder mit FF (hex) verknüpft !!! Als Anfänger darf man noch solche schlechten Lösungen wie eure posten ...!
Leider die Frage nicht genau gelesen! Es wurde nach _spiegeln_ nicht negieren gefragt.
-
Thread
bits eines bytes umdrehen
du willst also die bits an einer seite des bytes "spiegeln", oder? hab zwar von c nich so die ahnung, aber nimm einfach den inline-assembler und roll das eine byte rechts raus ins carry-flag und von da linkswärtig wieder in ein anderes byte...
Hallo, einfach XOR mit 0xFF byte ^= 0xFF ; Gruss Thomas
-
Thread
Keine Open Load Meldung bei ata6836c und IFX9201SG!
zuerst NOP(); NOP(); NOP(); //Wartezeit: WICHTIG, muss wohl sein vor senden HighByte! SSP2CON1bits.WCOL = 0; SSP2BUF = send_cmd_high; // write to buffer for TX while (SSP2STATbits.BF == 0u); status2 = SSP2BUF; SET_PORT(M_CS); //Disable ATA6836 //Spiegeln für Bit16-0 Ansicht, statt Bit0-16 status1 = FKT_bits8_spiegeln(status1); //Low Byte status2 = FKT_bits8_spiegeln(status2); //High Byte //16Bit Status zusammensetzen, 2x 8Bit status16 = (status2 * 256) + status1; return status16; //Wird später
-
Thread
Lcd Datenleitungen verkehrt angeschlossen
0xcc); // n = ((n >> 4) & 0x0f) | ((n << 4) & 0xf0); return n; } [/c] Nicht das ganze Byte spiegeln, nur die beiden Nibbles in sich (wg. Nibble Ausgabe).
// n = ((n >> 4) & 0x0f) | ((n << 4) & 0xf0); > return n; > } > [/c] > > Nicht das ganze Byte spiegeln, nur die beiden Nibbles in sich (wg. > Nibble Ausgabe). Danke müsste jetzt eigentlich funktionieren, macht es aber nicht... rufe ich die Funktion mirror an der richtigen Stelle auf?
-
Thread
Wie drehe ich eine Bitreihenfolge um??
Spiegeln
spiegelnden Daten, mit bits gibt man die Anzahl der Bits die gespiegelt werden. Will man nur ein Byte spiegeln nimmt man "bit_swap(x, 8)". Man kann aber auch nur zum Beispiel 5 Bits spiegeln lassen oder 13, ganz egal...
-
Thread
LED-Matrix; glimmen nicht aktiver LEDs
srcMirror=x; mirror(); //Bits spiegeln SSP1BUF=dstMirror; //schreibe lByte while(SSP1STATbits.BF==0); dummy=SSPBUF; x=(x>>8); //hByte ins lByte schieben } [/c] int ist ganz schlecht
reichen. Also ein uint8_t Die ganze Schleife ist im Grunde unnötig. Mach die eine Funktion, die 1 Byte raustaktet und ruf die dann von WriteLine 2 mal auf [C] void writeByte( uint8_t byte ) { srcMirror = byte; mirror(); //Bits spiegeln SSP1BUF = dstMirror; //schreibe lByte
-
Thread
Xmega Pin Zustand effizient spiegeln
nicht richtig ist. Im Grunde würde es reichen bei jedem Flankenwechsel den aktuellen Zustand zu spiegeln. So müsste die Systemlast auf das notwendige Minium sinken. Gruß Chris
Hi, DMA uh oh, aber ich glaube der kann nur Byte weiße Daten schieben. ABER: es müsste einen PIN Change interrupt geben bei den XMEGAS für alle Pins. MfG ich
-
Thread
Bits tauschen?!
Schleife erledigen.. Muss doch funktionierten oder? [c] static inline uint8_t swapBits(uint8_t byte) { uint8_t tmp = 0; if(byte&1<<7) tmp|=1<<0; if(byte&1<<6) tmp|=1<<1; if(byte&1<<5) tmp|=1<<2; if(byte&1<<4) tmp|=1<<3; if(byte&1<<3) tmp|=1<<4; if(byte&1<<2) tmp|=1<<5; if(byte&1<<1) tmp|=1<<6; if(byte&1<<0) tmp|=1<<7; return tmp; } [/c]
-
Thread
AVR, Sinustabelle zu groß für den Speicherplatz
Hast du dir mal die API zu den pgm_ Befehlen angeguckt? Da kann man auch größere Einheiten als Bytes lesen. Oder du legst deine Werte als Bytes ab, wobei 2 Bytes dann ein Wort ergeben und halt 2 mal read_byte machst und zusammenbaust. Du kannst den Pointer auch einfach auf uint8_t umbiegen und liest
Waqrum verwendest du überhaupt pgm_read_byte? result = sinusTabelle[i]; sollte das gleiche Ergebnis bringen.
-
Thread
Linearisierung eines Ausgangssignal mit Mikrocontroller
jetzt, die Funktion die ich in Excel mit dem > Least Square Fit errechnet habe an der Geraden zu spiegeln, welche > ich nachher haben will (orange Gerade im angehängten Bild). Warum vertauscht du nicht x,y und lässt dir gleich den Fit für eine Korrekturfunktion ausgeben?
…. | 0,27 | 3704 | [/c] Die RAM Belegung lag bei 10% (von 2048 Byte). Die ROM Belegung bei 10%...15% (von 30720 Byte) (Ausgabe der Zeitwerte per Serial war noch drin. Alles in float. Keine Optimierungen.) Das Polynom 10 Grades schafft immerhin mehr als 3000 Samples
-
Thread
Bits spiegeln / C
Hallo zusammen, ich shifte meine Bits hiermit an die richtige Stelle, allerdings ist das Bild bei meiner 8x8 Matrix dann Spiegel verkehrt. Kann mir jemand helfen? seg_schieb[zaehler] = ((segment[zaehler]&0x01)<<6) + ((segment[zaehler]&0x02)<<4) + ((segment[zaehler]&0x04)<<2) + ((segment[zaehler]&0x08)>>3) + ((segment[zaehler]&0x10)>>1) + ((segment[zaehler]&0x20)>>4) + ((segment[zaehler]&0x40)>>4) + ((~
-
Thread
S65 display library on AT90CAN128: Compile errors
Display, oder in beiden? Bei einen von den beiden Displays gibts nen Kommando um das Display zu spiegeln/Drehen. Steht auch in dem Quellcode drin(afair).
SPI_SEND: sbi LCD_SPCR,SPE ;enable SPI out LCD_SPDR,T1 ;load byte in SPI data register SPI_SEND_0: sbis LCD_SPSR,SPIF rjmp SPI_SEND_0 ;transmitt byte to LCD push r0 ; short time workaround to be fixed in r0,LCD_SPDR
-
Thread
Denkfehler bei Displayansteuerung
das Pferd an der falschen Stelle auf. Alles was dich interessiert, ist die eine Funktion, die 1 Byte in die 4 Bits zerlegt und auf die Reise schickt. Diese 4 Bits musst du in sich spiegeln, um deine Torheit die Datenleitungen genau falsch herum anzuschliessen, wieder auszugleichen. So etwas macht man
Hi >Den Inhalt von data spiegeln wäre natürlich eine Lösung, aber ist das >denn auch so ohne weiteres möglich? bzw. wie genau? so: http://www.mikrocontroller.net/topic/51793#402058 MfG spess
-
Thread
zwei Fragen zu MAtrix mit LED-Streifen; Spannungsversorgung, Datenleitung
Ja, das "Spiegeln" machst Du in SW. Wichtig sind kurze Leitungen, und vor allem alle 5 LEDs einen Abblockkondensator 100nF. So kannst Du bist zu 200 LEDs kaskadieren.
erzeugt. 8 SPI Bits = 2 WS Bits 800kHz * 4 SPI Bits = 3,2 MHz SPI Takt Ein DMA Transfer umfasst 12 Bytes = 3 WS Bytes (GRB eine LED) Sobald als möglich werden die nächste 12 Bytes berechnet und die Daten für die nächste LED über DMA ausgegeben. Das ganze funktioniert ohne Verzug. Es wird dafür ca.
-
Thread
AVR-ASM Knobelei : Bitmanipulation am LCD im 4-Bit Mode
spess53 schrieb im Beitrag #3852760: > Dann spiegel doch einfach erst mal dein Byte, das du ausgeben willst: > Was genau ist spiegeln ? Kopieren ? Also r16 auf den Stack legen ? [avrasm] .nolist .include "m8def.inc" ;ATmega8 Labelzuweisungen .list; ; ;Stackpointer
Bernd Stein schrieb im Beitrag #3854102: > Was genau ist spiegeln ? > > [avrasm] > ; Byte in r16 > mirror_fast: > push r16 > swap r16 > mov r17,r16 > lsr r16 > lsr r16 > lsl r17 > lsl r17
-
Thread
RFID hex-dec
wissen, > ob dahinter ein tieferer Sinn steckt. Mit Sicherheit nicht. Die Karten-ID ist 5 Bytes lang und es wird garantiert (immer noch), dass diese ID einmalig ist. Da kannst du spiegeln, drehen, vertauschen oder sonstwas tun - es wird weder sicherer noch unsicherer dadurch. Auf der
- m.W.n. die unteren vier Bytes die "ID" darstellen, während im obersten/fünften Byte "Revision" und "Vendor" kodiert sind
-
Thread
Zweiklang Ton erzeugen
steht, dann ist es auch weder float, unsigend PCM noch signed PCM. Das ist Text. Ein Float ist 4 Byte, PCM je nach Auflösung 1 bis 4 Byte. Die Textzahlen sind bis zu 7 Byte + <CR> + <LF> ... also 9 Byte. Wo man das in AC einstellt, kann ich Dir aber auch nicht sagen, da ich damit nicht arbeite.
Jobst M. schrieb im Beitrag #5148178: > Das ist Text. > Ein Float ist 4 Byte, PCM je nach Auflösung 1 bis 4 Byte. > Die Textzahlen sind bis zu 7 Byte + <CR> + <LF> ... also 9 Byte. Laut dem Wiki von Audacity ist es aber genau so! http://manual.audacityteam.org/man/sample_data_import.html
-
Thread
Division mit "krummen" 10
Buffer[i-j-1] = temp; } Buffer[i] = '\0'; } [/c] Das hat den Sourcecode um satte 500 Bytes minimiert bei nur einer 16Bit Ausgabe (Dec: 786). Mit mul01(uIntValue) : [code] Program Memory Usage : 4508 bytes 13,8 % Full Data Memory Usage : 70 bytes 2,7 % Full [/code]
bringt nicht sonderliche Vorteile und ist auf 1024 begrenzt: [code] Program Memory Usage : 4506 bytes 13,8 % Full Data Memory Usage : 70 bytes 2,7 % Full [/code]
-
Thread
Bits drehen bzw. spiegeln
ich habe z.B. folgende Bitkombination: "01100100" wie kann ich die Bits in ASM drehen bzw. spiegeln, so daß: "00100110" herauskommt ? Achso, ich verwende einen PIC16F627.
Damit wird nur die untere und oberer Hälfte des Bytes getauscht, glaube ich...
-
Thread
Arbeitet ihr lieber mit SPI oder I2C Bauteilen?
Beispiel für mein Eingangsposting..ist das nicht > dieser Temperaturfühler bei dem man die Bits erst spiegeln muss oder > sowas?! Also ich musste da noch nix spiegeln. Aber das ist ein guter Baustein an dem du die schlechten Eigenschaften von I2C in der Praxis erforschen kannst. :) Olaf
0x02; /* read from address 2 of TC72 */ while(!(SPSR & (1<<SPIF))); SPDR = 0x00; /* send dummy byte */ while(!(SPSR & (1<<SPIF))); temperature_high_byte = SPDR; SPDR = 0x00; /* send dummy byte */ while(!(SPSR & (1<<SPIF))); temperature_low_byte = SPDR; PORTA &= ~(1<<PA5); ATSAM SERCOM: PORT
-
Thread
USART Routine für selbst entwickeltes Protokoll
folgendermaßen aussehen. S(Start der Nachricht) z(was wird gesendet) Datenstelle im EEprom( 2Bytes) 2Bytes frei 3Bytes Daten /n(Nachricht beendet) USART_Send_2("S","z",itoa((uint16_t)temp1,&buffer,10),"00",itoa((uint16_t)kenn[temp1],&buffer2,10)); void USART_Send_2(char *type, char
> S(Start der Nachricht) > z(was wird gesendet) > Datenstelle im EEprom( 2Bytes) > 2Bytes frei > 3Bytes Daten > /n(Nachricht beendet) > >USART_Send_2("S", "z", itoa((uint16_t)temp1,&buffer,10), "00", itoa((uint16
-
Thread
Problem mit Assembler (ATmega8 / AVR-GCC)
den Schwachsinn aus Deinem Debuger geglaubt habe. Der gibt vorne nicht die Adresse, sondern die Bytes an. **kopfschüttel* Gruß Jobst
loop: LDS click, PINB ; die Taster auslesen und STS PORTC, click ; und auf die LEDs spiegeln RJMP loop ; und nochmal...[/code]
-
Thread
Cortex M4F: RAM Image analysieren
schauen welche Werte ok sind oder nicht. Wäre schon schick, wenn es ein Programm gäbe das ein Byte Image und dem map File übereinander legt und zumindest die Werte der Variablen anzeigt. Aber ich glaub das werde ich dann wohl selbst schreiben müssen?
mit dem Debugger drauf gehen. Brauchst ja gar nicht laufen lassen. Ansonsten musst du halt die Bytes durchgehen, wobei man mit ein wenig Skripting da schon viel erreichen kann.
-
Thread
I2C Expander + LCD: Backlight auslesen
so wie ich die Designentscheidung trifft, die Zustände von 16 LCDs nicht im knappen Ram des µCs spiegeln zu wollen, dann kann man diesen einen Transistor austauschen und dieses eine Bit Ram durch ein paar Dutzend Bytes Code im Flash kompensieren. Je nach Aufgabenstellung schmeißt man da natürlich mit
wie ich die Designentscheidung > trifft, die Zustände von 16 LCDs nicht im knappen Ram des µCs spiegeln > zu wollen, dann kann man diesen einen Transistor austauschen und dieses > eine Bit Ram durch ein paar Dutzend Bytes Code im Flash kompensieren. Je > nach Aufgabenstellung schmeißt man da natürlich
-
Thread
Byte auf verteilten Ausgängen ordnen
0x0E, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x07, 0x0F }; static void portout2( const uint8_t byte ) { PORTD = (PORTD & 0x17) | pgm_read_byte( &lut1[ (byte & 0x0F) ] ); PORTC = (PORTC & 0xF0) | pgm_read_byte( &lut2[ (byte >> 4) ] ); } static void portout1( const uint8_t byte ) {
sbi 0x0b, 7 rjmp .+2 cbi 0x0b, 7 // 10 Bytes [/c] Das sind 8*10 Bytes = 80 Bytes. + 2(mov am Start) + 2(rjmp am ende) ergibt 84 Bytes. Ergibt 8*5 Takte bei setzen und 8*4 Takte bei rücksetzen des bits. Mit besserer Optimierung könnte
-
Thread
Warum LSB first bei UART?
im Schieberegister direkt an der LSB Position und es ist kein weiterer Aufwand notwendig (um das Byte zu drehen / spiegeln), man kann das Byte dann direkt so wieder (in der Hardware) so auslesen wie es sein soll. Sollte ich falsch liegen, bitte ich um Korrektur.
Schieberegister direkt an der LSB Position und es ist kein weiterer > Aufwand notwendig (um das Byte zu drehen / spiegeln), man kann das Byte > dann direkt so wieder (in der Hardware) so auslesen wie es sein soll. Das funktioniert aber mit MSB first und links schieben aber besser. Unabhängig von
-
Thread
LCD Datenleitungen invertieren
Software ist da viel flexiebler, da gibt es keine Ebenenbeschränkungen und Leitungskreuzungen. Das Spiegeln eines Bytes wurde hier schon oft erläutert, ist überhaupt kein Problem. Peter
, wenn du mal nen String senden willst, musst du den mit Hex-Zeichen zusammenbaun. Aber ne 128/256Byte Flash-Tabelle wäre auch kein Problem. Dann wäre man sogar freigestellt die Datenleitungen nach *beliebigem* Schema zu verkabeln.
-
Thread
Arduino und halbfunktionaler Wiznet W5500
Beitrag #8025667: > Soweit ich mich erinnere beginnen die > Einschränkungen bei knapp über 500 Bytes. Solange du nicht dazu sagst auf was du das beziehst, liegen die Einschränkungen bei der MTU und nicht bei 500 Bytes.
sind das maximal 548 Bytes UDP-Payload.
-
Thread
LED Fading in schön
bei einem konstanten Zeitverlauf und 8-Bit als PWM-Wert bräuchte man für eine Gerade bestenfalls 2 Bytes, bei 10 Geraden – also dann für den ganzen Verlauf – gerade mal 20 Bytes. Bei 16-Bit-PWM könnte man im gleichen Beispiel durchaus mit 30 Bytes auskommen. Wenn man es noch spiegeln könnte und würde,
Erlöschen doppelt so lang > gemacht. Ja, davon gehe ich auch aus – mit dem vorgeschlagenen Spiegeln geht viel Freiheit in der Gestaltung des gewünschten, angenehmen Effekts vorloren, was auch immer das heißen mag.
-
Thread
Erfahrungen eines Einsteigers
. C beginngt nun mal erst ab Bytes aufwärts, eigentlich erst so richtig ab int aufwärts und mit Bytes hat man schon zeitweise zu kämpfen. Auf Bitebene kanns dann schon mal extrem tricky werden.
Buffer +1 sbci r31,hi8(-(massage)) ld r0,-Z // Get current Message byte sts doi.current_byte,r0 // Put into current byte buffer [/code] ich verbrauche wesentlich weniger Register (wir sind hier in der ISR, daher ist jedes Register das man nicht braucht gesparte
-
Thread
STM32F4 Probleme mit USART
eine Seite im Nettz, die massenweise nützliche "Bit Routinen" und Makros bereit stellt, wie zb Spiegeln eines Bytes, rotieren über 64 Bit usw. Habe mich nur leider danach tot gesucht die wieder zu finden. >>Das heisst nichts. Es gibt Leute, die programmieren seit Jahren in C und >>lernen immer
Seite im Nettz, die massenweise nützliche "Bit > Routinen" > und Makros bereit stellt, wie zb Spiegeln eines Bytes, rotieren über 64 > Bit usw. Habe mich nur leider danach tot gesucht die wieder zu finden. > >>>Das heisst nichts. Es gibt Leute, die programmieren seit Jahren in C und >>>lernen
-
Thread
C asm Inline-Coding im AVR-Studio
Georg static void lcd_out( uint8_t data ) { data &= 0xF0; // Die 4 Bits im oberen Nibble spiegeln // MSB LSB // bit7 bit6 bit5 bit4 0 0 0 0 // Nach der Spiegelung: // MSB LSB // bit4 bit5 bit6 bit7 0 0 0 0 asm volatile ( "
Georg Schl. schrieb im Beitrag #2241318: > 1. Woher weiss die Assemblerroutine, welches Byte sie manipulieren soll Es gibt keine "Assemblerroutine" sondern nur einen String, in dem GCC Ersetzungen macht (Inline Assembler). Hier wird %0 dem ersten Operanden zugeordnet etc. ZB http://
-
Thread
Bei einer Zahl die Bits untersuchen, AVR-Stud. in C
es jetzt! Noch mal Danke!!! Gibt es eigentlich einen Befehl, der die Bits einer Variablen spiegeln kann (also so, dass das LSB zum MSB wird und umgekehrt)?
schrieb im Beitrag #3035175: >> Gibt es eigentlich einen Befehl, der die Bits einer Variablen spiegeln >> kann (also so, dass das LSB zum MSB wird und umgekehrt)? > > könnte man für sowas und ähnliche allgemeine probleme (z.b. variable in > string umwandeln) eine Hilfsdatei schreiben und im AVR-Studio
-
Thread
Little Endian oder Big Endian Format?
rein, wenn ich vom motorolla-format ausgehe und dann auf intel umwandle, muss ich dann *alle* bits spiegeln oder nur jeweils die Bits von einem Byte, also die Reihenfolge der Bytes bleibt gleich, nur die Bits in den Bytes werden gedreht, oder wird alle gedreht?
Nur die Bytes. Die Bits werden zwar manchmal anders numeriert, aber deren Wertigkeit im Byte ändet sich nicht.
-
Thread
LSB <----> MSB tauschen in c
ist es vermutlich optimal, die beiden Nibbles des Byte über ne 16ner Tabelle zu spiegeln und dann die Hälften mit 'swap' zu tauschen. Cheers Detlef
|= (byte_1 & 0x20); byte_2 |= (temp >> 3); temp |= (byte_1 & 0x10); byte_2 |= (temp >> 1); temp |= (byte_1 & 0x08); byte_2 |= (temp << 1); temp |= (byte_1 &
-
Thread
Integer-Wert in ASCII-char
| g | h | +---+---+---+---+---+---+---+---+ um diesen String (ohne zusätzliches Array) zu spiegeln, genügt es jeweils das erste mit dem letzten Element zu vertauschen, dann das zweite mit dem vorletzten usw. bis man in der Mitte angekommen ist. +---+---+---+---+---+---+---+---+ | a |
#if XPAR_MICROBLAZE_0_USE_ICACHE microblaze_init_icache_range(0, XPAR_MICROBLAZE_0_CACHE_BYTE_SIZE); microblaze_enable_icache(); #endif #if XPAR_MICROBLAZE_0_USE_DCACHE microblaze_init_dcache_range(0, XPAR_MICROBLAZE_0_DCACHE_BYTE_SIZE); microblaze_enable_dcache
-
Thread
CANopen - diverse Fragen
mir eine SDO Nachricht ansehe, dann ist diese wie folgt aufgebaut: COB ID (XXX), DLC(8), Command(byte), Index(byte0, byte1), Sub-index(byte), Date(byte0 bis byte4) Normalerweise kenne ich es so, dass man Binärzahlen so schreibt, dass das niederwertigste Bit rechts steht. Jetzt steht hier aber z.B., dass beim Index byte0 links von byte1 steht. Bedeutet das jetzt, dass ich die ganze Bitfolge einfach "spiegeln" muss, oder muss das so gesplittet werden, dass ich die Bitfolge nach 4 byte trenne und einfach überkreuze?