-
Thread
Quantisierungsfehler
Rundungsverfahren eingesetzt werden z.B. Mittelwertbildung aus mehreren samples mit anschließender Division durch N oder kaufmännisches Runden.
-
Thread
Zeitaufgelöste Frequenzmessung - Interuptprioritätsproblem?
Auch das schreiben in den externen Speicher könnte zu lange dauern. Da sind auch noch ein paar Divisionen (%) drin, auch die sollte man vermeiden, weil sie zu langsam werden. Einen Zyklischen Zähler für den Ringpuffer macht man besser per runterzählen bis 0 und dann neu starten bei der Länge-1. Der C-Code
-
Thread
Exakter Manchester Code mit ATmega328 generieren
beinhalten ;-) Aber selbst C-Standard-String-Funktionen oder bestimmte Integer Multiplikationen/Divisionen können ziemlich viel Zeit verbrauchen. Es gibt für manche Dinge wie z.B. Zahl-nach-String-Umwandlung spezielle µC-optimierte Implementationen, die nicht alles können, dafür aber ein Vielfaches schneller
-
Thread
Sinusgenerator für FPGA gesucht
Wenn die Frequenz nur im Mittel stimmen muss kann man auch eine Division mit Rest durchführen und erhält eine jitter-behaftete Ausgangsfrequenz.
-
Thread
Poti grillen verhindern
die Variable s ("Stellung") ein, geht von 0 (linker Anschlag) bis 1 (rechter Anschlag), um die Division durch 0 zu verhindern nehmen wir 0.999 statt 1 R1 = 100 Ohm * s; R2 = 100 Ohm * (1-s) Ausgangsspannung ist dann 1V * 1 / (1-s) und das ist sowas von nichtlinear. Wenn ich hingegen den R2
> Variable s ("Stellung") ein, geht von 0 (linker Anschlag) bis 1 (rechter > Anschlag), um die Division durch 0 zu verhindern nehmen wir 0.999 statt > 1 ??? Was du hier machst, ist eine Spannungsregelung mit einer Parrallellast. Also mit einer Erhöhung des Ausgangsstromes zwingst du die Spannung
-
Thread
10V Referenzspannung
gensearch&Ntt=s102&Ntx=mode+matchallpartial&No=0&getResults=true&appliedparametrics=true&locale=de_DE&divisionLocale=de_DE&catalogId=&skipManufacturer=false&skipParametricAttributeId=&prevNValues=2008+203968&mm=1000001||,&filtersHidden=false&appliedHidden=false&autoApply=false&originalQueryURL=%2Fjsp%2Fsearch
3Dmode%2Bmatchallpartial%26No%3D0%26getResults%3Dtrue%26appliedparametrics%3Dtrue%26locale%3Dde_DE%26divisionLocale%3Dde_DE%26catalogId%3D%26skipManufacturer%3Dfalse%26skipParametricAttributeId%3D%26prevNValues%3D2008%2B203968 https://www.buerklin.com/default.asp?event=ShowPHNode%28SE,hsb,7EE94D8B-8D82
-
Thread
TRMS - Periode erkennen
und Stop der Integration einen Nulldurchgang Abzuwarten geht auch, aber man benötigt dann eine Division, weil die Integrationszeit vom Signal abhängt und nicht fest gewählt werden kann.
-
Thread
Aquariumcontroller: hängt sich auf / stürzt ab / friert ein - Hilfe!
durch 100 übergeben (temperaturwert/100), und vom positiven Temperaturwert der Rest der Modulo-Division durch 100 (abs(temperaturwert)%100), wobei die Nachkommastellen zweistellig mit ggf. führender Null formatiert ausgegeben wird. Aber wie gesagt, wenn Du vom Controller einfach Hundertstel-Celsius
-
Thread
Spannungsteiler
gleichen Widerständen, im Endeffekt kommt also max. 5V heraus. Die ggf. erforderliche Multiplikation/Division führst du auf dem Mikrocontroller oder PC durch.
-
Thread
hex-Wert inkrementieren ohne a.f
vom TO gefrag, das inkrementieren um eins machen, das ist WESENTLICH schneller als die ganzen divisionen in deinem code...)
-
Thread
UART Test SDK500 --- Problem
was du da geschrieben hast, ist vermutlich eine division... und nicht nur ein fehlerhafter kommentar.
-
Thread
ADC an Olimex AT90CANBoard
Voltage Reference with external capacitor on AREF pin ADMUX |= (1<<REFS0); //Set Prescaler Division factor to 128 (16MHz CPU) //Enable ADC ADCSRA |= (1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); //Read one value to warm up ADC //Start single conversion ADCSRA |= (1<<ADSC); //
-
Thread
Transistor Sättigung und Arbeitspunkt
die Impedanz (vulgo: der Innenwiderstand) des Basisspannungsteilers hoch genug, daß auch nach der Division durch die Stromverstärkung des Transistors noch genug Ausgangsimpedanz bleibt, die den Strom durch die LED auf ungefährliche Werte begrenzt. Natürlich würde man so etwas nicht absichtlich aufbauen
-
Thread
Byte Adresse in Wort Adresse umwandeln Gesperrt
ist. Wenn ich das glauben würde, dann würde ich als nächstes Fragen warum du bisher noch keine Division in der Schule hattest.
-
Thread
Bursts in einem Signal zählen
Lesen und Überschreiben des Summenwertes. Gut dann noch den Mittelwert aus der Summe, also eine Division, aber die brauchst du bei deinem IIR Ansatz genauso. Viel Erfolg
-
Thread
Motorolla 68HC11
en.wikipedia.org/wiki/Freescale_68HC11 Und warum baut Microchip so alten Schrott ? "GI spun the division off as Microchip Technology in 1987" Klaus Rotter schrieb im Beitrag #3697232: > und der 68HC11 hatte halt IMHO nie internen Flash-Speicher 68HC811
-
Thread
CPU Cycles printf bzw sprintf
Jörg Wunsch schrieb im Beitrag #3726285: > Ändert aber nicht viel an der Dynamik der verwendeten Division. Die 16 Bit Division soll 20 Takte brauchen, was bei 25MHz dann 0,8µs wären. Das ist m.E. für die geplante Anwendung hinreichend schnell (Schätzwert < 30µs für itoa).
Beitrag #3726341: > Kann ich mir in dieser Allgemeinheit für einen Prozessor ohne > Hardware-Division nicht vorstellen. Ich ja eigentlich auch nicht, aber da der C166 einen Hardware-Divider auf dem Chip hat, schon :-) Die 20 Takte gelten übrigens für 32/16 Division, bei der der eingebaute Barrelshifter
-
Thread
STM32F4 einfache PWM
TIM_TimeBaseStructure.TIM_Period = (timer_clk/timer_out_clk); TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //timer init TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure); //common PWM config TIM_OCInitStructure.TIM_OCMode
-
Thread
C vs. C++ zur Mikrocontrollerprogrammierung - oder: Auf welche C++ Features lieber verzichten?
Hintertür doch wieder float-Arithmetik einhandeln -- etwa zur Konvertierung oder Multiplikationen/Divisionen zur Anpassung des Dezimalpunks/Nachkommastellen. Dann die böse C++-Überraschung: Für die Konstanten-Tabellen erzeugt der C++-Compiler ad-doc Konstruktoren und geht davon aus, daß die Tabellem
-
Thread
while(1) Laufbedinung bricht ab
Was machen denn die Variablen die Du 0 setzt? Division durch Null in einer Funktion? Prima Gelegenheit den Debugger zu bemühen, bzw. Debug Nachrichten zu senden.
-
Thread
Einstieg in STM32 : STM32F103C8T6 --> Kompilieren und Flashen?
die diversen Bibliotheksfunktionen aus den zuständigen Bibliotheken mit dazulinkt (z.B. Integer-Division, double-Addition, und sonstigen Kram, den nur der Compiler kennt und benutzt). Dazu muß der Linker auch wissen, für welche Zielplattform das Ganze gut sein soll, damit er die richtige Laufzeit-Bibliothek
-
Thread
Atmega88 mit 100kHz
langsam > schalten. Ach, das wusste ich gar nicht. Danke für den Hinweis! Dann ist ein Clock Division Factor von 1, 2, 4, 8, 16, 32, 64, 128 und 256 möglich... gut zu wissen. Damit käme man z.B. auf 125kHz.
-
Thread
C - called Object is not a function or a function pointer
die folgenden Operatoren: [pre] ≤ ≥ ≮ ≯ ≠ Vergleiche ⋅ ÷ Multiplikation und Division ∘ Verkettung von Funktionen ∧ ∨ ¬ Logikoperatoren ∈ ∉ Elementrelation π Kreiszahl ℤ ℚ Datentypen (ganze bzw. rationale Zahlen) [/pre] In
-
Thread
PT1 Filter mit sehr kleine Koeffizienten und Rundung
Siehe auch http://www.ibrtses.com/embedded/exponential.html Man macht die Division am besten als 2^n, sprich nach rechts schieben.
-
Thread
Hilfe die Prüfsumme zu berechnen
Addition? Springt der bei 255 wieder auf 0? Ja, das heißt "modulo 256". Der Rest, der bei einer Division durch 256 übrig bleibt, also das unterste Byte. Also in hex kommt nach 0xff ja 0x100, aber es wird nur das unterste Byte verwertet. Du kannst also einfach alle Bytes aufaddieren, in einen ausreichend
-
Thread
16 Bit Division auf 8051
vernünftigen Programmiersprache in Betracht ziehen, in C51 gibt es sicherlich solch eine einfache Division. Üblicherweise schreibt kein effizient arbeitender Programmierer seine Divisionen selbst sondern er setzt fertige Bibliotheken ein. So was gab es früher (als ich noch mit dem 8031 gespielt habe
Anbei mal die 16Bit Division.
-
Thread
CVE Meldungen lokal oder auf Server einlesen/filtern
request_result.getheader('Content-Length')) one_percent = content_size // 100 # integer division pivots = ['-', '\\', '|', '/'] percent = 0 download = '' print('\nDownloading [{}] Bytes'.format(content_size)) while content_size > 0: for p in pivots:
-
Thread
Momentanfrequenz aus analytischem Signal ohne Arctan
Phase-Unwrapping bei der Berechnung mittels arctan(Q(t)/I(t)), gezielt behandelt werden müssen (Division durch Null ist bereits vermerkt).
-
Thread
STM32F4 Discovery: Problem mit DMA (ADC + Audio DAC)
TIM_CounterMode_Up; timerInitStructure.TIM_Period = 999; timerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; timerInitStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM2, &timerInitStructure); TIM_Cmd(TIM2, ENABLE); TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); }
eingelesen werden komme ich bei meinen gewünschten 48kHz raus (prescaler=35-1; period=50-1; ClockDivision=TIM_CLK_DIV1). Es werden auf jeden Fall beide Buffer beschrieben, allerdings verstehe ich hier zwei Dinge noch nicht ganz. Habe einen Ausschnitt der Daten aus einem Buffer wieder angehängt, hier
-
Thread
[ASM] Unbenutzte Symbole entfernen
mm-Umwandlung mit Multiplikationen ausführe und auch sonst nirgends was dividiere, verschwindet die Division automatisch aus der ausführbaren Datei. Ich habe das eigentlich auch immer für den Normalfall gehalten. Von Pascal, C oder Assembler ist das übrigens völlig unabhängig. Georg
mm-Umwandlung mit Multiplikationen ausführe und > auch sonst nirgends was dividiere, verschwindet die Division automatisch > aus der ausführbaren Datei. Ich habe das eigentlich auch immer für den > Normalfall gehalten. Von Pascal, C oder Assembler ist das übrigens > völlig unabhängig. Im Prinzip ja.
-
Thread
C - Banknoten Check vereinfachen möglich?
dann mache Quersumme += 1 + 1 - Ansonsten einfach auf Quersumme aufrechnen - Dann Berechne den Divisionsrest -> Quersumme % 9 - Berechne Differenz -> Differenz = 8 - Divisionsrest - Übrprüfe Letzte Zahl im Kode, ob die übereinstimmt mit Differenz - Wenn Ja, dann ist die Note Echt - Wenn Nein, handelt
dann mache Quersumme += 1 + 1 - Ansonsten einfach auf Quersumme aufrechnen - Dann Berechne den Divisionsrest -> Quersumme % 9 - Berechne Differenz -> Differenz = 7 - Divisionsrest - Übrprüfe Letzte Zahl im Kode, ob die übereinstimmt mit Differenz - Wenn Ja, dann ist die Note Echt - Wenn Nein, handelt
-
Thread
Erkennen, was den Interrupt ausgelöst hat.
. Hauptsache Du verwendest keine Delays im Interrupthandler. Oder LCD-, UART-Ausgaben, Float, Division und anderes lahmes Zeugs.
-
Thread
Assembler High-Byte und low-Byte
3,125 3h als hibyte merken, 3 von 3,125 abziehn, ergibt ,125 als Rest. ,125 mal 256 (vorherige Division aufheben) = 32 32 in hex umwandeln : 20h , das lobyte
Ja interessant wird es eben erst ab 256 Ich verwende z.B. in einer Division 3600 und dann schreibe ich eben ldi R16, low(3600) ldi R17, High(3600) als es erst mit dem Win-Taschenrachner auf 0000 1110 0001 0000 zu zerlegen und dann die Register mit ldi R16, 0b00010000
-
Thread
LMT84 Temperatursensor mit TI MSP430G
genauer sollte es noch gehen. Die Ganzzahlrechnung kann man noch verbessern in dem man vor der Division noch mit 10 multipliziert, 5 addiert, und wieder durch 10 dividiert. Dann hast Du kaufmännische Rundung auf der letzten Stelle. Dann hat der MSP2553 noch Kalibrierungswerte für den ADC im InfoMEMA
-
Thread
AtTiny13 Clock auf 128kHz und Division = 0/1
ich habe um Strom zu sparen versucht die Fequenz meines Tinys auf 128kHz zu stellen und und den Division Factor auf 1 gestellt. Seit her funktioniert die Kommunikation mit meinem USBASP nicht mehr. Ich bekomme immer nur Chip = 00000 Hab ich es vermurkst? Grüße Alex
-
Thread
Byte z.B. 23 aufteilen in Einzellbytes 2 und 3
ohne modulo a = 23; deine zahl b = 23 / 10; b ist jetzt 2 c = a - b; da hast du den rest der division wenn's dann doch binär wäre hast du ne Zahlenbasis von 16. Das wichtigste (schon tausendmal hier im Forum erwähnt) sind präzise Fragestellungen. Aber leider ist das nicht mehr im Schulwissen
> > a = 23; deine zahl > b = 23 / 10; b ist jetzt 2 > c = a - b; da hast du den rest der division so ist c jetzt aber 21! Du meintest vrmtl. c = a - 10*b; Dann ist die verbliebene 3 in c. > ... mfg, Sammy Davis Junior
-
Thread
RGB LED Algorithmus zur Farberzeugung
rgb. Ganz grob: [c] // Sei fp ein fixed-point Datentyp // fpmul, fpdiv die multiplikation/division zweier fp werte // fp(int) die Wandlung von int zu fp // fp2u8(fp) wandelt fixed point in u8, schneidet fractions ab fp Hue_2_RGB(fp v1,fp v2,fp vH ) //Function Hue_2_RGB { if
= a*b*256, also zuviel. Deswegen braucht es hier eine Korrektur des Ergebnisses (analog bei der Division) [c] fp fpmul(a,b) { return (fp)((u32)(a * b) / 256) ; } fp fpdiv(a,b) { return (fp)((u32)(256 * a) / b) ; } [/c]
-
Thread
FPU für ARM7
bräuchte, aber selbst bei gleichem Takt von FPGA und Controller wären es dann mindestens 2. Bei Divisionen ggf noch viel mehr(kommt auf den Takt des ARM an). Im compiler würde ich das über eine Funktion lösen, also mult(a,b) -> welche dann eben die entsprechenden schreib und lesebefehle ausführt.
-
Thread
Ein Bytecode-Interpreter für ATMega644 u.a.
float64-Bibliothek auf dem Bytecode-Interpreter laufen lässt. Es werden ca. 20 Additionen und 12 Divisionen pro Sekunde ausgeführt. Sinus-Berechnungen und Konversion nach dezimal sind noch langsamer. Die reine float64-Bibliothek (ohne den Code zum Testen) hat einen Bytecode von ca. 5700 Bytes. Der Code
hinzuschreiben. Das dauert zwar länger, spart aber Programmspeicher. Beispiel dafür sind etwa die Division/Modulo-Routinen, die avr-gcc von Hause aus mitbringt. > Und wie erwähnt, schneidet mein Compiler bei 32- > oder 64-Bit-Datentypen besser ab, weil die Operationen nicht aus vielen > 8-Bit Operationen
-
Thread
uVision KEIL
0x00000700); /*kein ABP1 prescaler */ TIM2->CR1 &= (~TIM_CR1_CKD_0 & ~TIM_CR1_CKD_1); /*keine Clock division*/ TIM2->CCER &= (~TIM_CCER_CC1E); /*deaktiviere Capture/Compare Output 1 Channel (um Parameter zu aendern)*/ TIM2->CCMR1 &= ~(TIM_CCMR1_CC1S_0 & TIM_CCMR1_CC1S_1); /*konfiguriere Capture/Compare
-
Thread
PI Regler ohne Gleitkommaberechnung
Faktor von 0,135 läßt sich beispielsweise mit guter Genauigkeit als 138 / 1024 darstellen. Die Division durch 1024 kostet den uC ein müdes Lächeln. Und schon hast du einen Float-Faktor eliminiert.
Noch effizienter ist eine Division durch 256 oder durch 65536.
-
Thread
Schiebeoperation negative Zahl
lade in Indexregister X den Wert -128 (80h) stx Wert ;speichere $80 in Wert asr Wert ;Division durch 2 asr Wert ;Division durch 2
-
Thread
MSP430 C-Programmierung, Programmgröße reduzieren
Außerdem: Bibliotheksfunktionen im MAP-File prüfen. Auch so etwas, was man nicht gleich sieht: Division, Modulo, Multiplikation (wenn der Prozessor keinen Multiplizierer hat),... Im MAP-File siehst Du die Speicherfresser. fchk
"Genähert könnte eine int-Division durch 164 reichen." was bedeutet das?
-
Thread
avr32 vs. ARM
32 MHz (Flash aus, Code im RAM) AVR32 AT32UC3L 13 mA @ 50 MHz (Fibonacci), ~8.3 mA @ 50 MHz (Division) (Peripherie getaktet, Code im Flash) Hinzukommt das die Cortex-M0/M3 gerade mal bei 0.9 bzw. 1.25 DMIPS/MHz liegen, die AVR32 dagegen bei 1.5 DMIPS/MHz. Nimmt man noch ein paar andere ala Renesas
-
Thread
STM32: Seriell senden via DMA funktioniert zwar, aber wo wird´s gestartet?
TIM_TimeBaseStructure.TIM_Period = 65535; TIM_TimeBaseStructure.TIM_Prescaler = 0; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); /* Prescaler configuration */ TIM_PrescalerConfig(TIM2, 4, TIM_PSCReloadMode_Immediate
-
Thread
Frage zu Pipeline
eher spezialisiert als MQ-Register für ebensolche Doppelwortoperationen wie Multiplikation und Division (daher das Q), ggf. auch manche Schiebeoperationen. Als die Chipdesigner später anfingen, solche Operationen zu pipelinen (*), haben sie sich allerdings selbst in den Allerwertesten gebissen, denn
-
Thread
wurzel ziehen nicht möglich - Freescale
> berechnen. Dazu braucht man lediglich Gleitkommaoperationen > Addition, Multiplikation und Division. oje es ist lange her, dass wir bei der Wurzel-Herleitung in der Schule mit Addition, Multiplikation und Division gearbeitet haben. Ich kann micht garnicht mehr daran erinnern, wie wir es gamacht
> berechnen. Dazu braucht man lediglich Gleitkommaoperationen > Addition, Multiplikation und Division. da hast du recht, wusste aber niht mehr wie das ging.
-
Thread
RISC oder CISC - Was ist besser?
fertiggestellt werden kann. Aus diesem Grund hatte der erste SPARC übrigens auch keine Multiplikation und Division, was aber später aus Performanzgründen nachgeflickt wurde. Hierbei ist wichtig, daß keine CPU eine Instruktion in einem Taktzyklus ausführen kann; es sind immer mehrere Schritte nötig. Wenn man aber
codierungstechnisch bevorzugt wird, variable Shiftweiten nur in CL stehen dürfen, Multiplikation/Division implizit EAX/EDX verwenden, etc. pp. Beim Pentium werden die 8 Pseudo-Universalregister intern auf 40 Register umverteilt und die Instruktionen in Micro-Ops zerlegt, damit sie einigermaßen effizient
-
Thread
FIFO Buffer in C
^ Ich denke schon das eine 16Bit Division sowohl größer als auch langsamer ist als ein 'logical and'.
-
Thread
AD Wandler abgleichen ATMEL MEGA8
ein Signal zwischen 0 und 5 Volt am Eingang des AD Wandlers liegen und rechne die Spannung durch Division durch 1024 auf 2 Stellen aus. Leider ist die Abweichung zwischen der gemessenen angelegten Spannung und der Spannungsausgabe des µM mit zunehmender Spannung sehr hoch (bis 0,5 Volt). Was muß man tun
in Millivolt machen, also nicht adc_wert * 5 sondern adc_wert * 5000. Dann dürfte auch bei einer Division durch 1024 was sinnvolleres rauskommen. Gruß Johnny