-
Thread
Arm Cortex im DIP Gehäuse Gesperrt
Division ins Spiel, ebenso bei den Cortex-R. Da die Cortex-M0 aber auf dem nur minimal erweiterten alten Thumb-Befehlssatz basieren, blieb ihnen die Division erspart.
Jörg W. schrieb im Beitrag #5211780: > Division ist die kostspieligste der Grundrechenarten, daher hat man > diese dort weggelassen. Division ist laufzeitintensiv, aber nicht wirklich aufwändig zu implementieren. Während man eine Multiplikation
-
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
Optimierung von Bit-Transfer-Operationen
bld je benötigt zu haben. Ich habe T nur als Userflag benutzt, z.B. um zu unterscheiden, ob die Division den Quotienten oder den Rest berechnen soll. Beim 8051 waren die Bitbefehle erheblich leistungsfähiger, da konnte man sogar Bits aus Portpins einlesen oder ausgeben (MOV C, P1.2 oder MOV P2.3, C)
-
Thread
Frage zu Primzahlenaufgabe
deinen Beitrag! Nur das verstehe ich leider nicht ganz. Meiner Überlegung nach müsste doch bei der Division des Terms 1 + p1*p2*....pn durch die jeweilige Primzahl immer der Rest 1 entstehen? Beispielsweise 1+2*3*5=31 => 31:5=6R1. Dann wäre allgemein formuliert immer das Ergebnis des Terms der kleinste
p1*p2*....pn sein kann. Das entspricht Deinem "Meiner Überlegung nach müsste doch bei der Division des Terms 1 + p1*p2*....pn durch die jeweilige Primzahl immer der Rest 1 entstehen?" Jetzt bleibt noch zu zeigen daß der kleinste Teiler größer 1 von 1 + p1*p2*....pn (genannt p(1 + p1*p2*...
-
Thread
Ist x>>16 das Gleiche wie x/65536?
Division: [code] mov r3, #65536 sdiv r0, r0, r3 [/code] Shift: [code] asrs r0, r0, #16 [/code] gcc version 6.3.1
Mike schrieb im Beitrag #5203417: > Allerdings ist die Division eine aufwändige Operation, da der ARM sie > iterativ berechnen muss, denn es gibt keinen Maschinen-Divisionsbefehl. Eigentlich sollte jeder halbwegs moderne Compiler eine Division/Multiplikation
-
Thread
STM32 PWM One Pulse Mode mit variablen Puleweiten
Dshot600 TIM_TimeBaseStructure.TIM_Prescaler = 0; //84MHz TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); /* PWM Mode configuration */ TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1
Dshot600 TIM_TimeBaseStructure.TIM_Prescaler = 1; //84MHz TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); /* PWM Mode configuration */ TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1
-
Thread
STM32F103 USART1 affects TIM1? TIM1 interrupt frequenz varying
which I didn't set. So the right initialization would be[c]TIM_TimeBase_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBase_InitStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBase_InitStructure.TIM_Period = 999; TIM_TimeBase_InitStructure.TIM_Prescaler = 1799; TIM_TimeBase_InitStructure.TIM_RepetitionCounter
-
Thread
FloatingPoint Division von Ganzzahlen
gegeben. Meine Idee war es nun, die von Altera Quartus bereitgestellte IP-Core zur FloatingPoint Division zu nutzen. Anschließend kann ich das Ergebnis der Division (C) wieder normalisieren und entsprechend verstärken ohne auf die Genauigkeit der Division verzichten zu müssen.. bzw. erhoffe ich mir so
> Meine Idee war es nun, die von Altera Quartus bereitgestellte IP-Core > zur FloatingPoint Division zu nutzen. Anschließend kann ich das Ergebnis > der Division (C) wieder normalisieren und entsprechend verstärken ohne > auf die Genauigkeit der Division verzichten zu müssen. Ich möchte Dir
-
Thread
STM32F446 - Timer kommt zu oft?
schreiben. BSRR ist aber ein schlechtes Beispiel, daher hier mit TIM_CR1_CKD: [c]void setClockDivision (uint8_t ckd) { TIM2->CR1 = (TIM2->CR1 & ~TIM_CR1_CKD_Msk) | (((uint16_t) ckd) << TIM_CR1_CKD_Pos); }[/c] Oder auch Werte abfragen: [c]uint8_t getClockDivision (void) { return (TIM2->CR1
> TIM_CR1_CKD_Pos; }[/c] Etwas kürzer gehts mit den vordefinierten Makros: [c]void setClockDivision (uint8_t ckd) { MODIFY_REG(TIM2->CR1, TIM_CR1_CKD_Msk, ((uint16_t) ckd) << TIM_CR1_CKD_Pos); } uint8_t getClockDivision (void) { return READ_BIT(TIM2->CR1, TIM_CR1_CKD_Msk) >> TIM_CR1_CKD_Pos
-
Thread
Umrechnung von Dezi zu HEX und Kontrolle
Man kann das aber auch selber schreiben. Mit etwas Bitoperationen geht das recht einfach. Mit Division und Modula aber auch (etwas langsamer)
-
Thread
STM32L1 PWM mit DMA falsche Periodendauer
TIM_CounterMode_Up; TimerInitStructure.TIM_Period = 0xFFFF; TimerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseInit(TIM2, &TimerInitStructure); //PWM CHANNEL OutputChannelInit.TIM_OCMode = TIM_OCMode_PWM1; OutputChannelInit.TIM_Pulse = 0; OutputChannelInit.TIM_OutputState
-
Thread
Auswahl eines ARM-µC für Einsteiger
Cortex M0+ die wichtigsten ARM-Vorteile wie bedingte Ausführung und Barrel-Shift eingespart wurden. Division hat er auch nicht. DMA haben auch beide.
M0+ die wichtigsten ARM-Vorteile wie bedingte > Ausführung und Barrel-Shift eingespart wurden. Division hat er auch > nicht. Mehr Einsatz von 16Bit und 32Bit Datentypen Verarbeitung und..... >DMA haben auch beide. Naja du möchtest doch jetzt nicht den sehr speziellen und begrenzten light
-
Thread
Wird ein Interrupt gespeichert?
möchte. *Synchrone Interrupts* stehen in direktem Zusammenhang mit dem Befehlsablauf. Sowas wie Division durch 0 fällt darunter. Werden oft auch zwecks Unterscheidung als Traps oder Exceptions bezeichnet. *Asynchrone Interrupts* werden von Ereignissen ausgelöst, die mit dem Befehlsablauf nichts zu
-
Thread
STM32 Timer External clock
Triggern. Das funktioniert mit folgender Initialisierung: [code] TIM_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_InitStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_InitStructure.TIM_Period = 0xFFF; TIM_InitStructure.TIM_Prescaler = 0; TIM_TimeBaseInit(TIM1, &TIM_InitStructure);
-
Thread
SD Karte mit FatFs über SPI an Atmega, wie kann man die Schreibgeschwindigkeit maximieren?
kodiert -> 16KB/s -> reicht doch? Wenn du aber alles in Dezimal umrechnest sind das ne menge Divisionen, und die Kosten auf nem AVR wirklich Zeit: https://www.mikrocontroller.net/articles/ArithmetikBenchmark Rechne dann mal mit einer Division pro Dezimalstelle. 10Bit->5 Stellen -> 245Takte pro Division
-
Thread
Zählerüberlauf
nennt sich der zweite Operand der Modulo-Operation Modul, Es klingt irgendwie logisch... Division -> Divisor (Teilung -> Teiler) Modulo -> Modul (mit dem Maß, Modus, Maß) Zumindest brauchbar, auch wenn schwer zu belegen. Danke für die Vorschläge.
-
Thread
Projektaufgabe: STM32F401 - FreeRTOS - LCD Modul - Taschenrechner
sein kann, also eigentlich 4 Zahlen (A=12,5 C=-12,5 B=2,3 D=-2,3). Multiplikation (A mal B), Division (A durch B) , Potenzieren (A hoch B), wenn möglich Wurzelziehen (Quadratwurzel https://de.wikipedia.org/wiki/Schriftliches_Wurzelziehen ) Ohne den Teil von Gruppe A geben Sie das Zeichen für
-
Artikel
Einfache Division in VHDL und ASM
in C programmierbar sind, bzw. nicht über Multiplikation oder Division verfügen, sowie für FPGAs und PLDs, in denen keine Multiplizierer zur Verfügung stehen, oder genutzt werden sollen. = Methode 1 = Eine Division kann bekanntermassen grundsätzlich durch eine inverse
0 1 1 1 0 1 0 0 1 1 0 1 0 0_0 1 0 1 0 0 1 0_0 0 0 1 = x/3 = 52 + 82/256 + 1/256/16 = 52,32 Eine Division durch 7 lässt sich mit nur 4 Vektoren (1/8 + 1/64 + 1/512 + 1/4096) auf 0,1% genau durchführen. Für weitere Divisionen mit 9,11,13,17 .. etc lässt sich eine Tabelle mit Excel oder MATLAB erzeugen.
-
Thread
"if" wird nicht richtig ausgeführt
reinpassen) und nur mit signed-Operatoren. Also kein Einer-Komplement ("~") und auch kein shift statt Division. Der Compiler kennt diese Tricks selber, aber er weiß auch, wann er sie benutzen darf. Erst wenn Bits und Takte ganz knapp werden, dann kann/muß man tricksen. Davor ist es nur verschwendete Zeit.
-
Thread
VHDL Grundlagen : Rechnen
gelegt. Die Testbench stellt sicher, dass b nie Null ist. Diese Aufgabe soll wie die schriftliche Division, also durch Vergleiche und Subtraktionen gelöst werden. Abzugeben ist wie immer nur die entsprechende VHDL Datei. Für die beiden Lösungsvarianten könnt ihr also diese Datei kopieren oder auch beide
-
Thread
AVR Assembler Division
Ich habe versucht, in Assembler eine Division von zwei 8-bit Zahlen zu berechnen, allerdings funktioniert das Programm bei einigen Zahlenwerten nicht (z.B. bei 130 / 2, bei 129 / 2 jedoch einwandfrei): [c] div: mov r18,r16 clr
STATUS,C ;C=0? dann ist Ergebnis negativ - Ende ; der Division GOTO Div8_8_Rest ;JA, Division beendet, Rest berechnen incf Quotient_0,f ;NEIN, Qoutient +1 GOTO Div8_8_Loop ;erneute Subtraktion Divisor-Dividend ; Div8_8_Rest
-
Thread
logarithmischer Detektor AD8362
XdBm/100Bit5 = -10dBm /180Bit5 <==> XdBm = -10dBm /180Bit5 *100Bit5 XdBm = -5,5dBm Bei der Division muss man noch passend Runden: wenn der Rest r: r = {0 : 0<= r <0.5 // 5 : 0.5<= r <1 }
-
Thread
AVR GCC Optimizer Level in C-Programm abfragen
times;i++) {sumADC += ADC_read(channel);} return sumADC/times; // das dauert länger wegen der Division } [/c] Was ich erlebt habe ist, dass der Optimizer mit -O2 und -O3 den Code messung1=ADC_read_avg(ADC_pin_check,2); nicht ausführt. Das umgehe ich, indem ich temporär auf -O1 zurückgehe,
RichardHi schrieb im Beitrag #5166561: > return sumADC/times; // das dauert länger wegen der Division ... Es sei denn die Funktion wird geinlined, die Division durch 2 ist schnell (bitshift). Le X. schrieb im Beitrag #5166565: > Stelle nur kurze, präzise Fragen die sich ebenso kurz und präzise
-
Thread
n-te Wurzel aus riesigen Zahlen ziehen, wie geht das?
das unabhängig von der Größe der ursprünglichen Zahl ist, so daß man einen passenden Pseudo-Divisionsalgorithmus benutzen kann. Die altbekannte Quelle für sowas (Lampe,Jorke,Wengel) hatte sowas mit dem Z80 für die Quadratwurzel mal durchexerziert. Bin jetzt aber zu faul, das alles wieder herauszukramen
-
Thread
Python Verständnisfrage
Ein Operator, dargestellt durch das Prozent-Zeichen (%), der mit Ganzzahlen arbeitet und für die Division einer Zahl durch eine andere den Rest berechnet. Gruß Newbie
-
Thread
Zwei Glühlampen widerstand
ganz andere Teile und zweitens zwei unterschiedliche Lampen. Da ist aber nichts mit einfacher Division zu machen.
-
Thread
1 Byte in dual 7 Segment Anzeige übersetzen
im Beispiel geht das schon. Schwierig wird die Division, wenn der Divisor variabel ist. Ich verwende dafür einen IP-Core der pro Bit einen Takt braucht. Duke
chris schrieb im Beitrag #5166495: > Ich dachte, Divisionen sind in VHDL zu vermeiden Divisionen durch Zweierpotenzen gingen schon immer (ist ja einfach: Bits abschneiden = anders verdrahten, wobei dieses simple Verfahren nur für positive Zahlen korrekt
-
Thread
STM32F303K8 Input Capturing via internen Komparator
htim2.Init.CounterMode = TIM_COUNTERMODE_UP; htim2.Init.Period = 4294967295; htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; if (HAL_TIM_IC_Init(&htim2) != HAL_OK) { _Error_Handler(__FILE__, __LINE__); } sMasterConfig.MasterOutputTrigger
-
Thread
Taschenrechner am Arbeitsplatz
-Solar II + klein und kompakt + Hauptnutzen für kleinste Berechnungen, Addition, Subtraction, Division, Multiplikation, Kehrwert, Logarithmus etc. + ENG Taste - leider nur Solar. Im Labor oder bei schlechtem Tageslicht unvorteilhaft - keine Umrechnung für Binär und Hex Letztens habe ich noch
-
Thread
Getrigerte DDFS
Triggersignalen wird der Takt mittels counter gezählt. des Ergebnis fließt als Divisor in eine Division ein. Hierbei gillt der Wertebereich der genutzten Sinustabelle als Dividend. Das ergebnis dient mir als Schrittweite für die Sinustabelle. Funktioniert einwandfrei. Die Berechnunsdauer der Division
-
Artikel
Entscheidung Mikrocontroller
anderen Controllern in Software nachgebildet werden muss. Beispiele sind z. B. Multiplikation und Division. Wer in einer Hochsprache programmiert, merkt davon nicht viel, da es dort die Befehle sowieso zur Verfügung stehen, aber sie brauchen auf einem Controller ohne Hardwareunterstützung eben deutlich