-
Thread
Quelle für bezahlbare Hochtemperatur-Flachkabel?
F2807S-10-050-55 3601/10-100 von 3M: http://www.mouser.de/ProductDetail/3M-Electronic-Solutions-Division/3601-10-100/?qs=yiCaORDwWV6MhQqF6e5d6g%3D%3D
-
Thread
Deterministischer Pseudozufall
könntest du dir mal XTEA anschauen, das ist eine sehr kompakte Chiffre mit 64 Bit Blocklänge die ohne Division oder Multiplikation auskommt. Allerdings muss die Verschlüsselung mehrere Zyklen durchlaufen, damit die Ausgabe genügend zufällig aussieht. Der empfohlene Wert (für Verschlüsselung) sind 32 Iterationen
-
Thread
drehendes Solarpanel
können. Einfachst sind Sachen wie Addition, Subtraktion. Einfach ist die Multiplikation und Division. Die meisten können auch noch Zinsrechnung, die Grundlagen(!) der Algebra und Geometrie, Bruchzahlen und Dezimalbrüche - also immer noch recht einfach - aber schon das ist nicht mehr als "Einfachst
-
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
sprechende Namen
tatsächlich ein Problem. Viele Kommentare im Code sind dort nämlich deutsch - das ist das Erbe von StarDivision (StarOffice).
-
Thread
Mikrocontroller: Codeoptimierung
einfach dieses [c] Tick * (CYCLE / 1000.0) [/c] schreibst. Der Compiler führt dann die Division bereits zur Compile-Zeit aus.
-
Thread
STM32 SPI im IRQ
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); TIM_TimeBase_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBase_InitStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBase_InitStructure.TIM_Period = 100; TIM_TimeBase_InitStructure.TIM_Prescaler = 6400; TIM_TimeBaseInit
-
Thread
Cortex Faults: Was macht man im Handler?
Ergebnissen am Ende führen (NaN oder inf). Daher halte ich auch das für wenig sinnvoll und würde bei Division durch Null immer anhalten. Andersherum gefragt: Welcher Algorithmus funktioniert noch richtig, der eine Division durch Null durchführt und Unendlich als Ergebnis erhält? Ist ein Algorithmus, der
Fällen kommen Divisionen durch 0 oder extrem kleine Werte aufgrund äußerer Umstände vor, als da wären menschliche Fehler bei Kalibrierungen, Überläufe oder Fehler bei Datenübertragungen, Störungen bei Sensoren usw. Natürlich
-
Thread
STM32 TIM2-ETR: Pin belastet Quelle
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_Base_Init(&htim2) != HAL_OK) { Error_Handler(); } sClockSourceConfig.ClockSource
-
Thread
String zurücksetzen
verwechseln. - Off-by-one-Fehler. - Unbeabsichtiges Semikolon nach Schleifenkopf. - Ungewollte Integer-Division (double x = 1/2;).
-
Thread
Problem beim Rechnen mit AVR + großen Zahlen
[CODE] double intdb = 20*log10(0.04080641756); [/CODE] Es scheint also irgendwas bei der Division schief zu laufen. Nur was? So klappt es leider auch nicht: [CODE] double intdb = 20*log10(342309/8388607); [/CODE] Vielen Dank schon mal für Eure Mithilfe!! Gruß Matthias
> double temp = 342309/8388607; Die Division wird in int durchgeführt, entsprechend geht jeder Nachkommaanteil flöten. Probier mal double temp = 342309/8388607d;
-
Thread
CRC Berechnung Codewort
Thema CRC angesehen: http://www.mikrocontroller.net/articles/CRC Dort wird der Rest aus der Division von 111010011100100000:100110 berechnet. Dieser ist laut dem Artikel 100 (alles in Binärdarstellung). In C lässt sich der Rest einer Division ja wunderbar mit dem Modulo-Operator berechnen. Wenn ich
Dezimalzahlen entspricht 111010011100100000 = 239.392 und 100110 = 38 und tatsächlich ist das Ergebnis der Division von 239.392:38 = 6299 Rest 30. Und 30 entspricht der Binärzahl 11110 und nicht 100. Kann mir mal bitte Jemand sagen, warum der Modulo-Operator hier nicht funktioniert oder wo mein Fehler liegt?
-
Thread
AVR -> STM8/32. Was ist anders? Was zu beachten? Was benötigt? Gesperrt
Pointer-Operationen, Shifts um variable Bit-Zahlen, Stack-Zugriffe, je nach Modell auch Arithmetik (Division, Floating-Point)).
lassen, alle nase lang vor. Klar, man kann skalieren und dann mit int64 rechnen (viel Spaß bei Divisionen..), aber weitaus angenehmer als derartige Workarounds ist es eben, gleich in double zu rechnen. Aber da wir hier in einem Bastelforum sind: Denk mal an DDS-Berechnung für die diversen DDS von
-
Thread
Einheitenumrechnung
> Gilt für Potenzen auch. > > Ergo: m^-3 = 1/(m^3) Wie man von der Rechenregel für die Division durch einen Bruch auf die Rechenregel für Potenzen mit negativem Exponenten kommt, solltest du vielleicht etwas näher erläutern. Ich kann es jedenfalls nicht ganz nachvollziehen. > Arbeit =
-
Thread
Es gibt noch immer Entwickler-Jobs in Hochlohnländern. Wieso?
etliche Showstopper eingeschlichen, und damit meine ich nicht die vergleichsweise triviale Pentium-Division. Sondern echte Designfehler, wie beim K6 der ersten Generation. Und kaum hatte Intel eine schöne und wichtige neue Befehlssatzerweiterung rausgebracht (Haswell TSX), musste die auch sogleich wieder
-
Thread
STM32F4xxx - FPU - GCC Codegenerierung
@ 168 MHz bei > doppelter Genauigkeit. Das kann ich kaum glauben, zumindest nicht für die Division. Beweise?
168 MHz bei >> doppelter Genauigkeit. > > Das kann ich kaum glauben, zumindest nicht für die Division. Beweise? Hab grad keinen F4-Aufbau auf dem Tisch liegen, deswegen kann ich's Dir nicht rausmessen, aber wenn jemand grad Zeit hat: https://www.mikrocontroller.net/topic/261021
-
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
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
PWM Signal mit STM32
TIM_CounterMode_Up; timerInitStructure.TIM_Period = period; timerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; //timerInitStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM2, &timerInitStructure); TIM_Cmd(TIM2, ENABLE); } void InitializePWMChannel() { TIM_OCInitTypeDef
-
Thread
STM32: interne Pull-Ups für SPI
0; htim4.Init.CounterMode = TIM_COUNTERMODE_UP; htim4.Init.Period = 0; htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; sConfig.EncoderMode = TIM_ENCODERMODE_TI1; sConfig.IC1Polarity = TIM_ICPOLARITY_RISING; sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI; sConfig.IC1Prescaler
htim12.Init.CounterMode = TIM_COUNTERMODE_UP; htim12.Init.Period = 0; htim12.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; if (HAL_TIM_PWM_Init(&htim12) != HAL_OK) { Error_Handler(); } if (HAL_TIM_OnePulse_Init(&htim12, TIM_OPMODE_SINGLE) != HAL_OK) { Error_Handler(
-
Thread
Aktuelle FPGAs in QFP
dann aber keinen Support, wenn man nicht genau das gleiche Host OS fährt. Nunja. Die Software-Division sollte vielleicht auch mal zum Docker-Konzept wechseln, was Auslieferung von Tools angeht. > War vor allem lange Zeit ein Problem als JTAG-Downloadkabel nur über > einen Windriver basierten Treiber
-
Thread
Problem Timer1 überlauf
eines Vorteilers: Zeit = Quarz / Vorteiler / Timer Code ausführen benötigt Zeit, insbesondere Division und Float. Da Du keinerlei Angaben machst, kann man nur vermuten. Wenn der Timer alle 10µs überlaufen soll, wirst Du dazwischen kaum Berechnungen machen können. Du mußt die Zeit so lang wählen,
-
Thread
QTouch SAMD20E17
system_gclk_gen_get_config_defaults(&gclk_conf); gclk_conf.source_clock = SYSTEM_CLOCK_SOURCE_OSC48M; gclk_conf.division_factor = 1; //Pre-scaler gclk_conf.run_in_standby = false; gclk_conf.output_enable = false; system_gclk_gen_set_config(GCLK_GENERATOR_0, &gclk_conf); system_gclk_gen_enable(GCLK_GENERATOR
system_gclk_gen_get_config_defaults(&gclk_conf); gclk_conf.source_clock = SYSTEM_CLOCK_SOURCE_OSC48M; gclk_conf.division_factor = 12; //Pre-scaler gclk_conf.run_in_standby = true; gclk_conf.output_enable = false; system_gclk_gen_set_config(GCLK_GENERATOR_1, &gclk_conf); system_gclk_gen_enable(GCLK_GENERATOR
-
Thread
C: Werte aus Array mit 3.3 multiplizieren?
Fließkommazahl umwandeln müssen. Eventuell reicht aber auch Multiplikation mit 33 und anschließende Division durch 10. Beachte aber mögliche Überläufe und Rundungsfehler. > Dafür habe ich den Wert aus dem Array zunächst in einer extra Variable > "sp" gespeichert. [c] uint8_t buffer[2]; uint16
-
Thread
eigene pow - Funktion
Variable? Das wäre doch exp((a/20) * ln(10)) ln(10) ist eine Konstante, bleibt also nur die Division von a durch 20 und die Anwendung von exp(). Also brauchst Du nur eine Taylor-Approximation von exp().
-
Thread
Variabler Clockdivider in Verilog
Simulation funktioniert. Wenn ich es aber auf den FPGA spiele bekommt der Divider immer 0 als Divisionswert. Hat jemand eine Idee was ich da falsch mache?
-
Thread
Probleme mit Timer Prescaler und OC beim STM32F103
TIM_CounterMode_Up; TIM_TimeBase_InitStructure.TIM_Period = 1023; TIM_TimeBase_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseInit(TIM2, &TIM_TimeBase_InitStructure); //TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); TIM_OC_InitStructure.TIM_OCMode = TIM_OCMode_Toggle; TIM_OC_InitStructure.TIM_OCIdleState
-
Thread
STM32F103C Systemtakt Einstellung Hilfe
{/* PREDIV1 selected as PLL clock entry */ /* Get PREDIV1 clock source and division factor */ prediv1source = RCC->CFGR2 & RCC_CFGR2_PREDIV1SRC; prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1; if (prediv1source == 0) {
{/* PLL2 clock selected as PREDIV1 clock entry */ /* Get PREDIV2 division factor and PLL2 multiplication factor */ prediv2factor = ((RCC->CFGR2 & RCC_CFGR2_PREDIV2) >> 4) + 1; pll2mull = ((RCC->CFGR2 & RCC_CFGR2_PLL2MUL) >> 8 ) + 2; SystemCoreClock
-
Thread
STM32F4 PWM Problem
TIM_CounterMode_Up; TIM_TimeBaseStructure.TIM_Period = 4200 - 1; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); /* Channel 1, 2 and 3 Configuration in PWM mode */ TIM_OCInitStructure.TIM_OCMode
-
Thread
Digitalen Filter aus Matlab in µC umsetzen
Koeffizienten verdoppeln - Koeffizienten auf die am nächsten liegende Zweierpotenz runden, ebenso den Divisionsfaktor zur Dezimierung am Ende - Das ganze nochmal zur Überprüfung durch Matlab schicken - In C Implementieren, Compiler setzt Multiplikationen und Divisionen in Shift-Operationen um. Auf die Weise
>- In C Implementieren, Compiler setzt Multiplikationen und Divisionen in >Shift-Operationen um. Wenn 2er Potenzen. Man kann auch skalieren und nur mit integer werten rechnen, find das paper allerdings nciht mehr. Gruß J
-
Thread
Befehl in C (Bitmanipulation)
"adr" wird um 8 Bits nach rechts geshifted, was gleichbedeutend ist mit einer Division durch 256. Das Resultat wird mit der Konstanten 1 verANDet. Und das Resultat davon wiederum wird nach "unsigned char" gecastet und dann etwas namens "DEECON" zugewiesen. Aufgrund der verANDung
-
Thread
Division eines Floatwertes mit sich selbst ergibt nicht 1
implizit in "int" gecasted, so dass dort der Wert 33381 steht. Das Gleiche nach der anschließenden Division, zunächst ergibt sich hier (33381 / 130.9 = 254.9). Dieses Ergebnis wird aber wiederum implizit in Integer gecasted, daher ergibt sich 254.
ne das steht in dem Betreff: Division eines Floatwertes mit sich selbst ergibt nicht 1
-
Thread
Programmgeschwindigkeit Arduino
paar hundert ms aktualisieren, siehe [[Interrupt]]. 4.) Aufwändige mathematische Operationen wie Division und Wurzel möglichst vermeiden. Eine Division kann man durch rechtschieben ersetzen, wenn man den Divisor als 2er Potenz auslegt, also 2, 4, 8, 16 etc. Die Wurzel kann man über eine Tabelle "ausrechnen
void ADC_Init(void) { ADMUX =((1<<REFS0) | (1<<REFS1)); // ref 2,5V //Free Running Mode, Division Factor 128, Interrupt on ADCSRA=(1<<ADEN)|(1<<ADSC)|(1<<ADATE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)|(1<<ADIE); } ISR (ADC_vect) { ANALOG_OFF; //ADC OFF static unsigned char start=0; if
-
Thread
Horizon EDA [War: Neues, halbfertiges Elektronik-CAD-Programm]
sich jemand beim Umrechenen mm vs. inch und retour vertan hat. Sei es das er Multiplikation mit Division verwechselt hat, oder aber einen falschen Faktor verwendet hat, oder als Längeneinheit preußische Lachter verwendet hat. Mit freundlichem Gruß: Bernd wiebus alias dl1eic http://www.l02.de
-
Thread
Eingabe und Berechnung mit Modulo
noch ein wichtiger Zusammenhang. "+" Addition, "-" Subtraktion, "*" Multiplikation und "/" Division sind bekannt. "%" Modulo auch, aber wie ist der Modulo über die anderen Rechenoperatoren definierbar ?
ziffernweise von Hinten nach Vorne: nextchar2: Zeichen=Zahl%10 (Modulo) Zahl=Zahl/10 (Integer-Division) Ausgabe Zeichen (als ASCII +$30 ... oder auch "0") Ist Zahl>0 ? goto nextchar2 MfG
-
Thread
Stm32F4 Timer
Hab ich: TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV4; //42MHz 100000 passen ja nicht in den vorteiler. mein Problem ist wie ich das berechne das ich auf 10Sekunden komme komme, das hatte ich gefragt.
ich dann den Timerclock auf 42Mhz habe das war falsch. TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV4 Aber wozu ist diese Einstellung daran hapere ich noch . könnte mir das jemand kurz erklãren. danke
-
Thread
STM32F1 Brushless Motor Steuerung
TIM_TimeBaseStructure.TIM_Period = TimerPeriod; //2800 - 1; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); TIM_UpdateRequestConfig(TIM1, TIM_UpdateSource_Global); TIM_UpdateDisableConfig
TIM_TimeBaseStructure.TIM_Period = TimerPeriod; //2800 - 1; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); /* Channel 1, 2 and 3 Configuration in PWM mode */ TIM_OCInitStructure.TIM_OCMode