Geekly articles weekly

DevBoy: einen Signalgenerator machen

Hallo Freunde!

In früheren Artikeln habe ich über mein Projekt und seinen Softwareteil gesprochen . In diesem Artikel werde ich Ihnen erklären, wie Sie einen einfachen Signalgenerator für 4 Kanäle erstellen - zwei analoge Kanäle und zwei PWM-Kanäle.



Analoge Kanäle


Der Mikrocontroller STM32F415RG enthält einen 12-Bit- DAC -Wandler (Digital-Analog) in zwei unabhängige Kanäle, mit dem unterschiedliche Signale erzeugt werden können. Sie können Daten direkt in die Register des Konverters laden, dies ist jedoch nicht sehr geeignet, um Signale zu erzeugen. Die beste Lösung besteht darin, ein Array zu verwenden, in das eine Signalwelle erzeugt wird, und dann den DAC mit einem Trigger vom Timer und DMA auszuführen. Durch Ändern der Frequenz des Timers können Sie die Frequenz des erzeugten Signals ändern.

Zu den „ klassischen “ Wellenformen gehören: Sinus, Mäander, Dreieck und Sägezahn.

Bild

Die Funktion zum Erzeugen dieser Wellen im Puffer ist wie folgt
// ***************************************************************************** // *** GenerateWave ******************************************************** // ***************************************************************************** Result Application::GenerateWave(uint16_t* dac_data, uint32_t dac_data_cnt, uint8_t duty, WaveformType waveform) { Result result; uint32_t max_val = (DAC_MAX_VAL * duty) / 100U; uint32_t shift = (DAC_MAX_VAL - max_val) / 2U; switch(waveform) { case WAVEFORM_SINE: for(uint32_t i = 0U; i < dac_data_cnt; i++) { dac_data[i] = (uint16_t)((sin((2.0F * i * PI) / (dac_data_cnt + 1)) + 1.0F) * max_val) >> 1U; dac_data[i] += shift; } break; case WAVEFORM_TRIANGLE: for(uint32_t i = 0U; i < dac_data_cnt; i++) { if(i <= dac_data_cnt / 2U) { dac_data[i] = (max_val * i) / (dac_data_cnt / 2U); } else { dac_data[i] = (max_val * (dac_data_cnt - i)) / (dac_data_cnt / 2U); } dac_data[i] += shift; } break; case WAVEFORM_SAWTOOTH: for(uint32_t i = 0U; i < dac_data_cnt; i++) { dac_data[i] = (max_val * i) / (dac_data_cnt - 1U); dac_data[i] += shift; } break; case WAVEFORM_SQUARE: for(uint32_t i = 0U; i < dac_data_cnt; i++) { dac_data[i] = (i < dac_data_cnt / 2U) ? max_val : 0x000; dac_data[i] += shift; } break; default: result = Result::ERR_BAD_PARAMETER; break; } return result; }

In der Funktion müssen Sie einen Zeiger auf den Anfang des Arrays, die Größe des Arrays, den Maximalwert und die gewünschte Wellenform übergeben. Nach dem Aufruf wird das Array mit Samples für eine Welle der gewünschten Form gefüllt, und Sie können den Timer starten, um den neuen Wert regelmäßig in den DAC zu laden.

Der DAC in diesem Mikrocontroller hat eine Einschränkung: Die typische Einschwingzeit (die Zeit vom Laden eines neuen Werts in den DAC bis zum Erscheinen am Ausgang ) beträgt 3 ms. Aber nicht alles ist so einfach - diese Zeit ist maximal, d.h. Wechsel von Minimum zu Maximum und umgekehrt. Beim Versuch, den Mäander zurückzuziehen, sind diese verunreinigten Fronten sehr deutlich sichtbar:



Wenn eine Sinuswelle ausgegeben wird, ist die Verstopfung der Fronten aufgrund der Wellenform nicht mehr so ​​auffällig. Wenn jedoch die Frequenz erhöht wird, verwandelt sich das sinusförmige Signal in ein dreieckiges, und mit einer weiteren Erhöhung nimmt die Signalamplitude ab.

