-
Thread
Bauen oder nicht bauen ?
verbrauchen und gleichzeitig ein paar mehr Farben wie der C64 zu schaffen.
binären Grenzen, an denen sich immer etwas verdoppelt/halbiert. Ich habe mich gewundert warum die C64-Sprites 24x21 Pixel haben - aber die vertikale Reduzierung auf 21 Pixel ist nötig damit die Sprite-Pixeldaten in einen 64-Byte-Block im Speicher passen (es sind aber nur 63 Bytes, ein Byte wird verworfen
-
Thread
Frequenzzähler 1Hz - 40MHz
ich ... |- * die F_CPU Abfrage auf 24 Bit in der |main.c|, die nun raus könnte. Neu hinzugekommen sind die 64Bit Funktionen von Matthias Hopf und eine Anpassung der bin2bcd Funktion auf 5 (6) Byte Argumenten. In der |main.c| sind nun
Wir kommen also "anfänglich" nicht um diese Darstellung um her, die Mathematik ist auch klar: [c] fx fref fref * Nx -- = ---- <==> fx = --------- Nx Nref Nref [/c] Wir betrachten nun noch die 64-Bit Arithmetik: "fref
-
Thread
Double gegen Integer
eseries.cpp **** { 6019 .loc 17 382 0 discriminator 2 6020 09f2 48396C24 cmpq %rbp, 40(%rsp) 6020 28 6021 09f7 0F845903 je .L493 [/c]
Das ist die 64-Bit Integer Version mit Vorzeichen. Die ist noch langsamer. Latenz: - Integer Division s64: 39-103 Takte - SSE Fliesskomma 32/64: 10-13 Takte Durchsatz: - Integer Division s64: 24-81 Takte - SSE
-
Thread
Merkwürdige Compileroptimierung, wo liegt (mein) Denkfehler
48: 8c b9 out 0x0c, r24 ; 12 4a: 08 95 ret 0000004c <main>: } int main(void) { 4c: 80 e0 ldi r24, 0x00 ; 0 uint8_t zmax = 25; while (zmax--) {// hier absichtlich 64 reingeschrieben, um PufferB1 auch zu bearbeiten for (uint8_t j=0; j<64; j++) if (PufferB[j]>127) PufferB[j] = '.'; 4e: 9e e2 ldi r25, 0x2E ; 46 50: e8 2f mov r30, r24
-
Thread
Globales Struct/Array nicht automatisch initialisieren
Ich habe mal irgendwo aufgeschnappt, dass globale variablen in c immer initialisiert werden. Man müsste es nur ausschalten können. Hier der Vollständigkeit halber meine Versuche und mein Ergebnis daraus: GLOBAL:[code] #define SIZE 24 char buf[SIZE]; int main
2291 [/pre] Mit Puffergröße 64 Bytes: [pre] $ avr-gcc-4.7.0 -Os -DFIFO_SIZE=64 -mmcu=atmega8 -o avrtest avrtest.c $ avr-size -A avrtest avrtest : section size addr .text 82 0 .bss 132 8388704
-
Thread
10 * 10 Bit multiplizieren
die Mühe machen, wenn der Compiler 16*16->32 kann? weil der Compiler eine zeitaufwendige 32*32->64 Multiplokation macht und die oberen 32 Bit wegwirft. Das dauer auf einem 8-Bit µC (ATtiny 25) *ohne MUL Befehl* mindestens ein paar hundert Taktzyklen!
Assemblerroutinen gibts hier: http://www.mikrocontroller.net/articles/AVR_Arithmetik#24_Bit_.2A_24_Bit http://avr-asm.tripod.com/math32x.html -> "MUL32" Multiply Unsigned Rd64 = Rd32 * Rr32 http://elm-chan.org/cc_e.html ->AVR assembler libraries - 16bit x 16bit multiply(signed/
-
Thread
Welcher µC für meinen Zweck?
#4693348: > Cortex M7 mit 216MHz, FPU, 2M-Flash und 512K-Ram Es gibt einen großen Bedarf an kleinen uC bis 64K Flash und 4K RAM der weitgehend durch günstige 8051 und PIC abgedeckt wird. Vergleichbare AVR und XMEGA sind doppelt bis dreimal so teuer, warum sollten die eingesetzt werden. Bei mehr RAM sind
Lothar schrieb im Beitrag #4694897: > Wenn man aber 24-Bit Auflösung tatsächlich braucht z.B. bei einem > Prozessofen mit PT1000 und 0.01K Auflösung und +/-0.05K Genauigkeit, > dann nimmt man zur Regelung eben einen 32-Bit uC Und 32 bit genau warum?
-
Thread
LTspice-Modell für MOSFET IRLL024N
habe. Ganz links VDD ist die allgemeine Spannungsversorgung, die aus einem Spannungsregler aus den 24 V erzeugt wird. Damit wird der µC versorgt. Das soll mal ein ESP32 werden, aktuell teste ich noch mit ATtiny1614. Die Spannungsquelle GPIO stellt einen PWM-Ausgang des µC dar. Hier ist der kürzestmögliche
V_drain wieder bei 24 V angekommen.
-
Thread
Hat hier schon mal jemand einen WinXP-Treiber nach Win7/64 konvertiert?
als Sourcecode in C vorliegen habe, den krieg ich aber eben nicht einfach so in dem 64-Bit-Windows ans laufen. > Am einfachsten wäre es die alte HW durch neue zu ersetzen. Gibt es da > nichts brauchbares mehr? Tatsächlich
na, ich dachte, man nimmt den C-Code als Basis für die Strukturen, passt dann alles Unpassende so an, dass das in WIN7/64 verstanden wird, und kompiliert das dann neu.
-
Thread
Handlicher Ethernet-Controller mit SPI von Microchip
es lebt: ARP + ICMP sind fertig: [c] > ping 192.168.0.5 PING 192.168.0.5 (192.168.0.5): 56 data bytes 64 bytes from 192.168.0.5: icmp_seq=0 ttl=64 time=1.3 ms 64 bytes from 192.168.0.5: icmp_seq=1 ttl=64 time=1.3 ms 64 bytes from 192.168.0.5: icmp_seq=2 ttl=64 time=1.3 ms 64 bytes from 192.168.0.5: icmp_seq=3 ttl=64 time=1.4 ms [/c] Jetzt bastel ich erstmal nen eigenen tcp stack :) Ziel ist es das ganze inkl Webcam kram in einen mega8 zu packen *g*
-
Thread
AtMega16 Timer Problem
3c 00 jmp 0x78 ; 0x78 <__bad_interrupt> 20: 0c 94 3c 00 jmp 0x78 ; 0x78 <__bad_interrupt> 24: 0c 94 3c 00 jmp 0x78 ; 0x78 <__bad_interrupt> 28: 0c 94 3c 00
out 0x15, r1 ; 21 c4: 90 e4 ldi r25, 0x40 ; 64 c6: 91 bb out 0x11, r25 ; 17 c8: 82 bb out 0x12, r24 ; 18 ca: 83 e0 ldi r24, 0x03
-
Thread
Taschenrechner - Algorithmen
Ich verwende den ATMEGA1284P unter Arduino .. und alles wird in der Programmiersprache C++ gemacht. Bei mir hatten 32kByte Speicherplatz nicht mehr gereicht (64Bit-Arithmetik). Jetzt sind es 128kByte Speicher. Aber besten Dank bezüglich der Information zum Zeitaufwand -- etwa 500 Stunden
gewechselt. Mein Taschenrechner hat jetzt 15x 7-Segment-Anzeige (vorher 12x 7-Segment-Anzeige). Die 24 Tasten können komfortabler genutzt werden (bis zu 3 Tasten gleichzeitig drücken). C++ (Objektorientierung) kommt bei mir nicht vor.
-
Thread
Kann man denn jetz das hi- und low-byte eines uint16_t effizient lesen in c?
add r22, r24 31a: 71 1d adc r23, r1 31c: 82 e0 ldi r24, 0x02 ; 2 31e: 90 e0 ldi r25, 0x00 ; 0 320: 07 d0 rcall .+14 ; 0x330 <__eewr_word_tn24a> 322: 74 cf
80 91 64 00 lds r24, 0x0064 5e: 68 2b or r22, r24 60: 80 e6 ldi r24, 0x60 ; 96 62: 90 e0 ldi r25, 0x00 ; 0 64: 03 c0
-
Thread
Bitmanipulation beschleunigen
ldi r19, 0xFF ; 255 44c: 28 2f mov r18, r24 44e: 20 7c andi r18, 0xC0 ; 192 450: 20 34 cpi r18, 0x40 ; 64 452: c1 f0 breq .+48 ; 0x484 <variant_eprofi+0x7a>
r19, 0x0F ; 15 47c: 28 2f mov r18, r24 47e: 20 7c andi r18, 0xC0 ; 192 480: 20 34 cpi r18, 0x40 ; 64 482: 41 f7 brne .-48 ; 0x454 <variant_eprofi+0x4a>
-
Thread
Neuer ATtiny104?
Implementierung lässt sich LDS/STS also bestenfalls dann verwenden, wenn das RAM explizite beschrieben wird:[c]#include <avr/io.h> typedef struct { int x; char c; } ram_t; #define RAM (*(ram_t*) RAMSTART) int get_x (void) { return RAM.x; }[/c] [avrasm]get_x: lds r24,64
RAM.x - RAM.c; }[/c] [avrasm]get_value: ldi r30,lo8(64) ldi r31,0 subi r30,lo8(-(2)) sbci r31,hi8(-(2)) ld r20,Z subi r30,lo8((2)) sbci r31,hi8((2)) ld r24,Z subi r30,lo8(-(1))
-
Thread
welches FRAM wählen?
Bei AliExpress gibt es billig I2C-FRAMs 24C64/24W64 mit 64kbit, oder die 24C256/24W256 (256kbit). Ich benutze gerade ein 24CL64 (für 3,3V) im eigenen Projekt. Sind im I2C (mit 1MHz) zwar nicht so flott wie ein SPI SRAM wäre, aber
Mario L. schrieb im Beitrag #5715887: > I2C-FRAMs 24C64/24W64 mit 64kbit, oder die > 24C256/24W256 (256kbit). Danke Mario für den Hinweis auf AliExpress. 24C64 und 24C256 scheinen EEPROMs. FM24W64-G ist ein F-RAM IIC FRAM 64k 3-5V, bei
-
Thread
ARM - µC
Also, ich glaube, ich schreibe mal was über mich. Ich bin 24 Jahre alt und interessiere mich seit meinem 11 (??) Lebensjahr für elektronik und habe früh gemerkt, dass alles eigentlich über µC gesteuert wird ... mein hobby hat in den letzten Jahren nicht nachgelassen
das was anderes, wir haben kongrete Projekte. Sei es wie bei mir eine MoBa Steuerung unter Linux in C# mit Mono und einigen Interfaces wie CAN, RS 485, Ethernet und USB alleine wegen dem Linux mit Mono brauch der Prozessor schon die 200 Mips und bei den 64MB die der AT91RM9200 maximal verwalten kann
-
Thread
Serielle Visualisierung mit Comvisu
Morgen. ich habe ein Problem. Wenn ich mit dem Analoganzeige/Schieber einen Single Wert sende zB. 24,1 - 24,9 wird bei mir immer nur als Integer Wert 24 anerkannt (verarbeitet, zurückgemeldet). Nachkommastelle 1 eingestellt. rodnas
anderen Programm erstellt werden. Keine Ahnung, ob dein GUI Toolkit das gut unterstützt. 3) Der µC selbst kann die GUI an comvisu schicken und so die Visu aufbauen. Dann hat man immer die richtige Anzeige zum richtigen Projekt. Ich denke es würde reichen, wenn comvisu das ganze als BASE64 exportieren
-
Thread
Übersicht Controller und Einstiegskosten (Debugger, Compiler)?
Arm: 49,80 µs Mit 32 Bit Double ATmega128, gcc -O2, AVRStudio5: 656,75 µs M32C, gcc -O2, KPIT: 296,90 µs RX610, gcc -O2, KPIT: 24,90 µs (mit FPU on) Cortex-M3, armcc, -O2, Keil Arm: 20,45 µs Alle mit C99 (armcc --c99, gcc -std=c99), und
heissen? Richtig, immer vergesse ich die Hälfte hier noch RX610 mit -nofpu Option hinzugefügt: Mit 64 Bit Double: M32C, gcc -O2, KPIT: 1305,90 µs RX610, gcc -O2, KPIT: 222,75 µs -m64Bit-doubles -nofpu RX610, gcc -O2, KPIT: 105,00 µs -m64Bit-doubles
-
Thread
c++ Code langsam
Hier, unter Windows mit MinGW g++.exe (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 8.1.0 sieht das alles etwas anders aus. Alles mit g++, O3 und std c++17 kompiliert. foobars c Version, ich schätze, da ist aber einfach Get-Content auch
Byteschubbserei wenn man den Sources trauen kann. https://code.woboq.org/userspace/glibc/sysdeps/x86_64/multiarch/strspn-c.c.html
-
Thread
Womit anfangen?
Wilhelm S. schrieb im Beitrag #4597306: > Deine Frage erinnert mich an C64-Zeiten; alle meinten, solch einen > Apparat haben zu müssen, aber keiner hatte eine vernünftige > (sinnvolle) Anwendung. Deshalb hatte ich damals schon 'Atari ST und statt TOS lief da MINIX drauf
Wilhelm S. schrieb im Beitrag #4597306: > Deine Frage erinnert mich an C64-Zeiten; alle meinten, solch einen > Apparat haben zu müssen, aber keiner hatte eine vernünftige > (sinnvolle) Anwendung. c64? ne PET2001 1979 erst Spiele dann Steuer dann Telefonwähler
-
Thread
Ergebnisse einer FFT zusammen fassen
one to eight entries long, with corresponding conversion result FIFOs -Hardware averaging of up to 64 samples -Efficient transfers using Micro Direct Memory Access Controller (μDMA) [/c] habe mal aus der doku heraus kopiert. der kann noch mehr. c-hater schrieb im Beitrag #7224176: > Also nö, explizit
29/64) a1 = 0 (ist das verboten ?) a2 = -1 (ist immer -1 ?) b0 = gibt es nicht b1 = -cos(2*pi*12/64)+j*sin(2*pi*12/64) b1 = 0 + j*1 [/code] [c] void df2_biquad_goertzel_1(float32_t* x, float32_
-
Thread
AVR exakt Millisekunden zählen
TCNT0 = 256-(F_CPU/256+500)/1000; #elif F_CPU>2000000 TCNT0 = 256-(F_CPU/64+500)/1000; #else TCNT0 = 256-(F_CPU/8+500)/1000; #endif timerCounter++; } [/c]
+500)/1000; > #elif F_CPU>2000000 > TCCR0 = (1<<CS01)+(1<<CS00); // Prescaler 64 > TCNT0 = 256-(F_CPU/64+500)/1000; > #else > TCCR0 = (1<<CS01); // Prescaler 8 > TCNT0 = 256-(F_CPU/8+500)/1000; Du mußt es andersrum machen: [c] #
-
Thread
AD-Wert springt
, 4020, 1005 1005, 1005, 4020, 4020, 1005 [/c] Drehe ich das Poti gegen Masse, sind die Spikes erwartungsgemäß am besten in den Messwerten zu sehen: [c] Max Min Ov OvH Out 6, 6, 24, 24, 6 6, 6, 24, 24, 6 27, 2, 27, 24, 6 !!! 6, 5, 23, 24, 6 6, 6, 24, 24, 6 6, 6, 24, 24, 6 26, 2, 27, 24, 6 !!! 6, 6, 24, 24, 6 [/c] Wenn ich jetzt anfange, an AVCC zu filtern, müsste ich das Poti idealerweise mit hinter die Filterschaltung
-
Thread
Empfehlung 8-Bit-Controller: STM8
bescheidenen Registersatz, aber er ist verflixt schnell !!!! Etliche Mathe- u. Bit-Befehle (auch über 64k gesehen), gehen mit nur einem Takt !!! Da kann sich ein AVR (PIC sowiso) oder auch ein (R8C - auch M16C ) "warm anziehen". Selbst der R32C ist in machen Fällen langsamer (wenn man gleiche takt-f annimmt
entsprechenden parametrischen Suchen bemüht, was ich gefunden habe hat mich ernüchtert: NXP: größter 80C51er hat 8k RAM, dafür nur 64k Flash. TI: "Up to 32 kB Flash, up to 1.2 kB RAM" sagt wohl alles, dafür angebich einen 24-Bit-ADC. Analog: Maximal 62k Flash, 2304 Bytes SRAM. Preis: 5 Dollar/Stk. bei
-
Thread
Division 64Bit durch 32Bit gesucht
Division 64 durch 64 Bit (ohne Vorzeichen): Vorteil: wenig Register 8 Register R0 ...R7 8 Register R16...R24 16 SRAM-Bytes Nachteil: rechenintensiver Hinweis: Excel kann nur bis 48Bit genau rechnen
Quellcode für 8 Bit CPUs findet man zum Beispiel zu alten Commodore-Rechnern (6502 BASIC) wie PET oder C64. Aber diesen Rat wirst Du wohl erst dann verstehen, wenn die Integer-Rechnerei genug Scherereien gemacht hat ;-)
-
Thread
C64 gibt kein Lebenszeichen
Ich habe gerade per eBay einen C64C bekommen, der angeblich vorher noch getestet wurde. Zuerst einmal ein Lob an Commodore: ich halte den C64 für einen der formschönsten Computer, der je hergestellt wurde! Das Design ist einfach klassisch
So, der eine ist ein ASSY 250469 auf dem Modulator steht: C64E HKM S/N 1080083 WW 15 90 der andere: ASSY 250469 C64C HB41378576E Modulator: C64E N1 HKC S/N 685061 WW 90 (Es sind 2 C64 dabei gewesen. Ebay-Artikel: "C64 mit 2 Tastaturen....") PS:
-
Thread
AVR-ASM: Simulierter call
r14 pop r13 pop r12 out __SREG__, r0 pop r0 ret [/avrasm] [c] // Testcode im C-Programm, das die ASM-Routine aufruft: Schedule(10, 10, funktionsadresse); [/c] Der Trick bei der Sache ist, daß es für Schedule insgesamt 4 Funktionseinsprünge gibt, die sich
Johann L. schrieb im Beitrag #2317951: > Zudem sind Adressen in C/C++ und Objektgrößen immer Byte-Adressen, Hier gehts um ASM-Programmierung - nicht um C/C++. > Und die Binutils sind wesentlich weiter verbreitet, älter und auch > bekannter. Klar. Nur ist
-
Thread
Noch ein Taschenrechner auf ATMega Basis
Die I2C-Unterstützung (NFRAM = FM24CL64B) ist in Arbeit, wird aber noch ein paar Tage brauchen. Ich habe das ganze per Compileswitch schaltbar gemacht. Also alternativ interner EEPROM für Programm- und Zahlenspeicher
RAM. Gestaltet sich mit BASCOM und den entsprechenden Libs angenehm einfach. Ich hab es mit einem 24C512 getestet, bei mir tut es anstandslos. Und wenn sich der FRAM FM 24C64B-G nicht irgendwie zickig tut, sollte er auch funktionieren. Source auf Github https://github.com/Feinmechaniker/UPN/blob
-
Thread
Moderne AVR (Nachfolger Atmega und Attiny)
AVR64DB28, AVR64DB32, AVR64DB48, AVR64DB64, AVR64DD14, AVR64DD20, AVR64DD28, AVR64DD32, AVR64DU28, AVR64DU32, AVR64EA28, AVR64EA32, AVR64EA48, AVR64SD28, AVR64SD32, AVR64SD48, AVR128DA28, AVR128DA32, AVR128DA48
AVR64DA64, AVR64DB28, AVR64DB32, > AVR64DB48, AVR64DB64, AVR64DD14, AVR64DD20, AVR64DD28, AVR64DD32, > AVR64DU28, AVR64DU32, AVR64EA28, AVR64EA32, AVR64EA48, AVR64SD28, > AVR64SD32, AVR64SD48, AVR128DA28
-
Thread
32Bit Variable beschreiben
anzeigt, jedoch kein cast [nicht im eigentlichen Sinne]) gerade das möglich macht, was Du willst. [c] 0x12<<24 [/c] gucken wir uns mal binär an. Die 12 ist ein Integer, hat 16 Bit: 0000.0000.0000.1010 Wenn man das 24 mal nach links verschiebt, dann bleibt 0000.0000.0000.0000 denn links von dem 15. Bit ist _nichts_ mehr. Deswegen warnt Dich auch der Compiler. Bei [c] 0x12L<<24 [/c] erhälst Du 0000.0000.0000.0000.0000.0000.0000.1010 was nach dem Schieben um 24 Bit durchaus noch darstellbar ist. 0000.1010.0000.0000.0000.0000.0000.0000
-
Thread
Angebot leiser PC. Bitte prüfen.
Maik M. schrieb im Beitrag #3224288: > Das ist Käse. Die 24/7 Platten haben einfach nur eine höhere garantierte > Lebenszeit (MTBF). Die Angabe 24/7 bezieht sich darauf, dass diese > Platten im Dauerbetrieb in etwa so lange halten, wie Standardplatten im > Kurzzeitbetrieb es gabe mal Festplatten wo die anzahl der Startzyklen bei den 24/7 platten geringer waren, ob es jetzt noch der Fall ist weiss ich nicht. Eine 24/7 Festplatte ist für Dauerbetrieb ausgelegt, dies findet in einem OfficePC aber nicht statt. > SSDs sind dafür garnicht
-
Thread
Versetzte Rechtecksignale auswerten, kein drehgeber
"geniale" 64k Tabelle.
Hallo Falk, ich habe noch eine kleine Korrektur im Abschnitt timer_loop 8bit Code: [c] sbrs tmp, OCF1A ; <-- rjmp timer_loop nop [/c]
-
Thread
Peter Danneggers Bootloader (fastboot) für AVR-GCC-Toolchain
Nachtrag, und man braucht natürlich noch diese beiden Macros [c] .macro xIn .if @1<64 in @0,@1 .else lds @0,@1 .endif .endmacro .macro xOut .if @0<64 out @0,@1 .else sts @0,@1 .endif .endmacro[/c]
1 1e24: 30 ea ldi r19, 0xA0 ; 160 [/c]
-
Thread
Bilineare Interpolation mit Festkomma
ldi r23, 0x01 ; 1 2bc: db 01 movw r26, r22 2be: ae 1b sub r26, r30 2c0: bf 0b sbc r27, r31 2c2: 89 81 ldd r24, Y+1 ; 0x01 2c4: 90 e0 ldi r25, 0x00 ; 0 2c6: a8 9f mul r26, r24 2c8: 90 01 movw r18, r0 2ca: a9
r1 320: 28 0f add r18, r24 322: 39 1f adc r19, r25 324: 64 1b sub r22, r20 326: 75 0b sbc r23, r21 328: 26 9f mul r18, r22 32a: c0 01 movw r24, r0 32c: 27 9f
-
Thread
Z80 - Bytedefinition mitten in Assemblerdatei
gerade verarbeiteten Opcode überschreiben. Ich kann mich lebhaft an einen Fall auf den 6510 (aka C64) erinnern, wo der Code nur verschleiert war (EOR mit einem festen Byte). Ich habe da lange gegrübelt wie der Prozessor die Schleife verläßt um den Code anzuspringen. Dann fiel es mir wie Schuppen von
Handtelefoniereinrichtung an. Bis Du da drauf eigenen Code laufen lassen kannst, hast Du eher den C64 im Keller wieder gefunden.
-
Thread
RTC für sehr fühe und späte Zeiten
in der der Rechner nicht läuft. Ein ähnlicher Kalender, aber für die Jahre 1583 bis 3267 und mit 24-Bit Datum plus 24-Bit Zeit, läuft auf einer 8-Bit CPU so nebenher und braucht noch etwas weniger Bytes (die Funktionen für 24-Bit Arithmetik hat man auf so einem Rechner ja sowieso). Außerhalb dieses
Sekundenzeitstempel? > die Zeit lässt sich bis nach dem Ende unserer Zeit einstellen. > (Bei Verwendung von uint64_t Variablen) Meinten Sie: int64_t? Gerade bei einer Zeitmaschine wäre das vorteilhaft ;)
-
Thread
I2C EEprom Speicherverwaltung
Hallo Ich habe hier zwei I2C EEproms. Eins 24c256 8x32 und eins mit 8x256. Beim 8x32 kann ich wunderbar mit AT24WriteByte(adr,wert); und mit AT24ReadByte(adr); (siehe Anhang)auslesen und wieder einlesen. Beim 8x256 bekomme ich
Der "AT24C512B" hat 512K, also 64KByte. Gibts bei Reichelt für 1.50€ im DIP-8 Package.
-
Thread
LED_Laufschrift mit Mega 32 und MAX 7219
: In function 'test_Init': ../LED_Laufschrift.c:58: warning: 'main' is normally a non-static function ../LED_Laufschrift.c: In function 'main': ../LED_Laufschrift.c:64: error: 'tu' undeclared (first use in this function) ../LED_Laufschrift.c:64: error: (Each undeclared identifier is reported only once ../LED_Laufschrift.c:64: error: for each function it appears in.) ../LED_Laufschrift.c:64: error: expected ';' before 'was' ../LED_Laufschrift.c: In function 'test_Init': ../LED_Laufschrift.c:74: error: expected declaration
-
Thread
AVR ATmega1284P Bootloader wie 644p
3b d1 60 e2 80 e7 38 d1 60 e0 8f e0 |d...;.`...8.`...| 1fcb0 35 d1 8c e7 91 ee 90 93 85 00 80 93 84 00 10 92 |5...............| 1fcc0 80 00 85 e0 80 93 81 00 81 e0 86 bb cf ef 10 e0 |................| 1fcd0 ff 24 f3 94 83 e0 e8 2e 90 ee d9 2e 01 c0 c0 2f |.$.
2a 98 82 e0 44 d1 80 e0 42 d1 c2 e0 dc ef fe 01 > |*...D...B.......| > 301fc90 84 91 3d d1 21 96 fc ef cf 32 df 07 c1 f7 2a 9a > |..=.!....2....*.| > 311fca0 64 e2 80 e6 3b d1 60 e2 80 e7 38 d1 60 e0 8f e0 > |d...;.`...8
-
Thread
mini2440 Odyssee
(irq = 76) is a S3C2440 brd: module loaded at24 0-0050: 1024 byte 24c08 EEPROM (writable) S3C24XX NAND Driver, (c) 2004 Simtec Electronics s3c24xx-nand s3c2440-nand: Tacls=1, 9ns Twrph0=3 29ns, Twrph1=2 19ns s3c24xx-nand
a/drivers/leds/leds-s3c24xx.c +++ b/drivers/leds/leds-s3c24xx.c @@ -95,7 +95,11 @@ static int s3c24xx_led_probe(struct platform_device *dev) s3c2410_gpio_cfgpin(pdata->gpio, S3C2410_GPIO_INPUT); } else { s3c2410
-
Thread
ASUS Eee PC 4G 701 Speichererweiterung
[code] xubuntu@xubuntu:~$ sudo file -s /dev/sdd1 /dev/sdd1: DOS/MBR boot sector, code offset 0x3c+2, OEM-ID "mkfs.fat", sectors/cluster 4, root entries 512, sectors 2048 (volumes <=32 MB), Media descriptor 0xf8, sectors/FAT 2, sectors/track 32, heads 64, hidden sectors 2048, reserved 0x1, serial
532 drwxr-xr-x 2 xubuntu xubuntu 16384 Jan 1 1970 . drwxr-x---+ 3 root root 4096 Nov 24 14:18 .. -rw-r--r-- 1 xubuntu xubuntu 524288 Nov 24 14:15 701.ROM [/code]
-
Thread
Mega 2561 und Heliostat-Projekt
. Azimut Grundstellungserkennung 09. + Ausgangsklemme für Encoderversorgung im Rotor (Impulse A/B 24V DC) 10. - Ausgangsklemme für Encoderversorgung im Rotor (Impulse A/B 24V DC) 11. + 24V DC Ausgangsklemme für Elevationsmotorspannungsversorgung 12. - 24V DC Ausgangsklemme für Elevationsmotorspannungsversorgung 13. + 24V DC Ausgangsklemme für Azimutmotorspannungsversorgung 14. - 24V DC Ausgangsklemme für Azimutmotorspannungsversorgung und die Berechnung der Sonnenposition in Delphi (leider keine C oder Bascom
-
Thread
s. Testprogramm für Festplatte
------------------------------------------------------- +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F 000: 0A 00 01 0F 00 50 2F C0 C3 24 06 00 00 00 03 03 010: 00 5C 5C 00 00 00 00 00 00 00 04 32 00 64 64 11 020: 00 00 00 00 00 00 05 33 00 53 51 E0 B5 00 00 00 030: 00 00 07 0F 00 4A 3C 3D
64 64 49 00 00 00 00 00 00 C2 22 0D0: 00 29 37 29 00 00 00 14 00 00 C3 1A 00 50 40 C0 0E0: C3 24 06 00 00 00 C5 12 00 64 64 00 00 00 00 00 0F0: 00 00 C6 10 00 64 64 00 00 00 00 00 00 00 C7 3E 100: 00
-
Thread
Siebkondensator für Netzteil berechnen
MaWin schrieb im Beitrag #4657726: > 80mA last = 150mA Trafonennstrom. > > 24V * 0.15A = 3.6VA, Leerlaufspannungsüberhöhung also ca. 33% > > 24V * 1.1 * 1.414 * 1.33 = 49.64V Das einzig Zuverlässige daran ist die Quadratwurzel aus 2, um einen Sinus-Effektivwert in einen Spitzenwert
Du nicht. Wie groß muß den den der C Deiner Meinung nach sein. Deine Aussage in einem früheren Post wo Du sinngemäß sagst das 100µ nicht reichen ist nichts sagend. Also wie groß ist der C für 24V bei 80mA zu bemessen? Rechne das doch
-
Thread
DS18B20 Verkabelungs od Software Problem
9 Resolution actually set to: 12 Requesting temperatures...DONE Temperature for device: 0 Temp C: 23.00 Temp F: 73.40 Temperature for device: 1 Temp C: 23.37 Temp F: 74.07 Temperature for device: 2 Temp C: 24.37 Temp F: 75.87 Temperature for device: 3 Temp C: 23.69 Temp F: 74.64 Requesting temperatures...DONE Temperature for device: 0 Temp C: 23.00 Temp F: 73.40 Temperature for device: 1 Temp C: -127.00 Temp F: -196.60 Temperature for device: 2 Temp C: 24.31 Temp F: 75.76 Temperature for device: 3 Temp C: 23.69 Temp F: 74.64 Requesting
-
Thread
Projekt: Virtuelle Instrumente an serielle Schnittstelle
sowie Osx portieren lässt. Da hier auch Zugriffe auf die Hardware eine Rolle spielen bleibt fast nur C/C++ übrig.
Serial/Hardwarezugriffe Zugriffe machen. Eine Frage der Library. Vergesst das mal. Immer mit diesem C/C++...
-
Thread
DSP-Plattform für Audio
kein dithern des Datenstrom und normierter headroom) braucht man 17+(Faktor 10 = 4) + ca 3-4 Bit = 24 Bit. Daher haben typische Audio DSPs eher 24 Bit und arbeiten intern mit 48 Bit Vektoren. Für die 24 Bit Plattformen (moderne ADCs) hat man seit Jahren 56+ Bit intern in den Digitalpulten (28x2).
Werner schrieb im Beitrag #3240564: > Aber mit zwei Instructions bin ich auch beim 32Bit-DSP mit 64 Bit > dabei und wo braucht man schon mehr ? Für die reine Audio-Bearbeitung werden in Pulten regelmässig mit 48 Bit gerechnet, wegen 24 im Quadrat. Zur einfachen Fehlervermeidung nimmt man etwas
-
Thread
Hardware-Multiplier auf Mega32 ungenutzt?
642: c9 01 movw r24, r18 644: 44 e0 ldi r20, 0x04 ; 4 646: 88 0f add r24, r24 648: 99 1f adc r25, r25 64a: 4a 95 dec r20 64c: e1 f7 brne
Hundertvolt schrieb: > [avrasm] > Calc *= H_SENS_MUL; > 642: c9 01 movw r24, r18 > 644: 44 e0 ldi r20, 0x04 ; 4 > 646: 88 0f add r24, r24 > 648: 99 1f adc r25, r25 > 64a: 4a 95 dec r20 > 64c: e1 f7
-
Thread
64/128 Bit Softcore
Tempo nicht reicht. Mit Bezug zur Grafik oben nochmal einige alternative Werte vom Artix7: Bei 24x24 benötigt er nur 2 statt 4 Multiplier, dafür aber mehr FFs! Offenbar baut die Synthese (welche - anders als oben beim Spartan - auf "balanced" eingestellt sein kann, um das timing zu treffen) einige
Ist nur etwas still geworden um den oben angekündigten 64-Bit-RISC... Grüsse, - Strubi