-
Thread
CNC Servo-Ansteuerung für Kreisbewegung: Algorithmus
eigentlich recht problemlos auf einem kleinen 8-Bitter mit ordentlicher Auflösung berechnen. Ohne Division oder trigonometrische Funktionen. Der Algorithmus dazu heißt "digital differential Analyzer". Taugt für lineare und Kreisinterpolation. Tatsächlich sind die I- und J-Parameter der Kreisinterpolation
-
Thread
Effizienter Weg gesucht um zu prüfen, ob Variable im Bereich liegt
Bzgl. der Multiplikationslösung: 900/16 = a x / a = Bereich. -> Hier ganzahl division mit Rest. Aber ob das schneller ist, als die 16 Grenzen zu berechnen, und dann zu vergleichen, keine Ahnung.
dann so aus: [math] r = e \cdot \frac{2^n}{d} \cdot \frac{1}{2^n}[/math] Das 1/2^n ist eine Division durch eine Zweierpotenz und damit in Hardware nur ein "Ignorieren" der unteren Bits, also nur ein Umverdrahten. Bleibt also leztlich wieder nur die Aufgabe den mittleren Term 2^n/d zu optimieren
-
Thread
Fliesskomma Multiplikation möglichst in einem Takt ;)
sinnvoller mit 10000 zu skalieren damit die Faktoren nicht > verfälscht werden? Nein, eine Division durch 10000 macht die Sache im Vergleich zu Zweierpotenzen nicht wirklich schneller. Und die ganzen Nachkommastellen fallen bei der Ausgabe sowieso unter den Tisch. Lernt man soetwas heutzutage
Die Division mit einer Zweierpotenz ist wesentlich schneller und einfacher als mit einer Zehnerpotenz.
-
Thread
C/C++ - RT fähige Implementierung von localtime/gmtime
das in einer halben Stunde selber schreiben. Der einfachste Algorithmus trennt Datum von Uhrzeit (Division) und zählt dann das Datum jahrweise, dann monatsweise hoch. Grob formuliert ist das ungefähr wie folgt: int schaltjahr(int jahr) { if(jahr%4!=0) return 0; return 1; //ggf weitere Regeln
-
Thread
Kontaklose Chipkarten????
und so was zum Karte einstecken brauch ich nich, da kann ich auch meinem Schlüssel rausholen. Division
@Division. Du weißt auch nicht was de willst oder ? Dein Erster Post: <<<<<<<<<<<<< Hat damit schonmal jemand was gemacht? Ich denke ihr wisst wovon ich Spreche. Diese Chipkarten die man immer
-
Thread
Frage zu Parametern von Wärmeleitpaste
RellDocuments/SYS_10/accessories_64-68.pdf Dort wird zwar die Länge in Zoll (in) angegeben, aber Division und Multiplikation soll ja schon erfunden sein.
-
Thread
STM32 HAL U(S)ART Problem
; htim3.Init.CounterMode = TIM_COUNTERMODE_UP; htim3.Init.Period = 50; htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; if (HAL_TIM_Base_Init(&htim3) != HAL_OK) { Error_Handler(); } sClockSourceConfig.ClockSource
-
Thread
ASM zu C (Taschenrechner) IV
inkl. des Checksumbytes * addieren. Dann durch 256 dividieren. Der Rest dieser * Division (Modulo in manchen Programmietsprachen) * muss 0x3A sein (aus GTRprotokoll.pdf) * * Addieren der ersten 49 Bytes s.o. * Division durch 256 implizit durch Typ unsigned
funktioniert, brauche ich unsigned char (d.h. 8-Bit vorzeichenlose) Variablen. Dadurch spare ich die Division durch 256. > Die Stelle müsstest du mir nochmal erklären: > > Checksumme0 = 0x3a; > Checksumme0 -= Summe0; > Transmit0(Checksumme0); Die "Formel" kannst du leicht ableiten
-
Thread
Dividieren durch Schiften Gesperrt
Warum nimmst Du nicht einfach den Divisionsoperator? Compiler sind heutzutage durchaus in der Lage, zu erkennen, dass die Division gegebenenfalls durch Schiebeoperationen ersetzt werden kann? Vorteil: Es funktioniert. Gruß Marcus http://www.doulos.com
die auch von Divisions-Einheiten in den Prozessoren, die sowas haben, implementiert. Der Compiler müßte dann für eine Division umständlich die Rundung gegen 0 kaputtmachen. > Ist der rechte Operand negativ, ist das Ergebnis
-
Thread
Register reservieren in avr-gcc
übersetzter Code in meinem Programm landen könnte? Ja, die Libraries des Compilers. Wenn du z.B. den Divisions- oder Modulo-Operator verwendest, landen dafür Funktionen aus diesen Libraries in deinem Code (außer natürlich es lässt sich zu was anderem optimieren, wie Shiften). Oder auch (noch weniger offensichtlich
-
Thread
Compiler ausrechnen von Konstanten geht schief
> test = test/SoftwarePrescaler ; Was steht in Test vor der Division?
F_CPU*256)/8000000UL test = test/SoftwarePrescaler ;[/c]Dies bedeutet eben NICHT, dass die eine Division vorab ausgerechnet, und dann das Ergebnis für SoftwarePrescaler in die zweite Division eingesetzt wird. Das Resultat dieser beiden Zeilen ist, dass der Compiler folgendes vorgesetzt bekommt: [c]test
-
Thread
messen einer Periodendauer
aktuellen abgezogen. Die Differenz zu dem Wert im 100 ms-Register addieren und das ganze mit einer Division durch 32 in Millisekunden umrechnen. Es ist darauf zu achten, dass für die Differenzbildung eine vorzeichenbehaftete Variable verwendet wird, da die Differenz ja auch negativ sein kann. -Fertig,
-
Thread
Schrittmotor als Drehgeber mit Dynamik, AVR
neu eingetroffenen Impulse bewertet. Dabei werden kleine Werte (< CNT_SCHWELLE) ignoriert. Die Division temp_cnt /= CNT_SCHWELLE; unterdrückt das 'Rauschen'. Liegen die absoluten Zähleränderungen von 'temp_cnt' im Bereich >= 1 bis < DYN_SCHWELLE, werden sie 1:1 zum Gesamtzähler 'stepp_count' addiert
werden kann. Zu kleine Zähleränderungen werden bei der zyklischen Auswertung durch die Division/CNT_SCHWELLE unterdrückt. Somit ist es möglich, den Motor ganz langsam zu drehen, ohne die Anzeige zu verändern. Bei schnellerer Drehung ist die Signalspannung ausreichend hoch und entsprechend auswertbar
-
Thread
maßloser Speicherverbrauch bei int-Division
Du machst eine 64-Bit Division, denn 3151872000 ist signed in C99 und passt wie bereits gesagt _nicht_ in 32 Bits. Die Signedness hat sich von C90 nach C99 geändert, in C90 war die Konstamte noch unsigned. Du kannst die Konstante als unsigned machen, z.B. 3151872000UL. Die passt dann in 32 Bits und es wird dann eine 32-Bit Division. Wenn du Code sparen willst dann lass das "volatile" weg. Dann rechnet der Compiler das aus und es /kein/ Division in deinem Code. Dass ist dann noch kürzer als von Elm Chan.
-
Thread
Festkommazahl Konsolenausgabe
Klar. 2^30 / 2^31 = 1073741824 / 2147483648 = 0 Rest 1073741824 Hier setzt die normale Division ein, wie man sie mal gelernt hat. 1073741824 * 10 / 2147483648 = 5 Rest 0 Rest * 10 / 2147483648 ... -> 0,5 Klar, 2^30 * 10 > 32 Bit. Dafür gibt es zwei Lösungsmöglichkeiten. 1.) 64 Bit
-
Thread
Frage/Problem mit Timer STM32F4Discovery
= 5-1; // 84 MHz Clock down to 1 MHz (adjust per your clock) TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); /* TIM IT enable */ TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE
-
Thread
Schnittpunkt bei Strecken gesucht
Folgendes sollte recht schnell zu berechnen sein, da keine Divisionen und erst recht keine Wurzeln oder Winkelfunktionen verwendet werden: [pre] def c_liegt_auf_ab(xa, ya, xb, yb, xc, yc): # C wird als auf A liegend angesehen, wenn der Abstand von C zu AB
-
Thread
ATXmega: Compare Werte nach Überlauf ohne Funktion
die Anzahl der Überläufe des Timers die ich abwarten muss, um dann die Compare Werte (Rest der Division durch 2^16) für die Timer zu setzten und freizugeben. Soweit so gut. Das Programm funktioniert solange richtig, bis der erste Compare Wert nach einem Überlauf statt finden soll. Danach werden die
-
Thread
MSP430 Launchpad, PWM sehr unpräzise
TACCR0 = 180; TACCR1 = 100; TACCTL1 = OUTMOD_4; // Start timer from ACLK , no division , Up mode , clear , no interrupts TACTL = TASSEL_1 | ID_0 | MC_1 | TACLR; for (;;) { __low_power_mode_3 (); } return 0; }[/c] Man auf dem Oszi auch brav eine PWM, jedoch
= 80; TACCTL1 = OUTMOD_7; TACCTL2 = OUTMOD_7; // Start timer from ACLK , no division , Up mode , clear , no interrupts TACTL = TASSEL_1 | ID_0 | MC_1 | TACLR; for (;;) { __low_power_mode_3 (); } return 0; }[/c]
-
Thread
C Polynom 6.O wird falsch umgesetzt
Exponent -1, 0, 1 oder 2, wird pow nicht aufgerufen, sondern stattdessen direkt eine Multiplikation, Division oder gar nichts ausgeführt. Bei allen anderen Potenzen wird pow aufgerufen, auch wenn sie Teil eines Polynoms sind und deswegen optimiert werden könnten. Vielleicht passiert das ja in GCC 5 ;-)
-
Thread
MSP430 F167 schläft ein
// 19200 baud bei 8 MHz erzeugen UMCTL1 = 0x5B; // Korrektur der division noetig UCTL1 &= ~SWRST; // USART1 freigeben // IE2 |= UTXIE1; // TX-interrupt anschalten // IFG2 &= ~UTXIFG1; // initales interrupt-flag loeschen
-
Thread
Problem mit sqrt
ist auch gar nicht der Punkt. Der Punkt ist, daß der bei der Gleitkommamultiplikation (dito Division) entstehende Fehler ausschließlich von der Mantisse abhängt. Der Exponent (vulgo: der Größenunterschied zwischen den Operanden) beeinflußt den Fehler *überhaupt* nicht. Zumindest so lange nicht,
Schwenke schrieb im Beitrag #3271133: > Der Punkt ist, daß der bei der Gleitkommamultiplikation (dito Division) > entstehende Fehler ausschließlich von der Mantisse abhängt. Der Exponent > (vulgo: der Größenunterschied zwischen den Operanden) beeinflußt den > Fehler überhaupt nicht. Hierzu vielleicht
-
Thread
Durchschnittlichen Watt-Verbrauch berechnen
Grundlegender Fehler ist die die Formulierung "1,2 kW in der Stunde". Das "in der" impliziert ja eine Division. (So wie "6km in der Stunde zurücklegen" = 6km/h) richtig kann nur sein: Eine Stunde lang 1,2kW -> Gesamtverbrauch 1,2 kWh oder: In einer Stunde 1,2 kWh -> bei konstanter Leistungsaufnahme
-
Thread
AVR Simulator Data or unknown opcode
passiert. Es spielt auch keine wirkliche Rolle. Du versuchst gerade (bildlich gesprochen) eine Division durch 0 zu legitimieren, indem du dich davor drückst rauszufinden, wie es dazu kommen konnte, dass der Divisor 0 ist. Wie können stundenlang darüber diskutieren, ob das Ergebnis der Division 5 oder
-
Thread
PWM STM32F405
TIM_CounterMode_Up; TIM_TimeBase_InitStructure.TIM_Period = 32000; TIM_TimeBase_InitStructure.TIM_ClockDivision = 0; TIM_TimeBase_InitStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM1, &TIM_TimeBase_InitStructure); TIM_UpdateRequestConfig(TIM1, TIM_UpdateSource_Global); TIM_UpdateDisableConfig
Multiplexerfunktion mit AF2/TIM4 // Timer Config TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInitStructure.TIM_Period = 0x3FF-1; // 10bit Auflösung der PWM TIM_TimeBaseInitStructure.TIM_Prescaler
-
Thread
Zu wenig ram?
// Bit ist gesetzt! } [/c] Viel Spaß, Frank P.S. Sei unbesorgt: Der gcc wird die Division durch 8 durch einen Schiebebefehl ersetzen. Ebenso wird der Modulo-Operator durch entsprechendes Maskieren erledigt. Die obigen Macros sind daher bei Optimierung mit -Os nicht sehr CPU-intensiv.
-
Thread
PIC 16F690 Signal einlesen und dann verlängern
verkleinert wird. -Wenn der Zähler durch x geteilt wird weiss ich nicht was mit dem Rest der Division geschieht.
Beitrag #2388558: > -Wenn der Zähler durch x geteilt wird weiss ich nicht was mit dem Rest > der Division geschieht. Wie soll ich das verstehen?
-
Thread
Intervall softwaremässig realisieren
Fehler vor? Kann ich einem uint16_t den Wert Zeitimpulsrate zuordnen? // die warnings sind: division by zero integer overflow // integer overflow find ich komisch, weil eine 16bit-Variable bis 65536-1 wertemässig gehen müsste? Zeitzaehler = 0; eigenes_Flag |= Zeitimpuls_Overflow_BIT
-
Thread
PIC C-Compiler Vergleich
Berechnungen mit den Werten durchführen. Also z.B. ADC-Wert umskalieren mit Cast auf uint32_t und Division. Einzelne Bytes aus uint32_t-Werten extrahieren (mit Shift und Bitmaske) und ins EEPROM schreiben. Und vielleicht kleinere Algorithmen wie Daten per binärer Suche aus einer Lookup-Tabelle holen oder
-
Thread
Atmel AVR: Vergangene Zeit messen
overflow_counter = 0; return 0xFFFF; } uint32_t system_clock = get_system_clock(); uint32_t division_factor = get_division_factor_of_TCC0(); double timer_resolution = (system_clock / division_factor) - 1; double time_per_clock_cycle = 1.0 / timer_resolution; double time_diff = end - start;
overflow_counter = 0; return 0xFFFF; } uint32_t system_clock = get_system_clock(); uint32_t division_factor = get_division_factor_of_TCC0(); double timer_resolution = (system_clock / division_factor) - 1; double time_per_clock_cycle = 1.0 / timer_resolution; double time_diff = end - start;
-
Thread
Berechnung von "(id - (id % width)) / width" beschleunigen?
outA = id % width + (id / width)* 2 * width; > = id % width + id * 2 ; bei ganzzahliger Division verschwinden die Nachkommastellen [code] outA = 3 % 2 + (3 / 2) * 2 * 2 = 1 + 4; outA = 3 % 2 + 3 * 2 = 1 + 6; [/code] zu deiner Frage mit dem Minus: [code] Ausgangsgleichung: int outA
achtung* Das verändert das Ergebnis. Maik M. schrieb im Beitrag #2711986: > bei ganzzahliger Division verschwinden die Nachkommastellen Es treten bei meiner Rechnung weniger Rundungsfehler auf - kann ja aber sein, dass das gewollt war Maxim schrieb im Beitrag #2712195: > Wobei 2*id und id
-
Thread
Seriell-Parallel-Wandlung mit VHDL
schaffen Synthese-Tools sehr wohl, so etwas umzusetzen. Im Test hatte ich aber lediglich eine 8 bit Division, der Rest des Quotienten fiel hinten weg. Optimal wird die Umsetzung vielleicht auch nicht sein, aber das steht auf einem anderen Blatt. > Hast du dir mal den RTL-Plan nach der Synthese angeschaut
normalerweise (bzw. hoffentlich) im Handbuch der Synthese-Software. Bei Altera synthetisiert er auch Divisionen, falls die Signale Integer sind. Daraus generiert er Dir dann eine LPM_DIVIDE-Megafunction.
-
Thread
Lauflicht mit Richtungsumkehr
zum Verändern der Geschwindigkeit ja nur das speed_reg hin hin und her. Also Multiplikation bzw. Division mit 2. Was passiert aber, wenn du jetzt öfter einen der beiden Taster drückst? z.B. 32 mal? :-)
-
Thread
Quadratwurzelberechnung optimieren
Schritten) und nciht auf die Quadratwurzel beschränkt, aber hier zu aufwendig. Riesiger Minuspunkt: die Division.
-> aber um das Prinzip zu verstehen.. sollte in C konvertierbar sein. Der Algo benötigt genau 1 Division.
-
Thread
CLKPR portenamen
can be divided by setting the “CLKPR – Clock Prescale Register” - ATmega8: No internal clock division is used.
verstanden das ich doch ein atmega 48 kaufen sollt. Oldi schriebe "- ATmega8: No internal clock division is used." Danneger schrieb "Der alte ATmega8 kann nur per Fusebits auf 4 verschiedene RC-Oszillatorwerte gesetzt werden." Peter II schrib "wenn man eine spezielle Frequenz braucht kann man einen
-
Thread
bestimmung der komplexe Impedanz
(also das mit dem "e" hoch "j*phi" ) verwenden. Diese Form ist lediglich für Multiplikation und Division zweier komplexer Größen gut geeignet. Für die Addition/Subtraktion verwendest Du lieber die arithmetische Darstellung komplexer Größen (also x = a + jb) Wie man die eine in die andere Form überführt
-
Thread
AVR WGM Modus 11
Wenn ICR1 mit einbezogen wird, dann 1x 16 Bit-Register ICR1 setzen (nicht gepuffert!) 1x 16 Bit Division mit 2 (ok einfach, aber doch "Aufwand") 1x 16 Bit-Register OCR1A setzen für 1:1 1x Interrupt Routine (Compare Match A) 1x Vergleich um entweder Frequenz zu ändern oder Schritt zu zählen 1x Register
-
Thread
Arithmetischen Mittelwert bestimmen
Chris2k schrieb im Beitrag #2814684: > Offensichtliches Problem ist die Division, da der Divisor nun nicht mehr > ein Vielfaches von 2**n ist. Erst mal die Division: http://www.lothar-miller.de/s9y/archives/29-Division-in-VHDL.html > Zur geforderten Genauigkeit: Sollte recht hoch sein Hast du da noch genauere Angaben? Eine Integer-Division liefert traditionell eine Ganzzahl und den Rest...
-
Thread
Cordic - Sinussignal
Pseudo-Multiplikation. Jetzt brauchst du eine Zahl X bloß nach A..D zu zerlegen. Das ist die Pseudo-Division. Sie besteht nur aus tentativen Subtraktionen, also so etwa: if X >= A then ( X-A, merke A für später) if X >= B then ( X-B, merke B für später) .. usw. Jetzt hast du Merker für A..D, womit
-
Thread
Zeitfunktion
Timer 2 ist nur ein 8-Bit Zähler, d.h. der Wert für OCR2A muss zwischen 0 und 255 liegen, und die Division F_CPU / PRESCALE / IRQS muss ohne Rest aufgehen. Wenn man mag, kann man das auch noch extra abtesten: [c] // Testet Plausibilität der Einstellungen für // F_CPU, PRESCALE und IRQS #if F_CPU
-
Thread
FPGA - Art der Last
@DivisionByZero (Gast) >Als Ein- Mannbude reduzier ich auch das ein- oder andere Mal den ein- >oder andere C. Aber ich weiss was ich tue (im Layout und im FPGA). Aber >wenn ein Layouter meint er könne
-
Thread
uint32_t zu int16_t?
ist aber "offiziell" kein free-running-counter (a la Systicker) mehr möglich. Zudem ist jede Division durch 2^n eine echte Division (statt shift), da die Zahl ja negativ sein *könnte*. Bitte versteh mich nicht falsch, ich finde diese signed/unsigned-Probleme als mit die schlimmsten bei C. Wie
-
Thread
Schnelle Hashfunktion gesucht
keinen Kopf an der Hashfunktion machen, sondern einfach ausprobieren, was dein Bolide so als Divisionsrest-Hash leistet. Dein "dicker Brocken" wird bestimmt ein paar HW-Divider mitbringen, die Du für den Rest deiner Anwendung wahrscheinlich sowieso nicht brauchst. Wär' ja schade, wenn die ungenutzt
-
Thread
Arduino Code
wird immer >= 0 sein. Warum dividiert man mit einem Rechtsshift und nutzt nicht sofort eine Division? Hat das mit Geschwindigkeit und Aufwand zu tun? Ich denke eine Division wird im Compiler viel aufwändiger sein, d.h langsamer und ressourcenfressend? Danke
im Beitrag #5403128: > Warum dividiert man mit einem Rechtsshift und nutzt nicht sofort eine > Division? Eine Shift-Operation ist mit einem Assemblerbefehl gemacht, echte Divisionen dauern je nach Prozessor deutlich länger. Allerdings kann man mit dieser Shift-Operationen nur durch Zweierpotenzen
-
Thread
ADXL193 - Beschleunigung auslesen
Nullen ausgeben. Hab nicht auf die Datentypen geachtet. Respekt, gut gesehen. @TO: deine Division funktioniert so nicht, du musst 5.0 oder 1024.0 schreiben. Oder du definierst diese beiden Werte direkt als float.
Ralf B. schrieb im Beitrag #5353286: > @TO: deine Division funktioniert so nicht, du musst 5.0 oder 1024.0 > schreiben. Oder du definierst diese beiden Werte direkt als float. Da der AVR keine FPU hat macht das aber u.U. das Timing endgültig zu Sau.
-
Thread
AVR stürzt ab nach PCINT
decoder.dcc.cnt_bit_pos++; //complete byte detected, now check the divisionbit if (decoder.dcc.cnt_bit_pos > 7) { decoder.dcc.cnt_bit_pos = NULL; decoder.dcc.state.systemBits.get_data_byte = FALSE; } } else //get the division
data) { if (decoder.dcc.dcc_cnted_time <= decoder.dcc.dcc_time_logic_one) //division bit is 1 ==> end transmission { //check parity, if good ==> you can work with data decoder.dcc.RX[decoder.dcc.cnt_byte_pos + 1] = decoder.dcc.RX[decoder.dcc.cnt_byte_pos -
-
Thread
Allpcb - die Erklärung
/wiki/Division_(Mathematik)#Ist_1/0_=_%E2%88%9E?
eine Division x/0 sinnvoll zu definieren.
-
Thread
Programmierübung C Zahlenbereiche Algorithmus
effiziente Lösung suchst und ohne aufwändige Rechenoperationen auskommen möchtest, vergiss das mit der Division durch 128 gleich wieder. Einem Mikrocontroller fällt es erheblich leichter, eine Zahl 7 mal zu schieben, auch wenn die wahren Verfechter von C jetzt natürlich argumentieren werden, dass es die Aufgabe
Lösung suchst und ohne aufwändige Rechenoperationen > auskommen möchtest, vergiss das mit der Division durch 128 gleich > wieder. Einem Mikrocontroller fällt es erheblich leichter, eine Zahl 7 > mal zu schieben, auch wenn die wahren Verfechter von C jetzt natürlich > argumentieren werden, dass es
-
Thread
Warum keine Division
Hallo an alle, bin neu bei FPGAs und wollte mal fragen, wieso man mit einem FPGA nur wenige Divisionen machen kann? WArum kommt er mit Multiplikationen besser klar und warum frisst eine Division soviele Ressourcen. Danke
Ich vermute mal es läuft wie bei einer normalen schriftlichen Division ab: 1000/11 1/11 => 0 10/11 => 0 100/11 => 1 Rest 1 10/11 => 0 Ergebnis: 1000/11=10 Das würde bedeuten, dass die Division vor allem aus Subtraktionen, bedingten Sprüngen und Bitverschieben
-
Thread
ADC LCD Darstellung und seine Problemchen
Das kommt durch die Division mit den double-Werten. Dein compiler rechnet die Konstanten ja vorher schon aus, im Grunde steht da also nichts anderes als y=x*0,09765625. Je nachdem wie genau du es brauchst, kannst du natürlich