<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Programmieren on Elektronik Dachbude</title><link>https://neu.fkainka.de/tag/programmieren/</link><description>Recent content in Programmieren on Elektronik Dachbude</description><generator>Hugo</generator><language>de-DE</language><lastBuildDate>Tue, 08 Jun 2021 09:32:32 +0200</lastBuildDate><atom:link href="https://neu.fkainka.de/tag/programmieren/index.xml" rel="self" type="application/rss+xml"/><item><title>Remote App - NetIO</title><link>https://neu.fkainka.de/remote-app-netio/</link><pubDate>Sun, 12 Apr 2015 00:16:49 +0200</pubDate><guid>https://neu.fkainka.de/remote-app-netio/</guid><description>&lt;p&gt;In diesem Artikel möchte ich eine einfache Möglichkeit vorstellen sich eine eigene Smartphone Fernbedienung zusammenzustellen. Ich möchte gleich am Anfang darauf hinweisen, dass die App leider nicht kostenlos ist. Für &lt;a href="https://play.google.com/store/apps/details?id=com.luvago.netio"&gt;Android Geräte&lt;/a&gt; kostet die App zu dem Zeitpunkt an dem der Artikel geschrieben wurde 4.99€. In &lt;a href="https://itunes.apple.com/app/netio/id464924297?mt=8"&gt;Apples App-Store&lt;/a&gt; muss man sogar 10,99€ bezahlen. Dennoch denke ich, dass der Preis bei dem Service nicht völlig ungerechtfertigt ist.&lt;/p&gt;
&lt;figure&gt;&lt;a href="https://neu.fkainka.de/images/2015/04/Test53.jpeg"&gt;&lt;img class="size-medium wp-image-684" src="https://neu.fkainka.de/images/2015/04/Test53.jpeg" alt="Die Webseite" width="300" height="281" /&gt;&lt;/a&gt;&lt;figcaption&gt;Die Webseite&lt;/figcaption&gt;&lt;/figure&gt;
&lt;p&gt;Das Designen einer eigenen Steueroberfläche geschieht einfach über die Internetseite:&lt;/p&gt;</description></item><item><title>Befehlsliste Bascom</title><link>https://neu.fkainka.de/befehlsliste-bascom/</link><pubDate>Fri, 06 Feb 2015 00:15:25 +0100</pubDate><guid>https://neu.fkainka.de/befehlsliste-bascom/</guid><description>&lt;p&gt;Oft ist es so, dass man plötzlich vergisst, wie man jetzt gerade in dieser Programmiersprache einen bestimmten Befehl formulieren muss. Deswegen steht hier eine Auflistung einiger wichtiger Bascom Befehle. Die Liste ist nicht vollständig aber wird von Zeit zu Zeit ergänzt.&lt;/p&gt;
&lt;p&gt;Benutzen Sie Stg+F um in der Seite nach etwas bestimmten zu suchen.&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Befehl&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Schreibweise&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Grundlegendes&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Variable Dimensionieren&lt;/td&gt;
&lt;td&gt;Dim vByte As Byte Dim Bt_recieve_text As String * 50&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Sub Deklarieren&lt;/td&gt;
&lt;td&gt;Declare Sub Begin()&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Wartezeiten&lt;/td&gt;
&lt;td&gt;Waitms 500 Wait 1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pin an Port = High&lt;/td&gt;
&lt;td&gt;Portb.1 = 1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Port = High&lt;/td&gt;
&lt;td&gt;Portb = 255&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Abfragen/Schleifen&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;If Abfragen&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;If&lt;/strong&gt; x=1 &lt;strong&gt;Then&lt;/strong&gt; &lt;strong&gt;Elseif&lt;/strong&gt; x=3 &lt;strong&gt;Then&lt;/strong&gt; &lt;strong&gt;Else&lt;/strong&gt; &lt;strong&gt;End If&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Select Case&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Select Case X&lt;/strong&gt; &lt;strong&gt;Case 0:&lt;/strong&gt; &lt;strong&gt;Case 1 To 9:&lt;/strong&gt; &lt;strong&gt;Case Else:&lt;/strong&gt; &lt;strong&gt;End Select&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Loop-Schleife&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Do&lt;/strong&gt; &lt;strong&gt;Loop Until&lt;/strong&gt; ok =1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;For-Schleife&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;For&lt;/strong&gt; I = 1 &lt;strong&gt;To&lt;/strong&gt; X &lt;strong&gt;Next I&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Kommunikation&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Com1 konfigurieren (Hardware, lesen und schreiben)&lt;/td&gt;
&lt;td&gt;Open &amp;ldquo;com1:&amp;rdquo; For Binary As #1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Serielle schreiben&lt;/td&gt;
&lt;td&gt;Print “Hallo”&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Spezielle Com konfigurieren  (schreiben, Ch #3, Pind.3)&lt;/td&gt;
&lt;td&gt;Open &amp;ldquo;comd.3:9600,8,n,1&amp;rdquo; For Output As #3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Serielle #3 schreiben&lt;/td&gt;
&lt;td&gt;Print #3 , “Hallo”&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Serielle Spezial-Prozedur&lt;/td&gt;
&lt;td&gt;Config Serialin = Buffered , Size = 50 , Bytematch = 10Serial0charmatch() Input Bt_recieve_text Noecho End Sub&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RC5 Konfigurieren (Portb.1)&lt;/td&gt;
&lt;td&gt;Portb.1 = 1                                              &amp;lsquo;Pulup Rc5 Config Rc5 = Pinb.1 Enable Interrupts&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RC5 Empfangen&lt;/td&gt;
&lt;td&gt;Getrc5(vrc5_address , Vrc5_com)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;I²C Konfigurieren&lt;/td&gt;
&lt;td&gt;Config Scl = Portc.5 Config Sda = Portc.4 I2cinit&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;I²C Senden&lt;/td&gt;
&lt;td&gt;I2cstart I2cwbyte 48 I2cstop&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;I²C Empfangen&lt;/td&gt;
&lt;td&gt;I2cstart I2cwbyte 35 I2crbyte Status , Ack                                     &amp;rsquo; I2crbyte Antenna , Nack I2cstop&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;</description></item><item><title>ESP8266 Arduino-Programm: setLED</title><link>https://neu.fkainka.de/esp8266-arduino-programm-setled/</link><pubDate>Mon, 02 Feb 2015 00:00:12 +0100</pubDate><guid>https://neu.fkainka.de/esp8266-arduino-programm-setled/</guid><description>&lt;p&gt;Dieses Programm ist mein erster Versuch, das &lt;a href="https://neu.fkainka.de/kurzinfos-zum-wlan-modul-esp8266-wi07c/" title="Kurzinfos zum WLAN-Modul ESP8266 (Wi07c)"&gt;WLAN Modul ESP8266&lt;/a&gt; über den Arduino Uno zu bändigen. Die Funktion des Programms erscheint recht simpel. Über &lt;strong&gt;Steuerbefehle&lt;/strong&gt; lässt sich di&lt;strong&gt;e L-Led (digital Pin13)&lt;/strong&gt;, die auf fast jedem Arduino Board vorhanden ist, &lt;strong&gt;Ein- und Ausschalten&lt;/strong&gt;. Es gibt zwei Varianten. Die erste Variante erlaubt &lt;strong&gt;über den Browser direkt durch Eingabe einer URL&lt;/strong&gt; die LED zu schalten. Die zweite Variante läuft &lt;strong&gt;über einen eigenen TCP-Client&lt;/strong&gt;, wie ich ihn z.B. in dem Artikel über &lt;a href="https://neu.fkainka.de/wlan-modul-esp8266-erste-schritte/" title="WLAN Modul ESP8266 – Erste Schritte"&gt;die ersten Schritte&lt;/a&gt; verwendet habe.&lt;/p&gt;</description></item><item><title>Zeiterfassung für Hobby &amp; Arbeit</title><link>https://neu.fkainka.de/zeiterfassung-fuer-hobby-arbeit/</link><pubDate>Mon, 07 Oct 2013 12:28:29 +0200</pubDate><guid>https://neu.fkainka.de/zeiterfassung-fuer-hobby-arbeit/</guid><description>&lt;p&gt;Das Problem: Selbstständige bekommen unterschiedliche Aufgaben auf den Tisch, die meist auch unterschiedlich entlohnt werden. Bei manchen Jobs wird man pro Stunde bezahlt, bei anderen gibt es einen Festpreis und wieder andere werden durch Gewinnbeteiligung vergütet. Dabei den Überblick zu &lt;img alt="Protokollant" loading="lazy" src="https://neu.fkainka.de/images/2015/01/Protokollant.jpeg"&gt;behalten ist schwer. Deswegen muss ein kleines Tool her, mit dem man ohne große Umstände immer protokollieren kann, woran man gerade arbeitet und das später die Auswertung erleichtert.&lt;/p&gt;
&lt;p&gt;Das daraus entstandene Programm ist zu Teilen sehr speziell. Man kann es aber auch beispielsweise dazu verwenden, die Zeit für bestimmte Hobby-Projekte zu protokollieren. Alternativ kann man sich auch einfach nur den Quelltext anschauen und Teile für eigene Projekte übernehmen. Programmiert habe ich dieses Tool in Vb.Net 2012. Die Express-Edition gibt es wieder kostenlos unter folgendem Link:&lt;a href="http://www.microsoft.com/visualstudio/deu/downloads"&gt;http://www.microsoft.com/visualstudio/deu/downloads&lt;/a&gt;&lt;/p&gt;</description></item><item><title>VB.Net: Beispielprogramme aus Grundlagen der Elektronik</title><link>https://neu.fkainka.de/vb-net-beispielprogramme-aus-grundlagen-der-elektronik/</link><pubDate>Thu, 31 Jan 2013 18:02:23 +0100</pubDate><guid>https://neu.fkainka.de/vb-net-beispielprogramme-aus-grundlagen-der-elektronik/</guid><description>&lt;p&gt;Am besten lernt man eine Programmiersprache immer anhand von Beispielen, die man anschließend selbst nachprogrammiert. Deswegen werde ich hier einige Programme veröffentlichen und teilweise auch erklären. Da sich einige Programme sehr ähneln, habe ich sie in Pakete zusammengepackt und erkläre nur das erste im Detail. Bei den restlichen werden nur die Besonderheiten kurz erläutert.&lt;/p&gt;
&lt;p&gt;&lt;a href="http://wp.fkainka.de/wp-content/uploads/2015/01/Simulationsprogramme-1.zip"&gt;Alle Simulationsprogramme als Exe-Dateien&lt;/a&gt;&lt;/p&gt;
&lt;h2 id="beispielset-i"&gt;Beispielset I&lt;/h2&gt;
&lt;p&gt;&lt;a href="http://wp.fkainka.de/vb-net-beispiel-npn-transistor/" title="NPN-Transistor – VB.Net Beispiel"&gt;NPN-Transistor&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="http://wp.fkainka.de/reihenschaltung-vb-net-beispiel/" title="Reihenschaltung -VB.Net Beispiel"&gt;Reihenschaltung&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="http://wp.fkainka.de/innenwiderstand-vb-net-beispiel/" title="Innenwiderstand – VB.Net Beispiel"&gt;Innenwiderstand&lt;/a&gt;&lt;/p&gt;</description></item><item><title>Widerstand - VB.Net Beispiel</title><link>https://neu.fkainka.de/widerstand-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 17:45:33 +0100</pubDate><guid>https://neu.fkainka.de/widerstand-vb-net-beispiel/</guid><description>&lt;p&gt;Widerstände spielen in jeder Schaltung eine große Rolle. Sie ermöglichen es uns u.A. den Strom genau zu steuern und verhindern somit das Durchbrennen von LEDs und anderen Bauteilen. In diesem Programm dreht es sich speziell um die Widerstände der meist benutzen E24-Reihe. In dieser Reihe gibt es eine diskrete Anzahl von Widerstandswerten. Diese Werte kann man anhand der Farbringe ablesen. Die ersten beiden Ringe stehen für eine zweistellige Zahl, die noch mit einer Zahl 10x multipliziert wird. Der letzte Ring (meist golden) gibt die Genauigkeit dieser Angaben an (in diesem Fall 5%). Angenommen Sie suchen also einen 100-Ohm-Widerstand, müssen Sie nach den Farbringen braun (1), schwarz(0), braun (= 101 = 10) Ausschau halten. Die genauen Farbcodes finden Sie u.A. hier: &lt;a href="http://www.elektronik-kompendium.de/sites/bau/1109051.htm"&gt;http://www.elektronik-kompendium.de/sites/bau/1109051.htm&lt;/a&gt;&lt;/p&gt;</description></item><item><title>Diodenkennlinie - VB.Net Beispiel</title><link>https://neu.fkainka.de/diodenkennlinie-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 17:43:41 +0100</pubDate><guid>https://neu.fkainka.de/diodenkennlinie-vb-net-beispiel/</guid><description>&lt;p&gt;Dioden zeichnen sich durch ihre logarithmischen Strom/Spannungs-Kennlinie aus. Welche Form die U/I-Kurve aber genau annimmt; hängt von der Art der Diode und ihrer Temperatur ab. Das hier vorgestellte Programm simuliert dabei die vier geläufigsten Dioden bei Temperaturen zwischen 0° und 150°C. Sie können sich das Strom/Spannungs-Verhältnis bei gewählten Parametern angucken, oder Sie lassen sich gleich den ganzen Verlauf, also die Diodenkennlinie im Bereich von 0 bis 20 mA aufzeigen.&lt;/p&gt;
&lt;p&gt;Das Programm besteht größtenteils aus bekannten Elementen. Dreh und Angelpunkt ist die folgende Diodengleichung, die den Strom in Abhänigkeit von der Spannung und der Temperatur berechnet. I_s ist vom jeweiligen Diodentyp abhängig:&lt;/p&gt;</description></item><item><title>Elektronen - VB.Net Beispiel</title><link>https://neu.fkainka.de/elektronen-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 17:41:41 +0100</pubDate><guid>https://neu.fkainka.de/elektronen-vb-net-beispiel/</guid><description>&lt;p&gt;Dieses Programm simuliert, wie sich Elektronen in einem Leiter verhalten. Man kann gut sehen, wie sich die Elektronen bei kleinem Strom nur langsam fortbewegen. Bei größeren Strömen werden die Elektronen aktiver und bewegen sich schneller durch den Leiter. Wenn kein Strom anliegt bewegen sich die Elektronen trotzdem ein wenig, aber ohne eine bestimmte Richtung zu bevorzugen. Dies nennt man Rauschen. Zu beachten ist, dass sich die Elektronen nie berühren, sondern immer leicht voneinander abstoßen.&lt;/p&gt;</description></item><item><title>Tiefpassfilter - VB.Net Beispiel</title><link>https://neu.fkainka.de/tiefpassfilter-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 16:24:37 +0100</pubDate><guid>https://neu.fkainka.de/tiefpassfilter-vb-net-beispiel/</guid><description>&lt;p&gt;Die Simulation des Tiefpassfilters konnte mit geringen Änderungen aus dem Hochpassfilterprogramm entwickelt werden. Beide Programme unterscheiden sich nur in der Berechnung der Amplitude und Phasenverschiebung.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;z = Math.Sqrt(r * r + Xc * Xc)&lt;/em&gt;&lt;br&gt;
&lt;em&gt;uC = (u0 * Xc) / z&lt;/em&gt;&lt;br&gt;
&lt;em&gt;&amp;lsquo;Phasenverschiebung berechnen&lt;/em&gt;&lt;br&gt;
&lt;em&gt;phasev = (-Math.Acos(uC / u0)) * 180 / Math.PI&lt;/em&gt;&lt;br&gt;
&lt;em&gt;&amp;lsquo;Ur Zeichen&lt;/em&gt;&lt;br&gt;
&lt;em&gt;ZeichnenSin(freq, 3, uC, 0.5, phasev)&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;Diesmal eilt die Phase am Ausgang nach. Man kann sehr anschaulich das Verhalten des Filters untersuchen. Interessant ist z.B. der Fall der Grenzfrequenz. Die Amplitude ist gerade auf 0,7 gefallen (-3 dB), die Phase ist um 45 Grad verschoben.&lt;/p&gt;</description></item><item><title>Hochpassfilter - VB.Net Beispiel</title><link>https://neu.fkainka.de/hochpassfilter-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 16:22:48 +0100</pubDate><guid>https://neu.fkainka.de/hochpassfilter-vb-net-beispiel/</guid><description>&lt;p&gt;Das Programm stellt ein Zweikanal-Oszilloskop dar. Ein Sinusgenerator mit einstellbarer Frequenz und konstanter Amplitude liegt am Eingang des Tiefpassfilters und an einem Kanal des Oszilloskops. Die Sub &lt;em&gt;ZeichnenSinb&lt;/em&gt;  plottet den Sinus im Ausgabefenster&lt;/p&gt;
&lt;p&gt;&lt;em&gt;freq = (VScrollBarF.Maximum + VScrollBarF.Minimum - VScrollBarF.Value) / 10&lt;/em&gt;&lt;br&gt;
&lt;em&gt;u0 = 2&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;ZeichnenSinb(freq, 3, u0, 0.5, 0) &amp;lsquo;Eingangsspannung zeichnen&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;Der andere Kanal liegt am Ausgang des Filters. Die folgenden Rechnungen ermitteln die Ausgangsamplitude und die Phasenverschiebung. Die Ausgangsspannung wird entsprechend dieser Ergebnisse in einem zweiten Sinusgenerator gebildet.&lt;/p&gt;</description></item><item><title>Netzteil - VB.Net Beispiel</title><link>https://neu.fkainka.de/netzteil-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 16:20:20 +0100</pubDate><guid>https://neu.fkainka.de/netzteil-vb-net-beispiel/</guid><description>&lt;p&gt;Das Programm simuliert die Restwelligkeit eines 12V-Netzteils mit Vierweggleichrichter und Siebelko. Sowohl der Lastwiderstand als auch die Kapazität des Elkos lassen sich einstellen. Auf dem simulierten Oszilloskopschirm (der Picturebox) kann man den Spannungsverlauf sehen.&lt;/p&gt;
&lt;p&gt;Die Berechnungen sind hier verhältnismäßig simpel. Ut ist die gleichgerichtete Eingangswechselspannung, wobei die Sinusfunktion die Wechselspannung am Trafo berechnet und die Absolutwertbestimmung (Abs) den Vierweggleichrichter simuliert.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;vt = vt + 360 / 80&lt;/em&gt;&lt;br&gt;
&lt;em&gt;If vt &amp;gt;= 361 Then vt = 0&lt;/em&gt;&lt;br&gt;
&lt;em&gt;xvt = Math.PI * vt / 180.0&lt;/em&gt;&lt;br&gt;
&lt;em&gt;ut = Math.Abs(17 * (Math.Sin(xvt)))&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Arbeitspunkt Emitterschaltung - VB.Net Beispiele</title><link>https://neu.fkainka.de/arbeitspunkt-emitterschaltung-vb-net-beispiele/</link><pubDate>Wed, 30 Jan 2013 16:18:23 +0100</pubDate><guid>https://neu.fkainka.de/arbeitspunkt-emitterschaltung-vb-net-beispiele/</guid><description>&lt;p&gt;Für jeden Transistorverstärker gibt es einen optimalen Kollektorstrom, den man auch als Arbeitspunkt bezeichnet. Bei diesem Signalverstärker in Emitterschaltung sollte man den Basiswiderstand rb passend zur Stromverstärkung V möglichst so einstellen, dass die Kollektorspannung uce ohne Aussteuerung (ut=0) in der Mitte bei 2,5 V liegt. Das ergibt dann den idealen Arbeitspunkt, bei dem die größte verzerrungsfreie Aussteuerung möglich ist.&lt;br&gt;
&lt;em&gt;ib = 4.4 / rb + ut / 1000&lt;/em&gt;&lt;br&gt;
&lt;em&gt;ic = ib * v&lt;/em&gt;&lt;br&gt;
&lt;em&gt;uce = 5 - ic * 1000&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Gegenkopplung - VB.Net Beispiel</title><link>https://neu.fkainka.de/gegenkopplung-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 16:15:48 +0100</pubDate><guid>https://neu.fkainka.de/gegenkopplung-vb-net-beispiel/</guid><description>&lt;p&gt;In diesem Programm wird eine Emitterschaltung mit Gegenkopplung simuliert. Die Änderung zu einem normalen Transistorverstärker ist, dass hier die Basis über einen Widerstand mit dem Kollektor verbunden ist. Damit wird einer Vergrößerung des Kollektorstroms entgegengewirkt. Das Resultat ist eine verkleinerte Verstärkung aber auch eine geringere Verzerrung.&lt;/p&gt;
&lt;p&gt;In dem Programm treten viele Neuerungen auf einmal auf. Es wird hier zum ersten Mal mit einer gezeichneten Ausgabe auf einer Picturebox gearbeitet. Wenn Sie sich bereits mit älteren VB-Versionen auskennen, werden Sie hier einige Änderungen feststellen. Allerdings habe ich versucht, altbekannte Prozeduren nachzuprogrammieren. Das sollte die Umstellung erleichtern.&lt;/p&gt;</description></item><item><title>Schmitt-Trigger - VB.Net Beispiel</title><link>https://neu.fkainka.de/schmitt-trigger-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 16:09:40 +0100</pubDate><guid>https://neu.fkainka.de/schmitt-trigger-vb-net-beispiel/</guid><description>&lt;p&gt;Bei dem Schmitt-Trigger-Programm tritt wieder etwas Besonderes auf. Hier haben wir das erste Mal &lt;em&gt;Select Case&lt;/em&gt; statt einer IF-Abfrage benutzt. Das liegt daran, dass die Berechnung der Werte davon abhängen, welcher Zustand vorher gültig war. Visuell wird das in einer Hysteresekurve dargestellt.&lt;/p&gt;
&lt;details class="spoiler"&gt;
&lt;summary&gt;Quelltext&lt;/summary&gt;
&lt;p&gt;Public Class frmST&lt;br&gt;
Dim Re, Ui As Double&lt;br&gt;
Dim fall&lt;br&gt;
Dim uc1, ue, ub2, u1, ua As Double&lt;br&gt;
Dim i1, i2&lt;/p&gt;
&lt;p&gt;Private Sub frmST_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load&lt;br&gt;
fall = 1&lt;br&gt;
berechnen()&lt;br&gt;
End Sub&lt;/p&gt;</description></item><item><title>Invertierender Verstärker -VB.Net Beispiel</title><link>https://neu.fkainka.de/invertierender-verstaerker-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 16:07:49 +0100</pubDate><guid>https://neu.fkainka.de/invertierender-verstaerker-vb-net-beispiel/</guid><description>&lt;p&gt;Das Programm Inventierender Verstärker funktioniert ähnlich wie das vorangegangen Programm Nichtinvertierender Verstärker.&lt;/p&gt;
&lt;p&gt;Das Programm unterscheidet sich vom Vorgänger fast nur durch eine etwas andere Rechenregel (vgl. &lt;a href="http://elexs.de/kap7_3.htm"&gt;ELEXS&lt;/a&gt;)&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Rv = R1 / (R1 + R2)&lt;/em&gt;&lt;br&gt;
&lt;em&gt;V = -(R2 / R1)&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Uv = Rx * V&lt;/em&gt;&lt;/p&gt;
&lt;details class="spoiler"&gt;
&lt;summary&gt;Quelltext&lt;/summary&gt;
&lt;p&gt;&lt;em&gt;Public&lt;/em&gt; &lt;em&gt;Class frmIV&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Dim&lt;/em&gt; &lt;em&gt;R1, R2, Rx&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Dim V&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Dim Uo, Uplus, Uminus&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Dim&lt;/em&gt; &lt;em&gt;Uv, Rv&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Private Sub sR2_Scroll(ByVal sender As System.Object, ByVal e As System.Windows.Forms.ScrollEventArgs)Handles sR2.Scroll&lt;/em&gt;&lt;br&gt;
&lt;em&gt;berechnen()&lt;/em&gt;&lt;br&gt;
&lt;em&gt;End Sub&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Nichtinvertierender Verstärker - VB.Net Beispiel</title><link>https://neu.fkainka.de/nichtinvertierender-verstaerker-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 16:05:27 +0100</pubDate><guid>https://neu.fkainka.de/nichtinvertierender-verstaerker-vb-net-beispiel/</guid><description>&lt;p&gt;Dieses Programm simuliert eine Schaltung mit einem nichtinvertierenden Operations-Verstärker.&lt;/p&gt;
&lt;p&gt;Die eigentliche Berechnung im Programm ist ganz einfach und bestimmt die Verstärkung und die Ausgangsspannung aus dem Verhältnis von Widerständen (vgl. &lt;a href="http://elexs.de/kap7_2.htm"&gt;ELEXS&lt;/a&gt;).&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Rv = R2 / (R1 + R2)&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;V = (R1 + R2) / R2&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Uv = Ui * V&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;Die Rechnung kann theoretisch auch Ausgangspannungen außerhalb des Bereichs der Betriebsspannung ergeben. Deshalb wird hier in einem zweiten Schritt die tatsächliche Spannung nach oben und unten bis auf 0,5 V an der Betriebsspannung begrenzt. Wenn dieser Übersteuerungsfall eintritt weicht die Spannung am invertierenden Eingang des OPV von der am nichtinvertierenden ab und muss eigens aus dem Spannungsteilungsverhältnis berechnet werden.&lt;/p&gt;</description></item><item><title>Innenwiderstand - VB.Net Beispiel</title><link>https://neu.fkainka.de/innenwiderstand-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 16:03:19 +0100</pubDate><guid>https://neu.fkainka.de/innenwiderstand-vb-net-beispiel/</guid><description>&lt;p&gt;Mit dem Programm Innenwiderstand kann man beobachten, wie sich Strom und Spannung in Schaltungen verhalten, wenn man den Innenwiderstand einer Stromquelle, die Spannung der Stromquelle oder die Last verändert.&lt;/p&gt;
&lt;p&gt;Die Berechnung ähnelt der bei der Reihenschaltung, weil der innere und der äußere Widerstand einen Spannungsteiler bilden. Mehr dazu findet man in &lt;a href="http://elexs.de/kap2_6.htm"&gt;ELEXS&lt;/a&gt;&lt;a href="http://elexs.de/kap2_6.htm"&gt;.&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;rges = Ri + Ra&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Ia = Ui / rges&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Ua = Ra * Ia&lt;/em&gt;&lt;/p&gt;
&lt;details class="spoiler"&gt;
&lt;summary&gt;Quelltext&lt;/summary&gt;
&lt;p&gt;&lt;em&gt;Public&lt;/em&gt; &lt;em&gt;Class frmInnen&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Dim Ui, Ri, Ia, Ra, Ua&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Private&lt;/em&gt; &lt;em&gt;Sub berechnen()&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Dim rges&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Reihenschaltung -VB.Net Beispiel</title><link>https://neu.fkainka.de/reihenschaltung-vb-net-beispiel/</link><pubDate>Wed, 30 Jan 2013 15:57:17 +0100</pubDate><guid>https://neu.fkainka.de/reihenschaltung-vb-net-beispiel/</guid><description>&lt;p&gt;Dieses Programm berechnet Ströme und Spannungen in einer Reihenschaltung. Sowohl die beiden Widerstände als auch die Eingangsspannung sind dabei veränderbar.&lt;/p&gt;
&lt;p&gt;In diesem Programm wird die Funktion &lt;em&gt;Math.Round&lt;/em&gt; benutzt. Mit ihr kann man Zahlen auf eine bestimmte Anzahl von Nachkommastellen runden. Auf wie viele Stellen gerundet werden soll, gibt der zweite Parameter an, z.B.: &lt;em&gt;Math.Round(2.2345, 3)&lt;/em&gt;.&lt;/p&gt;
&lt;p&gt;Die eigentliche Berechnung (vgl. physikalische Hintergründe in &lt;a href="http://elexs.de/kap2_4.htm"&gt;ELEXS&lt;/a&gt;) steht in den folgenden drei Zeilen:&lt;/p&gt;
&lt;p&gt;&lt;em&gt;I = Math.Round(U / ((R1 + R2)), 3)&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Ur1 = R1 * I&lt;/em&gt;&lt;br&gt;
&lt;em&gt;Ur2 = U - Ur1&lt;/em&gt;&lt;br&gt;
Alles andere beschäftigt sich mit der Eingabe und Ausgabe von Werten.&lt;/p&gt;</description></item><item><title>NPN-Transistor - VB.Net Beispiel</title><link>https://neu.fkainka.de/vb-net-beispiel-npn-transistor/</link><pubDate>Wed, 30 Jan 2013 15:52:42 +0100</pubDate><guid>https://neu.fkainka.de/vb-net-beispiel-npn-transistor/</guid><description>&lt;p&gt;Bei diesem Programm geht es darum, eine einfache NPN-Transistor-Schaltung zu simulieren. Mit verschiedenen Schiebern kann man einen veränderlichen Widerstand und damit die Eingangsspannung verstellen. Interessante Größen werden dann berechnet und an entsprechenden Labels ausgegeben.&lt;/p&gt;
&lt;p&gt;Hauptsächlich können Sie an diesem Beispiel sehen, wie man eine Sub aufruft und wie man kleinere Rechnungen ausführt.&lt;/p&gt;
&lt;p&gt;Die visuelle Oberfläche ist größtenteils durch ein vorgegebenes Hintergrundbild definiert. Somit spart man sich das komplizierte Zeichnen im Desingeditor. Anschließend sind an den passenden Stellen Label und Schieber hinzugefügt worden.&lt;/p&gt;</description></item><item><title>VB.Net: Syntax</title><link>https://neu.fkainka.de/vb-net-syntax/</link><pubDate>Wed, 30 Jan 2013 15:44:01 +0100</pubDate><guid>https://neu.fkainka.de/vb-net-syntax/</guid><description>&lt;p&gt;In diesem Text werde ich auf die Besonderheiten und die Schreibweisen (Syntax) von VB.Net eingehen. Wenn Sie noch nie Programmiert haben empfehle ich vorher die Artikel über die &lt;a href="http://wp.fkainka.de/grundlagen-der-programmierung/" title="Grundlagen der Programmierung"&gt;Grundlagen der Programmierung&lt;/a&gt; zu lesen. Falls Sie schon andere Programmiersprachen benutzt haben interessiert Sie vielleicht nur, wie die man einzelne Elemente in VB.Net umsetzt. Deswegen werde ich hier in kurzer, übersichtlicher Form die Syntax dieser Programmiersprache erläutern. Auf diese Weise können Sie immer schnell nachschlagen, wenn Sie sich gerade nicht mehr sicher sind, wie man beispielsweise eine Schleife in VB.Net realisiert.&lt;/p&gt;</description></item><item><title>VB.Net: Steuerelemente</title><link>https://neu.fkainka.de/vb-net-steuerelemente/</link><pubDate>Wed, 30 Jan 2013 15:35:39 +0100</pubDate><guid>https://neu.fkainka.de/vb-net-steuerelemente/</guid><description>&lt;p&gt;Unter den zahlreichen Steuerelementen in VB.Net gibt esein paar, die sehr häufig in Fenster basierenden Programmen auftauchen:&lt;a href="http://wp.fkainka.de/wp-content/uploads/2015/01/elemt0.jpg"&gt;&lt;img alt="elemt0" loading="lazy" src="http://wp.fkainka.de/wp-content/uploads/2015/01/elemt0.jpg"&gt;&lt;/a&gt;Hier hätten wir u.A.:Button,&lt;br&gt;
Label, TextBox, CheckBox und das Formular selbst.&lt;/p&gt;
&lt;p&gt;Zu&lt;br&gt;
Beginn ist es am Einfachsten, wenn man sich auf die Eigenschaften und Ereignisse von Elementen konzentriert. Eigenschaften werden hauptsächlich vor dem Programmstart im Formmanager verändert um ein Startbild zu definieren. Aber auch zur Laufzeit ist es möglich, bestimmte Eigenschaften zu verändern. Man kann z.B. den Titeltext des Formulars verändern um den Benutzer auf einen Fehler hinzuweisen. Aber später mehr dazu.Wenn ein Ereignis (Event) ausgelöst wird überprüft das Programm, ob eine Prozedur zu diesem Ereignis definiert ist. Ist dies der Fall wird diese Prozedur ausgeführt. Eines der häufigsten Events ist der&lt;/p&gt;</description></item><item><title>VB.Net: Hello World</title><link>https://neu.fkainka.de/vb-net-hello-world/</link><pubDate>Wed, 30 Jan 2013 15:28:36 +0100</pubDate><guid>https://neu.fkainka.de/vb-net-hello-world/</guid><description>&lt;p&gt;Wir alle kennen das Problem. Eine einfache aber zeitaufwändige Computer-Aufgabe liegt vor uns. Sei es einen ganzen Ordner Bilder umzubenennen oder eine bestimmte Formel immer wieder neu mit dem Taschenrechner ausrechnen zu müssen. Dafür kann man sich entweder einen Tag Zeit nehmen, oder man entwirft schnell ein Programm, welches die gewünschten Aufgaben selbständig und schnell erledigt. Dafür ist ein PC schließlich da.&lt;/p&gt;
&lt;p&gt;Aber welche Programmiersprache eignet sich dafür? Gerade neue und moderne Programmiersprachen wie Java und C++ haben ein breites Spektrum an Möglichkeiten, allerdings wird das Programmieren dadurch auch viel komplizierter. Dazu kommt, dass eine einfache grafische Oberfläche oft mühsam im Quelltext programmiert werden muss, was die Sache nicht einfacher und übersichtlicher macht.&lt;/p&gt;</description></item><item><title>Grundlagen der Programmierung</title><link>https://neu.fkainka.de/grundlagen-der-programmierung/</link><pubDate>Wed, 30 Jan 2013 15:24:20 +0100</pubDate><guid>https://neu.fkainka.de/grundlagen-der-programmierung/</guid><description>&lt;p&gt;Unabhängig von der gewählten Programmiersprache gibt es einige allgemein gültige Elemente in der Informatik. So ist z.B. eine Integer-Variable überall gleich definiert als ein Container für eine ganze Zahl und besteht aus 16 Bit. Es ist egal ob Sie in Bascom, Arduino, Visual Basic oder Java programmieren, ein Integer bleibt ein Integer. Das Einzige was sich ändert ist der Quelltext, mit dem Sie die Variable initialisieren.&lt;/p&gt;
&lt;p&gt;An dieser Stelle soll deswegen eine kurze Einleitung zu den wichtigsten Elementen nahezu jeder Programmiersprache stehen. Gerade Anfänger können so immer mal wieder nachgucken wie z.B. eine Schleife, eine Funktion oder eine Variable funktioniert. Den Quelltext müssen Sie dann nur noch der jeweiligen Sprache anpassen.&lt;/p&gt;</description></item><item><title>Grundlagen der Programmierung: Zahlensysteme</title><link>https://neu.fkainka.de/grundlagen-der-programmierung-zahlensysteme/</link><pubDate>Wed, 30 Jan 2013 15:22:45 +0100</pubDate><guid>https://neu.fkainka.de/grundlagen-der-programmierung-zahlensysteme/</guid><description>&lt;p&gt;In der Informatik gibt es verschiedene Arten der Zahlendarstellung. Aus unserem Alltag kennen wir die Dezimaldarstellung, die auf dem 10er Prinzip beruht (Dezi = 10). Aber auch wenn es und natürlich und selbstverständlich vorkommt, ist dies nicht die einzige Möglichkeit Zahlen zu behandeln. Vielmehr kommt es uns nur wegen unserer 10 Finger selbstverständlich vor das 10er System zu benutzen. Computer sehen das aber anders.&lt;/p&gt;
&lt;h3 id="binär"&gt;Binär&lt;/h3&gt;
&lt;p&gt;Computer rechnen viel lieber mit dem Binärsystem (Bi = 2) in dem Binärsystem gibt es nur zwei Zustände die Eins oder Null heißen. Diese Zahl nennen wir mal Bit. 8 Bit ergeben ein Byte. Ein Beispiel für ein Byte : 11110111. Also insgesamt 8-Bits mit jeweiligen Zustand. Für den Computer ist diese Zahl verständlich, wir können uns aber nicht viel darunter vorstellen, es sei denn wir transformieren sie wieder in unser Dezimalsystem. Dazu muss man wissen, das es eine einfache Berechnung gibt. Das niedrigste Bit steht nämlich für die Zahl eins. Das zweite für die Zahl 2, das dritte für 4 und das vierte für 8 und so weiter. Um sich das besser vorzustellen hier eine Tabelle:&lt;/p&gt;</description></item><item><title>Grundlagen der Programmierung: Schleifen</title><link>https://neu.fkainka.de/grundlagen-der-programmierung-schleifen/</link><pubDate>Wed, 30 Jan 2013 15:21:32 +0100</pubDate><guid>https://neu.fkainka.de/grundlagen-der-programmierung-schleifen/</guid><description>&lt;p&gt;Oft ist es von Nöten, dass ein Programmteil so oft wiederholt wird, bis sich ein bestimmter Zustand geändert hat. Deswegen gibt es Schleifen. Die gängigsten Typen sind: For-Schleifen, While, Until –Schleifen.&lt;/p&gt;
&lt;p&gt;Die For-Schleife ist eine Art Zähler. Sie zählt von einem Startwert zu einem Endwert in einer Bestimmten Schrittweite und führt bei jedem Schritt den Programmcode aus. Hier ein Beispiel aus VB.Net:&lt;/p&gt;
&lt;p&gt;&lt;em&gt;For&lt;/em&gt; &lt;em&gt;i = 1&lt;/em&gt; &lt;em&gt;To&lt;/em&gt; &lt;em&gt;5&lt;/em&gt; &lt;em&gt;Step&lt;/em&gt; &lt;em&gt;1&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Grundlagen der Programmierung: If-Abfragen</title><link>https://neu.fkainka.de/grundlagen-der-programmierung-if-abfragen/</link><pubDate>Wed, 30 Jan 2013 15:20:23 +0100</pubDate><guid>https://neu.fkainka.de/grundlagen-der-programmierung-if-abfragen/</guid><description>&lt;p&gt;Eine IF-Abfrage ist dazu da, zu einer bestimmten Bedingung einen bestimmten Programmcode auszuführen. Die klassische Struktur solcher Abfragen sind: If – Bedingung Then – Dann mache folgendes, Else – Andernfalls mache folgendes. Hier ein simples Beispiel&lt;/p&gt;
&lt;p&gt;if i = 5 then&lt;/p&gt;
&lt;p&gt;(…)&lt;/p&gt;
&lt;p&gt;Else&lt;/p&gt;
&lt;p&gt;(…)&lt;br&gt;
end if&lt;/p&gt;
&lt;p&gt;Es ist auch möglich mehrere If-Abfragen ineinander zu verschachteln. Also eine If-Abfrage in einer If-Abfrage. Außerdem kann man mehre if-Then’s hintereinander schreiben bevor das else kommt, oder auch das else weglassen. In manchen Programmiersprachen kann man sogar das End if weglassen, wenn man if .. then.. in eine Zeile schreibt.&lt;/p&gt;</description></item><item><title>Grundlagen der Programmierung: Prozeduren</title><link>https://neu.fkainka.de/grundlagen-der-programmierung-prozeduren/</link><pubDate>Wed, 30 Jan 2013 15:19:14 +0100</pubDate><guid>https://neu.fkainka.de/grundlagen-der-programmierung-prozeduren/</guid><description>&lt;p&gt;Viele Programmiersprachen erlauben das Aufrufen von Unterprogrammen. Gerade wenn ein Teil des Programms besonders oft durchläuft, z.B. irgendeine Berechnung, kann es hilfreich sein, diesen Teil in einer gesonderten Prozedur auszulagern. Die Vorteile sind vor allem die Übersichtlichkeit, die Platzersparnis und die wieder Verwendbarkeit von Quelltexten.&lt;/p&gt;
&lt;p&gt;Eine Prozedur muss meistens zu Beginn eines Programms mit Namen und Parametern deklariert werden. Das funktioniert in Bascom z.B. so:&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Declare Sub Unterprogramm (Variable as Byte)&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Grundlagen der Programmierung: Variablen</title><link>https://neu.fkainka.de/grundlagen-der-programmierung-variablen/</link><pubDate>Wed, 30 Jan 2013 15:17:49 +0100</pubDate><guid>https://neu.fkainka.de/grundlagen-der-programmierung-variablen/</guid><description>&lt;p&gt;Variablen muss man sich grundsätzlich als einen Container für einen bestimmten Wert vorstellen. In den meisten Programmiersprachen müssen diese Container zu Beginn des Programms „bestellt“ werden. Das nennt man Initialisieren. Zur Initialisierung müssen Sie meistens auch den Typ der Variable und den Namen angeben. Den Typ, damit das der PC auch weiß, wie groß der Container sein soll, und den Namen, damit Sie den Container auch später wiederfinden. In VB.Net sieht die Initialisierung einer Variablen so aus:&lt;/p&gt;</description></item></channel></rss>