[C++] Zeiger auf 2D-Arrays

Im Zuge meiner Implementierung der Software für mein Matrixlicht hatte ich vor eine Routine zu schreiben, die es mir erlaubt von der ID des Musters, welches per DIP-Schalter ausgewählt werden kann, automatisiert auf das zugehörige 2D-Array zu schließen.

Nach einiger Recherche kam ich auf diesen Code:

int pattern0[X][Y] = {...};

/* N: Anzahl der Elemente im Pointer-Array */
int (*pattern_collection[N])[X] = {pattern0,...};

/* A: Index des Elements aus dem Pointer-Array */
int *p_selected_pattern = reinterpret_cast<int*>(*(pattern_collection + A) + X);

/* Prints pattern0[1][1] if Y is set to 0 and X to 0 */
std::cout << *(p_selected_pattern + Y) << std::endl;

EDIT: Es gab einige Fehler im Code, diese wurden berichtigt.

Integralrechnung: Linearität Teil 1b

Im letzten Mathematik-Artikel habe ich geschrieben, dass man anhand eines praktischen Beispiels sehen kann, dass die Regel \int \! (f(x) + g(x)) \, \mathrm{d}x = \int \! f(x) \, \mathrm{d}x + \int \! g(x) \, \mathrm{d}x gilt.

Dies möchte ich etwas verallgemeinern und anhand der Funktionen f(x) = a_1 \cdot x + b_1 und g(x) = a_2 \cdot x + b_2 zeigen. Dies ist kein Beweis! Diese Rechnung soll nur die Zusammenhänge (bei Polynomen 1. Grades zeigen).

\int \! ((a_1 \cdot x + b_1) +(a_2 \cdot x + b_2)) \, \mathrm{d}x = \int \! (a_1 \cdot x + b_1) \, \mathrm{d}x + \int \! (a_2 \cdot x + b_2) \, \mathrm{d}x

\Leftrightarrow \int \! (a_1 \cdot x + a_2 \cdot x + b_1 + b_2) \, \mathrm{d}x = \int \! (a_1 \cdot x + b_1) \, \mathrm{d}x + \int \! (a_2 \cdot x + b_2) \, \mathrm{d}x

\Leftrightarrow \int \! (x \cdot (a_1 + a_2)+ b_1 + b_2) \, \mathrm{d}x = \int \! (a_1 \cdot x + b_1) \, \mathrm{d}x + \int \! (a_2 \cdot x + b_2) \, \mathrm{d}x

\Leftrightarrow (\frac{1}{2}x^2 \cdot (a_1 + a_2)+ b_1 \cdot x + b_2 \cdot x) + c_3 = (\frac{1}{2} \cdot a_1 \cdot x^2 + b_1 \cdot x + c_1) + (\frac{1}{2} \cdot a_2 \cdot x^2 + b_2 \cdot x + c_2)

\Leftrightarrow \frac{1}{2} \cdot (a_1 + a_2) \cdot x^2 + (b_1+ b_2) \cdot x  + c_3 = (\frac{1}{2} \cdot a_1 \cdot x^2 + \frac{1}{2} \cdot a_2 \cdot x^2  + b_1 \cdot x + b_2 \cdot x +  c_1 + c_2)

\Leftrightarrow \frac{1}{2} \cdot (a_1 + a_2) \cdot x^2 + (b_1+ b_2) \cdot x  + c_3 = \frac{1}{2} \cdot (a_1 + a_2) \cdot x^2 + (b_1 + b_2) \cdot x +  c_1 + c_2

\Rightarrow c_3 = c_1 + c_2

Ich hoffe, ich konnte diesen Zusammenhang noch ein wenig stärker verdeutlichen. Der Zusammenhang c_3 = c_1 + c_2 gilt für alle Integrale, da sich die Funktionsterme der Stammfunktion restlos auslöschen (Durch Subtraktion der Stammfunktionen ohne c_n). Es bleiben lediglich die Integrationskonstanten übrig.

C++11 with eclipse-cdt

Das war der ausschlaggebende Artikel, der mir half C++ 11 mit Eclipse Neon zu programmieren.

diGital eFFects

Many modern programming language has cool language features like lambdas and automatic memory management. You can also use some of these modern and cool features in C++11. But writing C++11 in eclipse is not straight forward, as you need to configure for it. I will explain the configuration requirement for eclipse-cdt so that you can writing C++11 code in it.

  • I will be using eclipse neon for this demonstration but it should work with other version of cdt as long as the compiler has C++11 support for it.
  • I will only consider GNU-C++ compiler but it should work with other compilers (give it has support and you know the flags)
  • I am using linux (ubuntu) as platform. So, to use threading, I need pthread library. You may or may not need it based on your platform.

Let us first consider a simple C++11 code in eclipse.

Fire up your eclipse…

Ursprünglichen Post anzeigen 415 weitere Wörter

Integralrechnung: Linearität Teil 1a

Die Gleichung \int_a^b \! (f(x) + g(x)) \, \mathrm{d}x = \int_a^b \! f(x)  \, \mathrm{d}x + \int_a^b \! g(x) \, \mathrm{d}x  beschreibt das Integral der Summe zweier Funktionen als die Summe der Integrale dieser einzelnen Funktionen.

Auf Deutsch heißt das: Die Fläche unter dem einen Graphen addiert sich auf die Fläche des anderen Graphen.

