-
Thread
Ausgang nur kurz schalten
kompliziert an, ist es aber nicht hier mal der Code: [avrasm] Read_IO: IN Reg_A, Port_C ; Port einlesen COM Reg_A ; Bits drehen ANDI Reg_A, 0b00011100 ; nicht relevante Portpins ausblenden LDS Reg_B, in_Debounce ; kontrollierte Bits holen EOR
etwas schwierig ist. Ich habe zwar SPS Programmieren gehabt und auch einige komplizierte IF Abfragen in manchen Programmen realisiert und auch in der Abendbulme etwas C gelernt, habe aber geglaubt, dass man Mikrocontroller NUR mit Assembler programmieren kann. Ich habe einige Zusammenhänge bei
-
Thread
AVR-Programmer-Software für standalone FT232R
Verfügung stellen. Bei bedarf würde ich auch gerne an dem Projekt mitwirken, .net programmiere ich in C#. Hast du das Projekt in VB oder c# realisiert? Wie oben schon angedeutet würde ich das ganze evtl erstmal als StandAlone zum laufen bringen und anschließen in AVRStudio integrieren. Weiter könnte
@Umpa Lumpa Weil mich jede Abfrage eines Busystatus mindestens 0,1 Sekunde kostet und damit alles wieder sehr langsam wird. LG Christof Rieger
-
Thread
AtMega16 - HILFE
zwischen 0 und 255 (=2^8 Werte) geben lassen. Die einzelnen Bits dieses Werts gibst du dann nacheinander d.h. in einer Schleife als einzelne leuchtende/dunkle LED aus. Entsprechend verfährst du mit dem Einlesen der Tastenwerte. Anschliessend vergleichst du den 8-Bit LED-Zufallswert mit dem 8-Bit Eingabewert. Keine Schleife notwendig dafür.
-
Thread
OPV in der Sättigung
nun sage, ich will von 100mbar abwärts messen können, ist das sicherlich sinnvoll, und das sind 10 Bit, also gut machbar, oder vielleicht nehme ich einen 12Bit-ADC. Ich verstärke mir die Ausgangsspannung des Sensors also mit einem OPV mit dem Faktor 1200 +- 25. Wenn nun mehr als 100mbar = 1000 *
MSB [oder zumindest einen konstant hohen Wert, nachträglich angemerkt]. Da mache ich eine Software-Abfrage und zeige dann "> 100mbar" an. " Was meint ihr? Gruß Jens
-
Thread
Taste gedrückt halten - zähler++ in zwei Zeiten
die geschichte mit nem Timer Interrupt würde ich gerne vermeiden wenn es geht!? MFG Timo [c] int main() //Ansteuerung eines Servos { int cnt=0; int stepp = 125; int flag_hoch=0; char buffer[20]; init(); lcd_init(); while(1) { if(SERVO_PIN & (1 << HOCH)) //Abfrage
// debounced and inverted key state: // bit = 1: key pressed volatile uint8_t key_press; // key press detect volatile uint8_t key_rpt; // key long press and repeat [/C]
-
Thread
Kubikwurzel bilden
ist ganz einfach: Im Ergebniswort werden — beginnend mit dem höchstwertigen — nacheinander die einzelnen Bits testweise auf 1 gesetzt und geprüft, ob die dritte Potenz des Ergebnisses kleiner oder gleich dem Radikanden ist. Ist dies der Fall, wird das 1-Bit in das Ergebnis übernommen, ansonsten bleibt
Bit am Ausgang?
-
Thread
Eingänge auf LCD anzeigen
2; int PCB1_M; //Anzeigemerker Port C Bit1 PCB1_M= 3; PCB1_fix: if (!SP_1 O ST_RST) return; //Verlässt die Funktion O=&& if (!SP_3) goto AZ_2; //Springt in eine Andere Anzeige //Abfrage des einzelnen Bits------------------------------------------------------------------------------- //Abfrage PortC Bit 0 if (PCB0_M==0x01&D_PC)goto PCB0_fix; if(1==0x01&D_PC) goto PCB0_1; else goto PCB0_0; PCB0_1: lcd_setcursor(4,1); lcd_string("\x1A");
-
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
Wie fängt man ein Problem an zu lösen ?
etwas anderes angewöhnen. Bei MC-Programmierung muß man halt oft gezielt prüfen, ob ein bestimmtes Bit in einem Wert gesetzt ist oder man möchte so ein Bit setzen oder löschen. Ob man das jetzt direkt mit C-Operatoren macht ( if( wert & ( 1 << 5 ) )... oder if( wert & 0b00100000 ... ) oder sich dieses
dann alten Spezialfunktionen nicht mehr notwendig waren und man lieber wieder zurück auf Standard-C Mitteln ging. > Danach werde ich mir wohl angewöhnen müssen Ausgänge mit PORTB |= > (1<<PB2); (Als Beispiel) zu setzen und mit PORTB &= ~(1<<PB2); (Als > Beispiel) zurückzusetzen. Für die Abfrage
-
Thread
Taster-Entprellung am Tiny13 in Assembler
eor xl,tas ;nur Änderungen werden H and tz0,xl ;Prellzähler unveränderter Tasten löschen (Bit0) and tz1,xl ;Prellzähler unveränderter Tasten löschen (Bit1) com tz0 ;L-Bit zählen 0,2,->1, 1,3,->0 eor tz1,tz0 ;H-Bit zählen 0,2,->tz1 toggeln and xl,tz0 ;Änderungen nur
dann kann er halt nur ein mal wirken... Der AVR hat wunderbare Befehle zum Setzen und Löschen einzelner Bits in einem Teil des I/O-Bereiches (in dem auch die Ports liegen). SBI und CBI sind Deine Freunde. Das bringt Dir aber nicht viel, denn Dein Konzept ist sehr gewöhnungsbedürftig und alles Andere
-
Thread
PIC CCS C - Port Ausgang mit 8bit int setzen
Hallo Ich suche gerade nach einer Möglichkeit im CCS Compiler für den PIC184550 die PINs eines Portes direkt zu setzen. Also z.B. [code]PORTB = 11000000[/code] wodurch RB0 und RB1 gesetzt sein sollten. Gibt es irgendeine Möglichkeit dies mit einer 8 bit (oder auch 16 bit falls die direction noch enthalten sein muss)? Vielen Dank
-
Thread
project euler
= 0; i<n; i++) { //auf gleichheit prüfen if( a[i] != b[i] ) return 0; } return 1; }[/c]
Ich hätte die Zahl neu zusammengesetzt. (ungetestet) [c] int is_palindrome(uint64_t zahl) { uint64_t z, gedreht=0; for(z=zahl;z>0;z/=10) gedreht = gedreht * 10 + (z%10); return (gedreht==zahl); }[/c] Ein 32-Bit int kann Werte bis
-
Thread
ATMEGA8 - 2 analoge Signale einlesen (2-Ch AD-Wandler)
habe ich beim Lesen kapituliert. Ja, sorry für die schlechte Beschreibung. Ja die letzten vier Bits beziehen sich auf den Anschluss zum Poti. Also MUX0-MUX3. Und da alle vier Bits Null sind ist es ja der Anschluß ADC0 des µC. War für mich ne Bezeichnung wo ich das Kabel anzuschließen habe.
Deine SChreibweise wurde ja schon zur Genüge angesprochen. Zu noch einem Fehler (neben der Abfrage ob er fertig ist) [C] ADMUX |= 0b01100001; // Einlesen des Kanals 1 usw. [/C] und wie erwartest du, dass das ganz rechte 1 Bit (für Kanal 1) jemals wieder gelöscht wird? [C] ADMUX
-
Thread
AT90CAN128 Identifier filtern ?
Tag 0010 0000 0000 100X ID 0x2020 IDMask 1111 1111 1111 1111 ID Tag 0010 0000 0000 0010 [/c] Meine Idee: Aufgeteilt in die 4 Bereiche, frägt man dann immer die einzelnen Bereiche in einer Schleife ab. Oder gibt es einen anderen Weg, wie ich diese Identifier leichter filtern kann ? Oder wie kommt man von den 16 bit zu 11 bit ?
-
Thread
BMP085 driftet
eigene Stromversorgung aus nem 9V-Block mit nem Linearregler dahinter. Der Mikrocontroller zum Abfragen ist vom PC galvanisch isoliert und hat eine vom Sensor separate Stromversorgung. Sensor und Mikrocontroller haben aber ne gemeinsame Masse, ich hatte gerade kein I2C-Trennbaustein da. Ich glaube
von 0.01°C aus um den Druck um 0.03hPa zu ändern. In der Praxis ist eine nutzbare Auflösung in dem Bereich wohl nicht ohne großen Aufwand hinzubekommen.
-
Thread
MD25-Motor mit RN-Control V1.4 (Atmega32) angesteuert dreht sich nicht
nicht exakt berechnet!*/ void waitms(uint16_t ms) { for(; ms>0; ms--) { uint16_t __c = 4000; __asm__ volatile ( "1: sbiw %0,1" "\n\t" "brne 1b" : "=w" (__c) : "0" (__c) ); } } /*### Ports setzen ###*/ //Ports auf HIGH setzen static
/ (Baudrate * 16)) - 1 <- Quarfrequenz = 16*1000*1000 Hz!!!! } void sendchar(unsigned char c) { while(!(UCSRA & (1<<UDRE))) //Warten, bis Senden möglich ist { } UDR = c; //schreibt das Zeichen aus 'c' auf die Schnittstelle } void sendUSART(char *s) //*s funktiniert wie
-
Thread
4 Bit Schieberegister fuer Motorumbau (Versuch)
Sprit immer genau da wo er hin soll... Jetzt brauch ich aber das passende Schieberegister. (Ein µC ist damit unterfordert) Gibt es ein 4 Bit Schieberegister, dass ich mit einem Eingang immer Weiterschalten kann und das evtl. auch immer auf einen Ausgang resetet (z.B. switche bei reset zu Ausgang
funktionieren, da bei einem Viertakter nur bei jeder zweiten Umdrehung eingespritzt wird. Da wäre ein 8bit Schieberegister schon besser geeignet wo dann jedes zweite bit einfach frei bleibt. (Oder eben nach nötiger Einspritzreihenfolge) Dabei bräuchte man nicht einmal ein Schieberegister. Ein 4017 dürfte
-
Thread
PIC Probleme mit Programm BIN zu BCD
behandeln Beispiele: #define LED_ANZEIGE PORTB ; Segmente a-g (h) #define DIGITS PORTA ; Bit 0-3 #define TASTER PORTA,0 ; Bit 0 Abfrage: btfsc TASTER ; skip next wenn Taster offen ; liest sich einfacher wie btfsc PORTA,0 oder #define DIGIT1_AUS bcf
gesetzt zählt aber nicht wie in seinem programm bis 65 hoch. Ja habe clrf OPTION_REG drin somit ist bit3 auf 0.
-
Thread
AM oder FM Fernbedinung Rohrmotor -> bild
} } [/c] jetzt die Erklärung : [c] while(1) // hier gehts los ! { bit_anfang(); // sende bit anfang // lege PIN_on() auf 5 V // pause delay_us(5000) // lege pin PIN_off() auf
// sende bit0 { PIN_SENDER = 1; Delay( 360 ); PIN_SENDER = 0; Delay( 720 ); } if( bit_zu_senden == 0 ) // sende bit1 { PIN_SENDER = 1; Delay
-
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
String 2 ushort nach Datenübertragung
hier. Ich werde den Tread natürlich sofort schließen wenn dort eine Antwort kommt. Ich sende einzelne Bytes die über die serielle indem ich die Zahl auf 2 Bytes teile trans[0]=test1 & 0xFF; trans[1]=test1 >>8 & 0xFF; in einem mC von unsigned short int zu unsigned char convertiert werden. Die
Problem bei read war der Buffer. Ich kann nicht sagen, wie groß das Array seien wird... Ich sende 3 12 Bit Datenwerte mit 1000 Hz. Ist das ein Problem wenn ich den Buffer abfrage und bis zum einlesen kommen schon wieder Werte dazu?? Das könnte doch bei der Datenrate schon passieren oder? Deswegen habe ich
-
Thread
Viele Drehimpulsgeber an einem PIC
und den Status einzeln abfragen. Das braucht dann 22 Ports und du muss die Encoder mit Dioden entkoppeln. Die Abfragezeit für alle machst du dann etwas größer als die Entprellzeit, dann hast du nach 2 Abfragen den Zustand
>Ich würde vorschlagen, einen kleinen MC (14-Pin) für je 4 Encoder und >dann per I2C oder SPI vom Master auslesen. Wenn schon I2C dann mit PCF8574 oder sein 16bit Bruder und auf Interrupt reagieren. Wobei die Sache mit den Shiftregistern wohl am billigsten sein dürfte und auch vollkommen
-
Thread
Strings ohne Null am Ende? Gesperrt
> char achComment[6] = "123456"; // zu lang In C ist das in Ordnung und hat den gewünschten Effekt, in C++ ist es ein Fehler. Dort kommst du um die Schreibweise mit den einzelnen Char- Konstanten wahrscheinlich nicht herum.
Das Blöde an der Stringverarbeitung von C ist, dass sie schon scheitert, wenn man damit einen 8-Bit Datenstrom von einer seriellen Schnittstelle verarbeiten möchte.
-
Thread
Alles Rund um den MEDION LIFE P89626 NAS
PPPoL2TP kernel driver, V1.0 NAND device: Manufacturer ID: 0xad, Chip ID: 0xf1 (Hynix NAND 128MiB 3,3V 8-bit) Scanning device for bad blocks Creating 7 MTD partitions on "NAND 128MiB 3,3V 8-bit": 0x000000000000-0x000000040000 : "stage1" 0x000000040000-0x0000003c0000 : "uboot" 0x0000003c0000-0x000000440000
dann ist zumindest das zuletzt genannte Kommando in der Lage irgendwo auf der Platte zu lesen: [c] #define CFG_64BIT_STRTOUL [/c]
-
Thread
RGB LED mit nur einem POTI dimmen
unabhaengige Zahlenwerte benoetigt werden, kann man immer noch einen ADC nehmen und jeweils einen Teil der Bits einer der drei Zahlen zuordnen (z.B. bei einem 12-Bit ADC die obersten vier Bit als Rot, die mittlersten Bit als Gruen und die intersten 4 Bits als Blau). Die Probleme einer nichtlinearen Abhaengigkeit
Ach ja, kleiner Nachtrag. So kannst du auch leicht die vollen 24 bit Farbtiefe abfragen, da kannst du sogar die letzten 2 bit des 10bit ADC abschneiden. Damit wird das ganze noch einfacher und auch weniger anfällig gegen Störungen. (Programmteil zum einstellen der RGB
-
Thread
STM32F2xx USART weigert sich
Sieht so aus als haettest Du recht. Ich finde in der GPIO.c für den 207er nur die Funktion. [c] void GPIO_PinAFConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_PinSource, uint8_t GPIO_AF) [/c] Die Funktion wurde auch von Dir aufgerufen. [c] GPIO_PinAFConfig
1; /* RTC enable, LSE als Quelle, 32kHz on */ } [/c]
-
Thread
IF Statement
Eingangspin vom STK600 mit Taster so funktioniert, dass er bei NICHT gedrücktem Taster eine 1 liefert (Bit ist gesetzt) und bei gedrücktem Taster dieses Bit eine 0 liefert. Will man also etwas tun, wenn ein Taster gedrückt ist, dann lautet die Abfrage if( !(PIND & (1 << PIND1) ) { // Taster
ist??? > PORTA &= ~(1 << PA0) = Ein > PORTA |= (1 << PA0) = Aus Probiers doch einfach aus [C] int main() { DDRA = 0xFF; PORTA = 0b11110000; while( 1 ) ; } [/C] welche LED leuchten? Die bei denen du ein 0-Bit gesetzt hast, oder die bei denen du ein 1-Bit gesetzt hast?
-
Thread
PIC12F675 brauche Hilfe
Damit ist der Eingang solide auf GND, wenn der Taster nicht betaetigt ist. LED Einschalten: gp4_bit = 1; LED Ausschalten: gp4_bit = 0; GP5 high? abfragen: if (gp5_bit) { .... } oder if (gp5_bit > 0) { .... } warten solange GP0 noch low ist: while (!gp0_bit) {} oder while (gp0_bit == 0
when the TMR0 > register timer/counter overflows from FFh to 00h. This > overflow sets the *T0IF* bit Das Flag kannst du ohne Interrupt Abfragen. Stefan Haussmann schrieb im Beitrag #2433934: > Ich hoffe dass es in diesem Forum einige Experten gibt, die mir einen > kleinen C-Code zukommen
-
Thread
12 bit Wert in Array aus uint8_t speichern
Aber soweit ich das sehe werden dort doch nur 8 bit genutzt, oder? Ich würde aber gerne schon die vollen 12 bit nutzen ;) http://www.mikrocontroller.net/topic/169509#1631439 Aber ich glaube ich habe mein if-Problem lösen können mit: [c] if(led
[c] // Blöcke 1, 3, 5, 7, ... [/c] Du hast für jedes Bit eine If-Abfrage? Schon mal was von Schleifen gehört?
-
Thread
Wie setze ich Ausgänge mit einer for-Schleife?
{ PORTC &= ~(1<<PD[i]); //ursprünglich sollte Port C gesetzt werden } } [/c] Ich wollte aber ungern für jeden Ausgang eine If Bedingung machen in der ich das einzelne Bit setze bzw. Rücksetze. ich finde es in einer for Schleife eleganter und
[c] for (i=0; i<7; i++) { PORTC = (PORTC && ~(1<<i)) || (((int)Fach[i] > 500 && Fach[i] < 800) << i); } [/c]
-
Thread
BASCOM AVR - Problem mit den Outputs (ATMega 8 und STK500)
Du musst ja nicht jedes Bit/LED einzeln setzen. Man kann auch sowas machen: PORTB = &B00001111 oder PORTB = 15 Schau doch bitte mal in die BASCOM Hilfe, da gibt es doch Beispiele inkl. Erklärung oder auch mal eins der
hi! http://www.dieelektronikerseite.de/uC%20Ecke/Lections/Bascom%20AVR%20-%20Befehlsreferenz.htm cya The_Ride
-
Thread
bitweise vergleichen
Erfüllt die obige Schreibweise diesen Zweck? Ja. Ich würde etwas mehr Übersicht reinbringen: [c] #define TESTBIT 0 ... if (Variable_16Bit & ( 1 << TESTBIT)) ... [/c]
Bitschieben Dass du auf dieses Bit testest, hat ja sicher einen Grund. 'Diesem Grund' gibt man einfach einen Namen. z.B.: [c] #define BIT_LED1 0 #define BIT_LED2 1 #define BIT_SONSTNOCHWAS 2 [/c] Selbstverständlich
-
Thread
PIC-Start Glückssache?
//////// void main(void){ setup(); init(); while(1){ RA2 = !RA2; } } [/c]
Hi, Ohne jetzt deine Config_Bits im einzelnen Aufzudröseln: Programm im RElease Modus und nicht im Debug Modus erstellt? (Im Debug mode muss ein explizites Startkomando kommen!) In MPLAB nicht per Einstellung auf "Anhalten"
-
Thread
stm32 Cortex I2C : Master zieht SCL auf Masse
= I2C_Ack_Enable; I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; I2C_InitStructure.I2C_ClockSpeed = ClockSpeed; I2C_Init(I2C1, &I2C_InitStructure); I2C_InitStructure.I2C_OwnAddress1
mein Fall, aber ich könnte mir vorstellen, dass sich dies in Bit 15 vom CCR übersetzt, das zusammen mit Bit 14 zwischen Standard (100Khz) und Fast Mode (400KHz) differenziert. Bit 15 F/S: I2C master mode selection 0: Standard Mode I2C 1: Fast Mode I2C I2C
-
Thread
datentransfer über ethernet
Register, die man mit Werten beschreiben muß. Oder? Optionen wären Embedded Core oder ein kleiner µC extra dafür, aber ist das nicht etwas arg krass? Ciao, Günter
implementieren hatte ich am Anfang auch vor, aber es steht sich einfach der Aufwand nicht dafür, dass man die Abfrage typischerweise genau einmal am Anfang braucht.
-
Thread
GNUBLIN www.gnublin.org
Treiber sendet nur für die *letzte* message, die ihm übergeben wird das STOP bit. Wenn ich ein I2C write/read Kommando [code]root@gnublin:~$ i2cget -y 1 0x48 1 b[/code] an den Treiber schicke, werden 2 Linux I2C messages an i2c_pnx_xfer() übergeben. Die erste enthält das I2C
ob der I2C pnx Treiber richtig arbeitet. Wenn die I2C engine mal im Nirwana ist, kann dieser sie bis jetzt leider nicht zurückholen. Mein workaround im Moment ist, nach jeder message ein STOP bit zu senden.
-
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
Lerne Assembler - brauche eure Hilfe
willst du die ADCs per SPI durch einen Atmel auslesen, um diese Daten dann per SPI an einen anderen µC weiterzuleiten? Warum liest der andere µC die Daten nicht direkt von den ADC per SPI aus?
Und noch ein Tipp: zumindest in der Testphase empfiehlt sich die Abfrage von SPSR.WCOL mit entsprechender Kontrollausgabe.
-
Thread
EleLa - Elektronik Lagerverwaltung ab V1.2.11A26
Bei manchen Abfragen waren SQL-Injections möglich. Es konnte zwar nichts manipuliert werden, aber dennoch ist es ein Bug. Ich bin jetzt alle SQL Befehle durch gegangen und habe den Code geändert. Die EXE V1.2.11C03
Hallo Markus, ich versuche das Programm unter Win7 64bit zu installieren. Das Verzeichnis gebe ich an als: "C:\Program Files (x86)\EleLa" (übliches Programmverzeichnis in Win7). Die Installation ist bei dem Verzeichnis unvollständig, ohne jegliche Fehlermeldung
-
Thread
AX81 - ZX81 im AVR
mehrere Vorteile. Zum ersten zwei RAM-Buffer, die man auch für temporäre Daten nutzen kann wenn im µC kein Platz mehr ist. Außerdem bekommt man damit konstante Schreibraten hin, da man die Buffer wechselseitig benutzen kann. Dann lassen sich gegenüber anderen Flash-Bausteinen (z.B. M25P16) einzelne Pages
Hallo Jörg, zwischenzeitlich habe ich auch die PIO-Funktion an Port C getestet (kleines 8-bit-Lauflicht) und es läuft top! Sobald ich einen Assembler installieren kann, werde ich die Ausgabe/Eingabe auch in MC testen. Bin gespannt wie die Takt-Zeiten sind und ob man dann
-
Thread
gcc und Optimierung
;-) [pre] $ egrep -i 'bst|bld' * avr-protos.h:extern void avr_output_bld (rtx operands[], int bit_nr); avr.c:#include "obstack.h" avr.c: avr_output_bld (operands, bit_nr); avr.c: avr_output_bld (operands, bit_nr); avr.c: avr_output_bld (operands
byte2 |= (1<<a1); if(digit0 & (1<<1)) //b1 gesetzt? byte2 |= (1<<b1); if(digit0 & (1<<2)) //c1 gesetzt? byte2 |= (1<<b1); ... Eine if-Abfrage pro möglichem Bit, ergibt also bei 32 Bit insgesamt 64 Befehle (128 Byte Flash) + ein paar Bytes Initialisierung. Schneller geht es meiner Meinung
-
Thread
Ping-Pong über LED-Brett für Anfänger
outp(0xff, DDRD); /* Enable 8-bit counter1, running on clk speed */ outp(BV(CS01), TCCR0); /* Set OCR1A as max value and Enable 16-bit counter, * running on clk/8 speed */ outp(BV(WGM12)|BV(CS11), TCCR1B); /*
nicht verzagen, beginn doch einfach mal mit den grundsätzlichen Sachen z.B. den Balken. Stichwort bit schieben (in C sind lautet der Befehl dafür << und >>).. Und wenn du einen ungefähren Lösungsansatz hast, kannst du ja wieder fragen.
-
Thread
DOG S 102 Grafikdisplay - Grundlagen
Wenn du das Display nicht abfragen kannst muss du dir einen Buffer im RAM aufbauen, dort kannst du einzelne Bits manipulieren und dann diesen RAM im ganzen ausgeben. Schriftarten werden im Flash abgelegt, von dort die Bytes lesen
Holger W. schrieb im Beitrag #2393608: > Wenn du das Display nicht abfragen kannst muss du dir einen Buffer im > RAM aufbauen, dort kannst du einzelne Bits manipulieren und dann diesen > RAM im ganzen ausgeben. geht das mit einem atmega8? 8 pages und 102 Spalten sind