Erzeugung bei 1 kHz ( 90% Amplitude ):



Erzeugung bei 10 kHz ( 90% Amplitude ):



Erzeugung bei 100 kHz ( 90% Amplitude ):



Schritte sind bereits sichtbar, da neue Daten mit einer Frequenz von 4 MHz in den DAC geladen werden.

Außerdem ist die Hinterkante des Sägezahnsignals unübersichtlich und von unten erreicht das Signal nicht den Wert, auf den es sollte. Dies liegt daran, dass das Signal keine Zeit hat, den angegebenen niedrigen Pegel zu erreichen, und die Software neue Werte lädt

Erzeugung bei 200 kHz ( 90% Amplitude ):



Hier können Sie bereits sehen, wie sich alle Wellen in ein Dreieck verwandelt haben.

Digitale Kanäle


Mit digitalen Kanälen ist alles viel einfacher - in fast jedem Mikrocontroller gibt es Timer, mit denen Sie ein PWM-Signal an die Ausgänge des Mikrocontrollers ausgeben können. Verwenden Sie am besten einen 32-Bit-Timer. In diesem Fall müssen Sie den Timer-Pre-Timer nicht zählen. Laden Sie einfach die Periode in ein Register und laden Sie den erforderlichen Arbeitszyklus in ein anderes Register.

Benutzeroberfläche


Es wurde beschlossen, die Benutzeroberfläche in vier Rechtecke mit jeweils einem Bild des Ausgangssignals, der Frequenz und der Amplitude / des Arbeitszyklus zu organisieren. Für den aktuell ausgewählten Kanal werden die Textdaten in Weiß angezeigt, der Rest in Grau.



Es wurde beschlossen, die Encoder zu steuern: Der linke ist für die Frequenz und den aktuell ausgewählten Kanal verantwortlich ( ändert sich beim Drücken der Taste ), der rechte ist für die Amplitude / das Tastverhältnis und die Wellenform verantwortlich ( ändert sich beim Drücken der Taste ).

Darüber hinaus wird die Unterstützung für den Touchscreen implementiert. Wenn Sie auf einen inaktiven Kanal klicken, wird dieser aktiv. Wenn Sie auf einen aktiven Kanal klicken, ändert sich die Wellenform.

Natürlich wird DevCore verwendet, um all dies zu tun. Der Code zum Initialisieren der Benutzeroberfläche und zum Aktualisieren der Daten auf dem Bildschirm sieht folgendermaßen aus:

Struktur mit allen UI-Objekten
  // ************************************************************************* // *** Structure for describes all visual elements for the channel ***** // ************************************************************************* struct ChannelDescriptionType { // UI data UiButton box; Image img; String freq_str; String duty_str; char freq_str_data[64] = {0}; char duty_str_data[64] = {0}; // Generator data ... }; // Visual channel descriptions ChannelDescriptionType ch_dsc[CHANNEL_CNT];
Initialisierungscode der Benutzeroberfläche
  // Create and show UI int32_t half_scr_w = display_drv.GetScreenW() / 2; int32_t half_scr_h = display_drv.GetScreenH() / 2; for(uint32_t i = 0U; i < CHANNEL_CNT; i++) { // Generator data ... // UI data int32_t start_pos_x = half_scr_w * (i%2); int32_t start_pos_y = half_scr_h * (i/2); ch_dsc[i].box.SetParams(nullptr, start_pos_x, start_pos_y, half_scr_w, half_scr_h, true); ch_dsc[i].box.SetCallback(&Callback, this, nullptr, i); ch_dsc[i].freq_str.SetParams(ch_dsc[i].freq_str_data, start_pos_x + 4, start_pos_y + 64, COLOR_LIGHTGREY, String::FONT_8x12); ch_dsc[i].duty_str.SetParams(ch_dsc[i].duty_str_data, start_pos_x + 4, start_pos_y + 64 + 12, COLOR_LIGHTGREY, String::FONT_8x12); ch_dsc[i].img.SetImage(waveforms[ch_dsc[i].waveform]); ch_dsc[i].img.Move(start_pos_x + 4, start_pos_y + 4); ch_dsc[i].box.Show(1); ch_dsc[i].img.Show(2); ch_dsc[i].freq_str.Show(3); ch_dsc[i].duty_str.Show(3); }