Das Szenario: f(x) = \frac{1}{2}x+1; g(x) = 3x+2, \mathrm{mit} x \in \mathbb{R}

Plot (2)

Szenario: f(x), g(x), f(x)+g(x)

Als erstes berechne ich die Stammfunktionen von f(x) und g(x):

\int \! f(x) \, \mathrm{d}x = \frac{1}{4}x^2 +x +c_1
\int \! g(x) \, \mathrm{d}x = \frac{3}{2}x^2 +2x +c_2

Nun addiere ich die Stammfunktionen:

(\frac{1}{4}x^2 +x +c_1) + (\frac{3}{2}x^2 +2x +c_2)
= \frac{1}{4}x^2 + \frac{6}{4}x^2  + 3x + c_1 + c_2
= \frac{7}{4}x^2 + 3x + c_1 + c_2

Der eben berechnete Term ist die Summe der Integrale der einzelnen Funktionen.

Jetzt berechne ich noch das Integral der Summe beider Funktionen:

f(x) + g(x) = (\frac{1}{2}x+1) + (3x+2)
= \frac{1}{2}x+\frac{6}{2}x+3
= \frac{7}{2}x+3

=  \int \! (\frac{7}{2}x+3) \, \mathrm{d}x = \frac{7}{4}x^2+3x +c_3

Man sieht:

\int_a^b \! (f(x) + g(x)) \, \mathrm{d}x = \int_a^b \! f(x)  \, \mathrm{d}x + \int_a^b \! g(x) \, \mathrm{d}x 
\Leftrightarrow \frac{7}{4}x^2 + 3x + c_3 = \frac{7}{4}x^2 + 3x + c_1 + c_2

Berechnet man jetzt die bestimmten Integrale für das gewählte Intervall x \in [1,2]:

\left. F(x) \right|_1^2 = \frac{7}{4}
\left. G(x) \right|_1^2 = \frac{13}{2}
\left. FG(x) \right|_1^2 = \frac{33}{4}

Kann man auch hier sehen:

\left. F(x) \right|_1^2 + \left. G(x) \right|_1^2 = \left. FG(x) \right|_1^2
\Leftrightarrow  \frac{7}{4} +  \frac{13}{2} =  \frac{7}{4} +  \frac{26}{4} \textbf{=}  \frac{33}{4}
\frac{33}{4} = \frac{33}{4}

LM8560: Nachttischwecker aufgeschraubt

Ich besitze einen Nachttischwecker der schon viele Jahre alt ist, noch von meinem Vater kommt. Ich habe vor kurzem das Batteriefach bestückt, und wollte sehen, welche Auswirkungen das hat. Das Batteriefach war für Uhr, soviel stand dran.

Erwartet habe ich, dass die Batterie die Uhr am Leben hält, wenn es einen Stromausfall oder sonstiges gibt. Ja, das ist auch der Fall, allerdings nur beschränkt. Und warum das so ist, erkläre ich hier:

Ich habe das Radio aufgemacht, um zu schauen, ob vielleicht ein Kondensator kaputt ist, weil ich doch große Zeitdifferenzen festgestellt habe.
Es hat sich herausgestellt, dass der gesamte Wecker in einem Chip steckt, vom eingebauten Radio mal abgesehen.
Der Chip ist der LM8560 – ein Alarm-Uhr-Kombichip. Im Datenblatt dazu fand ich auch eine Bedienungsanleitung für diesen alten Radiowecker, und habe Funktionen entdeckt, die ich vorher gar nicht kannte.

Nach genauem Nachlesen fand ich dann heraus, dass die Batterie nur dafür da ist, um Schwankungen der Frequenz auszugleichen und kurze Stromausfälle von ein paar Minuten zu überbrücken. Die Uhr erwartet, je nach Konfiguration, eine Frequenz von 50 oder 60Hz. Diese wird der von 230V/50Hz Wechselspannung bezogen. In Deutschland schwankt die Frequenz in der Regel um 49.9Hz und 50.1Hz, welche genau genug ist, damit die Uhr ohne weiteres bis zur Zeitumstellung um ein bis zwei Minuten nach einmaligem Einstellen exakt läuft.
Zusätzlich zu der Info habe ich auch heraus gefunden, wie die Sleep-Funktion funktioniert, und wie man sich die Betriebszeit in Sekunden anzeigen kann.

INT zu BCD Algorithmus

In der Ausbildung kamen wir an einen Punkt, wo wir einen Zahlenwert in die BCD-Schreibweise überführen mussten. Bevor ich erfahren habe, dass die SPS-Software einen vorgefertigten Baustein hat, habe ich mir selber einen Algorithmus ausgedacht.

Der Algorithmus für Zahlen von 0-99 ist wie folgt aufgebaut:

\text{I} = \text{int}(\frac{x}{10})

\text{II} = x - (\text{I} \cdot 10)

\text{III} = (\text{I} << 4)

\text{IV} = \text{II} + \text{III}

Als Rust-Programm:

fn int_to_bcd(x: i32) -> i32 {
    let tenths: i32;
    tenths = (x / 10) as i32;
    let ones: i32;
    ones = x - (tenths * 10);
    let shifted_tenths: i32;
    shifted_tenths = tenths << 4;
    shifted_tenths + ones
}

Als Funktionsblockdiagramm:

screenshot_20170111_180821