Bildschirmaktualisierungscode
  for(uint32_t i = 0U; i < CHANNEL_CNT; i++) { ch_dsc[i].img.SetImage(waveforms[ch_dsc[i].waveform]); snprintf(ch_dsc[i].freq_str_data, NumberOf(ch_dsc[i].freq_str_data), "Freq: %7lu Hz", ch_dsc[i].frequency); if(IsAnalogChannel(i)) snprintf(ch_dsc[i].duty_str_data, NumberOf(ch_dsc[i].duty_str_data), "Ampl: %7d %%", ch_dsc[i].duty); else snprintf(ch_dsc[i].duty_str_data, NumberOf(ch_dsc[i].duty_str_data), "Duty: %7d %%", ch_dsc[i].duty); // Set gray color to all channels ch_dsc[i].freq_str.SetColor(COLOR_LIGHTGREY); ch_dsc[i].duty_str.SetColor(COLOR_LIGHTGREY); } // Set white color to selected channel ch_dsc[channel].freq_str.SetColor(COLOR_WHITE); ch_dsc[channel].duty_str.SetColor(COLOR_WHITE); // Update display display_drv.UpdateDisplay();

Eine interessante Implementierung des Schaltflächenklicks wird implementiert (es ist ein Rechteck, über das die verbleibenden Elemente gezeichnet werden ). Wenn Sie sich den Code angesehen haben, sollten Sie Folgendes bemerkt haben: ch_dsc [i] .box.SetCallback (& ​​Callback, this, nullptr, i); in einer Schleife aufgerufen. Dies ist die Aufgabe der Rückruffunktion, die beim Drücken der Taste aufgerufen wird. Folgendes wird an die Funktion übertragen: die Adresse der statischen Funktion der statischen Funktion der Klasse, der this-Zeiger und zwei Benutzerparameter, die an die Rückruffunktion übergeben werden - ein Zeiger ( in diesem Fall nicht verwendet - nullptr wird übergeben ) und eine Nummer ( Kanalnummer wird übertragen ).

Von der Universitätsbank aus erinnere ich mich an das Postulat: " Statische Funktionen haben keinen Zugriff auf nicht statische Klassenmitglieder ." Das ist also nicht wahr . Da eine statische Funktion Mitglied einer Klasse ist, hat sie Zugriff auf alle Mitglieder der Klasse, wenn sie einen Link / Zeiger auf diese Klasse hat. Schauen Sie sich nun die Rückruffunktion an:

 // ***************************************************************************** // *** Callback for the buttons ********************************************* // ***************************************************************************** void Application::Callback(void* ptr, void* param_ptr, uint32_t param) { Application& app = *((Application*)ptr); ChannelType channel = app.channel; if(channel == param) { // Second click - change wave type ... } else { app.channel = (ChannelType)param; } app.update = true; }

In der ersten Zeile dieser Funktion tritt " Magie " auf. Danach können Sie auf alle Mitglieder der Klasse zugreifen, auch auf private.

Diese Funktion wird übrigens in einer anderen Aufgabe ( Rendern des Bildschirms ) aufgerufen. Innerhalb dieser Funktion müssen Sie sich also um die Synchronisation kümmern. In diesem einfachen " paar Abende " -Projekt habe ich dies nicht getan, da es in diesem speziellen Fall nicht wesentlich ist.

Auf GitHub hochgeladener Generator-Quellcode: https://github.com/nickshl/WaveformGenerator
DevCore ist jetzt einem separaten Repository zugeordnet und als Submodul enthalten.

Nun, warum brauche ich einen Signalgenerator, der im nächsten ( oder einem der folgenden ) Artikel beschrieben wird.

Source: https://habr.com/ru/post/de425409/

More articles:


All Articles