[{"content":"","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/cpp/","section":"Code Schnipsel","summary":"","title":"C++","type":"code-snippets"},{"content":" 1/*! \\brief kurze Beschreibung (im vorhinein) 2 * Ergaenzung der kurzen Beschreibung 3 * 4 * laengerer Beschreibungstext 5 */ 6int testVar = 0; 7 8int testVar = 0; //!\u0026lt; Beschreibung der Variable, nachfolgend 9int testVar = 0; /*!\u0026lt; Beschreibung der Variable, nachfolgend */ 10 11 12/*! \\class testClass 13 * \\brief kurze Beschreibung 14 */ 15class testClass 16{ 17public: 18 /*! \\fn testClass 19 * \\brief Beschreibung des Konstruktors 20 */ 21 testClass(); 22 /*! \\fn testClass 23 * \\brief Beschreibung des Destruktors 24 */ 25 ~testClass(); 26 27 int value1; //!\u0026lt; Beschreibung der Variable 28 29protected: 30 /*! \\fn set 31 * \\brief Beschreibung von Methoden 32 */ 33 void set(int value); 34 /*! \\fn get 35 * \\brief Beschreibung von Methoden 36 */ 37 int get(void); 38 39 int value2; 40private: 41 int value3; 42}; 43 44 45/*! \\struct zur Dokumentation einer C-Struktur 46 * \\class zur Dokumentation einer Klasse 47 * \\union zur Dokumentation einer Union 48 * \\enum zur Dokumentation eines Enumeration Typs 49 * \\fn zur Dokumentation einer Funktion 50 * \\var zur Dokumentation einer Variable 51 * \\def zur Dokumentation eines #defines 52 * \\typedef zur Dokumentation einer Typ Definition 53 * \\file zur Dokumentation einer Datei 54 * \\namespace zur Dokumentation eines Namensraumes 55 */ 56 57 58/*! \\param value1 - Beschreibung von Variablen in Parameterlisten 59 * \\param [in] value1 - Beschreibung von Eingabeparametern 60 * \\param [out] value1 - Beschreibung von Ausgabeparametern 61 * \\return Beschreibung des Rueckgabewertes 62 * \\retval value1 - Beschreibung bestimmter Return Werte 63 * \\pre Pre-Kondition 64 * \\post Post-Kondition 65 */ 66 67 68/*! \\note zusaetzliche Notizen 69 * \\author Angaben zum Erzeuger des Codes 70 * \\version Version des Codes 71 * \\date Datum der Erstellung 72 * \\test Testbeschreibung 73 * \\todo Aufgaben die noch erledigt gehoeren 74 */ 75 76/*! Erstellung einer Liste 77 * - Aufzaehlung 1 78 * - Aufzaehlung 2 79 * -# verschachtelte numerierte Aufzaehlung 1 80 * -# verschachtelte numerierte Aufzaehlung 2 81 */ 82 83 84/*! verschiedene Textformate 85 * /verbatim Verbatim Textausgabe 86 * /endverbatim 87 * 88 * /code Codeausgabe 89 * /endcode 90 */ 91 92/*! Einbetten einer Formel 93 * 94 * \\f$\\sqrt{f_{under}^{over}}\\f$ 95 * 96 * zwischen den \\f$ Marken koennen standard 97 * Latex Formel Beschreibungen eingegeben werden 98 */ 99 100 101/*! \\brief \u0026lt;big\u0026gt; es koennen auch HTML Kommandos eingebunden werden \u0026lt;/big\u0026gt; 102 */ 103 104 ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/cpp/doxygen/","section":"Code Schnipsel","summary":"","title":"C++ - Doxygen","type":"code-snippets"},{"content":" 1// Literatur: Vorlesungsunterlagen ISE3 (FH-Hagenberg) 2 3 4/*********************************************************************/ 5/* Projekt fuer dynamische Library (erzeugt dll.dll) */ 6/* bei DevCpp wird libDLL.a und libDLL.def erzeugt, */ 7/* bei VS sollte eine dll.def selbst angelegt werden */ 8/* und dll.lib wird erzeugt */ 9/*********************************************************************/ 10 11// dll.h: 12//--------------------------------------------------------------------- 13 #ifndef _DLL_H_ 14 #define _DLL_H_ 15 16 #if BUILDING_DLL 17 # define DLLIMPORT __declspec (dllexport) 18 #else 19 # define DLLIMPORT __declspec (dllimport) 20 #endif 21 22 extern DLLIMPORT int var; 23 24 DLLIMPORT int func(void); 25 // name mangling 26 DLLIMPORT int Add1(int const val1, int const val2); 27 // without name mangling 28 extern \u0026#34;C\u0026#34; DLLIMPORT int Add2(int const val1, int const val2); 29 30 class DLLIMPORT dllClass 31 { 32 public: 33 dllClass(); 34 virtual ~dllClass(void); 35 }; 36 37 #endif 38 39 40// dll.cpp: 41//--------------------------------------------------------------------- 42 #include \u0026#34;dll.h\u0026#34; 43 #include \u0026lt;windows.h\u0026gt; 44 45 BOOL APIENTRY DllMain (HMODULE hModule, 46 DWORD ul_reason_for_call, 47 LPVOID lpReserved) 48 { 49 switch (ul_reason_for_call) 50 { 51 case DLL_PROCESS_ATTACH: 52 MessageBox(0, \u0026#34;DLL_PROCESS_ATTACH called\u0026#34;, \u0026#34;DLL\u0026#34;, MB_OK); 53 break; 54 case DLL_THREAD_ATTACH: 55 break; 56 case DLL_THREAD_DETACH: 57 break; 58 case DLL_PROCESS_DETACH: 59 MessageBox(0, \u0026#34;DLL_PROCESS_DETACH called\u0026#34;, \u0026#34;DLL\u0026#34;, MB_OK); 60 break; 61 } 62 return TRUE; 63 } 64 65 66 DLLIMPORT int var=0; 67 68 DLLIMPORT int func(void) 69 { 70 return 42; 71 } 72 73 DLLIMPORT int Add1(int const val1, int const val2) 74 { 75 return val1 + val2; 76 } 77 78 extern \u0026#34;C\u0026#34; DLLIMPORT int Add2(int const val1, int const val2) 79 { 80 return val1 + val2; 81 } 82 83 dllClass::dllClass() 84 { 85 MessageBox(0, \u0026#34;dllClass CTOR called\u0026#34;, \u0026#34;DLL\u0026#34;, MB_OK); 86 return; 87 } 88 89 dllClass::~dllClass() 90 { 91 MessageBox(0, \u0026#34;dllClass DTOR called\u0026#34;, \u0026#34;DLL\u0026#34;, MB_OK); 92 return; 93 } 94 95 96// dll.def (bei DevCpp nicht n�tig): 97//--------------------------------------------------------------------- 98 LIBRARY\t\u0026#34;DLL\u0026#34; 99 100 DESCRIPTION \u0026#39;My personal dll :-)\u0026#39; 101 102 EXPORTS 103 var 104 func 105 Add1 106 Add2 107 108 109 110/*********************************************************************/ 111/* Projekt welches die Library verwendet */ 112/* dll.h und libDLL.a/dll.lib werden ins aktuelle Projekt kopiert, */ 113/* libDLL.a/dll.lib wird bei den Abhaengigkeiten des Linkers */ 114/* eingetragen */ 115/*********************************************************************/ 116 117// testDll.h: 118//--------------------------------------------------------------------- 119 #include \u0026lt;iostream\u0026gt; 120 #include \u0026lt;conio.h\u0026gt; 121 #include \u0026#34;dll.h\u0026#34; 122 123 using namespace std; 124 125 int main() 126 { 127 cout \u0026lt;\u0026lt; \u0026#34;var = \u0026#34; \u0026lt;\u0026lt; var \u0026lt;\u0026lt; endl; 128 var = 3; 129 cout \u0026lt;\u0026lt; \u0026#34;var = \u0026#34; \u0026lt;\u0026lt; var \u0026lt;\u0026lt; endl; 130 131 cout \u0026lt;\u0026lt; \u0026#34;func() = \u0026#34; \u0026lt;\u0026lt; func() \u0026lt;\u0026lt; endl; 132 133 cout \u0026lt;\u0026lt; \u0026#34;Add1(1,2) = \u0026#34; \u0026lt;\u0026lt; Add1(1,2) \u0026lt;\u0026lt; endl; 134 cout \u0026lt;\u0026lt; \u0026#34;Add2(1,2) = \u0026#34; \u0026lt;\u0026lt; Add2(1,2) \u0026lt;\u0026lt; endl; 135 136 dllClass *cl = new dllClass(); 137 delete cl; 138 139 _getch(); 140 return 0; 141 } 142 143 144 145/*********************************************************************/ 146/* Projekt welches die Library zur Laufzeit laedt */ 147/*********************************************************************/ 148 149// testDll2.h: 150//--------------------------------------------------------------------- 151 #include \u0026lt;iostream\u0026gt; 152 #include \u0026lt;windows.h\u0026gt; 153 #include \u0026lt;conio.h\u0026gt; 154 155 using namespace std; 156 157 int main () 158 { 159 // Funktionspointer gemaess der Schnittstelle 160 typedef int (* TAdd) (int const, int const); 161 162 // DLL dynamisch zur Laufzeit laden 163 HMODULE hDll = LoadLibrary(\u0026#34;dll.dll\u0026#34;); 164 if (hDll != 0) 165 { 166 // Funktionsadresse ermitteln 167 // via Namen 168 TAdd pAdd1 = (TAdd) GetProcAddress(hDll, \u0026#34;Add1\u0026#34;); 169 // via Ordinalnummer 170 //TAdd pAdd1 = (TAdd) GetProcAddress(hDll, MAKEINTRESOURCE(3)); 171 if (pAdd1 != 0) 172 cout \u0026lt;\u0026lt; \u0026#34;Add1(1,2) = \u0026#34; \u0026lt;\u0026lt; pAdd1(1,2) \u0026lt;\u0026lt; endl; 173 else 174 cout \u0026lt;\u0026lt; \u0026#34;Add1 not found (maybe name mangling)\u0026#34; \u0026lt;\u0026lt; endl; 175 176 TAdd pAdd2 = (TAdd) GetProcAddress(hDll, \u0026#34;Add2\u0026#34;); 177 if (pAdd2 != 0) 178 cout \u0026lt;\u0026lt; \u0026#34;Add2(1,2) = \u0026#34; \u0026lt;\u0026lt; pAdd2(1,2) \u0026lt;\u0026lt; endl; 179 else 180 cout \u0026lt;\u0026lt; \u0026#34;Add2 not found (maybe name mangling)\u0026#34; \u0026lt;\u0026lt; endl; 181 } 182 183 // Clean up 184 FreeLibrary(hDll); 185 _getch(); 186 return 0; 187 } ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/cpp/dynamic-linked-library/","section":"Code Schnipsel","summary":"","title":"C++ - Dynamic Linked Library","type":"code-snippets"},{"content":" 1// Literatur: 2// Manuals vom Hersteller FTDI 3 4// Library hinzufuegen: ftd2xx.lib 5// Header-Datei inkludieren: ftd2xx.h 6// DLLs in Ausgabe-Ordner kopieren: ftbusui.dll 7// ftcserco.dll 8// ftd2xx.dll 9// ftlang.dll 10// ftserui2.dll 11 12/* Beispiel einer Ausgabe-Datei: 13 date time value 14 2012.11.21 13:06:24 0xf0 15 2012.11.21 13:06:28 0xf1 16 2012.11.21 13:06:28 0xf0 17*/ 18 19#include \u0026lt;iostream\u0026gt; 20#include \u0026lt;fstream\u0026gt; 21#include \u0026lt;iomanip\u0026gt; 22#include \u0026lt;conio.h\u0026gt; 23#include \u0026lt;string\u0026gt; 24#include \u0026lt;time.h\u0026gt; 25#include \u0026lt;windows.h\u0026gt; 26#include \u0026#34;ftd2xx.h\u0026#34; 27 28using namespace std; 29 30#define D0 0x01 // TXD (orange wire) 31#define D1 0x02 // RXD (yellow wire) 32#define D2 0x04 // RTS (green wire) 33#define D3 0x08 // RTS (brown wire) 34 35#define RESET_MODE 0x00 36#define ASYNC_BIT_BANG 0x01 37#define SYNC_BIT_BANG 0x04 38 39 40int main(int argc, char **argv) 41{ 42 FT_HANDLE handle; 43 FT_STATUS status; 44 DWORD nrDevices; 45 DWORD bytesWritten; 46 DWORD bytesRead; 47 int devNr = 0; 48 unsigned char latency = 0; 49 unsigned char output = 0; 50 unsigned char input = 0; 51 int tmp = 0; 52 time_t rawtime; 53 struct tm* timeinfo; 54 55 56 try 57 { 58 if ((argc == 2) \u0026amp;\u0026amp; (strcmp(argv[1], \u0026#34;-list\u0026#34;) == 0)) 59 { 60 status = FT_ListDevices(\u0026amp;nrDevices, NULL, FT_LIST_NUMBER_ONLY); 61 if(status != FT_OK) 62 throw(\u0026#34;Can\u0026#39;t list connected devices!\u0026#34;); 63 64 cout \u0026lt;\u0026lt; \u0026#34;Number devices connected: \u0026#34; \u0026lt;\u0026lt; nrDevices \u0026lt;\u0026lt; endl; 65 } 66 else if ((argc == 3) \u0026amp;\u0026amp; (strcmp(argv[1], \u0026#34;-write\u0026#34;) == 0)) 67 { 68 devNr = atoi(argv[2]); 69 status = FT_Open(devNr, \u0026amp;handle); 70 if(status != FT_OK) 71 throw(\u0026#34;Can\u0026#39;t open device!\u0026#34;); 72 73 // 0...input, 1...output 74 FT_SetBitMode(handle, D0 | D1 | D2 | D3, ASYNC_BIT_BANG); 75 if(status != FT_OK) 76 throw(\u0026#34;Can\u0026#39;t set bit-mode!\u0026#34;); 77 78 // 9600 * 16 79 FT_SetBaudRate(handle, FT_BAUD_9600); 80 if(status != FT_OK) 81 throw(\u0026#34;Can\u0026#39;t set baud rate!\u0026#34;); 82 83 cout \u0026lt;\u0026lt; \u0026#34;End write mode with 0xff!\u0026#34; \u0026lt;\u0026lt; endl; 84 85 do 86 { 87 cout \u0026lt;\u0026lt; \u0026#34;New value (x x x x D3 D2 D1 D0): \u0026#34;; 88 cin \u0026gt;\u0026gt; hex \u0026gt;\u0026gt; tmp; 89 90 if (tmp != 0xFF) 91 { 92 output = (unsigned char)tmp \u0026amp; 0x0F; 93 FT_Write(handle, \u0026amp;output, 1, \u0026amp;bytesWritten); 94 if(status != FT_OK) 95 throw(\u0026#34;Can\u0026#39;t write to device!\u0026#34;); 96 97 Sleep(100); 98 } 99 } 100 while (tmp != 0xFF); 101 102 FT_Close(handle); 103 if(status != FT_OK) 104 throw(\u0026#34;Can\u0026#39;t close device!\u0026#34;); 105 } 106 else if ((argc == 4) \u0026amp;\u0026amp; (strcmp(argv[1], \u0026#34;-read\u0026#34;) == 0)) 107 { 108 // open output file 109 ofstream out(argv[3]); 110 if(!out.is_open()) 111 throw(\u0026#34;Can\u0026#39;t open file!\u0026#34;); 112 113 // open FTDI device 114 devNr = atoi(argv[2]); 115 status = FT_Open(devNr, \u0026amp;handle); 116 if(status != FT_OK) 117 throw(\u0026#34;Can\u0026#39;t open device!\u0026#34;); 118 119 // 0...input, 1...output 120 FT_SetBitMode(handle, 0, ASYNC_BIT_BANG); 121 if(status != FT_OK) 122 throw(\u0026#34;Can\u0026#39;t set bit-mode!\u0026#34;); 123 124 // 9600 * 16 125 FT_SetBaudRate(handle, FT_BAUD_9600); 126 if(status != FT_OK) 127 throw(\u0026#34;Can\u0026#39;t set baud rate!\u0026#34;); 128 129 cout \u0026lt;\u0026lt; \u0026#34;End read mode by unplugging the device!\u0026#34; \u0026lt;\u0026lt; endl; 130 out \u0026lt;\u0026lt; \u0026#34;date\\ttime\\tvalue\u0026#34; \u0026lt;\u0026lt; endl; 131 132 do 133 { 134 // clear device buffers 135 status = FT_Purge(handle, FT_PURGE_RX | FT_PURGE_TX); 136 if(status != FT_OK) 137 { 138 out.close(); 139 cout \u0026lt;\u0026lt; \u0026#34;File was written.\u0026#34; \u0026lt;\u0026lt; endl; 140 141 throw(\u0026#34;Can\u0026#39;t clear device buffers!\u0026#34;); 142 } 143 144 // read all inputs 145 status = FT_Read(handle, \u0026amp;input, 1, \u0026amp;bytesRead); 146 if(status != FT_OK) 147 { 148 out.close(); 149 cout \u0026lt;\u0026lt; \u0026#34;File was written.\u0026#34; \u0026lt;\u0026lt; endl; 150 151 throw(\u0026#34;Can\u0026#39;t read from device!\u0026#34;); 152 } 153 154 // if something changed 155 if (tmp != input) 156 { 157 time(\u0026amp;rawtime); 158 timeinfo = localtime(\u0026amp;rawtime); 159 out \u0026lt;\u0026lt; setfill(\u0026#39;0\u0026#39;); 160 out \u0026lt;\u0026lt; setw(4); 161 out \u0026lt;\u0026lt; timeinfo-\u0026gt;tm_year + 1900 \u0026lt;\u0026lt; \u0026#34;.\u0026#34;; 162 out \u0026lt;\u0026lt; setw(2); 163 out \u0026lt;\u0026lt; timeinfo-\u0026gt;tm_mon \u0026lt;\u0026lt; \u0026#34;.\u0026#34;; 164 out \u0026lt;\u0026lt; setw(2); 165 out \u0026lt;\u0026lt; timeinfo-\u0026gt;tm_mday \u0026lt;\u0026lt; \u0026#34;\\t\u0026#34;; 166 out \u0026lt;\u0026lt; setw(2); 167 out \u0026lt;\u0026lt; timeinfo-\u0026gt;tm_hour \u0026lt;\u0026lt; \u0026#34;:\u0026#34;; 168 out \u0026lt;\u0026lt; setw(2); 169 out \u0026lt;\u0026lt; timeinfo-\u0026gt;tm_min \u0026lt;\u0026lt; \u0026#34;:\u0026#34;; 170 out \u0026lt;\u0026lt; setw(2); 171 out \u0026lt;\u0026lt; timeinfo-\u0026gt;tm_sec; 172 out \u0026lt;\u0026lt; hex \u0026lt;\u0026lt; \u0026#34;\\t0x\u0026#34; \u0026lt;\u0026lt; (int)input \u0026lt;\u0026lt; dec \u0026lt;\u0026lt; endl; 173 } 174 tmp = input; 175 } 176 while(true); 177 178 FT_Close(handle); 179 if(status != FT_OK) 180 throw(\u0026#34;Can\u0026#39;t close device!\u0026#34;); 181 182 out.close(); 183 } 184 else 185 { 186 cout \u0026lt;\u0026lt; endl; 187 cout \u0026lt;\u0026lt; \u0026#34; \u0026#34; \u0026lt;\u0026lt; argv[0] \u0026lt;\u0026lt; \u0026#34; -list\u0026#34; \u0026lt;\u0026lt; endl; 188 cout \u0026lt;\u0026lt; \u0026#34; ... lists some information\u0026#34; \u0026lt;\u0026lt; endl; 189 cout \u0026lt;\u0026lt; endl; 190 cout \u0026lt;\u0026lt; \u0026#34; \u0026#34; \u0026lt;\u0026lt; argv[0] \u0026lt;\u0026lt; \u0026#34; -write 0\u0026#34; \u0026lt;\u0026lt; endl; 191 cout \u0026lt;\u0026lt; \u0026#34; ... opens device 0 in output mode\u0026#34; \u0026lt;\u0026lt; endl; 192 cout \u0026lt;\u0026lt; endl; 193 cout \u0026lt;\u0026lt; \u0026#34; \u0026#34; \u0026lt;\u0026lt; argv[0] \u0026lt;\u0026lt; \u0026#34; -read 0 samples.txt\u0026#34; \u0026lt;\u0026lt; endl; 194 cout \u0026lt;\u0026lt; \u0026#34; ... opens device 0 in input mode\u0026#34; \u0026lt;\u0026lt; endl; 195 cout \u0026lt;\u0026lt; \u0026#34; and stores read data in samples.txt\u0026#34; \u0026lt;\u0026lt; endl; 196 cout \u0026lt;\u0026lt; endl; 197 } 198 } 199 catch(char const *error) 200 { 201 cout \u0026lt;\u0026lt; \u0026#34;Error: \u0026#34; \u0026lt;\u0026lt; error \u0026lt;\u0026lt; endl; 202 } 203 catch(...) 204 { 205 cout \u0026lt;\u0026lt; \u0026#34;Undefined Error!\u0026#34; \u0026lt;\u0026lt; endl; 206 } 207 208 cout \u0026lt;\u0026lt; \u0026#34;Press any key...\u0026#34; \u0026lt;\u0026lt; endl; 209 getch(); 210 return 0; 211} ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/cpp/ftdi-bit-bang/","section":"Code Schnipsel","summary":"","title":"C++ - FTDI BitBang-Mode","type":"code-snippets"},{"content":" 1#include \u0026lt;iostream.h\u0026gt; 2 3using namespace std; 4 5int main() 6{ 7 cout \u0026lt;\u0026lt; \u0026#34;hello world\u0026#34; \u0026lt;\u0026lt; endl; 8 9 return 0; 10} ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/cpp/hello-world/","section":"Code Schnipsel","summary":"","title":"C++ - Hello World","type":"code-snippets"},{"content":" 1// Literatur: Vorlesungsunterlagen ASD3 von Thomas Scheidl (FH-Hagenberg) 2// http://linux.die.net/man/ 3 4 5//executable.cpp: 6//------------------------------------------------------------------- 7\t#include \u0026lt;iostream\u0026gt; 8\t#include \u0026lt;dlfcn.h\u0026gt; 9 10\tusing namespace std; 11 12\ttypedef void (*Test)(); 13 14\tint main() 15\t{ 16\tvoid *lib = dlopen(\u0026#34;./sharedobject.so\u0026#34;, RTLD_NOW); 17 18\tif (lib != 0) 19\t{ 20\tTest f1 = reinterpret_cast\u0026lt;Test\u0026gt;(dlsym(lib, \u0026#34;Test\u0026#34;)); 21 22\tif (f1 != 0) 23\t{ 24\tf1(); 25\t} 26\telse 27\t{ 28\tcout \u0026lt;\u0026lt; dlerror() \u0026lt;\u0026lt; endl; 29\tcout \u0026lt;\u0026lt; \u0026#34;failed get function pointer\u0026#34; \u0026lt;\u0026lt; endl; 30\t} 31 32\tdlclose(lib); 33\t} 34\telse 35\t{ 36\tcout \u0026lt;\u0026lt; \u0026#34;failed loading .so\u0026#34; \u0026lt;\u0026lt; endl; 37\t} 38\t} 39 40//sharedobject.cpp: 41//------------------------------------------------------------------- 42\t#include \u0026lt;iostream\u0026gt; 43 44\tusing namespace std; 45 46\textern \u0026#34;C\u0026#34; void Test() 47\t{ 48\tcout \u0026lt;\u0026lt; \u0026#34;Test\u0026#34; \u0026lt;\u0026lt; endl; 49\t} 50 51//Makefile: 52//------------------------------------------------------------------- 53\tmain: SO EXC 54 55\tSO: sharedobject.cpp 56\tg++ -shared -o sharedobject.so sharedobject.cpp 57 58\tEXC: executable.cpp 59\tg++ -o executable executable.cpp -ldl 60 61\tclean: 62\trm -f *.o ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/cpp/linux-shared-object/","section":"Code Schnipsel","summary":"","title":"C++ - Linux Shared Object","type":"code-snippets"},{"content":" 1// Literatur: Vorlesungsunterlagen SEN (FH Hagenberg, HSSE Semester 2) 2// C++ Referenz (http://www.cplusplus.com) 3 4// Klasse kapselt Members(Variablen), Methoden(Funktionen) 5// und regelt den Zugriff 6 7class aClass 8{ 9private: // eigener Zugriff +friends 10 int mVar; // Member 11protected: // eigener Zugriff +abgeleitete Klassen +friends 12 void doSomething(){} // Methode 13public: // oeffentlicher Zugriff 14 aClass(){} // Constructor: Initialisierung des Objektes 15 ~aClass(){} // Destruktor: Freigabe der Resourcen 16}; 17 18 19// Erzeugen von Instanzen (Objekten) 20// statisch - am Stack 21 aClass cl1; 22 cl1.setX(0); 23 24// dynamisch - am Heap 25 aClass *pCl2 = 0; 26 pCl2 = new aClass; 27 pCl2-\u0026gt;setX(0); 28 29 delete pCl2; 30 pCl2 = 0; 31 32 33// this-Pointer 34// versteckter/impliziter Parameter bei jeder Methode 35 void doSomething() 36 { 37 this-\u0026gt;setX(0); 38 } 39 40 aClass * const this; // so waere der this-Pointer deklariert 41 42 43// Konstante Methoden 44// Methode kann Members nicht veraendern 45 int doSomething() const 46 { 47 return mX; 48 } 49 50 51// Konstruktor Initialisierungsliste 52// Konstanten muessen initialisiert werden 53// explicit ... erlaubt keine implicite Konvertierung 54 class aClass 55 { 56 public: 57 aClass(): mConst(10), mVal(0) {} 58 explicit aClass(int value): mConst(10), mVal(value) {} 59 private: 60 int const mConst; 61 int mVal; 62 }; 63 64 aClass cl = 100; // nicht erlaubt da implizite Konvertierung 65 // von int nach aClass nicht erlaubt 66 67 68// Copy-Konstruktor 69 class aClass 70 { 71 aClass(aClass const \u0026amp;cl): mVal(cl.mVal), ... {} 72 }; 73 74 aClass cl1; // default CTOR 75 aClass cl2 = cl1; // Copy-CTOR 76 aClass cl3(cl1); // Copy-CTOR 77 78 aClass cl4; 79 cl4 = cl1; // Zuweisungsoperator = 80 81 82// friend-Funktion und Klassen 83 class aClass 84 { 85 friend void Function(aClass const \u0026amp;cl); 86 friend class bClass; 87 ... 88 }; 89 90 void Function(aClass const \u0026amp;cl) 91 { 92 cl.getX(); 93 ... 94 } 95 96 97// statische Member und Methoden 98// statische Member existieren 1x pro Klasse, nicht 1x pro Objekt 99 class aClass 100 { 101 ... 102 static int GetCnt() const 103 { 104 return cnt; 105 } 106 107 static int cnt; 108 }; 109 int aClass::cnt = 0; // static-Member initialisieren 110 111 int count = Object::GetCnt(); // Aufruf statischer Methoden 112 113 114// Beziehungen zwischen Klassen 115 class aClass: public bClass // \u0026#34;ist ein\u0026#34;-Beziehung (Spezialisierung) 116 { 117 ... 118 cClass *mCCl; // \u0026#34;hat\u0026#34;-Beziehung (Aggregation) 119 }; 120 121 122// Polymorphie 123// erforder einen Pointer oder eine Referenz 124 baseClass *pBase = new derivedClass1; 125 pBase = new derivedClass2; 126 127 128// Ueberladen 129// Unterscheidung am Rueckgabetyp alleine genuegt nicht 130 class aClass 131 { 132 ... 133 void doSomething(int val1, int val2); 134 void doSomething(int val1, double val2); 135 void doSomething(int val1, int val2, int val3); 136 }; 137 138 139// statischer und dynamischer Datentyp 140 baseClass *pBase = new derivedClass; 141 // statischer Datentyp = baseClass 142 // dynamischer Datentyp = derivedClass 143 144 // Aufruf jener Funktion, welcher dem dynamischen Datentyp entspricht 145 virtual void doSomethingMethod() 146 // DTOR immer virtuell, damit Objekte zur Gaenze geloescht werden 147 virtual ~aClass() 148 // diese Methode muss in der abgeleiteten Klasse implementiert werden, 149 // somit ist Klasse abstrakt 150 virtual void doSomethingMethod() = 0; 151 152 153// Aufteilung in Header- und Source-Datei 154// *.h 155 #ifndef ACLASS_H 156 #define ACLASS_H 157 158 class aClass 159 { 160 public: 161 aClass(); 162 ~aClass(); 163 164 void doSomething(); 165 private: 166 int mVal; 167 }; 168 169// *.cpp 170 #include \u0026#34;aclass.h\u0026#34; 171 172 aClass::aClass() 173 { 174 ... 175 } 176 aClass::~aClass() 177 { 178 ... 179 } 180 void aClass::doSomething() 181 { 182 ... 183 } 184 185 186// Template Klasse 187// selbst die Implementierung muss in der Header-Datei erfolgen 188 template \u0026lt;typename T\u0026gt; 189 class Value 190 { 191 public: 192 Value(T const \u0026amp;val); 193 void Print() const; 194 private: 195 T value; 196 }; 197 198 template \u0026lt;typename T\u0026gt; 199 Value\u0026lt;T\u0026gt;::Value(T const \u0026amp;val) 200 { 201 value = val; 202 } 203 template \u0026lt;typename T\u0026gt; 204 void Value\u0026lt;T\u0026gt;::Print() const 205 { 206 cout \u0026lt;\u0026lt; value; 207 } 208 209 Value\u0026lt;int\u0026gt; val1(4); 210 val1.Print(); 211 212 Value\u0026lt;double\u0026gt; val2(5.5); 213 val2.Print(); 214 215 216// Operator Overloading 217 class aClass 218 { 219 ... 220 aClass operator +(aClass const \u0026amp;cl); 221 bool operator ==(aClass const \u0026amp;cl); 222 }; 223 ostream \u0026amp;operator \u0026lt;\u0026lt;(ostream \u0026amp;out, aClass const \u0026amp;cl); 224 225 226// Vorwaertsdeklaration 227 class aClass; 228 229 class bClass 230 { 231 ... 232 private: 233 aClass mCl; 234 }; 235 236 class aClass 237 { 238 ... 239 private: 240 bClass mCl; 241 }; ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/cpp/oop-reference/","section":"Code Schnipsel","summary":"","title":"C++ - OOP Reference","type":"code-snippets"},{"content":" 1#include \u0026lt;iostream\u0026gt; 2 3using namespace std; 4 5int main(int argc, char *argv[]) 6{ 7 char *str1 = new char[10]; 8 char *str2 = new char[5]; 9 char *str3 = new char[10]; 10 11 for (int i=0; i\u0026lt;9; i++) 12 { 13 str1[i] = \u0026#39;a\u0026#39;; 14 str3[i] = \u0026#39;c\u0026#39;; 15 } 16 str1[9] = 0; 17 str3[9] = 0; 18 for (int i=0; i\u0026lt;4; i++) 19 { 20 str2[i] = \u0026#39;b\u0026#39;; 21 } 22 str2[4] = 0; 23 24 char **strArray = new char*[3]; 25 strArray[0] = str1; 26 strArray[1] = str2; 27 strArray[2] = str3; 28 29 cout \u0026lt;\u0026lt; strArray[0] \u0026lt;\u0026lt; endl; 30 cout \u0026lt;\u0026lt; strArray[1] \u0026lt;\u0026lt; endl; 31 cout \u0026lt;\u0026lt; strArray[2] \u0026lt;\u0026lt; endl; 32 33 /*******************************************/ 34 char **strArray2 = new char*[3]; 35 strArray2[0] = new char[10]; 36 strArray2[1] = new char[5]; 37 strArray2[2] = new char[10]; 38 39 for (int i=0; i\u0026lt;9; i++) 40 { 41 (strArray2[0])[i] = \u0026#39;a\u0026#39;; 42 (strArray2[2])[i] = \u0026#39;c\u0026#39;; 43 } 44 (strArray2[0])[9] = 0; 45 (strArray2[2])[9] = 0; 46 for (int i=0; i\u0026lt;4; i++) 47 { 48 (strArray2[1])[i] = \u0026#39;b\u0026#39;; 49 } 50 (strArray2[1])[4] = 0; 51 52 cout \u0026lt;\u0026lt; strArray2[0] \u0026lt;\u0026lt; endl; 53 cout \u0026lt;\u0026lt; strArray2[1] \u0026lt;\u0026lt; endl; 54 cout \u0026lt;\u0026lt; strArray2[2] \u0026lt;\u0026lt; endl; 55 56 return 1; 57} ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/cpp/pointer-to-pointer-array/","section":"Code Schnipsel","summary":"","title":"C++ - Pointer to Pointer Array","type":"code-snippets"},{"content":" 1// Literatur: Vorlesungsunterlagen SEN (FH Hagenberg, HSSE Semester 1) 2// C++ Referenz (http://www.cplusplus.com) 3 4// Praeprozessoranweisungen 5// beginnen mit # 6 #include \u0026lt;stdio\u0026gt; // Systemheader 7 #include \u0026#34;myModul.h\u0026#34; // benutzerdefinierte Header 8 9 #ifdef SYMBOL // bedingte Compilierung 10 #ifndef SYMBOL 11 #if SYMBOL == 1 12 ... 13 #else 14 ... 15 #endif 16 17 #define SYMBOL 18 #define SYMBOL 1 19 #undef SYMBOL 20 21 #define square(x) x*x // Makros 22 cout \u0026lt;\u0026lt; square(2); 23 24 #define assign(x,y) x=(y) 25 assign(x,3); 26 27 28// Modulisierung 29// asdf.h ... Headerdatei 30 #ifndef ASDF_H 31 #define ASDF_H 32 33 #include \u0026lt;string\u0026gt; 34 35 void DoSomething(std::string str); 36 37 #endif 38 39// asdf.cpp ... Sourcedatei 40 #include \u0026#34;asdf.h\u0026#34; 41 42 using namespace std; 43 44 void DoSomething(string str) 45 { 46 ... 47 } 48 49 50// Namespaces 51// Deklarationen in gemeinsamen Namensraum zusammenfassen 52 namespace mySpace 53 { 54 void doSomething() 55 { 56 ... 57 } 58 } 59 60 mySpace::doSomething(); 61 62 using namespace mySpace::doSomething; 63 doSomething(); 64 65 using namespace mySpace; 66 doSomething(); 67 68 69 namespace // anonyme Namespaces 70 { // nur in eigenen Datei sichtbar 71 void doSomething() 72 { 73 ... 74 } 75 } 76 doSomething(); 77 78 79// Datentypen 80 bool // true, false 81 char // 1 Byte -128 bis 127 82 unsigned char // 1 Byte 0 bis 255 83 int // 2 Byte -32 768 bis 32 767 84 // 4 Byte -2 147 483 648 bis 2 147 483 647 85 unsigned int // 2 Byte 0 bis 65 535 86 // 4 Byte 0 bis 4 294 967 295 87 long // 8 Byte 88 unsigned long // 8 Byte 89 float // 4 Byte +/- 3,4E+/-38 ( 7 digits) 90 double // 8 Byte +/- 1,7E+/-308 (15 digits) 91 92 char str[] = \u0026#34;hello\u0026#34;; // gespeichert wird: hello\\0 93 string // basic_string\u0026lt;char\u0026gt; ... 8 Bit pro Zeichen 94 wstring // basic_string\u0026lt;wchar_t\u0026gt; ... 16 Bit pro Zeichen 95 96 size_t s = sizeof(var); 97 98 int arr[] = {...}; 99 size_t arrElems = sizeof(arr) / sizeof(int); 100 101 102// Arrays 103 int values[10]; 104 values[0] = 0; 105 ... 106 values[9] = 0; 107 values[9] = *(values + 9) 108 109 int values[] = {1,2}; 110 int values[10] = {1,2}; // values[2] ... values[9] sind 0 111 int values[10] = {}; // alle values sind 0 112 113 int values[2][3]; 114 int values[2][3] = {{1,2,3},{4,5,6}} 115 values[0][0] = 0; 116 ... 117 values[1][2] = 0; 118 values[1][2] = *(values + (1 * 3) + 2); 119 120 121// Enumerationstypen 122 enum eColor {red, green, blue, yellow}; // intern integer als Datentyp 123 eColor c = red; 124 125 enum eColor {red = 2, green, blue, yellow}; 126 127 128// Typdefinitionen 129 typedef unsigned int uint; 130 uint number; 131 132 typedef int tArr[2][2]; 133 tArr arr; 134 135 136// Pointer, dynamische Variablen 137 int value = 10; 138 int *pInt = 0; 139 pInt = new int; 140 141 *pInt = 5; 142 cout \u0026lt;\u0026lt; *pInt \u0026lt;\u0026lt; endl; 143 144 delete pInt; 145 pInt = 0; 146 147 pInt = \u0026amp;value; 148 *pInt = 5; 149 150 151 int *arr = new int[10]; 152 arr[0] = 0; 153 ... 154 arr[9] = 0; 155 delete[] arr; 156 arr = 0; 157 158 int const * const pt = \u0026amp;var; // konstanter Pointer auf 159 // konstanten Integer-Wert 160 *pt = 1; // Fehler, da \u0026#34;int const\u0026#34; 161 pt = 0; // Fehler, da \u0026#34;* const\u0026#34; 162 163 //Probleme: Memory-Leaks ... Speicherfreigabe wurde vergessen 164 // Dangling-Pointer ... Speicher wurde freigegeben, 165 // Pointer zeigt aber noch auf Speicher- 166 // bereich 167 168 169// Funktionspointer 170 void f1() 171 { 172 ... 173 } 174 175 void (*pFunction)(); 176 pFunction = f1; 177 pFunction(); 178 179 180// Strukturen 181 struct sValues 182 { 183 int val1; 184 int val2; 185 int val3; 186 }; 187 188 sValues values; 189 values.val1 = 0; 190 191 sValues *pValues = new sValues; 192 (*pValues).val1 = 0; 193 pValues-\u0026gt;val1 = 0; 194 delete pValues; 195 pValues = 0; 196 197 struct // anonyme Datenstrukturen 198 { 199 int val1; 200 int val2; 201 int val3; 202 } values1, values2; 203 values1.val1 = 0; 204 values2.val1 = 0; 205 206 207// Bitfelder 208 struct BitField 209 { 210 unsigned int a:3; // 000 - 1111 211 unsigned int b:2; // 00 - 11 212 unsigned int c:3; // 000 - 111 213 }; 214 215 BitField bf; 216 bf.a = 5; 217 bf.b = 1; 218 bf.c = 4; 219 220 221// Unions 222 union uint32 223 { 224 unsigned int integerVal; 225 unsigned char charVal[4]; 226 }; 227 228 uint32 val; 229 val.integerVal = 0; 230 val.charVal[0] = 0xff; 231 232 233// arithmetische Operatoren 234 + // Addition 235 - // Subtraktion 236 * // Multiplikation 237 / // Division 238 % // Modulo (Divisionsrest) 239 240 i += 2; // i = i + 2; 241 i -= 2; 242 i /= 2; 243 i *= 2; 244 245 i++; // Postincrement: i = i + 1; 246 ++i; // Preincrement 247 i--; // Postdecrement 248 --i; // Preincrement 249 250 251// Vergleichsoperatoren 252 == // gleich 253 != // ungleich 254 \u0026lt; // kleiner 255 \u0026lt;= // kleiner gleich 256 \u0026gt; // groesser 257 \u0026gt;= // groesser gleich 258 259 260// logische Operatoren 261 \u0026amp;\u0026amp; // und (mit Kurzschlussauswertung) 262 \u0026amp; // und 263 || // oder (mit Kurzschlussauswertung) 264 | // oder 265 ! // nicht 266 267 268// Bitoperationen 269 \u0026amp; // bitweises und 270 | // bitweises oder 271 ~ // bitweises nicht 272 ^ // XOR (exclusives oder) 273 \u0026gt;\u0026gt; // Rechtsshift 274 \u0026lt;\u0026lt; // Linksshift 275 276 277// Alternativeoperator 278 y = (x \u0026lt; 0) ? 0 : 1; 279 280 if (x \u0026lt; 0) 281 y = 0; 282 else 283 y = 1; 284 285 286// Casts 287// C - Casts 288 int x; 289 double y; 290 291 x = (int)y; 292 y = (double)x; 293 294// C++ - Casts 295 dynamic_cast 296 // konvertiert einen Zeiger eines Klassentyps auf einen 297 // Zeiger in gleichen Ableitungskette 298 // uebernimmt Typpruefung, nur auf Zeiger und Referenzen von 299 // polymorphen Typen 300 static_cast 301 // ohne Typpruefung, auch fuer nicht-polymorphen Typen (~ wie C-Casts) 302 const_cast 303 // Qualifier const und volatile wird entfernt 304 reinterpret_cast 305 // Zeiger kann in beliebigen anderen Zeiger konvertiert werden 306 307 baseClass *pCl = 0; 308 derivedClass cl; 309 pCl = dynamic_cast\u0026lt;baseClass *\u0026gt;(\u0026amp;cl); 310 311 312// Anweisungen 313 break // Schleife wird beendet 314 continue // Sprung zum Schleifenstart 315 316 goto A; // beliebiges Sprungziel 317 A: ... 318 319 320// Vorwaertsdeklaration 321 int doSomething(); 322 323 int main() 324 { 325 ... 326 doSomething(); 327 ... 328 } 329 330 void doSomething() 331 { 332 ... 333 } 334 335 336// Parameteruebergabe 337 // \u0026#34;call by value\u0026#34; - Eingabeparameter 338 void doSomething(int param) 339 // \u0026#34;call by reference\u0026#34; - Uebergangsparameter 340 void doSomething(int \u0026amp;param) 341 342 // \u0026#34;call by reference\u0026#34;, bestimmte Anzahl 343 void doSomething(int arr[10]) 344 // \u0026#34;call by reference\u0026#34;, beliebige Anzahl 345 void doSomething(int arr[], size_t elems) 346 = 347 void doSomething(int *arr, size_t elems) 348 // \u0026#34;call by value\u0026#34; 349 void doSomething(int const arr[], size_t elems) 350 = 351 void doSomething(int const *arr, size_t elems) 352 // \u0026#34;call by value\u0026#34;, mehrdimensionales Array 353 void doSomething(int const arr[][cols]); 354 355 // Default-Parameter (nur im Header oder im main) 356 void doSomething(int val = 0) 357 358 359// Variablenspezifizierung 360 static 361 // - Lokale Variablen bleiben beim Verlassen des umschliessenden 362 // Blocks erhalten 363 // - Globale Variablen haben damit nur Datei-Sichtbarkeit 364 // - Member Variablen: es existiert nur eine Instanz fuer alle 365 // Objekte der selben Klasse 366 // - frei stehende Funktionen haben damit nur Datei-Sichtbarkeit 367 // - Methoden: koennen ohne Instanz einer Klasse aufgerufen werden, 368 // koennen aber nur auf statische Member Variablen zugreifen 369 extern 370 // Angabe, dass Variable oder Funktion in einer anderen Quelldatei 371 // definiert ist 372 mutable 373 // Member Variablen: die Variable kann auch bei konstanten Objekten 374 // einer Klasse veraendert werden 375 auto 376 // Speicher automatisch belegen und frei geben 377 register 378 // es wird versucht die Variable in einem Register abzulegen 379 // (zwecks Performance) 380 volatile 381 // Variable kann Externe veraendert werden und sollte durch den 382 // Compiler nicht optimiert werden 383 const 384 // Veraenderungen sind nicht zulaessig 385 386 387// Schleifen und Bedingte Ausfuehrung 388 if(...) 389 { 390 ... 391 } 392 else if(...) 393 { 394 ... 395 } 396 else 397 { 398 .... 399 } 400 401 for (int i=0; i\u0026lt;max; i++) 402 { 403 ... 404 } 405 406 while(...) 407 { 408 ... 409 } 410 411 do 412 { 413 ... 414 } 415 while(...); 416 417 switch(nr) 418 { 419 case 0: 420 ... 421 break; 422 case 1: 423 ... 424 break; 425 default: 426 } 427 428 429// Fehlerbehandlung 430 #include \u0026lt;cassert\u0026gt; 431 assert(NoFailure() == true); 432 433 try 434 { 435 if(...) 436 throw \u0026#34;Fehler in ...\u0026#34;; 437 } 438 catch(char const *error) 439 { 440 } 441 catch(...) 442 { 443 } 444 445 try 446 { 447 if(...) 448 throw (string(\u0026#34;Fehler in ...\u0026#34;)); 449 } 450 catch(string const \u0026amp;str) 451 { 452 } 453 454 455// Rekursion 456 int fakulty(int x) 457 { 458 if (x \u0026lt;= 1) // Abbruchbedingung 459 return 1; 460 461 return (fakulty(x-1) * x); // Rekursion 462 } 463 464 465// Templates 466 template \u0026lt;typename T\u0026gt; 467 void swap(T \u0026amp;x, T \u0026amp;y) 468 { 469 T tmp = x; 470 x = y; 471 y = tmp; 472 } 473 474 swap(int1, int2); 475 swap(str1, str2); ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/cpp/cpp-referenz/","section":"Code Schnipsel","summary":"","title":"C++ - Reference","type":"code-snippets"},{"content":" 1// Literatur: Vorlesungsunterlagen ISE3 (FH-Hagenberg) 2 3/*********************************************************************/ 4/* Projekt fuer statische Library (erzeugt StaticLib.lib) */ 5/*********************************************************************/ 6 7// StaticLib.h: 8//--------------------------------------------------------------------- 9 #ifndef STATICLIB_H 10 #define STATICLIB_H 11 12 int Add(int const val1, int const val2); 13 14 #endif 15 16 17// StaticLib.cpp: 18//--------------------------------------------------------------------- 19 #include \u0026#34;StaticLib.h\u0026#34; 20 21 int Add(int const val1, int const val2) 22 { 23 return val1 + val2; 24 } 25 26 27 28/*********************************************************************/ 29/* Projekt welches die Library verwendet */ 30/* die Library wird bei den Abhaengigkeiten des Linkers eingetragen */ 31/*********************************************************************/ 32 33// TestStaticLib.cpp: 34//--------------------------------------------------------------------- 35 #include \u0026lt;iostream\u0026gt; 36 #include \u0026lt;conio.h\u0026gt; 37 #include \u0026#34;StaticLib.h\u0026#34; 38 39 using namespace std; 40 41 int main() 42 { 43 int sum = Add(1,2); 44 cout \u0026lt;\u0026lt; \u0026#34;Summe: \u0026#34; \u0026lt;\u0026lt; sum \u0026lt;\u0026lt; endl; 45 46 _getch(); 47 return 0; 48 } ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/cpp/static-library/","section":"Code Schnipsel","summary":"","title":"C++ - Static Library","type":"code-snippets"},{"content":" 1// Literatur: Vorlesungsunterlagen SEN (FH Hagenberg, HSSE Semester 2) 2// C++ Referenz (http://www.cplusplus.com) 3 4// Strings 5 #include \u0026lt;string\u0026gt; 6 string s(\u0026#34;test\u0026#34;); 7 s.size(); 8 s.clear(); 9 bool isEmpty = s.empty(); 10 s[0] = \u0026#39;f\u0026#39;; 11 s.at(0) = \u0026#39;f\u0026#39;; 12 13 s += \u0026#34;next\u0026#34;; 14 s += str2; 15 s += \u0026#39;c\u0026#39;; 16 17 s.append(str2); 18 s.append(str2, 2, 3); // ab Zeichen 2, 3 Zeichen lang 19 s.append(\u0026#34;asdf\u0026#34;); 20 s.append(\u0026#34;asdfasdf\u0026#34;, 4); // 4 Zeichen vom String 21 s.append(10,\u0026#39;.\u0026#39;); // 10 x \u0026#39;.\u0026#39; 22 s.append(firstIter, secondIter); 23 24 s.push_back(\u0026#39;c\u0026#39;); 25 26 s.assign(str2); 27 s.assign(str2, 2, 3); // ab Zeichen 2, 3 Zeichen lang 28 s.assign(\u0026#34;asdf\u0026#34;); 29 s.assign(\u0026#34;asdfasdf\u0026#34;, ); // 4 Zeichen vom String 30 s.assign(10, \u0026#39;.\u0026#39;); // 10 x \u0026#39;.\u0026#39; 31 s.assign(firstIter, secondIter); 32 33 s.insert(2, str2); // String an Position 2 einfuegen 34 s.insert(2, str2, 3, 4); // String an Position 2 einfuegen, 35 // ab Zeichen 3, 4 Zeichen lang 36 s.insert(2, \u0026#34;asdf\u0026#34;); // String an Position 2 einfuegen 37 s.insert(2, \u0026#34;asdfasdf\u0026#34;, 4); // String an Position 2 einfuegen, 38 // 4 Zeichen vom String 39 s.insert(2, 10, \u0026#39;.\u0026#39;); // an Position 2, 10 x \u0026#39;.\u0026#39; einfuegen 40 s.insert(iter, \u0026#39;.\u0026#39;); 41 s.insert(iter, 10, \u0026#39;.\u0026#39;); 42 s.insert (iter, str2.begin(), str2.end); 43 44 s.erase(iter); 45 s.erase(firstIter, secondIter); 46 47 s.replace(2, 3, str2); // String an Position 2, 48 // 3 Zeichen lang ersetzen mit str2 49 s.replace(2, 3, str2, 4, 5); // String an Position 2, 50 // 3 Zeichen lang ersetzen mit str2 51 // (ab Position 4, 5 Zeichen lang) 52 s.replace(2, 3, \u0026#34;asdf\u0026#34;); // String an Position 2, 53 // 3 Zeichen lang ersetzen mit String 54 s.replace(2, 3, \u0026#34;asdfasdf\u0026#34;, 4); // String an Position 2, 55 // 3 Zeichen lang ersetzen mit str2 56 // (4 Zeichen vom String) 57 s.replace(2, 3, 10, \u0026#39;.\u0026#39;); // String an Position 2, 58 // 3 Zeichen lang ersetzen mit 10 x \u0026#39;.\u0026#39; 59 s.replace(firstIter, secondIter, str2); 60 s.replace(firstIter, secondIter, \u0026#34;asdf\u0026#34;); 61 s.replace(firstIter, secondIter, \u0026#34;asdfasdf\u0026#34;, 4); 62 s.replace(firstIter, secondIter, 10, \u0026#39;.\u0026#39;); 63 s.replace(firstIter, secondIter, str2.begin(), str2.end()); 64 65 s.copy(charArr, 2, 3); // String ab Position 2, 66 // 3 Zeichen lang in charArr kopieren 67 s.swap(str2); 68 s.c_str(); 69 70 size_t position = s.find(str2); 71 if (position != string::npos) 72 ... 73 s.find(str2, 2); // Suche ab Position 2 74 s.find(\u0026#34;asdf\u0026#34;); 75 s.find(\u0026#34;asdf\u0026#34;, 2); // Suche ab Position 2 76 s.find(\u0026#34;asdf\u0026#34;, 2, 3); // Suche ab Position 2, 3 Zeichen lang 77 s.find(\u0026#39;a\u0026#39;); 78 s.find(\u0026#39;a\u0026#39;, 2); // Suche ab Position 2 79 s.rfind(...); // von hinten Suchen 80 81 string s(\u0026#34;alle Selbstlaute durch Punkt ersetzen\u0026#34;); 82 size_t position; 83 position = s.find_first_of(\u0026#34;aeiou\u0026#34;); 84 while (position != string::npos) 85 { 86 s[position] = \u0026#39;.\u0026#39;; 87 position = s.find_first_of(\u0026#34;aeiou\u0026#34;, position + 1); 88 } // s = \u0026#34;.ll. S.lbstl..t. d.rch P.nkt .rs.tz.n.\u0026#34; 89 s.find_last_of(...); 90 s.find_first_not_of(...); 91 s.find_last_not_of(...); 92 93 str2 = s.substr(); // str2 == s 94 str2 = s.substr(2); // von Position 2 bis zum Ende 95 str2 = s.substr(2, 3); // von Position 2, 3 Zeichen lang 96 97 s.compare(str2) == 0 // Strings gleich 98 s.compare(\u0026#34;asdf\u0026#34;) 99 s.compare(2, 3, str2) // s ab Position 2, 100 // 3 Zeichen lang vergleichen 101 s.compare(2, 3, str2, 4, 5) // s ab Position 2, 102 // 3 Zeichen lang mit str2 ab Position 4, 103 // 5 Zeichen lang vergleichen 104 s.compare(2, 3, \u0026#34;asdf\u0026#34;) // s ab Position 2, 105 // 3 Zeichen lang vergleichen 106 s.compare(2, 3, \u0026#34;asdf\u0026#34;, 4) // s ab Position 2, 3 Zeichen lang mit 107 // \u0026#34;..\u0026#34; 4 Zeichen lang vergleichen 108 109 110// Streams 111 #include \u0026lt;iostream\u0026gt; 112 cout \u0026lt;\u0026lt; \u0026#34;text\u0026#34; \u0026lt;\u0026lt; var \u0026lt;\u0026lt; endl; // standard Ausgabe 113 cin \u0026gt;\u0026gt; intVal; // standard Eingabe 114 115 #include \u0026lt;fstream\u0026gt; 116 ofstream out(\u0026#34;file.txt\u0026#34;); 117 out \u0026lt;\u0026lt; \u0026#34;text\u0026#34;; 118 out.close(); 119 .is_open() 120 .put(char c) 121 .write(const char* c, streamsize maxc) 122 .flush 123 .eof() 124 .fail() 125 126 ifstream in(\u0026#34;file.txt\u0026#34;); 127 in \u0026gt;\u0026gt; intVal; 128 in.close(); 129 .is_open() 130 .get(char \u0026amp;c) 131 .getline(char *c, streamsize maxc) 132 .read(char *c, streamsize maxc) 133 .eof() 134 .fail() 135 136// String Streams 137 #include \u0026lt;sstream\u0026gt; 138 ostringstream oss; 139 oss \u0026lt;\u0026lt; \u0026#34;text\u0026#34;; 140 oss.str(); 141 142 istringstream iss(string); 143 iss \u0026gt;\u0026gt; intVal; 144 145 146// Stream-Manipulatoren 147 hex // Hexadezimalausgabe (bis auf Widerruf) 148 oct // Oktalausgabe 149 dec // Dezimalausgabe 150 151 scientific // Exponenten Darstellung 152 fixed // normale Darstellung 153 154 setprecision(4) // Nachkommastellen fuer naechste Ausgabe 155 setw(3) // Weite der Zahl 156 setfill(\u0026#39;0\u0026#39;) // Fuellzeichen setzen 157 158 left // Ausrichtung 159 right 160 161 upercase // Grossschreibung 162 nouppercase 163 164 boolalpha // Ausgabe von true/false 165 noboolalpha 166 167 ostream \u0026amp;hr (ostream \u0026amp;os) // eigener Manipulator 168 { 169 os \u0026lt;\u0026lt; endl; 170 os \u0026lt;\u0026lt; \u0026#34;-------------\u0026#34;; 171 os \u0026lt;\u0026lt; endl; 172 return os; 173 } 174 175 176// Container 177// Queue - FIFO Datenstruktur 178 queue\u0026lt;int\u0026gt; q; 179 q.push(1); // fuegt Element am Ende ein 180 ivalue = q.front(); // liefert Element am Anfang 181 q.pop(); // loescht Element am Anfang 182 183// Stack - LIFO Datenstruktur 184 stack\u0026lt;int\u0026gt; s; 185 s.push(1); // fuegt Element oben ein 186 ivalue = s.top(); // liefert oberstes Element 187 s.pop(); // loescht oberstes Element 188 189// Vektor - automatisch wachsendes Array 190// + schnelles Einfuegen/Loeschen am Ende 191// + Direktzugriff mit Indexoperator 192 #include \u0026lt;vector\u0026gt; 193 vector\u0026lt;int\u0026gt; v; 194 v.push_back(0); // fuegt Element am Ende ein 195 v[0] // Zugriff auf Element an Stelle 0 196 v.erase(iter); // Element loeschen 197 v.erase(v.begin(), iter); // Bereich loeschen 198 v.empty() // Ueberpruefung ob leer 199 v.size() // Ausgabe der Groesse 200 v.pop_back(); // Element am Ende loeschen 201 v.clear(); // Container loeschen 202 203// Liste - doppelt verkettete Liste 204// + schnelles Einfuegen/Loeschen an jeder Position 205// - nur sequentiellen Zugriff (beide Richtungen) 206 #include \u0026lt;list\u0026gt; 207 list\u0026lt;int\u0026gt; l; 208 l.insert(iter, 0); // Einfuegen eines Elements an 209 // bestimmten Iterator-Position 210 l.push_front(0); // fuegt Element am Anfang ein 211 l.push_back(0); // fuegt Element am Ende ein 212 l.pop_front(); // Element am Anfang loeschen 213 l.pop_back(); // Element am Ende loeschen 214 l.front(); // liefert Element vom Anfang 215 l.back(); // liefert Element vom Ende 216 l.sort(); // Elemente sortieren 217 l.reverse(); // Ordnung der Elemente vertauschen 218 l.clear(); // Container loeschen 219 l.removeif(praedikat); // Loescht Elemente, 220 // welche Bedingung erfuellen 221 l.remove(0); // Loescht alle Elemente mit gleichen Wert 222 223// Map - assoziativer Container mit Schluessel/Werte Paar 224// (eindeutige Schluessel) 225// + Einfuegen und Suchen von Schluesseln in logarithmischer Zeit 226// + Loeschen von Schluesseln in konstanter Zeit 227// + aufsteigend geordnet nach Schluessel 228 #include \u0026lt;map\u0026gt; 229 map\u0026lt;string, int\u0026gt; m; 230 m.insert(pair\u0026lt;string, int\u0026gt;(\u0026#34;test\u0026#34;, 100)); 231 232 pair\u0026lt;map\u0026lt;string, int\u0026gt;::iterator, bool\u0026gt; ret; 233 ret = m.insert(pair\u0026lt;string, int\u0026gt;(\u0026#34;test\u0026#34;, 100)); 234 if (ret.second == false) 235 { 236 cout \u0026lt;\u0026lt; \u0026#34;Element existiert bereits: \u0026#34; \u0026lt;\u0026lt; ret.first-\u0026gt;second \u0026lt;\u0026lt; endl; 237 } 238 239 m.erase(iter); 240 m.erase(\u0026#34;test\u0026#34;); 241 m.erase(firstIter, secondIter); 242 m.clear(); 243 m.find(\u0026#34;test\u0026#34;)-\u0026gt;second; 244 m.count(\u0026#34;test\u0026#34;); 245 m.size(); 246 m.empty(); 247 m[\u0026#34;test2\u0026#34;] = 50; 248 249// Set - assoziativer Container mit Schluesseln (eindeutige Schluessel) 250// + Einfuegen und Suchen von Schluesseln in logarithmischer Zeit 251// + Loeschen von Schluesseln in konstanter Zeit 252// + aufsteigend geordnet nach Schluessel 253 #include \u0026lt;set\u0026gt; 254 set\u0026lt;string\u0026gt; s; 255 s.insert(\u0026#34;test\u0026#34;); 256 s.erase(iter); 257 s.erase(\u0026#34;test\u0026#34;); 258 s.erase(firstIter, secondIter); 259 s.clear(); 260 iter = s.find(\u0026#34;test\u0026#34;); 261 s.count(\u0026#34;test\u0026#34;); 262 s.size(); 263 s.empty(); 264 265// Bitset 266 #include\u0026lt;bitset\u0026gt; 267 bitset\u0026lt;4\u0026gt; b; 268 b.set(); // alle Bits setzen 269 b.set(2); // Bit an Position 2 setzen 270 b.set(2, true); // Bit an Position 2 setzen 271 b.set(2, false); // Bit an Position 2 loeschen 272 273 b.reset(); // alle Bits loeschen 274 b.reset(2); // Bit an Position 2 loeschen 275 276 b.flip(); // alle Bits negieren 277 b.flip(2); // Bit an Position 2 negieren 278 279 int size = b.size(); // Anzahl der Bits 280 int cnt = b.count(); // Anzahl an gesetzten Bits 281 bool erg = b.any(); // true, wenn irgend ein Bit gesetzt 282 bool erg = b.none(); // true, wenn kein Bit gesetzt 283 bool erg = b.test(2); // true, wenn Bit an Position 2 gesetzt 284 285 286 dequeue // ... double ended queue 287 // + schnelles Einfuegen/Loeschen am Anfang und am Ende 288 slist // ... einfach verkettete Liste 289 // + benoetigt weniger Speicher 290 // - Durchlauf nur in eine Richtung 291 multimap // ... Schluessel/Werte Paare 292 // (mehrfache Verwendung von Schluessel erlaubt) 293 multiset // ... Schluessel (mehrfache Verwendung von Schluessel erlaubt) 294 295 296// Iteratoren 297 vector\u0026lt;int\u0026gt;::iterator iter = vec.begin(); 298 vector\u0026lt;int\u0026gt;::const_iterator citer = vec.end(); 299 vector\u0026lt;int\u0026gt;::reverse_iterator riter = vec.rbegin(); 300 vector\u0026lt;int\u0026gt;::reverse_const_iterator rciter = vec.rend(); 301 302 back_inserter(Container) 303 forward_inserter(Container) 304 inserter(Container, Container.end()) 305 306 distance(firstIter, secondIter) // Abstand der Iteratoren 307 advance(Iter, distance) // Iterator weiter setzen 308 309// Stream Iteratoren 310 istream_iterator\u0026lt;int\u0026gt; in(cin); 311 istream_iterator\u0026lt;int\u0026gt; eos; 312 copy(in, eos, back_inserter(vec)); 313 314 ostream_iterator\u0026lt;int\u0026gt; out(cout, \u0026#34; \u0026#34;); 315 copy(vec.begin(), vec.end(), out); 316 317 318// Praedikate 319 bool Pred(int x, int y) // true ... Aktion wird ausgefuehrt 320 { // false ... Aktion wird nicht ausgefuehrt 321 return x \u0026gt; y; 322 } 323 324 bool Pred(int x) 325 { 326 return x \u0026gt;= 0; 327 } 328 329 plus\u0026lt;\u0026gt; 330 minus\u0026lt;\u0026gt; 331 multiplies\u0026lt;\u0026gt; 332 divides\u0026lt;\u0026gt; 333 modulus\u0026lt;\u0026gt; 334 negate\u0026lt;\u0026gt; 335 336 logical_and\u0026lt;\u0026gt; 337 logical_not\u0026lt;\u0026gt; 338 logical_or\u0026lt;\u0026gt; 339 340 equal_to\u0026lt;\u0026gt; 341 not_equal_to\u0026lt;\u0026gt; 342 greater\u0026lt;\u0026gt; 343 greater_equal\u0026lt;\u0026gt; 344 less\u0026lt;\u0026gt; 345 less_equal\u0026lt;\u0026gt; 346 347 348// Algorithmen 349 #include \u0026lt;algorithm\u0026gt; 350 fill(v.begin(), v.end(), 0); 351 fill_n(v.begin(), 3, 0); 352 fill_n(back_inserter(v), 10, 0); 353 354 generate(v.begin(), v.end(), Func); 355 generate(v.begin(), 3, Func); 356 357 copy(c1.begin(), c1.end(), back_inserter(c2)); 358 copy(c1.begin(), c1.end(), ostream_iterator\u0026lt;int\u0026gt;(cout, \u0026#34; \u0026#34;)); 359 copy_backward(c1.begin(), c1.end(), ...); 360 361 iter = find(v.begin(), v.end(), 5); 362 iter = find_if(v.begin(), v.end(), Pred); 363 364 count(v.begin(), v.end(), Elem); 365 count_if(v.begin(), v.end(), Pred); 366 for_each(v.begin(), v.end(), Func); 367 bool vorhanden = binary_search(v.begin(), v.end(), 5); 368 369 bool gleich = equal(v.begin(), v.end(), v2.begin()); 370 bool gleich = equal(v.begin(), v.end(), v2.begin(), Pred); 371 bool kleiner = lexicographical_compare(v.begin(), v.end(), 372 v2.begin(), v2.end()); 373 bool kleiner = lexicographical_compare(v.begin(), v.end(), 374 v2.begin(), v2.end(), Pred); 375 376 elemC = max(elemA, elemB); 377 elemC = max(elemA, elemB, Pred); 378 iterC = max_element(v.begin(), v.end()); 379 iterC = max_element(v.begin(), v.end(), Pred); 380 min 381 min_element 382 383 transform(v.begin(), v.end(), v.begin(), negate\u0026lt;int\u0026gt;()); 384 transform(str.begin(), str.end(), str.begin(), toupper); 385 transform(v1.begin(), v1.begin()+5, v2.begin(), 386 vres.begin(), plus\u0026lt;int\u0026gt;()); 387 388 sum = accumulate(v.begin(), v.end(), 0); 389 prod = accumulate(v.begin(), v.end(), 1, multiplies\u0026lt;int\u0026gt;()); 390 391 sort(v.begin(), v.end()); 392 sort(v.begin(), v.end(), Pred); 393 stable_sort(v.begin(), v.end()); 394 stable_sort(v.begin(), v.end(), Pred); 395 396 merge(v.begin(), v.end(), v2.begin(), v2.end(), vres.begin()); 397 merge(v.begin(), v.end(), v2.begin(), v2.end(), vres.begin(), Pred); 398 399 400// Operationen fuer nicht initialisierte Container 401 uninitialized_copy 402 uninitialized_fill 403 uninitialized_fill_n 404 405 406// Funktions Adaptoren 407 bind1st(divide\u0026lt;int\u0026gt;(), 10) 408 bind2nd(divide\u0026lt;int\u0026gt;(), 10) 409 410 bind2nd(not2(less\u0026lt;int\u0026gt;()), 10) = not1(bind2nd(less\u0026lt;int\u0026gt;(), 10)) 411 412 char* chNrs[] = {\u0026#34;10\u0026#34;,\u0026#34;20\u0026#34;,\u0026#34;30\u0026#34;}; 413 int intNrs[3]; 414 transform(chNrs, chNrs+3, intNrs, ptr_fun(atoi)); 415 416 vector\u0026lt;string*\u0026gt; v; 417 v.push_back(new string(\u0026#34;asdf\u0026#34;)); 418 v.push_back(new string(\u0026#34;asdfasdf\u0026#34;)); 419 vector\u0026lt;int\u0026gt; lengths(v.size()); 420 transform(v.begin(), v.end(), lengths.begin(), mem_fun(\u0026amp;string::length)); 421 422 vector\u0026lt;string\u0026gt; v; 423 v.push_back(\u0026#34;asdf\u0026#34;); 424 v.push_back(\u0026#34;asdfasdf\u0026#34;); 425 vector\u0026lt;int\u0026gt; lengths(v.size()); 426 transform(v.begin(), v.end(), lengths.begin(), 427 mem_fun_ref(\u0026amp;string::length)); 428 429 430 431 432// generische Algorithm 433 template \u0026lt;typename TIter, typename T\u0026gt; 434 TIter find(TIter first, TIter second, T const \u0026amp;val) 435 { 436 while ((first != second) \u0026amp;\u0026amp; (*first != val)) 437 { 438 first++; 439 } 440 return first; 441 } 442 443 template \u0026lt;typename TIter, typename TPred\u0026gt; 444 TIter find_if(TIter first, TIter second, TPred p) 445 { 446 while((first != second) \u0026amp;\u0026amp; !p(*first)) 447 { 448 first++; 449 } 450 return first; 451 } 452 453 template \u0026lt;typename TInItor, typename TOutIter\u0026gt; 454 TOutIter copy(TInIter first, TInIter second, TOutIter result) 455 { 456 for(; first!=second; first++) 457 { 458 *result = *first; 459 } 460 return result; 461 } 462 463 464// Funktoren 465 template \u0026lt;typename T\u0026gt; 466 class multiplies: public binary_function\u0026lt;T,T,T\u0026gt; 467 { 468 public: 469 T operator() (T const \u0026amp;x, T const \u0026amp;y) const 470 { 471 return x*y; 472 } 473 }; 474 475 class startsWith: public unary_function\u0026lt;string,bool\u0026gt; 476 { 477 public: 478 startsWith(char ch): startCh(ch){} 479 bool operator() (string const \u0026amp;str) const 480 { 481 return ((str.length() \u0026gt; 0) \u0026amp;\u0026amp; (str[0] == startCh)); 482 } 483 private: 484 char startCh; 485 }; 486 startsWith(\u0026#39;A\u0026#39;) 487 488 class startsWithChar: public binary_function\u0026lt;string,char,bool\u0026gt; 489 { 490 public: 491 bool operator() (string const \u0026amp;str, char ch) const 492 { 493 return ((str.length() \u0026gt; 0) \u0026amp;\u0026amp; (str[0] == ch)); 494 } 495 }; 496 bind2nd(startsWithChar(), \u0026#39;A\u0026#39;) ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/cpp/std-header-reference/","section":"Code Schnipsel","summary":"","title":"C++ - STD-Header Reference","type":"code-snippets"},{"content":"","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/","section":"Code Schnipsel","summary":"","title":"Code Schnipsel","type":"code-snippets"},{"content":"","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/graphviz/","section":"Code Schnipsel","summary":"","title":"GraphViz","type":"code-snippets"},{"content":" 1Einfuehrung in Graphviz - Graph Visualization Software 2 3 Hilfreiche Dokumentationen unter \u0026#34;http://www.graphviz.org\u0026#34;. 4 5 Generierung der Bilder: 6 dot -Tpng test.dot -o test.png 7 dot -Tps test.dot -o test.ps 8 dot -Tpdf test.dot -o test.pdf 9 10 einfache Beispiel: 11 digraph G { 12 start -\u0026gt; 1; 13 14 /* A ist Label von Pfeil 1 zu 2 */ 15 1 -\u0026gt; 2 [label = \u0026#34;A\u0026#34;]; 16 1 -\u0026gt; 3 [label = \u0026#34;B\u0026#34;]; 17 18 2 -\u0026gt; 3 19 2 -\u0026gt; 1 20 21 3 -\u0026gt; 3 [label = \u0026#34;E\u0026#34;]; 22 23 /* Startknoten nicht sichtbar */ 24 start [label = \u0026#34;\u0026#34;, shape = plaintext]; 25 26 /* Knoten 1 ohne Kreis */ 27 1 [shape = plaintext]; 28 29 /* Knoten 2 erhaelt andere Bezeichnung */ 30 2 [label = \u0026#34;make a\\nstring\u0026#34;]; 31 } 32 33 mehrere Knoten mit selben Bezeichnung: 34 digraph G { 35 /* Anordnung von links nach rechts (RL, TB, BT) */ 36 rankdir=LR; 37 38 1 -\u0026gt; 2; 39 1 -\u0026gt; 3; 40 1 -\u0026gt; 4; 41 42 2 -\u0026gt; 5; 43 2 -\u0026gt; 6; 44 45 3 -\u0026gt; 7; 46 47 4 -\u0026gt; 8; 48 4 -\u0026gt; 9; 49 50 1 [label=\u0026#34;A\u0026#34;]; 51 2 [label=\u0026#34;B\u0026#34;]; 52 3 [label=\u0026#34;C\u0026#34;]; 53 4 [label=\u0026#34;D\u0026#34;]; 54 5 [label=\u0026#34;A\u0026#34;]; 55 6 [label=\u0026#34;E\u0026#34;]; 56 7 [label=\u0026#34;F\u0026#34;]; 57 8 [label=\u0026#34;F\u0026#34;]; 58 9 [label=\u0026#34;G\u0026#34;]; 59 } ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/graphviz/graphviz/","section":"Code Schnipsel","summary":"","title":"Graphviz - Einführung","type":"code-snippets"},{"content":"","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/latex/","section":"Code Schnipsel","summary":"","title":"LaTeX","type":"code-snippets"},{"content":" 1% Literatur: LaTeX kurz \u0026amp; gut, O\u0026#39;Reilly, ISBN: 3-89721-500-4 2 3 4% Kommandouebersicht 5%-------------------------------------------------------------------------- 6% Latex-Datei in DVI-Datei (Device Independent File) uebersetzen 7% latex input.tex 8% DVI-Datei in PS-Datei (Postscript) konvertieren 9% dvips -o output.ps input.dvi 10% PDF-Datei erzeugen (nur Bilder in PDF gekapselt einbindbar) 11% pdflatex input.tex 12 13 14% minimales Latex-Dokument 15%-------------------------------------------------------------------------- 16 \\documentclass[a4paper]{article} 17 \\usepackage[T1]{fontenc} 18 \\usepackage[latin1]{inputenc} 19 \\usepackage{german} 20 21 \\begin{document} 22 \\section{Ueberschrift} 23 Hallo Welt. 24 \\end{document} 25 26% Dokumentklassen 27% article ... technischer Artikel 28% book ... Buch 29% report ... laengerer technischer Artikel 30% letter ... Brief 31% slides ... Overhead-Folien 32 33% Dokumentklassenoptionen 34% 10pt ... 10 Punkt Grundschrift Groesse 35% 11pt ... 11 Punkt Grundschrift Groesse 36% 12pt ... 12 Punkt Grundschrift Groesse 37% a4paper ... DIN A4 Dokument 38% a5paper ... DIN A5 Dokument 39% b5paper ... DIN B5 Dokument 40% draft ... Text ueber Rand schwarz markieren 41% final ... Text ueber Rand nicht markieren 42% landscape ... Querformat 43% notitlepage ... keine Titelseite ausgeben 44% titlepage ... Titelseite ausgeben 45% onecolumn ... einspaltig 46% twocolumn ... zweispaltig 47% oneside ... einseitig 48% twoside ... doppeltseitig 49 50 51% zusaetzliche Pakete 52%-------------------------------------------------------------------------- 53% alltt ... definiert die Umgebung alltt, in der Text unveraendert 54% uebernommen wird (aehnlich verbatim) 55% fontenc ... definiert Zeichensatz-Enkodierung 56% (OMS, OML, OT1, OT4, T1, TS1, T2A, T2B, T2C, TX2) 57% inputenc ... definiert Abbildung von Zeichen im Dokument auf 58% interne Latex-Codes 59% (ascii, ansinew, applemac, latin1, latin2, latin3, 60% latin4, latin5, latin9, latin10, utf8) 61% german ... deutschsprachige Anpassungen 62% ngerman ... deutschsprachige Anpassungen (neue Rechtschreibung) 63% graphics ... fuer das Einbinden von Grafiken 64 65 66% Gliederungsbefehle 67%-------------------------------------------------------------------------- 68% part, section, subsection, subsubsection, paragraph, 69% subparagraph, chapter 70% jeder Befehl mit Zaehler part, section, ... 71 72 befehl[verzeichniseintrag]{ueberschrift} 73 befehl*{ueberschrift} ... nicht im Inhaltsverzeichnis 74 auflisten 75 76% Zaehler 77 \\addtocounter{zaehler}[zahl] 78 \\newcounter{zaehler}[hauptzaehler] ... neuer Zaehler 79 \\stepcounter{zaehler} ... Zaehler inkrementieren und 80 untergeordnete Zaehler 81 zurueck setzen 82 \\setcounter{zaehler}{zahl} ... Zaehler setzen 83 \\value{zaehler} ... Ausgabe des Zaehler-Wertes 84 \\the_zaehler_ ... Wert als Text ausgeben 85 86 87% Seitenformat 88%-------------------------------------------------------------------------- 89% Satzspiegelparameter 90 \\setlength{\\footheight}{Hoehe} 91 92 \\pageheight ... Papierhoehe 93 \\pagewidth ... Papierbreite 94 95 \\topmargin ... vertikaler Abstand zwischen 96 Papierrand und Kopfzeile 97 \\headheight ... Hoehe der Kopfzeile 98 \\headsep ... vertikaler Abstand zwischen Kopfzeile und Text 99 \\textheight ... Hoehe des Textblocks 100 \\footskip ... vertikaler Abstand zwischen Text und Fusszeile 101 \\footheight ... Hoehe der Fusszeile 102 103 \\evensidemargin ... horizontaler Abstand zwischen linken Papierrand 104 und Text (gerade Seite) 105 \\oddsidemargin ... horizontaler Abstand zwischen linken Papierrand 106 und Text (ungerade Seite) 107 \\textwidth ... Breite des Textblocks 108 \\marginparsep ... horizontaler Abstand zwischen Text und 109 Randbemerkung 110 \\marginparwidth ... Breite der Randbemerkung 111 112 \\marginparpush ... min. vertikaler Abstand zwischen Randbemerkungen 113 \\columnsep ... horizontaler Abstand mehrspaltiger Texte 114 \\columnseprule ... Liniendicke der Spaltentrennlinie 115 116% Seitenstil 117 \\pagestyle{Stil} ... fuer alle Seiten 118 \\thispagestyle{Stil} ... nur fuer aktuelle Seite 119% empty ... leere Kopf- Fusszeile 120% headings ... Kopfzeilen-Text laut Dokumentenklasse, 121% leere Fusszeile 122% myheadings ... selbst definieren 123% plain ... leere Kopfzeile, in Fusszeile nur 124% zentrierte Zeilennummer 125 126% Titelseite 127 \\maketitle ... Ausgabe der Titelseite 128 129 \\author{ } ... Author Angaben 130 \\title{ } ... Titel Angaben 131 \\date{ } ... Datum Angaben 132 \\thanks{ } ... zusaetzliche Informationen als Fussnote 133 134% Zusammenfassung 135 \\begin{abstract} 136 ... 137 \\end{abstract} 138 139% Fussnoten 140 \\footnote[Nummer]{Text} 141 \\footnote{Text} ... fortlaufende Nummerierung 142 143% Randbemerkungen 144 \\marginpar[linker Text]{rechter Text} 145 146% Absatzformat 147%-------------------------------------------------------------------------- 148% Ausrichtung 149 \\begin{center} \\begin{...} ... Zentriert 150 ... \\centering 151 \\end{center} ... 152 \\end{...} 153 154 \\begin{flushleft} \\begin{...} ... Linksbuendig 155 ... \\raggedright 156 \\end{flushleft} ... 157 \\end{...} 158 159 \\begin{flushright} \\begin{...} ... Rechtsbuendig 160 ... \\raggedleft 161 \\end{flushright} ... 162 \\end{...} 163 164% Zitate 165 \\begin{quote} \\begin{quotation} 166 ... ... 167 \\end{quote} \\end{quote} 168 169% neue Zeile 170 \\\\[Abstand] ... zusaetzlicher Abstand nach Zeilenumbruch 171 \\\\*[Abstand] ... mit Verhinderung des Seitenumbruchs 172 173% Einzuege eines Absatzes 174 \\indent ... Zeileneinzug einschalten 175 \\noindent ... kein Zeileneinzug 176 177% eigene Positionierung 178 \\newline 179 \\newpage 180 181 182% Zeichensaetze 183%-------------------------------------------------------------------------- 184 \\textrm{ } \\rmfamily ... Serifenschrift 185 \\textsf{ } \\sffamily ... Serifenlose Schrift 186 \\texttt{ } \\ttfamily ... Maschinenschrift 187 \\textmd{ } \\mdseries ... Medium 188 \\textbf{ } \\bfseries ... Halbfett 189 \\textup{ } \\upshape ... Aufrecht 190 \\textit{ } \\itshape ... Kursiv 191 \\textsl{ } \\slshape ... Geneigt 192 \\textsc{ } \\scshape ... Kapitaelchen 193 \\emph{ } \\em ... Hervorgehoben 194 \\textnormal{ } \\normalfont ... Defaul-Schrift 195 196 \\tiny 197 \\scriptsize 198 \\footnotesize 199 \\small 200 \\normalsize 201 \\large 202 \\Large 203 \\LARGE 204 \\huge 205 \\Huge 206 207% Umlaute 208 \\\u0026#34;a \\\u0026#34;o \\\u0026#34;u \\\u0026#34;A \\\u0026#34;O \\\u0026#34;U \\\u0026#34;s 209 \u0026#34;a \u0026#34;o \u0026#34;u \u0026#34;A \u0026#34;O \u0026#34;U \u0026#34;s ... bei deutschsprachigen 210 Dokumente (german, ngerman) 211 ae oe ue AE OE UE ss ... bei entsprechenden inputenc 212 213% Symbole 214 \\S ... Paragraph 215 \\copyright ... Copyright 216 \\LaTeX ... Latex Zeichenfolge 217 \\TeX ... TEX Zeichenfolge 218 219% Listen 220%-------------------------------------------------------------------------- 221% Aufzaehlungen 222 \\begin{itemize} 223 \\item ... 224 \\end{itemize\\ 225 226% numerierte Aufzaehlung 227 \\begin{enumerate} 228 \\enum ... 229 \\end{enumerate} 230 231% Definitionslisten 232 \\item[Ausdruck] Beschreibung 233 234% Formeln 235%-------------------------------------------------------------------------- 236 Formel innerhalb eines Textes 237 $ ... $ 238 abgesetzte Formel 239 \\[ ... \\] 240 abgesetzte Formeln 241 \\begin{eqnarray*} ... \\end{eqnarray*} 242 abgesetzte numerierte Formel 243 \\begin{equation} ... \\end{equation} 244 abgesetzte numerierte Formeln 245 \\begin{eqnarray} ... \\end{eqnarray} 246 247% Symbole 248 \\ast ... Faltungsoperator 249 \\div ... Divisionszeichen 250 \\cdot ... Multiplikationszeichen 251 \\wedge ... Und-Verknuepfung 252 \\vee ... Oder-Verknuepfung 253 \\pm ... Plus-Minus 254 255 \\approx ... ungefaehr 256 \\sim ... ungefaehr (eine Schleife) 257 \\simeq ... ungefaehr-gleich 258 259 \\le ... kleiner 260 \\leq ... kleiner-gleich 261 \\ll ... viel kleiner 262 \\ge ... groesser 263 \\geq ... groesser-gleich 264 \\gg ... viel groesser 265 266 \\in ... Element von 267 268% Pfeile 269 \\downarrow ... Pfeil nach unten 270 \\uparrow ... Pfeil nach oben 271 \\updownarrow ... Pfeil nach unten u. oben 272 \\leftarrow ... Pfeil nach links 273 \\rightarrow ... Pfeil nach rechts 274 \\leftrightarrow ... Pfeil nach links u. rechts 275 276 \\Downarrow ... Pfeil nach unten (zwei Striche) 277 \\Uparrow 278 ... 279 280 \\nearrow ... Pfeil nach rechts-oben 281 \\nwarrow ... Pfeil nach links-oben 282 \\searrow ... Pfeil nach rechts-unten 283 \\swarrow ... Pfeil nach links-unten 284 285% Operationen 286 \\prod ... Produkt 287 \\sum ... Summe 288 \\int ... Integral 289 \\oint ... Kurvenintegral 290 291% Klammerung 292 ( ) 293 \\[ \\] 294 \\{ \\} 295 296 \\left( \\right) ... automatische Vergroesserung 297 \\left\\[ \\right\\] 298 \\left\\{ \\right\\} 299 300% Funktionen 301 \\sin \\cos \\tan \\cot 302 \\arcsin \\arccos \\arctan \\arccot 303 \\sinh \\cosh \\tanh \\coth 304 305 \\arg \\exp \\inf \\lim \\liminf 306 \\ln \\log \\lg 307 \\max \\min 308 309% grichische Buchstaben 310 \\alpha \\beta \\gamma ... 311 \\Alpha \\Beta \\Gamma 312 313% sonstige Symbole 314 x^{ } ... Exponent 315 x_{ } ... Indizes 316 \\sqrt[Ordnung]{} ... Wurzel 317 \\frac{}{} ... Bruch 318 \\limits_{}^{} ... Exponent und Indizes genau unterhalb 319 und oberhalb 320 321 \\ldots ... Punkte auf der Grundlinie 322 \\cdots ... Punkte in der Mitte 323 \\vdots ... vertikale Punkte 324 \\ddots ... diagonale Punkte 325 326 \\quad ... zusaetzlicher Abstand 327 \\qquad ... groesserer zusaetzlicher Abstand 328 329 330% Tabellen 331%-------------------------------------------------------------------------- 332% Tabelle fuer mathematischen Modus 333 \\begin{array}[Position]{Spaltenformat} 334 ... 335 \\end{array} 336 337% normale Tabelle 338 \\begin{tabular}[Position]{Spaltenformat} 339 ... 340 \\end{tabular} 341 342% Tabelle mit fixen Breite 343 \\begin{tabular*}{Breit}[Position]{Spaltenformat} 344 ... 345 \\end{tabular*} 346 347% Position ... Position im umgebenden Text 348% Spaltenformat ... wieviele Spalten und deren Formatierung 349 c ... zentrierte Spalte 350 l ... linksbuendige Spalte 351 r ... rechtsbuendige Spalte 352 p{Breite} ... Spalte mit Text ueber 353 mehrere Zeilen 354 | ... vertikale Linie 355 356 *{Anzahl}{Spaltenformat} ... Wiederholung von Spalten 357 @{Text} ... Ausrichtung auf Text 358 \\multicolumn{Anzahl}{Spaltenformat}{Text} ... Text ueber mehrere 359 Spalten 360 361 \\cline{Spalte-Spalte} ... horizontale Linie 362 \\hline ... horizontale Linie ueber 363 gesamte Tabellespalte 364 \\vline ... vertikale Linie ueber 365 gesamte Tabellenhoehe 366 367 368% Graphiken 369%-------------------------------------------------------------------------- 370 \\usepackage[dvips]{graphics} 371 372% Bounding Box selbst angeben 373 \\includegraphics[lux,luy][rox,roy]{bild.eps} 374% lux ... x-Koordinate der linken unteren Ecke 375% luy ... y-Koordinate der linken unteren Ecke 376% rox ... x-Koordinate der rechten oberen Ecke 377% roy ... y-Koordinate der rechten oberen Ecke 378 379% Bild skalieren 380 \\includegraphics[width=1\\textwidth]{bild.eps} 381 382 383% bewegliche Objekte 384%-------------------------------------------------------------------------- 385% damit Latex die Positionierung von Objekten selbst entscheiden kann, 386% werden die Objekte gekapselt 387% fuer Bilder: 388 \\begin{figure}[Position] 389 ... 390 \\caption{ } 391 \\end{figure} 392 393% fuer Tabellen: 394 \\begin{table}[Position] 395 ... 396 \\caption{ } 397 \\end{table} 398 399 400% Verzeichnisse 401%-------------------------------------------------------------------------- 402% Inhaltsverzeichnis 403 \\tableofcontents 404 405% Stufe bis zu der nummeriert wird 406 \\secnumdepth 407% Stufe bis zu welcher sie im Inhaltsverzeichnis erscheinen 408 \\tocdepth 409% zusaetzlichen Eintrag hinzufuegen 410 \\addcontentsline{toc}{Gliederung}{Eintrag} 411 412% Tabellenverzeichnis 413 \\listoftables 414 415% zusaetzlichen Eintrag hinzufuegen 416 \\addcontentsline{lot}{table}{Eintrag} 417 418% Abbildungsverzeichnis 419 \\listoffigures 420 421% zusaetzlichen Eintrag hinzufuegen 422 \\addcontentsline{lof}{figure}{Eintrag} 423 424% Literaturverzeichnis 425% Einfuegen eines Literaturverweises 426 \\cite[Anmerkung}{Schluessel} 427 428 \\bibliographystyle{gerabbrv} 429 \\bibliography{literatur} 430 431 432% Querverweise 433%-------------------------------------------------------------------------- 434 \\label{Marke} ... Markierung setzen 435 \\ref{Marke} ... Referenzieren (Kapitel-, Abschnittsnummer) 436 \\pageref{Marke} ... Referenzieren (Seitennummer) 437 438 439% Dateien einbinden 440%-------------------------------------------------------------------------- 441 \\include{datei.tex} ... Einbinden der Datei mit Seitenvorschub 442 davor und dahinter 443 \\input{datei.tex} ... Einbinden der Datei ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/latex/latex-reference/","section":"Code Schnipsel","summary":"","title":"LaTeX - Reference","type":"code-snippets"},{"content":"","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/matlab/","section":"Code Schnipsel","summary":"","title":"Matlab","type":"code-snippets"},{"content":" 1%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 2% Kommunikation mittels UART % 3%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 4 5 hUart = serial(\u0026#39;COM1\u0026#39;); 6 set(hUart, \u0026#39;BaudRate\u0026#39;, 115200); 7 set(hUart, \u0026#39;DataBits\u0026#39;, 8); 8 set(hUart, \u0026#39;StopBits\u0026#39;, 1); 9 set(hUart, \u0026#39;InputBufferSize\u0026#39;, 1024); 10 set(hUart, \u0026#39;OutputBufferSize\u0026#39;, 1024); 11 set(hUart, \u0026#39;Timeout\u0026#39;, 10); 12 fopen(hUart); 13 tmpData = [uint8(data)]; 14 transmitUartData(hUart, CMD, size(tmpData,2), tmpData); 15 16 if (transmitUartDataWithRetry(hUart, CMD, ... 17 size(tmpData,2), ... 18 tmpData) ~= 1) 19 disp(\u0026#39;Senden fehlgeschlagen!\u0026#39;); 20 end 21 22 [retcmd, retlength, retdata, cksumOk] = receiveUartData(hUart); 23 fclose(hUart) 24 25 26 function successful = transmitUartDataWithRetry 27 (hUart, cmd, dataLength, data) 28 % transmit with retries when send error occurres 29 % 30 % input: 31 % hUart ... uart handle for transmit 32 % cmd ... command to send 33 % dataLength ... length of data 34 % data ... data to send 35 % output: 36 % successful ... how many chars sent 37 global CMD_ACK 38 39 maxRetry = 5; 40 successful = 0; 41 sendCnt = 0; 42 while (successful == 0) \u0026amp;\u0026amp; (sendCnt \u0026lt; maxRetry) 43 % send data 44 transmitUartData(hUart, cmd, dataLength, data); 45 46 % receive message 47 [retcmd, retlength, retdata, cksumOk] = 48 receiveUartData(hUart); 49 50 % prove if ack message received 51 if ((retcmd == CMD_ACK) \u0026amp;\u0026amp; 52 (retlength == 0) \u0026amp;\u0026amp; 53 (cksumOk == 1)) 54 successful = 1; 55 else 56 sendCnt = sendCnt + 1; 57 pause(1); 58 end; 59 end; 60 61 function transmitUartData(hUart, cmd, dataLength, data) 62 % transmit packet to targets 63 % 64 % input: 65 % hUart ... uart handle for transmit 66 % cmd ... command to send 67 % dataLength ... length of data 68 % data ... data to send 69 length = dataLength + 1; 70 calccksum = double(cmd) + double(length); 71 calccksum = mod(calccksum, 2^8); 72 for k=1:dataLength 73 calccksum = calccksum + double(data(k)); 74 calccksum = mod(calccksum, 2^8); 75 end 76 77 if (dataLength \u0026gt; 0) 78 fwrite(hUart, [uint8(cmd), uint8(length), 79 data(1:dataLength), uint8(calccksum)]); 80 else 81 fwrite(hUart, [uint8(cmd), 82 uint8(length), uint8(calccksum)]); 83 end; 84 85 86 function [cmd, dataLength, data, cksumOk] = receiveUartData(hUart) 87 % reads received packet from targets 88 % 89 % packet: \u0026lt;cmd\u0026gt;\u0026lt;length\u0026gt;\u0026lt;data1\u0026gt;...\u0026lt;dataN\u0026gt;\u0026lt;cksum\u0026gt; 90 % 91 % input: 92 % hUart ... uart handle for transmit 93 % output: 94 % cmd ... command 95 % dataLength ... length of data 96 % data ... received data 97 % cksumOK ... if checksum is OK 98 data = 0; 99 cmd = fread(hUart, 1); 100 if cmd 101 length = fread(hUart, 1); 102 if length 103 dataLength = length-1; 104 if (length-1 \u0026gt; 0) 105 data = fread(hUart, length-1); 106 end 107 calccksum = double(cmd) + double(length); 108 calccksum = mod(calccksum, 2^8); 109 for i=1:length-1 110 calccksum = calccksum + double(data(i)); 111 calccksum = mod(calccksum, 2^8); 112 end 113 114 cksum = fread(hUart, 1); 115 if (cksum == calccksum) 116 cksumOk = 1; 117 else 118 display(\u0026#39;CS Error!\u0026#39;); 119 cksumOk = 0; 120 end; 121 else 122 % receive timeout occured 123 cmd = 0; 124 dataLength = 0; 125 data = 0; 126 cksumOk = 0; 127 end; 128 else 129 % receive timeout occured 130 cmd = 0; 131 dataLength = 0; 132 data = 0; 133 cksumOk = 0; 134 end; 135 136 137%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 138% Kommunikation mittels TCP/IP % 139%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 140 141 ipAddress = \u0026#39;127.0.0.1\u0026#39;; 142 targetPort = 1234; 143 socket = tcpip(ipAddress, targetPort); 144 fopen(socket); 145 146 if strcmp(socket.Status, \u0026#39;open\u0026#39;) 147 tmpData(1) = mod(floor(data/(2^24)), 2^8); 148 tmpData(2) = mod(floor(data/(2^16)), 2^8); 149 tmpData(3) = mod(floor(data/(2^8)), 2^8); 150 tmpData(4) = mod(data, 2^8); 151 transmitTcpData(socket, CMD, 4, tmpData); 152 153 tmpData = [tmpData, ... 154 uint8(real(complNr)), ... 155 uint8(imag(complNr))]; 156 if (transmitTcpDataWithRetry(socket, CMD, size(tmpData,2), 157 tmpData) ~= 1) 158 disp(\u0026#39;Senden fehlgeschlagen!\u0026#39;); 159 end 160 161 [cmd, length, data, cksumOk] = receiveTcpData(socket); 162 end 163 164 fclose(socket); 165 166 167 function successful = transmitTcpDataWithRetry(hSocket, cmd, 168 dataLength, data) 169 % transmit configuration with retries when send error occurres 170 % 171 % input: 172 % hSocket ... tcp socket for transmit 173 % cmd ... command to send 174 % dataLength ... length of data 175 % data ... data to send 176 % output: 177 % successful ... how many chars sent 178 global CMD_ACK 179 180 maxRetry = 5; 181 successful = 0; 182 sendCnt = 0; 183 while (successful == 0) \u0026amp;\u0026amp; (sendCnt \u0026lt; maxRetry) 184 % send data 185 transmitTcpData(hSocket, cmd, dataLength, data); 186 187 % receive message 188 [retcmd, retlength, retdata, cksumOk] = 189 receiveTcpData(hSocket); 190 191 % prove if ack message received 192 if ((retcmd == CMD_ACK) \u0026amp;\u0026amp; 193 (retlength == 0) \u0026amp;\u0026amp; 194 (cksumOk == 1)) 195 successful = 1; 196 else 197 sendCnt = sendCnt + 1; 198 end; 199 end; 200 201 function transmitTcpData(hSocket, cmd, dataLength, data) 202 % transmit packet to targets 203 % 204 % input: 205 % hSocket ... tcp socket for transmit 206 % cmd ... command to send 207 % dataLength ... length of data 208 % data ... data to send 209 length = dataLength + 2; 210 calccksum = mod((cmd + length), 2^8); 211 for k=1:dataLength 212 calccksum = mod((calccksum + data(k)), 2^8); 213 end 214 if (dataLength \u0026gt; 0) 215 fwrite(hSocket, 216 [cmd, length, data(1:dataLength), calccksum]); 217 else 218 fwrite(hSocket, [cmd, length, calccksum]); 219 end; 220 221 function [cmd, dataLength, data, cksumOk] = receiveTcpData(hSocket) 222 % reads received packet from targets 223 % 224 % packet: \u0026lt;cmd\u0026gt;\u0026lt;length\u0026gt;\u0026lt;data1\u0026gt;...\u0026lt;dataN\u0026gt;\u0026lt;cksum\u0026gt; 225 % 226 % input: 227 % hSocket ... tcp socket for receiving 228 % output: 229 % cmd ... command 230 % length ... length of packet = N(data) + 1(cksum) 231 % data ... received data 232 % cksum ... cksum of rec. data = (cmd+length+data1+...+dataN)%2^8 233 data = 0; 234 cmd = fread(hSocket, 1); 235 if cmd 236 length = fread(hSocket, 1); 237 if length 238 dataLength = length-2; 239 if (length-2 \u0026gt; 0) 240 data = fread(hSocket, length-2); 241 end 242 calccksum = mod((cmd + length), 2^8); 243 for i=1:length-2 244 calccksum = mod((calccksum + data(i)), 2^8); 245 end 246 cksum = fread(hSocket, 1); 247 if (cksum == calccksum) 248 cksumOk = 1; 249 else 250 cksumOk = 0; 251 end; 252 else 253 % receive timeout occured 254 cmd = 0; 255 dataLength = 0; 256 data = 0; 257 cksumOk = 0; 258 end; 259 else 260 % receive timeout occured 261 cmd = 0; 262 dataLength = 0; 263 data = 0; 264 cksumOk = 0; 265 end; ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/matlab/communication/","section":"Code Schnipsel","summary":"","title":"Matlab - Communication","type":"code-snippets"},{"content":" 1% Erstellung einer Bedienoberflaeche mit Matlab 2 3% 1) guide starten 4% 2) Oberflaeche \u0026#34;zusammenklicken\u0026#34; 5% und bereits erste Einstellungen vornehmen 6% 3) generierte .m-File editieren 7 8% Komponenten des .m-Files 9 % Ausgabe eines Warn-Dialoges 10 warndlg(\u0026#39;Message\u0026#39;, \u0026#39;Titel\u0026#39;); 11 12 13 % Verwendung eines Timers 14 tmr1 = timer(\u0026#39;TimerFcn\u0026#39;, {@tmrFcn, params}, \u0026#39;Period\u0026#39;, 15 1, \u0026#39;ExecutionMode\u0026#39;, \u0026#39;fixedDelay\u0026#39;); 16 start(tmr1); 17 18 % Verarbeitung Pausieren [sec (0.1 -\u0026gt; 100ms)] 19 pause(1); 20 21 % generierte Funktions-Aufrufe 22 function tmrFcn(hObject, eventdata, params) 23 stop(tmr1); 24 25 26 function testGui_OpeningFcn(hObject, eventdata, handles, varargin) 27 % wird vor der Darstellung der GUI aufgerufen 28 % -\u0026gt; Anlegen von globalen Variablen, GUI initialisieren 29 30 global var1 31 global var2 32 33 var1 = 0; 34 var2 = 1; 35 36 function testGUI_CloseFcn(src,evnt) 37 % kann selbst erstellt werden um aufraeum-Arbeiten zu erledigen 38 39 % Erstellung/Einbindung: 40 set(handles.figure1,\u0026#39;CloseRequestFcn\u0026#39;,@testGUI_CloseFcn); 41 42 function pushbutton_button1(hObject, eventdata, handles) 43 % Einsprung-Punkt bei Button-Betaetigung 44 45 % durch Angabe der verfuegbaren globalen Variablen, 46 % kann auf diese zugegriffen werden 47 global var1 var2 48 49 var1 = 2; 50 51 function edit_edit1_Callback(hObject, eventdata, handles) 52 % Einsprung-Punkt bei Veraenderung des Textfeldes 53 set(hObject, \u0026#39;String\u0026#39;, \u0026#39;asdf\u0026#39;); 54 string = get(hObject, \u0026#39;String\u0026#39;); 55 56 % globaler Zugriff auf GUI Elemente 57 set(handles.edit_edit1, \u0026#39;String\u0026#39;, \u0026#39;asdf\u0026#39;); 58 string = str2num(get(handles.edit_edit1, \u0026#39;String\u0026#39;)); 59 60 % Setzen von Attributen 61 markedObjectColor = [.6 .6 1.0]; 62 unmarkedObjectColor = [1.0 1.0 1.0]; 63 set(handles.edit_edit1, \u0026#39;BackgroundColor\u0026#39;, markedObjectColor); 64 drawnow(); 65 66 % String als Funktions-Namen verwenden 67 fhandle = str2func(get(handles.edit_edit1,\u0026#39;String\u0026#39;)); 68 result = fhandle(param1, param2); 69 70 function edit_edit1_CreateFcn(hObject, eventdata, handles) 71 % Einsprung-Punkt bei der Erstellung des Textfeldes 72 73 function popupmenu_popup1_Callback(hObject, eventdata, handles) 74 % Einsprung-Punkt beim Auswaehlen eines Eintrages im Popup-Menue 75 76 contents = get(hObject, \u0026#39;String\u0026#39;); 77 index = get(hObject, \u0026#39;Value\u0026#39;); 78 actContent = contents{index}; 79 80 str1{1} = \u0026#39;item1\u0026#39;; 81 str1{2} = \u0026#39;item2\u0026#39;; 82 set(hObject, \u0026#39;String\u0026#39;, str1); 83 84 function slider_sl1_Callback(hObject, eventdata, handles) 85 % Slider wurde bewegt 86 global SldMax SldMin 87 88 % Slider Wert holen und umrechnen 89 actVal = round(get(hObject,\u0026#39;Value\u0026#39;) * (SldMax - SldMin) + SldMin); 90 91 % Slider Position setzen 92 actVal = (value - SldMin) / (SldMax - SldMin); 93 set(handles.slider_sl1, \u0026#39;Value\u0026#39;, actVal); 94 95 function radiobutton_rb1_Callback(hObject, eventdata, handles) 96 % auf Radio-Button wurde geklickt 97 98 set(hObject,\u0026#39;Value\u0026#39;,0); 99 set(hObject,\u0026#39;Value\u0026#39;,1); ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/matlab/gui/","section":"Code Schnipsel","summary":"","title":"Matlab - GUI","type":"code-snippets"},{"content":" 1% Literatur: Einfuehrung in MATLAB (ELT3 - FH Hagenberg) 2 3% MATrix LABoratory 4 5% Hilfsfunktionen 6 help % Ueberblick Funktionsgruppen 7 help general % allgemeine Befehle 8 help / % Operatoren und Sonderzeichen 9 help \u0026lt;function\u0026gt; % Funktionsbeschreibung 10 type \u0026lt;function\u0026gt; % Funktionsquellcode 11 lookfor \u0026lt;Stichwort\u0026gt; % Stichwortsuche im Hilfetext 12 13 14% Zahlendarstellung 15 % alle Zahlen im Format: double precision 16 % (1 Bit Vorzeichen, 11 Bit Exponent, 52 Bit Mantisse) 17 a = 123 18 b = -100.13 19 b = -1.0013e2; % ; verhindert Ausgabe der Operation 20 21 x = a + j*b % komplexe Zahl (j \u0026lt;=\u0026gt; i) 22 23 Inf % Unendlich 24 NaN % Not a Number 25 pi 26 realmax % groesste Zahl 27 realmin % kleinste Zahl 28 29 30% Operationen 31 + - * ^ / % arithmetische Operationen 32 .* .^./ % elementweise Operationen 33 34 x = A \\ b % loest lineare Gleichungssysteme 35 A*x = b 36 37 == ~= \u0026lt; \u0026gt; \u0026lt;= \u0026gt;= % Vergleichsoperationen 38 isequal() % Vergleich von Matrizen 39 \u0026amp;\u0026amp; || xor any all % logische Operatoren 40 \u0026amp; | ~ % logische bitweise Operatoren 41 42 [1 2]\u0026#39; = [1; 2] = % Transponierte Matrix 43 1 44 2 45 46 sin asin % Bogenmass 47 sind asind % Grad 48 -\u0026gt; cos tan cot sec csc 49 50 exp % Exponentialfunktion e^ 51 log log10 log2 % Logarithmus (natuerl., 10er, dual) 52 sqrt 53 abs angle complex conj imag real % Funktionen fuer komplexe Zahlen 54 fix floor ceil round % Runden 55 mod rem % Modulus 56 sign % Vorzeichen 57 58 59% Variablen 60 who whos % Anzeige definierter Variablen 61 clear % alle Variablen loeschen 62 clear \u0026lt;variable\u0026gt; 63 64 A = [1 2 3] = [1,2,3] % Zeilenvektor 65 1 2 3 66 B = [1;2;3;4;5] % Spaltenvektor 67 1 68 2 69 3 70 C = [1 2 3;4 5 6] % Matrize 71 1 2 3 72 4 5 6 73 74 A = 1:3:15 % Nummer generieren 75 1 4 7 10 13 76 B = 1:4 77 1 2 3 4 78 79 A = linspace(6,8,5) % Intervall unterteilen 80 6.00 6.50 7.00 7.50 8.00 81 B = logspace(0,2,5) % Intervall logarithmisch 82 1.00 3.16 10.00 31.62 100.00 % unterteilen 10^0, 10^2 83 84 A = zeros(2,4) % Matrizen generieren 85 0 0 0 0 86 0 0 0 0 87 B = ones(2,3) 88 1 1 1 89 1 1 1 90 C = eye(3) 91 1 0 0 92 0 1 0 93 0 0 1 94 D = rand(2,4) 95 96 A=[1 1 2 2; % Submatrizen 97 3 3 4 4; 98 5 5 6 6; 99 7 7 8 8]; 100 B=A(2:3,2:4) 101 B = 102 3 4 4 103 5 6 6 104 105 A=[1 2 3 4 5 6 7 8 9; 106 9 8 7 6 5 4 3 2 1]; 107 A(:,2:2:end) 108 A = 109 2 4 6 8 110 8 6 4 2 111 A(:,5:end)=[] % Elemente loeschen 112 A = 113 1 2 3 4 114 9 8 7 6 115 A(1:3,2:3)=ones(3,2) % mit 1en fuellen 116 A = 117 1 1 1 4 118 9 1 1 6 119 0 1 1 0 120 121 A = zeros(2,2,0); % Array dynamisch erweitern 122 A(:,:,1) = zeros(2,2); % -\u0026gt; Bedingung: Elemente mit 123 A(:,:,2) = ones(2,2); % gleicher Groesse 124 125 126% Vektorfunktionen 127 length % Laenge eines Vektors 128 max % Element mit groessten Index 129 min % Element mit kleinsten Index 130 sum % Summe der Elemente 131 prod % Produkte der Elemente 132 any % liefert 0, wenn alle Elemente 0 133 all % liefert 1, wenn kein Element 0 134 mean % arithm. Mittelwert des Vektors 135 sort % sortiert Vektor aufsteigend 136 137 A\u0026#39; = transpose(A) % transponierte Matrix 138 A.\u0026#39; = ctranspose(A) % konjugiert komplex transponiert 139 fliplr(A) % vertikale Spiegelung 140 flipud(A) % horizontale Spiegelung 141 rot90(A) % Drehung 142 repmat(A,z,s) % zxs Blockmatrix aus A 143 reshape(A,z,s) % Matrixdimensionen aendern 144 diag(A,k) % k-te Nebendiagonale 145 146 eig % Eigenwert, Eigenvektor 147 inv % inverse Matrix 148 expm, sqrtm % Matrix-Exponential, -Wurzel 149 poly % charakteristische Polynom 150 det % Determinante 151 size % Matrixdimension 152 norm % Norm einer Matrix oder eines Vektors 153 154 155% Zeichenketten 156 a = \u0026#39;Z\u0026#39; 157 char, double % Umwandlung 158 strcat str2mat strcmp upper lower % Funktionen 159 ischar isletter isspace % logische Funktionen 160 161 A = \u0026#39;string\u0026#39;; % String erweitern 162 A = [A \u0026#39;string2\u0026#39;]; 163 164 165% Dateiverwaltung 166 pwd what cd type delete dir ls rmdir mkdir copyfile movefile fileattrib 167 save \u0026lt;Dateiname\u0026gt; \u0026lt;Variablenliste\u0026gt; % Variablen speichern 168 load \u0026lt;Dateiname\u0026gt; % Variablen laden 169 -ascii % im Textformat gespeichert 170 171 fid = fopen(filename, modus) 172 = -1 % falls Datei nicht existiert 173 \u0026#39;r\u0026#39; % read 174 \u0026#39;w\u0026#39; % write 175 \u0026#39;a\u0026#39; % append 176 [A, count] = fread(fid, size, precision) 177 % size - angegebene Anzahl an Daten 178 % precision - Binaerformat (\u0026#39;int16\u0026#39;, \u0026#39;int32\u0026#39;, \u0026#39;float32\u0026#39;, \u0026#39;float64\u0026#39;) 179 count = fwrite(fid, A, precision) 180 position = ftell(fid) % Position einer Datei ermitteln 181 status = fseek(fid, offset, origin) % Position anpassen 182 % (origin: \u0026#39;bof\u0026#39;, \u0026#39;eof\u0026#39;) 183 count = fprintf(fid, format, A, ...)% formatiertes Schreiben 184 %c % einzelnes Zeichen 185 %d % Dezimaldarstellung 186 %u % Dezimaldarstellung (unsigned) 187 %e % Exponentialdarstellung 188 %f % Fliesskommadarstellung 189 %s % Zeichenkette 190 %x % Hexadezimaldarstellung 191 \\n \\b \\r \\t \\\\ 192 [A, count] = fscanf(fid, format, size) % formatiertes Lesen 193 fclose(fid) 194 195 196% Scripts 197 pause % auf Tastendruck warten 198 pause(n) % n Sekunden warten 199 200 if expression % bedingte Anweisung 201 statements 202 elseif expression 203 statements 204 else 205 statements 206 end 207 208 209 switch switch_expr % switch Anweisung 210 case case_expr, 211 statement, ..., statement 212 case {case_expr1, case_expr2, case_expr3,...} 213 statement, ..., statement 214 ... 215 otherwise, 216 statement, ..., statement 217 end 218 219 220 for variable = expr % for Schleife (zahler = n:1:10) 221 statement, ..., statement 222 end 223 224 225 while expression % while Schleife 226 statements 227 end 228 229 230% Funktionen 231 % in .m Datei gespeichert 232 % Funktionsname sollte Namen entsprechen 233 % Hilftext startet unterhalb der 1. Zeile 234 % Variablen sind lokal gueltig 235 function[Rueckgabeliste] = Name(Parameterliste) 236 237 nargin % Anzahl Eingabeargumente 238 nargout % Anzahl Ausgabeargumente 239 exist % existiert Variable/Funktion 240 varargin % Eingabepar.liste unbest. Laenge 241 varargout % Ausgabepar.liste unbest. Laenge 242 243 global % Variable global definieren 244 245 246% Grafiken 247 plot(x,y) % Polygonzug mit den Knoten (xk,yk) 248 plot(y) = plot(1:length(y),y) 249 plot(x,y,s) % Stilparameter s 250 % Punkttypen: .,o,x,+,*,s,d,v,^,\u0026lt;,\u0026gt;,p,h 251 % Linientypen: -,:,-.,-- 252 % Farben: b,g,r,c,m,y,k 253 % Beispiel: plot(x,y,\u0026#39;c+:\u0026#39;) 254 plot(x1,y1,s1,x2,y2,s2,...) % mehrere Linien 255 256 % Achsensystem 257 axis([xmin xmax ymin ymax]) % Grenzen des Achsensystems setzen 258 axis on, axis off % Achsensystem ein- und ausschalten 259 axis auto, axis manual % autom. Anpassung ein-/ausschalten 260 axis equal % gleiche Laengeneinheiten 261 axis tight % an Daten angepasster Ausschnitt 262 axis image = axis equal, axis tight 263 axis square % quadratischer Ausschnitt 264 axis fill % Ausfuellen des Bildfensters 265 grid on, grid off % Gitterlinien ein- und ausschalten 266 box on, box off % Achsensystem im Box-Format 267 pbaspect([x,y,z]) % Seitenverhaeltn. des Achsensystems 268 view(az,el) % Blickwinkel einstellen (in Grad) 269 270 % Beschriftungen 271 title % Ueberschrift 272 xlabel, ylabel, zlabel % Beschriftung der Achsen 273 legend % Legende anfuegen 274 text % Text in der Grafik 275 colorbar % Farblegende 276 277 % mehrere Grafiken 278 hold on % in einem Achsensystem 279 subplot % in einem Fenster 280 figure % in unterschiedlichen Fenstern 281 figure(figurenumber) % Umschalten zwischen Fenstern 282 clf, cla % Grafik loeschen 283 close(figurenumber), close all % Fenster schliessen 284 285 % Beispiel 1 286 t = 0:0.01:10; 287 x1 = exp(-2*t).*cos(5*t); 288 x2 = exp(-2*t).*sin(5*t); 289 figure(1), clf 290 plot(t,x1), grid 291 hold 292 plot(t,x2,\u0026#39;.g:\u0026#39;) 293 hold 294 axis([0,5,-1,1]) 295 xlabel(\u0026#39;t [s]\u0026#39;) 296 ylabel(\u0026#39;Voltage [V]\u0026#39;) 297 legend(\u0026#39;Funktion 1\u0026#39;,\u0026#39;Funktion 2\u0026#39;) 298 title(\u0026#39;Darstellung von Funktionen\u0026#39;) 299 pause 300 301 % Beispiel 2 302 d = 0.1; wk = 1e4; 303 w = logspace(1,6,1000); 304 s = j*w; 305 G = 1./(1+2*d*(s/wk)+(s/wk).^2); % Transfer function 306 figure(2), clf 307 subplot(211) 308 semilogx(w,20*log10(abs(G))), grid 309 ylabel(\u0026#39;|G(j\\omega)| [dB]\u0026#39;); 310 title(\u0026#39;Bodediagramm fuer G(s)\u0026#39;); 311 subplot(212); 312 semilogx(w,180/pi*angle(G)), grid 313 xlabel(\u0026#39;\\omega [s^{-1}]\u0026#39;); 314 ylabel(\u0026#39;\\angle G(j\\omega) [grad]\u0026#39;); 315 % Find maximum 316 [max_abs_G, i] = max(20*log10(abs(G))); 317 fprintf(\u0026#39;\\n\u0026#39;) 318 fprintf(\u0026#39;Max(abs(G)) in dB: %g\\n\u0026#39;, max_abs_G) 319 fprintf(\u0026#39;bei w = %g\\n\u0026#39;, w(i)) 320 pause 321 322 % Beispiel 3 323 x = 1:0.1:10; 324 y=exp(x); 325 figure(3), clf 326 semilogy(x,y) 327 grid 328 329 330% Symbolic Math Toolbox 331 % ermoeglicht Arbeiten mit symbolischen Variablen 332 syms x y 333 e = (1+x)^4/(1+x^2)+4/(1+x^2) 334 pretty(e) 335 4 336 (1 + x) 4 337 -------- + ------ 338 2 2 339 1 + x 1 + x 340 341 % Vereinfachungen 342 simplify, expand, factor, collect 343 simple % Search for shortest form 344 numden % Numerator and denominator 345 horner % Nested polynomial representation 346 subexpr % Rewrite in terms of subexpressions 347 coeffs % Coefficients of a multivariate polynomial 348 sort % Sort symbolic vectors or polynomials. 349 subs % Symbolic substitutionify(e) 350 351 % grafische Darstellung von Funktionen 352 syms x 353 ezplot(exp(-x*x/2),-5,5); grid; 354 355 % sonstige Funktionen 356 taylor, diff, int, laplace, ilaplace, dsolve ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/matlab/matlab-reference/","section":"Code Schnipsel","summary":"","title":"Matlab - Reference","type":"code-snippets"},{"content":"","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/perl/","section":"Code Schnipsel","summary":"","title":"Perl","type":"code-snippets"},{"content":" 1# Parameteruebergabe an den Webserver 2 3 # Parameteruebergabe mit Get 4 # Informationen wird an URL angehaengt 5 # z.B. http://www.xyz.com/prog.cgi?feld1=value1\u0026amp;feld2=value2 6 # normale URL 7 # ? 8 # Attribut=Wert 9 # \u0026amp; 10 # Attribut=Wert 11 12 # Hexadecimal-Darstellung wird mit % eingeleitet 13 # + statt Leerzeichen 14 15 # \u0026lt;form method=\u0026#34;get\u0026#34; action=\u0026#34;/cgi-bin/prog.cgi\u0026#34;\u0026gt; 16 # ... 17 # \u0026lt;/form\u0026gt; 18 19 # Parameteruebergabe mit Post 20 # Uebertragung im Request (unbegraenzte Laenge) 21 22 # \u0026lt;form method=\u0026#34;post\u0026#34; action=\u0026#34;/cgi-bin/prog.cgi\u0026#34;\u0026gt; 23 # ... 24 # \u0026lt;/form\u0026gt; 25 26 27# Eingabefelder 28 # einzeiliges Eingabefeld 29 # \u0026lt;input type=text name=\u0026#34;name1\u0026#34; size=60 maxlength=80\u0026gt; 30 31 # mehrzeiliges Eingabefeld 32 # \u0026lt;textarea name=\u0026#34;name2\u0026#34; rows=15 cols=40\u0026gt; 33 # Dieser Text erscheint im Textfeld als Vorbelegung. 34 # \u0026lt;/textarea\u0026gt; 35 36 # Auswahllisten-Felder 37 # \u0026lt;select name=\u0026#34;auswahl\u0026#34; size=1 multiple\u0026gt; 38 # \u0026lt;option value=\u0026#34;1\u0026#34;\u0026gt; Anzeigename1 39 # \u0026lt;option value=\u0026#34;2\u0026#34; selected\u0026gt; Anzeigename2 40 # \u0026lt;option value=\u0026#34;3\u0026#34;\u0026gt; Anzeigename3 41 # \u0026lt;/select\u0026gt; 42 43 # Radiobuttons 44 # \u0026lt;input type=radio name=\u0026#34;name3\u0026#34; value=\u0026#34;wert1\u0026#34;\u0026gt; Anzeigename1 45 # \u0026lt;input type=radio name=\u0026#34;name3\u0026#34; value=\u0026#34;wert2\u0026#34;\u0026gt; Anzeigename2 46 # \u0026lt;input type=radio name=\u0026#34;name3\u0026#34; value=\u0026#34;wert3\u0026#34;\u0026gt; Anzeigename3 47 48 # Checkboxen 49 # \u0026lt;input type=checkbox name=\u0026#34;name4\u0026#34; value=\u0026#34;wert1\u0026#34;\u0026gt; Anzeigename1 50 # \u0026lt;input type=checkbox name=\u0026#34;name4\u0026#34; value=\u0026#34;wert2\u0026#34;\u0026gt; Anzeigename2 51 # \u0026lt;input type=checkbox name=\u0026#34;name4\u0026#34; value=\u0026#34;wert3\u0026#34;\u0026gt; Anzeigename3 52 53 # Formular absenden 54 # \u0026lt;input type=submit value=\u0026#34;Formular abschicken\u0026#34;\u0026gt; 55 56 # Formular ruecksetzen 57 # \u0026lt;input type=reset value=\u0026#34;Inhalt loeschen\u0026#34;\u0026gt; 58 59 60# Formular-Daten lesen 61 sub CGIDatenlesen 62 { 63 local $cgidaten; 64 65 if ($ENV{\u0026#34;REQUEST_METHOD\u0026#34;} eq \u0026#34;POST\u0026#34;) # Erkennen der Sende-Methode 66 { 67 # bei der Post-Methode wird von der Standard-Eingabe lesen 68 read (STDIN, $cgidaten, $ENV{\u0026#34;CONTENT_LENGTH\u0026#34;}); 69 } 70 else 71 { 72 # bei der Get-Methode wird der Query_String verwendet 73 $cgidaten = $ENV{\u0026#34;QUERY_STRING\u0026#34;}; 74 } 75 76 return $cgidaten; 77 } 78 79 80# CGI Daten Aufbereiten 81 sub CGIDatenaufbereiter 82 { 83 local ($cgidatenskalar, $name, $daten); 84 local @cgidatenliste; 85 local %cgidatenhash; 86 87 # Uebergegebene Daten zwischenspeichern 88 if ($_[0]) 89 { 90 $cgidatenskalar = $_[0]; 91 } 92 else 93 { 94 print STDERR \u0026#34;Es wurden keine Daten uebergeben\\n\u0026#34;; 95 } 96 97 # einzelne Daten teilen 98 @cgidatenliste = split(/[\u0026amp;;]/ , $cgidatenskalar); 99 100 foreach $listeneintrag (@cgidatenliste) # fuer jede Daten 101 { 102 # \u0026#34;+\u0026#34; durch Leerzeichen ersetzen 103 $listeneintrag =~ s/\\+/ /go; 104 105 # in Variablenname und -wert trennen 106 ($name, $daten) = split( /=/ , $listeneintrag); 107 108 # Hexwerte durch Zeichen ersetzen 109 $name =~ s/\\%(..)/pack(\u0026#34;c\u0026#34;,hex($1))/ge; 110 $daten =~ s/\\%(..)/pack(\u0026#34;c\u0026#34;,hex($1))/ge; 111 112 # Key-Werte-Paar dem Hash hinzuf�gen 113 $cgidatenhash{$name} = $daten; 114 } 115 116 # getrennte Daten retournieren 117 return %cgidatenhash; 118 } 119 120 121# weitere CGI-Umgebungsvariablen 122 # DOCUMENT_ROOT Absoluter Pfad der Document-Root 123 # GATEWAY_INTERFACE vom Web-Server verwendete CGI-Version 124 # HTTP_ACCEPT welche Dateiformate vom Benutzer akzeptiert werden 125 # HTTP_ACCEPT_LANGUAGE eingestellte Browser-Sprache 126 # HTTP_HOST Hostname des Web-Servers 127 # HTTP_REFERER Aufrufer 128 # HTTP_USER_AGENT Bezeichnung des Web-Clients 129 # PATH vom CGI-Skript sichtbarer Pfad 130 # PATH_INFO an die URL hinzugefuegte Pfad 131 # PATH_TRANSLATED absoluter Pfad des CGI-Skripts 132 # QUERY_STRING alles nach dem ? in der URL - bei der Get-Methode 133 # REMOTE_ADDR IP-Adresse des Client-Hosts 134 # REMOTE_HOST FQDN (DNS) des Client-Hosts 135 # REMOTE_PORT lokaler TCP-Port des Clients 136 # REMOTE_USER Name des entfernten Users (bei Authentifizierung) 137 # REQUEST_METHOD HTTP-Methode: Get, Post 138 # SCRIPT_FILENAME absoluter Name des CGI-Skripts 139 # SCRIPT_NAME Name des CGI-Skripts (relativ zur Document-Root) 140 # SERVER_NAME Name des Web-Servers 141 # SERVER_PORT HTTP-Port, auf dem der Server kontaktiert wurde 142 # SERVER_PROTOCOL Protokoll zwischen Server und Client 143 # SERVER_SOFTWARE Web-Server-Software-Information ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/perl/forms/","section":"Code Schnipsel","summary":"","title":"Perl - Forms","type":"code-snippets"},{"content":" 1# PERL = Practical Extraction and Report Language 2# Comprehensive Perl Archive Network - CPAN (http://www.cpan.org) 3 # Perl Interpret downloadbar unter: 4 # http://wwww.perl.com 5 # http://www.activestate.com/pw32 6 7 # Perl-Script ausfuehren: 8 # perl scriptname -d ... Debugger 9 # perl scriptname -w ... Warnungen (deaktivierbar) 10 # perl scriptname -W ... Warnungen fest aktiviert 11 # perl scriptname -X ... Warnungen fest deaktiviert 12 # perl scriptname -c ... Syntaxanalyse 13 14 15# Hello-World Beispiel: 16 #! user/bin/perl # Pfadangabe des Interpreters 17 print \u0026#34;Hello world! \\n\u0026#34;; # \\r ... Carriage Return (Zeilenvorschub) 18 # \\n ... Line Feed 19 # \\a ... Alarm 20 # \\t ... Tabulator 21 # \\b ... Backspace 22 # \\e ... Escape 23 # \\f ... Formfeed (Seitenvorschub) 24 25 26# Datentypen 27 # Skalare (Zahl, Text, Referenz) 28 $a = 0; 29 $a = 0xff; 30 $b = \u0026#34;text\u0026#34;; 31 $b = \u0026#39;text\u0026#39;; 32 $c = $a . \u0026#34;text\u0026#34; . $b; 33 34 35 # Arrays (Indizierbare Liste skalarer Werte) 36 @d = (\u0026#34;one\u0026#34;, \u0026#34;two\u0026#34;, $b, \u0026#34;text\u0026#34;); 37 # d[0] ... one 38 # d[1] ... two 39 # d[2] ... text 40 # d[3] ... text 41 42 $tmp = $d[0]; # erstet Element 43 $tmp = $d[-1]; # letztes Element 44 push(@d, \u0026#34;three\u0026#34;); # Element/e am Ende hinzufuegen 45 push(@c, \u0026#34;four\u0026#34;, @d); 46 $tmp = pop(@d); # letztes Element entfernen u. zurueckgeben 47 delete(@d[0]); # Element loeschen 48 delete(@d[0, 2]); 49 50 $tmp = @d; # tmp ... onetwotexttext 51 $tmp = join(\u0026#34;:\u0026#34;, @d); # tmp ... one:two:text:text 52 @d = split(/:/, $tmp); # Aufteilen und in ein Array speichern 53 54 sort @d; # nach Alphabet sortieren 55 reverse @d; # Elemente umkehren 56 57 $nr = scalar @d; # Anzahl der Array-Elemente 58 $nr = $#d + 1; # Index des letzten Elements 59 60 # Hashes (Assoziatives Array skalarer Werte) 61 %address = (\u0026#34;name\u0026#34; =\u0026gt; \u0026#34;muster1\u0026#34;, 62 \u0026#34;street\u0026#34; =\u0026gt; \u0026#34;muster2\u0026#34;, 63 \u0026#34;town\u0026#34; =\u0026gt; \u0026#34;muster3\u0026#34;, 64 \u0026#34;state\u0026#34; =\u0026gt; \u0026#34;muster4\u0026#34; 65 ); 66 67 $tmp = $address{\u0026#34;name\u0026#34;}; # Rueckgabe des Wertes mit bestimmten Key 68 $address{\u0026#34;door\u0026#34;} = \u0026#34;2\u0026#34;; # Element hinzufuegen 69 delete($address{\u0026#34;town\u0026#34;}); # Key und Wert loeschen 70 delete($address{\u0026#34;town\u0026#34;, \u0026#34;state\u0026#34;}); 71 72 @tmp = keys %address; # Erhalt saemtlicher Keys 73 @tmp = values %address; # Erhalt saemtlicher Werte 74 if (exists($address{\u0026#34;name\u0026#34;})) 75 { ... } # Abfrage ob Element vorhanden ist 76 77 # spezial Variablen 78 $_ # standardmaessige Eingabe-, Ausgaberaum 79 # (aktuelles Element innerhalb von 80 # Schleifen) 81 $/ # Trennzeichen fuer Eingaberecords 82 # (defaultmaessig: Newline-Zeichen) 83 $\\ # Trennzeichen fuer Ausgaberecords 84 # (defaultmaessig: Leerstring) 85 $0 # Name des Skripts 86 $^O # Name des Betriebssystems 87 88 @ARGV # Array mit den Kommandozeilen-Parametern 89 @INC # Verzeichnis-Liste, wo nach Perl-Scripten 90 # gesucht wird 91 92 %ENV # Umgebungsvariablen 93 94 # Referenzen 95 $ref = \\$var; # Referenz von einem Skalar $var 96 $$ref # der von $ref referenzierte Skalar 97 98 $ref = \\@var; # Referenz von einem Array 99 $$ref[0] # Dereferenzierung einer Array-Referenz 100 $ref-\u0026gt;[0] 101 102 $ref = \\%var; # Referenz von einem Hash 103 $$ref{\u0026#34;key\u0026#34;} # Dereferenzierung einer Hash-Referenz 104 $ref-\u0026gt;{\u0026#34;key\u0026#34;} 105 106 $ref = \\\u0026amp;mysub; # Referenz einer Funktion 107 \u0026amp;$ref(); # Aufruf der Funktion 108 $ref-\u0026gt;(); 109 110 $isRef = ref($var); # Ueberprueft ob Variable Referenz ist 111 112 113# Operatoren 114 # Arithmetisch 115 $x = $y + $z; # Addition 116 $x += $y; 117 $x = $y - $z; # Subtraktion 118 $x = $y * $z; # Multiplikation 119 $x = $y / $z; # Division 120 $x = $y % $z; # Modulo 121 $x = $y ** $z; # Exponentierung 122 123 $x = $y . $z; # Zusammenfuehrung 124 $x = $y x $z; # Wiederholung, $y wird $z mal wiederholt 125 126 # Numerisch 127 == eq # gleich 128 != ne # ungleich 129 \u0026lt; lt # kleiner 130 \u0026lt;= le # kleiner gleich 131 \u0026gt; gt # groesser 132 \u0026gt;= ge # groesser gleich 133 \u0026lt;=\u0026gt; cmp # Vergleich 134 135 # Logisch 136 $x \u0026amp;\u0026amp; $y $x and $y # Und 137 $x || $y $x or $y # Oder 138 $x xor $y # Exklusiv-Oder 139 !$x not $x # Negation 140 141 # Bitoperationen 142 $x \u0026amp; $y # Und 143 $x | $y # Oder 144 $x ^ $y # Exklusiv-Oder 145 ~$x # Komplement 146 $x\u0026lt;\u0026lt;1 # Links-Shift 147 $x\u0026gt;\u0026gt;1 # Rechts-Shift 148 149 150# Schleifen 151 # foreach 152 foreach $skalar (@array) 153 { ... } 154 155 foreach $skalar (keys %hash) 156 { ... } 157 158 # der Schleifenrumpf wird fuer jedes Element des Arrays ausgefuehrt 159 # das aktuelle Element wird dem $skalar uebergeben 160 # wenn @array leer ist, wird der Anweisungsblock nie ausgefuehrt 161 162 # for 163 for ($i=0, $i\u0026lt;10, $i++) 164 { ... } 165 166 $i=0 # links ... Startanweisung 167 $i\u0026lt;10 # mitte ... Bedingung 168 $i++ # rechts ... Auszufuehrende Anweisung nach einem Durchlauf 169 170 # wird solange ausgefuehrt, solange die Bediengung erfuellt ist 171 172 # if-else 173 if ($bedingung1) 174 { ... 175 } 176 elsif ($bedingung2) 177 { ... 178 } 179 else 180 { ... 181 } 182 183 if # wenn die $bedingung1 erfuellt ist, 184 # wird der zugehoerige Anweisungsblock ausgefuehrt 185 elsif # wird nur ueberprueft, wenn vorherige Bedingungen nicht erfuellt 186 # wurden (vorangestellte if/elsif) 187 else # wird ausgefuehrt wenn saemtliche vorherigen Bedingungen nicht 188 # erfuellt wurden 189 190 # while und unless 191 while ($bedingung) 192 { ... 193 } 194 195 do 196 { ... 197 } 198 while ($bedingung) 199 200 # solange die Bedingung erfuellt ist, 201 # wird der Anweisungsblock ausgefuehrt 202 203 # until 204 until ($bedingung) 205 { ... 206 } 207 208 do 209 { ... 210 } 211 until ($bedingung); 212 213 # bis die Bedingung erfuellt wird, 214 # wird der Anweisungsblock ausgefuehrt 215 216 217# Funktionen 218 sub functionName 219 { 220 @_ # Array mit uebergebenen Parametern 221 $_[0] # erster Parameter 222 $_[1] # zweiter Parameter 223 ... 224 } 225 226 functionName; # Aufruf der Subroutine 227 functionName($parameter); # Aufruf mit Uebergabe 228 229 # vordefinierte Funktionen 230 chr($var) # Rueckgabe des Zeichens welches durch 231 # Dezimalzahl repraesentiert wird 232 hex($var) # Wert interpretiert als Hexadezimalstring 233 oct($var) # Wert interpretiert als Oktalstring 234 ord($var) # numerische Werte des ersten Zeichens 235 236 abs($var) # Absolutwert 237 int($var) # ganzzahliger Teil 238 239 sqrt($var) # Quadratwurzel 240 exp($var) # e^$var 241 log($var) # natuerliche Logarithmus (Basis e) 242 243 sin($var) # Sinus (Bogenmass) 244 cos($var) # Cosinus 245 atan2($y, $x) # Arkus-Tangens 246 247 srand($time) # Initialisierung des Zufallszahlen- 248 # generators 249 rand($var) # Zufallszahl zwischen 0 und $var 250 251 time # Anzahl Sekunden seit Beginn der Epoche 252 @time = localtime(time) # Zeit 253 # Index Beschreibung 254 # 0 Sekunden 255 # 1 Minuten 256 # 2 Stunden 257 # 3 Tag des Monats 258 # 4 Monat (Jaenner = 0) 259 # 5 Jahre seit 1900 260 # 6 Wochentag (Sonntag = 0) 261 # 7 Jahrestag (1. Jaenner = 0) 262 # 8 Sommerzeit (SZ = True, WZ = False) 263 ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) = @time; 264 265 266# Filehandling 267 # Datei oeffnen 268 open(FH, \u0026#34;test.txt\u0026#34;); # zum Lesen 269 open(FH, \u0026#34;\u0026lt;$file\u0026#34;); # zum Lesen 270 open(FH, \u0026#34;\u0026gt;$file\u0026#34;); # zum Schreiben (Datei ueberschreiben) 271 open(FH, \u0026#34;\u0026gt;\u0026gt;$file\u0026#34;); # zum Schreiben (an Datei anhaengen) 272 273 open(FH, \u0026#34;\u0026gt;$file\u0026#34;) || die(\u0026#34;file not found\u0026#34;); 274 275 open(FH, \u0026#34;\u0026lt;:bytes\u0026#34;, \u0026#34;test.bin\u0026#34;); 276 # :bytes 8-Bit-Bytes 277 # :encoding(UTF-8) waehlt Codierung 278 # :raw Low-Level-E/A 279 280 # FD ist ein Filehandle (STDIN, STDOUT, STDERR vordefiniert) 281 282 # Datei schliesen 283 close(FH); 284 285 # Datei lesen und schreiben 286 $char = getc(FH); # Zeichen lesen 287 $readChars = read(FH, $chars, $length, $offset); 288 $line = \u0026lt;FH\u0026gt;; # Zeile lesen 289 $line = readline(FH); 290 @allLines = \u0026lt;FH\u0026gt;; # saemtliche Zeilen lesen 291 292 print FH \u0026#34;text\u0026#34;; # in Datei schreiben 293 294 eof(FH); # TRUE wenn am Ende oder nicht geoeffnet 295 296 # Dateitestoperationen 297 if (-e \u0026#34;test.txt\u0026#34;) # -e ... ob Datei existiert 298 { ... 299 } 300 # -r ... lesbar 301 # -w ... schreibbar 302 # -x ... ausfuehrbar 303 304 # -z ... Datei hat 0 Bytes 305 # -s ... existiert und Groesse ungleich 0 306 307 # -f ... \u0026#34;normale\u0026#34; Datei 308 # -d ... Ordner 309 # -T ... Datei enthaelt ASCII Text 310 # -B ... Binaerdatei 311 312 # Operationen fuer Verzeichnisse 313 opendir(FH, \u0026#34;C:\\\\\u0026#34;); 314 closedir(FH); 315 316 $entry = readdir(FH); # naechster Verzeichnis-Eintrag 317 # undef, wenn am Ende angelangt 318 $entries = readdir(FH); # saemtliche Verzeichnis-Eintraege 319 320 # weitere Operationen 321 chmod # Datei-Rechte aendern 322 chown # Datei-Besitzer aendern 323 rename # umbennen 324 unlink # loeschen 325 stat # zusaetzliche Informationen 326 chdir # Arbeitsverzeichnis wechseln 327 mkdir # Verzeichnis anlegen 328 rmdir # Verzeichnis loeschen (nur wenn leer) 329 330 331# Aufteilung von Projekten 332 # Library 333 # config.pl # abgelegt in \u0026#34;~/libs\u0026#34; 334 my $confVal1 = 10; # lokale Variable 335 our $confVal2 = \u0026#34;test\u0026#34;; # globale Variable 336 1; 337 338 # basesubs.pl # abgelegt in \u0026#34;~/libs\u0026#34; 339 print \u0026#34;basesubs\u0026#34;; 340 341 sub sub1 342 { 343 print \u0026#34;basesubs-sub1\u0026#34;; 344 } 345 1; 346 347 # projectsubs.pl # abgelegt im Projekt-Ordner 348 package Project; # Angabe eines Namensraumes 349 print \u0026#34;projectsubs\u0026#34;; 350 351 sub sub2 352 { 353 print \u0026#34;projectsubs-sub2\u0026#34;; 354 } 355 356 sub sub3 357 { 358 print \u0026#34;projectsubs-sub3\u0026#34;; 359 } 360 1; 361 362 # useall.pl # abgelegt im Projekt-Ordner 363 print \u0026#34;main 1\u0026#34;; 364 push(@INC, \u0026#34;~/libs\u0026#34;); # Suchpfad ergaenzen 365 require \u0026#34;config.pl\u0026#34;; 366 require \u0026#34;basesubs.pl\u0026#34;; 367 require \u0026#34;projectsubs.pl\u0026#34;; 368 369 print \u0026#34;main 2\u0026#34;; 370 $tmp = $confVal2; 371 sub1(); 372 Project::sub2(); 373 sub3(); 374 print \u0026#34;main 3\u0026#34;; 375 # Ausgabe: 376 # main 1 377 # basesubs 378 # projectsubs 379 # main 2 380 # basesubs-sub1 381 # projectsubs-sub2 382 # projectsubs-sub3 383 # main 3 384 385 # Modul 386 # Module.pm # abgelegt in \u0026#34;~/lib\u0026#34; 387 package Special::Module; 388 $Special::Module::VERSION = 0.1; 389 use Exporter; 390 @ISA = (\u0026#34;Exporter\u0026#34;); 391 our @EXPORT = (\u0026#34;sub2\u0026#34;); 392 print \u0026#34;Module\u0026#34;; 393 394 sub sub1 395 { 396 print \u0026#34;Module-sub1\u0026#34;; 397 } 398 sub sub2 399 { 400 print \u0026#34;Module-sub2\u0026#34;; 401 } 402 1 403 404 # useall.pl # abgelegt im Projekt-Ordner 405 print \u0026#34;main 1\u0026#34;; 406 use lib \u0026#39;~/lib\u0026#39;; # Suchpfad ergaenzen 407 use Special::Module; # gleichwertig mit: 408 # require \u0026#34;Special/Module.pm\u0026#34; 409 # import default symbols 410 411 print \u0026#34;main 2\u0026#34;; 412 Special::Module::sub1(); 413 sub2(); 414 print \u0026#34;main 3\u0026#34;; 415 # Ausgabe: 416 # Module 417 # main 1 418 # main 2 419 # Module-sub1 420 # Module-sub2 421 # main 3 422 423 424# weitere Operationen 425 exec # fuehrt Befehl aus und kehrt nicht zurueck 426 system # fuehrt Befehl in einem Child-Prozess aus, 427 # und wartet auf dessen Ende 428 sleep # Pause fuer x Sekunden ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/perl/perl-reference/","section":"Code Schnipsel","summary":"","title":"Perl - Reference","type":"code-snippets"},{"content":" 1# Mustererkennung und Substitution 2 # mit der Mustererkennung kann man eine Variable 3 # auf einen bestimmten Inhalt durchsuchen 4 $zuUntersuchen =~ m/\u0026lt;Suchmuster\u0026gt;/\u0026lt;Option\u0026gt;; 5 6 # Substitution ist aehnlich der Mustererkennung, 7 # ausser dass das gefundene Muster ersetzt werden kann 8 $zuErsetzen =~ s/\u0026lt;Suchmuster\u0026gt;/\u0026lt;Ersetzung\u0026gt;/\u0026lt;Option\u0026gt;; 9 10 # Optionen 11 # g globale Suche, findet/ersetzt alle vorkommenden Muster 12 # i ignoriere Gross-/Klein-Schreibung 13 # o Suchmuster nur beim ersten Durchlauf kompiliert 14 # m behandelt den zu durchsuchenden String 15 # als wuerde er aus mehreren Zeilen bestehen 16 # s behandelt den zu durchsuchenden Strin 17 # als wuerde er aus einer Zeile bestehen 18 # x erlaubt Verwendung erweiterter regulaerer Ausdruecke 19 20 21 # Suchmuster 22 # grundsaetzlich kann das Suchmuster aus einem normalen String bestehen 23 # (z.B. \u0026#34;Hallo\\tWelt\u0026#34;) 24 # folgende Sonderzeichen haben in den regulaeren Ausdruecken eine 25 # spezielle Bedeutung: . + * ? ^ $ ( ) [ ] { } | \\ 26 # um solch ein Zeichen trotzdem zu suchen wird \\x verwendet 27 28 # \\d sucht nach einer Ziffer [0...9] 29 # \\D sucht nach keiner Ziffer 30 # \\w sucht ein Wortzeichen [0...9a...zA...Z_] 31 # \\W sucht kein Wortzeichen 32 # \\a sucht nach einem Alarm-Zeichen 33 # \\e sucht nach einem Escape-Zeichen 34 # \\f sucht nach einem Seitenvorschub (Form feed) 35 # \\n sucht nach einem Zeilenvorschub (Newline) 36 # \\r sucht nach einem Wagenruecklauf (Carriage Return) 37 # \\s sucht nach einem Leerzeichen (white Space) und \\t \\n \\r \\f 38 # \\S sucht nach einem Nicht-WhiteSpace 39 # \\t sucht nach einem Tabulator 40 # \\b prueft auf eine Wortgrenze 41 # z.B. \\bl\\wben\\b richtig: leben falsch: erleben 42 # laben verloben 43 # loben 44 # \\B prueft auf eine Nicht-Wortgrenze 45 # \\A prueft auf den Anfang eines Strings 46 # \\Z prueft auf das Ende eines Strings 47 # . beliebiges Zeichen (ausser \\n) 48 # [...] ein Zeichen aus einer Menge 49 # [^...] ein Zeichen nicht aus einer Menge 50 # | trennt alternative Muster 51 # ( ) Gruppierung von Zeichen 52 53 54 # Quantifier (Wiederholungsfaktoren) 55 # * Angabe muss mindestens 0 mal vorkommen 56 # + Angabe muss mindestens 1 mal vorkommen 57 # ? Angabe muss hoechstens 1 mal vorkommen 58 # {n} Angabe muss genau n-mal vorkommen 59 # {n,} Angabe muss mindestens n-mal vorkommen 60 # {n,m} Angabe muss mindestens n-mal und hoechstens m-mal vorkommen ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/perl/regular-expressions/","section":"Code Schnipsel","summary":"","title":"Perl - Regular Expressions","type":"code-snippets"},{"content":"","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/php/","section":"Code Schnipsel","summary":"","title":"PHP","type":"code-snippets"},{"content":" 1\u0026lt;? 2// PHP steht fuer \u0026#34;Hypertext Pre-Processor\u0026#34; und wird 3// direkt mit HTML in eine Datei geschrieben 4 5 // moegliche Arten PHP Code in HTML Site einzubinden: 6?\u0026gt; 7 \u0026lt;? ... ?\u0026gt; 8 \u0026lt;?php ... ?\u0026gt; 9 \u0026lt;script language=\u0026#34;php\u0026#34;\u0026gt; ... \u0026lt;/script\u0026gt; 10 11\u0026lt;? 12 // Dateien inkludieren 13 include(\u0026#34;dateiname\u0026#34;); 14 // Namensraeume 15 namespace MyProject; 16 namespace MyProject\\Sub\\Level; 17 require \u0026#39;asdf.php\u0026#39;; 18 use MyProject; 19 \\funcName(...); // globale Funktion aufrufen 20 // Fehlermeldung ignorieren 21 @ vor einen Ausdruck 22 23 24 // standard Ausgabe 25 echo \u0026#34;hello world\u0026lt;br\u0026gt;\u0026#34;; 26 echo $str; 27 echo $str, \u0026#34;and\u0026#34; ,$str; 28 echo \u0026#34;$str and $str\u0026#34;; 29 $str = \u0026lt;\u0026lt;\u0026lt;EOD 30 Text, welcher ueber 31 mehrere Zeilen geht 32EOD; 33 34 print \u0026#34;hello world\\n\u0026#34;; 35 sprintf(\u0026#39;hello world %d %s\u0026#39;, $integer, $string); 36 print_r($arr); 37 38 39 // Variablen Definition 40 global, static // Geltungsbereiche 41 42 $boolean = true; 43 $text = \u0026#34;hello\u0026#34;; 44 $firstChar = $text[0]; 45 $integer = 12; 46 $integer = 0xff; // hexadezimal 47 $integer = 0123; // octal 48 $float = 1.2; 49 $float = 1.2e3; 50 $float = 1E-2; 51 52 53 // Konstanten 54 define(\u0026#34;NAME\u0026#34;, \u0026#34;value\u0026#34;); 55 const NAME = \u0026#39;value\u0026#39;; 56 57 __LINE__ // ... aktuelle Zeilennummer 58 __FILE__ // ... vollstaendige Pfad- und Dateiname einer Datei 59 __DIR__ // ... Name des Verzeichnisses 60 __FUNCTION__ // Name der Funktion 61 __CLASS__ // Name einer Klasse 62 __METHOD__ // Name einer Klassenmethode 63 __NAMESPACE__ // Name des aktuellen Namespace 64 65 66 // global definierte Variablen 67 $GLOBALS // Referenziert alle Variablen, die im 68 // globalen Gueltigkeitsbereich vorhanden sind 69 $_SERVER // Informationen ueber Server und 70 // Ausfuehrungsumgebung 71 $_GET // HTTP GET-Variablen 72 $_POST // HTTP POST-Variablen 73 $_FILES // HTTP Dateiupload-Variablen 74 $_REQUEST // HTTP Request-Variablen 75 $_SESSION // Sessionvariablen 76 $_ENV // Umgebungsvariablen 77 $_COOKIE // HTTP Cookies 78 $php_errormsg // Die vorangegangene Fehlermeldung 79 $HTTP_RAW_POST_DATA // Raw POST-Daten 80 $http_response_header // HTTP Response-Header 81 $argc // Die Anzahl der an das Skript 82 // uebergebenen Argumente 83 $argv // Array der an das Skript 84 // uebergebenen Argumente 85 86 87 // Session Variablen 88 session_start(); // Session starten und Wert speichern 89 session_register(\u0026#39;variable\u0026#39;); 90 $variable = \u0026#39;value\u0026#39;; 91 92 session_start(); 93 $_SESSION[variable] // Wert auf weiteren Seite verwenden 94 95 96 // Array Definitionen 97 $arr = array(\u0026#34;first\u0026#34;, \u0026#34;second\u0026#34;, \u0026#34;third\u0026#34;); 98 $arr = array(\u0026#39;index1\u0026#39; =\u0026gt; \u0026#39;value1\u0026#39;, \u0026#39;index2\u0026#39; =\u0026gt; \u0026#39;value2\u0026#39;); 99 $arr[\u0026#39;index1\u0026#39;]; 100 101 $arr[] = \u0026#34;1\u0026#34;; 102 $arr[] = \u0026#34;2\u0026#34;; 103 sort($arr); 104 count($arr); 105 106 array(\u0026#34;somearray\u0026#34; =\u0026gt; array(0 =\u0026gt; 10, 1 =\u0026gt; 11, \u0026#34;a\u0026#34; =\u0026gt; 12)); 107 echo $arr[\u0026#34;somearray\u0026#34;][0]; 108 echo $arr[\u0026#34;somearray\u0026#34;][1]; 109 echo $arr[\u0026#34;somearray\u0026#34;][\u0026#34;a\u0026#34;]; 110 111 unset($arr[0]); // 0-Element loeschen 112 unset($arr); // gesamte Array loeschen 113 114 foreach($arr as $key=\u0026gt;$value) // Array durchlaufen 115 { 116 echo \u0026#34;arr[$key] = $value \u0026lt;br\u0026gt;\u0026#34;; 117 } 118 119 $arr = array(1 =\u0026gt; \u0026#39;one\u0026#39;, 2 =\u0026gt; \u0026#39;two\u0026#39;, 3 =\u0026gt; \u0026#39;three\u0026#39;); 120 unset($a[2]); 121 /* arr = array(1 =\u0026gt; \u0026#39;one\u0026#39;, 3 =\u0026gt; \u0026#39;three\u0026#39;); */ 122 $brr = array_values($arr); 123 /* $brr = array(0 =\u0026gt; \u0026#39;one\u0026#39;, 1 =\u0026gt;\u0026#39;three\u0026#39;) */ 124 125 $arr1 = array(2, 3); 126 $arr2 = $arr1; 127 $arr2[] = 4; // $arr2 wurde geaendert 128 // $arr1 bleibt gleich 129 $arr3 = \u0026amp;$arr1; 130 $arr3[] = 4; // $arr1 und $arr3 sind 131 // die selben 132 133 134 isset($var); 135 136 137 // Referenzen 138 $a =\u0026amp; $b; // a ist gleich dem Objekt b 139 140 141 // Casts 142 (bool) 1 143 (boolean) 1 144 (int) 12 145 (integer) 12 146 (real), (double), (float) 147 (string) 148 (array) 149 (object) 150 151 gettype() 152 is_bool() 153 is_long() 154 is_float() 155 is_string() 156 is_array() 157 is_object() 158 159 160 // Classes 161 class cl 162 { 163 var $var; 164 165 function cl() // C-TOR 166 { } 167 function __construct() 168 { } 169 170 function __destruct() // D-TOR 171 { } 172 173 function doSmth() 174 { 175 $this-\u0026gt;var = array(); 176 } 177 178 final public function asdf() // kann nicht 179 { } // ueberschrieben werden 180 181 public $public = \u0026#39;Public\u0026#39;; // Sichtbarkeit 182 protected $protected = \u0026#39;Protected\u0026#39;; 183 private $private = \u0026#39;Private\u0026#39;; 184 185 public function asdf() {} 186 protected function asdf() {} 187 private function asdf() {} 188 } 189 $cl1 = new cl; 190 $cl1-\u0026gt;doSmth(); 191 192 class cl2 extends cl // Ableiten 193 { 194 function doSmth() 195 { 196 cl::doSmth(); // Scope Resolution 197 parent::doSmth(); 198 self::doSmth(); 199 ... 200 } 201 } 202 203 abstract class abstrCl // abstrakte Klasse 204 { 205 // Methode welche implementiert werden muss 206 abstract protected function doSmth(); 207 208 // Gemeinsam verfuegbare Methode 209 public function doSmth2() 210 { ... } 211 } 212 213 interface iAsdf // Interface 214 { 215 public function doSmth1($var1, $var2); 216 public function doSmth2(); 217 } 218 class asdf implements iAsdf 219 { ... } 220 221 222 // Serializing 223 // classa.inc: 224 class A 225 { 226 var $one = 1; 227 228 function doSmth() 229 { } 230 } 231 232 // page1.php: 233 include(\u0026#34;classa.inc\u0026#34;); 234 $a = new A; 235 $s = serialize($a); 236 $fp = fopen(\u0026#34;test.dat\u0026#34;, \u0026#34;w\u0026#34;); 237 fwrite($fp, $s); 238 fclose($fp); 239 240 // page2.php: 241 include(\u0026#34;classa.inc\u0026#34;); 242 $s = implode(\u0026#34;\u0026#34;, @file(\u0026#34;test.dat\u0026#34;)); 243 $a = unserialize($s); 244 $a-\u0026gt;doSmth(); 245 246 247 // Formularuebergaben 248 // Formular: 249 // \u0026lt;form action=\u0026#34;doit.php\u0026#34; method=\u0026#34;post\u0026#34;\u0026gt; 250 // \u0026lt;input type=\u0026#34;text\u0026#34; name=\u0026#34;inputVar\u0026#34;\u0026gt; 251 // \u0026lt;input type=\u0026#34;submit\u0026#34;\u0026gt; 252 // \u0026lt;/form\u0026gt; 253 254 // vorhandene Variablen 255 echo $_POST[\u0026#39;inputVar\u0026#39;]; 256 echo $_REQUEST[\u0026#39;inputVar\u0026#39;]; 257 echo \u0026#34;Eingabe: $inputVar\u0026#34;; 258 259 260 // Arithmetische Operationen 261 $i = $x + $y; // Addition 262 $i = $x - $y; // Subtraktion 263 $i = $x * $y; // Multiplikation 264 $i = $x / $y; // Division 265 $i = $x % $y; // Modulo 266 $i = $x . $y; // Verbinden von Strings 267 $i++; // Post-Inkrement 268 ++$i; // Pre-Inkrement 269 $i--; // Post-Dekrement 270 --$i; // Pre-Dekrement 271 272 $i += $x; 273 $i -= $x; 274 $i *= $x; 275 $i /= $x; 276 277 278 // Bit Operationen 279 \u0026amp; // Und 280 | // Oder 281 ^ // XOR 282 ~ // Negiert 283 \u0026lt;\u0026lt; // shift left 284 \u0026gt;\u0026gt; // shift right 285 286 287 // Logische Operationen 288 and 289 or 290 xor 291 ! 292 \u0026amp;\u0026amp; 293 || 294 295 296 // Vergleiche 297 $i \u0026lt; $j // kleiner 298 $i \u0026gt; $j // groesser 299 $i \u0026lt;= $j // kleiner gleich 300 $i \u0026gt;= $j // groesser gleich 301 $i == $j // gleich 302 $i === $j // identisch 303 $i != $j // ungleich 304 $i !== $j // nicht identisch 305 $i \u0026lt;\u0026gt; $j // ungleich 306 307 308 // Kontrollstrukturen 309 while ($CONDITION) 310 { } 311 312 do 313 { } 314 while ($CONDITION); 315 316 for ($i=0; $i\u0026lt;10; $i++) 317 { } 318 319 foreach ($values as $value) 320 { } 321 322 if ($CONDITION) 323 { } 324 else if ($CONDITION) 325 { } 326 else 327 { } 328 329 CONDITION ? $true : $false 330 331 switch ($var) 332 { 333 case \u0026#34;asdf\u0026#34;: 334 break; 335 case \u0026#34;qwer\u0026#34;: 336 break; 337 default: 338 } 339 340 341 // Funktionen 342 function aFunc ($Var) // call-by-value 343 { 344 return $Var; 345 } 346 347 function aFunc (\u0026amp;$Var) // call-by-reference 348 { 349 $Var .= \u0026#39;asdf\u0026#39;; 350 } 351 352 function aFunc_retArr () // Rueckgabe eines Arrays 353 { 354 return array(1, 2, 3); 355 } 356 $res = aFunc_retArr(); 357 $res[0] 358 $res[1] 359 $res[2] 360 361 function aFunc ($Var = \u0026#34;preinit\u0026#34;) // Vorinitialisierung 362 function aFunc ($Var = NULL) 363 364 365 // Exceptions 366 try 367 { 368 throw new Exception(\u0026#39;asdf\u0026#39;); 369 } 370 catch (Exception $exc) 371 { 372 echo $e-\u0026gt;getMessage(); 373 } 374 375 376 // String Operationen 377 $var = \u0026#34;asdf\u0026#34;; 378 echo \u0026#34;some text before $vars\u0026#34;; // wuerde nicht funktionieren 379 echo \u0026#34;some text before ${var}s\u0026#34;; // wuerde funktionieren 380 echo \u0026#34;some text before {$var}s\u0026#34;; // wuerde funktionieren 381 382 strlen($str); 383 384 trim(\u0026#34; asdf \u0026#34;); // Whitespaces am Anfang und Ende entfernen 385 ltrim(\u0026#34; asdf\u0026#34;); // -,,- am Anfang 386 chop(\u0026#34;asdf \u0026#34;); // -,,- am Ende 387 388 strtoupper(\u0026#34;asdf\u0026#34;); // in Grossbuchstaben umwandeln 389 strtolower(\u0026#34;ASDF\u0026#34;); // in Kleinbuchstaben umwandeln 390 ucfirst(\u0026#34;asdf\u0026#34;); // ersten Buchstaben -\u0026gt; gross 391 ucwords(\u0026#34;asdf asdf\u0026#34;); // jeder erste Buchstabe eines Wortes -\u0026gt; gross 392 393 nl2br(\u0026#34;asdf\\nasdf\u0026#34;); // new line to \u0026lt;br\u0026gt; 394 395 preg_split(\u0026#34;/-/\u0026#34;, $str); // String aufteilen 396 implode(\u0026#39;-\u0026#39;, $strArray); // String-Array zusammenfuegen 397 398 // \\n linefeed 399 // \\r carriage return 400 // \\t horizontal tab 401 // \\v vertical tab 402 // \\f form feed 403 // \\\\ backslash 404 // \\$ dollar sign 405 // \\\u0026#34; double quote 406 407 408 // Datei Operationen 409 $datei = fopen(\u0026#34;asdf.txt\u0026#34;,\u0026#34;r\u0026#34;); 410 // r ... lesen 411 // r+ ... lesen und schreiben 412 // w ... schreiben (falls existiert -\u0026gt; zuvor loeschen) 413 // w+ ... lesen und schreiben (falls existiert -\u0026gt; zuvor loeschen) 414 // a ... anfuegen (Cursor befindet sich am Ende) 415 // a+ ... lesen und anfuegen (Cursor befindet sich am Ende) 416 feof($datei); 417 $zeile = fgets($datei); 418 $zeile = fgets($datei,1000); 419 fwrite($datei, $str . \u0026#34;...\u0026#34;); 420 fclose($datei); 421 422 423 // Bild Operationen 424 \u0026lt; ? 425 Header( \u0026#34;Content-type: image/gif\u0026#34;); 426 $img = imagecreate(200,100); 427 $clr = ImageColorAllocate($img, 0x01,0x02,0x03); 428 ImageFilledRectangle($img,0,0,200,100,$clr); 429 Imagestring($img, 5, 20, 20, \u0026#34;asdf\u0026#34;, $clr); 430 ImageGif($img); 431 ImageDestroy($img); 432 ? \u0026gt; 433 434 435 // Datenbank Operationen 436 $connection = mysql_connect(\u0026#34;localhost\u0026#34;,\u0026#34;user\u0026#34;,\u0026#34;pwd\u0026#34;); 437 if (!$connection) 438 { 439 echo \u0026#34;no connection!\\n\u0026#34;; 440 exit; 441 } 442 else 443 { 444 $query = \u0026#34;SELECT col1,col2 FROM table\u0026#34;; 445 $result = mysql_db_query(\u0026#34;www2\u0026#34;, $query, $connection); 446 list($Col1, $Col2) = mysql_fetch_row($result); 447 mysql_close($connection); 448 } 449 450 451 // Cookie 452 \u0026lt; ? 453 $expireSec = time() + 3600*24*10; 454 setcookie(\u0026#34;Name\u0026#34;, \u0026#34;Value\u0026#34;, $expireSec, \u0026#34;/\u0026#34;); 455 SetCookie(\u0026#34;Name\u0026#34;, \u0026#34;Value\u0026#34;, $expireSec, \u0026#34;/path\u0026#34;,\u0026#34;.domain\u0026#34;); 456 ? \u0026gt; 457 \u0026lt;HTML\u0026gt; 458 459 $_COOKIE[\u0026#34;Name\u0026#34;] // auf vorhandene Cookies zugreifen 460 $expireSec = time() - 3600; // Cookie loeschen 461 setcookie(\u0026#34;Name\u0026#34;, \u0026#34;\u0026#34;, $expireSec, \u0026#34;/path\u0026#34;); 462 463?\u0026gt; ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/php/php-reference/","section":"Code Schnipsel","summary":"","title":"PHP - Reference","type":"code-snippets"},{"content":"","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/scilab/","section":"Code Schnipsel","summary":"","title":"Scilab","type":"code-snippets"},{"content":" 1clear // clear variables and keywords 2clc // clear command window 3 4 5function res = rescale(value, value_max) 6 res = 0; 7 8 // check boundaries 9 if (value \u0026gt; value_max) 10 value = value_max; 11 elseif (value \u0026lt; 0) 12 value = 0; 13 end 14 15 // rescale value (new range 0 to 63) 16 for i=1:6 17 res = res * 2; 18 value_max = int(value_max / 2); 19 20 if (value \u0026gt; value_max) 21 res = res + 1; 22 value = value - value_max; 23 end 24 end 25endfunction 26 27for j=1:1000 28 a(j)=rescale(j,1000); 29 b(j)=j*63/1000; 30 c(j)=abs(a(j)-b(j)); 31 c_max = max(c); 32end ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/scilab/rescale/","section":"Code Schnipsel","summary":"","title":"Scilab - Rescale","type":"code-snippets"},{"content":"","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/system-verilog/","section":"Code Schnipsel","summary":"","title":"System Verilog","type":"code-snippets"},{"content":" 1// Literatur: Vorlesungsunterlagen AMV von Rainer Findenig (FH-Hagenberg) 2 3// Coverage ... Grad der Abdeckung 4 5// Covergroups \u0026amp; Coverpoints 6 bit mysignal2; 7 int mysignal3; 8 9 covergroup mycg @(myEvent); 10 label1: coverpoint mysignal1; 11 label2: coverpoint mysignal2 { 12 bins enabled = { 1 }; 13 bins disabled = { 0 }; 14 } 15 label3: coverpoint mysignal3 { 16 bins firstSection = { 0, 1, 2 }; 17 bins secondSection = { 10, 20, 30 }; 18 bins other = default; 19 } 20 label4: coverpoint mysignal4 { 21 // bins die nicht betrachtet werden 22 ignore_bins zero = {0}; 23 ... 24 // bins die nicht auftreten sollten/duerfen 25 illegal_bins invalid = default; 26 ... 27 // Transition Coverage: 28 // wie oft wurden bestimmte Uebergaenge ausgefuehrt 29 bins posEdge = ( 0 =\u0026gt; 1 ); 30 bins negEdge = ( 1 =\u0026gt; 0 ); 31 bins nothing = ( 0 =\u0026gt; 0 ), ( 1 =\u0026gt; 1 ); 32 } 33 // Conditional Coverage: Bsp. keine Infos waehrend Reset 34 label5: coverpoint mysignal5 iff (!rst); 35 endgroup 36 37 mycg cg = new; // Objekt muss angelegt werden 38 mycg = new; 39 40 41// Cross Coverage 42 covergroup cg_opcodes @(posedge clk); 43 val_cmd: coverpoint cmd { 44 bins arith = { ... }; 45 bins logic_ = { ... }; 46 ... 47 } 48 val_reg: coverpoint regaddr; 49 50 cmd_with_reg: cross val_cmd, val_reg; 51 52 // Illegale Kombinationen markieren 53 // Bsp. logische Operationen duerfen Register 0 nicht nuetzen 54 cmd_with_reg: cross val_cmd, val_reg { 55 illegal_bins log_r0 = binsof(val_cmd.logi_) \u0026amp;\u0026amp; 56 binsof(val_reg) intersect {0}; 57 } 58 endgroup 59 60 61// Bereiche Betrachten 62 int regaddr; 63 ... 64 covergroup somecg @(someevent); 65 reg_address: coverpoint regaddr { 66 bins zero = { 0 }; // 1 bin 67 bins local_ [] = { [1:7] }; // 7 bins: local_[1]..local_[7] 68 bins in = { [8:15] }; // 1 bin 69 bins out [] = { [16:24] }; // 8 bins 70 71 bins invalid = default; 72 } 73 endgroup 74 75 76// zufaellig generierte Werte 77 typedef enum { NOP=0, SLEEP=1, 78 LOADI=2, LOAD=3, STORE=4, 79 JUMP=8, JUMPC=10, JUMPZ=11, 80 MOVE=12, 81 AND=16, OR=17, XOR=18, NOT=19, 82 ADD=20, ADDC=21, SUB=22, SUBC=23, 83 COMP=24, 84 INC=26, DEC=27, 85 SHL=28, SHR=29, SHLC=30, SHRC=31 } aProl16Command; 86 typedef bit [REGISTER_WIDTH-1 : 0] aData_v; 87 88 class clProl16Opcode; 89 rand int ra; 90 rand int rb; 91 rand aProl16Command cmd; 92 rand aData_v data; 93 // rand ... zufaellige Werte 94 // randc ... zufaellige Werte, wiederholt Werte erst 95 // wenn bereits alle vorgekommen 96 97 constraint no_invalid_model_cmd { 98 cmd != NOP; 99 cmd != SLEEP; 100 cmd != LOAD; 101 cmd != STORE; 102 }; 103 104 constraint only_valid_regA { 105 ra \u0026gt;= 0; 106 ra \u0026lt; REGISTER_NR; 107 }; 108 109 constraint only_valid_regB { 110 rb \u0026gt;= 0; 111 rb \u0026lt; REGISTER_NR; 112 }; 113 114 function void pre_randomize(); 115 begin 116 $write(\u0026#34;pre_randomize: Called for randomizing data.\u0026#34;); 117 end 118 endfunction 119 120 function void post_randomize(); 121 begin 122 $write(\u0026#34;post_randomize: Called after randomizing data.\u0026#34;); 123 end 124 endfunction 125 endclass 126 127 ... 128 opcode = new (); 129 void\u0026#39;(opcode.randomize()); 130 // void damit keine Warnings ausgegeben werden 131 132 opcode.randomize() with { 133 cmd == NOP; 134 }; 135 136 137 138// Constraints steuern 139 opcode.only_valid_regA::constraint_mode(0); // Constraint aus 140 opcode.only_valid_regA::constraint_mode(1); // Constraint ein 141 opcode::constraint_mode(0); 142 143 // Constraint Modus auslesen 144 int on = opcode.only_valid_regA::constraint_mode(); 145 146 opcode.only_valid_regA::rand_mode(0); // Random-Funkt. aus 147 int on = opcode.only_valid_regA::rand_mode(); // auslesen 148 149 150// weitere Constraints 151 constraint array_size { data.size() \u0026lt;= 8; }; 152 constraint id_not_null { id != 0; }; 153 constraint c { 154 // inclusive 155 src_port inside { [8\u0026#39;h0:8\u0026#39;hA],8\u0026#39;h14,8\u0026#39;h18 }; 156 // exclusive 157 ! (des_port inside { [8\u0026#39;h4:8\u0026#39;hFF] }); 158 } 159 160 constraint len { 161 length dist { 162 [64 : 127 ] := 10, // mindestens 10x im Bereich 64-127 163 [128 : 511 ] := 10, // ... 164 [512 : 2048] := 10 165 }; 166 } 167 constraint src { 168 src_port dist { 169 0 := 1, 170 1 := 1, 171 2 := 5, 172 4 := 1 173 }; 174 } 175 176 // gewichtete Distribution: 177 constraint high_id { 178 id dist { 179 [0 : 0x400] :/ 25, // 25% im Bereich 0-0x400 180 [0x401 , 0x800] :/ 75 // 75% im Bereich 0x401-0x800 181 } 182 } 183 // bedingte Constraints 184 constraint my_const { 185 (id == 0) -\u0026gt; data.size() \u0026gt;= 2; 186 (id == 100) -\u0026gt; data.size() == 0; 187 188 if (size == RUNT) { 189 length \u0026gt;= 0; 190 length \u0026lt;= 63; 191 } else if (size == OVERSIZE) { 192 length \u0026gt;= 1501; 193 length \u0026lt;= 5000; 194 } 195 }; 196 197 // Iterative Constraints 198 constraint frame_sizes { 199 data.size inside {[1:10]}; // im Bereich 1-10 200 foreach (data[i]) // bekommt jedes Element ein 201 data[i] == i; // eigenes Constraint 202 } 203 204 // Variable Ordnung der Constraints 205 constraint frame_sizes { 206 solve zero before data.size; // zuvor wird zero ausgewertet, 207 zero -\u0026gt; data.size == 0; // danach data.size 208 data.size inside {[0:10]}; 209 foreach (data[i]) 210 data[i] == i; 211 } 212 213 214// zufaelliges Abarbeiten eines Zweiges 215 task do_randcase(); 216 begin 217 randcase 218 20 : begin // 20 gibt das Gewicht 219 $write (\u0026#34;first randcase \\n\u0026#34;); // dieses Zweiges an 220 end // (aus Summe berechnet) 221 20 : begin 222 $write (\u0026#34;second randcase \\n\u0026#34;); 223 end 224 20 : begin 225 $write (\u0026#34;third randcase\\n\u0026#34;); 226 end 227 endcase 228 end 229 endtask ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/system-verilog/coverage/","section":"Code Schnipsel","summary":"","title":"System Verilog - Coverage","type":"code-snippets"},{"content":" 1// Literatur: 2// Vorlesungsunterlagen AMV von Rainer Findenig (FH-Hagenberg) 3// Doulos - http://www.doulos.com/knowhow/sysverilog/ 4// ASIC World - http://www.asic-world.com/systemverilog/tutorial.html 5// ElectroSofts - http://electrosofts.com/systemverilog/ 6 7// HDVL - Hardware Description and Verification Language 8// Erweiterung zu Verilog 9 10 11// Definition von Packages 12// -\u0026gt; globale bzw. Projektspezifische Definitionen und Parameter 13 package global; 14 parameter DATA_WIDTH = 8; 15 parameter ADDR_WIDTH = 8; 16 parameter END_ADDRESS = (2**ADDR_WIDTH) - 1; 17 18 parameter DEAKTIVATED = 0; 19 parameter AKTIVATED = 1; 20 21 parameter CLOCK_PERIOD = 10ns; 22 endpackage 23 24 25// den Namensraum verfuegbar machen 26 import global::*; 27// Datei includieren 28 `include \u0026#34;ram-bh.sv\u0026#34; 29 30 31// verschiedene Module (Architekturen) 32 module RAM # ( 33 // Paramter Liste 34 parameter int gDataWidth = 32; 35 parameter int gAddrWidth = 8 36 ) 37 ( 38 // Port Liste 39 input logic clk_i; 40 input logic rst_i; 41 input logic [gDataWidth-1 : 0] dat_i; 42 input logic [gAddrWidth-1 : 0] adr_i; 43 input logic we_i; 44 output logic [gDataWidth-1 : 0] dat_o 45 ); 46 logic [gDataWidth-1 : 0] storage [2**gAddrWidth-1 : 0]; 47 48 // Prozess wird zu Begin einmal aufgerufen 49 initial begin 50 storage[0] = \u0026#39;0; 51 storage[1] = \u0026#39;0; 52 ... 53 end 54 55 // Prozess existiert immer und wird bei den Events aufgerufen 56 always @(posedge clk_i or rst_i) 57 begin 58 ... 59 end 60 endmodule 61 62 module top (); 63 logic clk = 0; 64 logic rst = AKTIVATED; 65 ... 66 67 initial begin 68 #0ns rst = AKTIVATED; 69 #1ns rst = DEAKTIVATED; 70 end 71 72 always #CLOCK_PERIOD clk = ~clk; 73 74 // Ram Instantiieren 75 RAM # (.gDataWidth (DATA_WIDTH), 76 .gAddrWidth (ADDR_WIDTH) 77 ) 78 duv(.clk_i (clk), 79 .rst_i (rst), 80 .dat_i (datM), 81 .adr_i (adr), 82 .we_i (we), 83 .dat_o (datS) 84 ); 85 endmodule 86 87 // eigenes Modul-Konstrukt fuer die Testbench 88 program ram_tb (); 89 // nur initial begin Bloecke 90 initial begin : stimuli 91 // koennen aber endlos Schleifen haben 92 end : stimuli 93 endprogram 94 95 96// Basisdatentypen 97 // 4-state-logic (0, 1, X, Z) 98 reg clk = 0; // user-defined size 99 logic // identical to reg in every way 100 // logic [7:0] a_byte; 101 integer // 32 bits, signed 102 103 // 2-state-logic (0, 1) -\u0026gt; Simulationszeit verringert sich 104 bit // user-defined size 105 byte // 8 bits, signed 106 shortint // 16 bits, signed 107 int // 32 bits, signed 108 longint // 64 bits, signed 109 110 time // 64-bit, unsigned 111 shortreal // like float in C 112 real // like double in C 113 realtime //identical to real 114 115 116// Typdefinitionen und Enumerationen 117 typedef bit [7 : 0] data_v; 118 data_v data; 119 120 enum { circle, ellipse, freeform } c; 121 enum bit [3:0] {bronze=0, silver, gold} newMedal; 122 123 typedef enum {Idel = 0, StartBit, Data, Parity, StopBit} aState; 124 aState s = Idle; 125 case(s) 126 Idle: 127 ... 128 endcase 129 130 131// Arraydefinitionen 132 // packed arrays, festgelegte Darstellung als Bitstrom 133 bit [7 : 0] data; 134 135 // unpacked arrays, Werkzeug kann Abbildung frei waehlen 136 bit data [7 : 0]; 137 138 bit [7 : 0] data_list [4] // [0:3] 139 // z.B. data_list[0] xxxxxxxx 76543210 140 // data_list[1] xxxxxxxx 76543210 141 // data_list[2] xxxxxxxx 76543210 142 // data_list[3] xxxxxxxx 76543210 143 144 // dynamische Arrays (nur unpacked, aufsteigend Indiziert) 145 bit a1[], a2[]; // zwei leere Arrays 146 a1 = new[10]; // Array anlegen 147 a2 = a1; // Array kopieren 148 a2 = new[a2.size*2](a2); // a2 Groesse verdoppeln 149 a1 = new[5]; // neues Array anlegen 150 // (-\u0026gt; Garbage Collector) 151 a1.delete; // Array loeschen 152 153 // packed \u0026lt;-\u0026gt; unpacked (Bit-stream cast) 154 typedef bit [0 : 7] data_v; 155 data_v packed; 156 bit unpacked [8]; 157 packed = data_v\u0026#39;(unpacked); // unpacked -\u0026gt; packed 158 159 // packed \u0026lt;-\u0026gt; unpacked (Streaming operators) 160 int a[2], b1, b2; 161 bit [64:1] x = { \u0026gt;\u0026gt; {a}}; // pack a left-to-right 162 bit [63:0] x = { \u0026lt;\u0026lt; {a}}; // pack a bit reverse 163 bit [0:63] x = { \u0026gt;\u0026gt; {b1, b2}}; // pack b1, b2 164 165 { \u0026lt;\u0026lt; { 8\u0026#39;b0011_0101 }} // bit reverse -\u0026gt; 1010_1100 166 { \u0026lt;\u0026lt; 4 { 6\u0026#39;b11_0101 }} // 0101_11 167 { \u0026gt;\u0026gt; 4 { 6\u0026#39;b11_0101 }} // 1101_01 168 169 // linke Seite kuerzer als rechte: Fehler 170 // rechte Seite kuerzer als linke: linksbuendig, mit 0 gefuellt 171 172 // Streams nicht direkt als Wert verwendbar -\u0026gt; Cast notwendig 173 typedef bit [0 : 7] data_v; 174 data_v data; 175 bit ret[8]; 176 assert (data == data_v\u0026#39;({ \u0026gt;\u0026gt; {ret}})) 177 178 // Array durchlaufen 179 int a[] = new[100]; 180 foreach (a[i]) 181 a[i] = i; 182 183 a = \u0026#39;0; // Array mit 0 fuellen 184 a = \u0026#39;1; 185 a = \u0026#39;z; 186 a = \u0026#39;x; 187 188 189// Strukturen und Unions (aehnlich zu C) 190 struct { 191 int x, y; 192 } p; 193 p.x = 1; 194 p = { 1,2 }; 195 196 typedef struct packed { 197 int x, y; 198 } Point; 199 Point p; 200 201 202// Zuweisungen 203 // non-blocking Assignment: Zuweisung im naechsten \u0026#34;Delta-Cycle\u0026#34; 204 always @(posedge clk) begin 205 A \u0026lt;= A + 1; 206 B \u0026lt;= A; // B bekommt alten Zustand von A 207 end 208 209 // blocking Assignment: Zuweisung sofort 210 always @(posedge clk) begin 211 A = A + 1; 212 B = A; // B bekommt neuen Zustand von A 213 end 214 215 216// Operatoren 217 //Type Symbol Operation 218 // Arithmetik * Multiplizieren 219 // / Dividieren 220 // + Addieren 221 // - Subtrahieren 222 // % Modulo 223 // + unaer Plus 224 // - unaer minus 225 // Logik ! logische Negation 226 // \u0026amp;\u0026amp; logisches Und 227 // || logisches Oder 228 // Vergleich \u0026gt; groeser 229 // \u0026lt; kleiner 230 // \u0026gt;= groeser gleich 231 // \u0026lt;= kleiner gleich 232 // Gleichheit == gleich 233 // != ungleich 234 // Bit ~ bitweise Negation 235 // ~\u0026amp; nand 236 // | or 237 // ~| nor 238 // ^ xor 239 // ^~ xnor 240 // ~^ xnor 241 // Shift \u0026gt;\u0026gt; right shift 242 // \u0026lt;\u0026lt; left shift 243 // Verkettung { } Concatenation 244 // Bedingung ? Conditional 245 246 247// Schleifen und Bedingungen 248 // IF 249 if (Cond1) 250 doSomething1(); 251 else if (Cond2) 252 doSomething2(); 253 else 254 doSomething3(); 255 256 if (Cond) 257 begin 258 doSomething1(); // werden mehrere Zeilen benoetigt, 259 doSomething2(); // so braucht man einen begin-end-Block 260 end 261 262 // DO-WHILE 263 do 264 ... 265 while(Cond); 266 267 // WHILE 268 while (Cond) begin 269 ... 270 end 271 272 // FOR 273 for (int i=15, logic j=0; i\u0026gt;0; i--,j=~j) 274 ... 275 276 // CASE 277 case(address) 278 0 : $display (\u0026#34;Adresse = 0\u0026#34;); 279 1 : 280 begin 281 $display (\u0026#34;Adresse = 1\u0026#34;); 282 $display (\u0026#34;weitere Zeile\u0026#34;); 283 end 284 default : $display (\u0026#34;default Zweig\u0026#34;); 285 endcase 286 287 // REPEAT 288 repeat (16) begin 289 ... 290 end 291 292 293// Ueberschriften 294 begin : label 295 end : label 296 297 module myModule ... 298 ... 299 endmodule : myModule 300 301 loop : for (...) 302 303 304// Ausgaben 305 // Syntax aehnlich zu \u0026#34;printf\u0026#34; 306 $display(\u0026#34;@%t: data = %0d\u0026#34;, $time, data); 307 $write(); 308 $time // aktuelle Simulationszeit 309 $finish // Simulation beenden 310 311 string sv = \u0026#34;SystemVerilog\u0026#34;; 312 string s; 313 s = {sv, \u0026#34; \u0026#34;, \u0026#34;ist echt einfach.\u0026#34;}; 314 $display (\u0026#34;%s\\n\u0026#34;, s); // Bildschirmausgabe: 315 // \u0026#34;SystemVerilog ist echt einfach.\u0026#34; 316 317 318 319// Assertions 320 assert (A == B); // wenn A!=B wird ein Fehler ausgegeben 321 assert (A == B) $display (\u0026#34;OK. A gleich B\u0026#34;); 322 assert (A == B) $display (\u0026#34;OK. A gleich B\u0026#34;); 323 else $error(\u0026#34;Fehler: A ungleich B\u0026#34;); 324 assert (A == B) else $error(\u0026#34;Fehler: A ungleich B\u0026#34;); 325 326 327// Timing-Kontrolle 328 wait (cond); // level-sensitive 329 // -\u0026gt; warte, bis cond wahr ist 330 @(posedge clk); // warte auf steigende Flanke von clk 331 repeat (2) @(negedge clk); // warte 2x auf negative Flanke von clk 332 @(sig); // warte, bis sich sig aendert 333 @(posedge clk, rst) == @(posedge clk or rst) 334 #1ns rst = 0; // 1e ns warten, danach rst auf 0 setzen 335 ##1 rst = 0; // 1en Clock Zyklus warten 336 wait(0); // endlos Warten 337 338 339// Function vs. Task 340 // fuer Berechnungen (passieren in Nullzeit) 341 function int calcCrc(input int data0 = \u0026#39;0, data1); 342 ... 343 calcCrc = 0; 344 ... 345 return crc; // return ueberschreibt calcCrc Wert 346 endfunction 347 res = calcCrc(.data0(d0), .data1(d1)); 348 res = calcCrc(d0, d1); // Reihenfolge wird beachtet 349 350 // koennen Zeit verbrauchen 351 task waitForClk(input int data_i, output int data_o); 352 ... 353 @(posedge clk); 354 endtask 355 356 357// Clocking Block - beschreibt wie die Eingaenge und Ausgaenge 358// gesampled und synchronisiert werden 359 clocking clock1 @(posedge clk1); 360 default input #2ns // default input skew 361 output #3ns; // default output skew 362 input a1, a2; 363 input #1 a3; // eigens spezifizierte input skew 364 output b1; 365 output #1 b2; // eigens spezifizierte output skew 366 endclocking 367 368 369 370 371// Interfaces - fuer gemeinsame Schnittstellen 372 interface wishboneBusIf(input logic clk, rst); 373 logic ack, stb, cyc, we; 374 logic [DATA_WIDTH-1 : 0] datM, datS; 375 logic [ADDR_WIDTH-1 : 0] adr; 376 logic [DATA_WIDTH/8-1 : 0] sel; 377 378 clocking cb @(posedge clk, rst); 379 input ack, datS; 380 output stb, cyc, we, datM, adr, sel; 381 endclocking 382 383 modport master(clocking cb); 384 modport slave( 385 input stb, 386 input cyc, 387 input we, 388 input datM, 389 input adr, 390 input sel, 391 output ack, 392 output datS 393 ); 394 endinterface 395 396 program wishbone_tb ( 397 wishboneBus_if wishboneBus 398 ); 399 wishboneBus.clk; 400 wishboneBus.master.cb.ack; 401 endprogram 402 403 RAM duv ( 404 .clk_i (wishboneBus.clk), 405 .rst_i (wishboneBus.rst), 406 .adr_i (wishboneBus.slave.adr), 407 .dat_i (wishboneBus.slave.datM), 408 ... 409 .ack_o (wishboneBus.slave.ack) 410 ); 411 412 413// OOP - Klassen 414 class wishboneBFM_c; 415 // Interfaces muessen in Klassen immer virtuell sein, 416 // damit die Aenderungen nach aussen sichtbar werden 417 virtual wishboneBus_if wishboneBus; 418 logic [ADDR_WIDTH-1 : 0] actAddr; 419 local logic mem1; // private Members 420 protected logic mem2; // protected Members 421 422 // CTor, nur einer erlaubt 423 function new(virtual wishboneBus_if wishboneBus); 424 this.wishboneBus = wishboneBus; 425 endfunction 426 427 task busWrite(input logic [ADDR_WIDTH-1 : 0] addr, 428 input logic [DATA_WIDTH-1 : 0] data); 429 wishboneBus.cpM.stb \u0026lt;= 0; 430 wishboneBus.cpM.cyc \u0026lt;= 0; 431 432 @(posedge wishboneBus.clk) 433 wishboneBus.cpM.adr \u0026lt;= addr; 434 wishboneBus.cpM.datM \u0026lt;= data; 435 wishboneBus.cpM.we \u0026lt;= 1; 436 wishboneBus.cpM.sel \u0026lt;= \u0026#39;0; 437 wishboneBus.cpM.stb \u0026lt;= 1; 438 wishboneBus.cpM.cyc \u0026lt;= 1; 439 do 440 @(posedge wishboneBus.clk); 441 while(!wishboneBus.cpM.ack); 442 wishboneBus.cpM.stb \u0026lt;= 0; 443 wishboneBus.cpM.cyc \u0026lt;= 0; 444 endtask : busWrite 445 446 function bit [15 : 0] calcCrc; 447 ... 448 return crc; 449 endfunction 450 endclass 451 452 wishboneBFM_c bfm = new(...); 453 bfm.busWrite(...); 454 int crc = bfm.calcCrc(); 455 456 457 // Parametrisierte Klasse 458 class #(parameter int N = 1) Register; 459 bit [N-1:0] data; 460 ... 461 endclass 462 463 Register #(4) R4; // data ist bit [3:0] 464 Register #(.N(8)) R8 // data ist bit [7:0] 465 Register R; // data ist bit [0:0] 466 467 468 // Ableiten 469 class ShiftRegister extends Register; 470 task shiftleft; data = data \u0026lt;\u0026lt; 1; endtask 471 task shiftright; data = data \u0026gt;\u0026gt; 1; endtask 472 endclass 473 474 475 // virtuelle Klassen 476 virtual class Register; 477 ... 478 endclass 479 480 481// Automatic Storage 482 // wird eine Funktion bzw. ein Task mehrmals aufgerufen, 483 // so muss die Wiedereintrittsfaehigkeit gegeben sein 484 485 // in Verilog wurden Parameter statisch allokiert 486 // -\u0026gt; mittels automatic Starge auf Stack legen 487 program automatic Test(...); 488 task automatic doIt(); 489 ... 490 endtask 491 ... 492 endprogram 493 494 // Methoden in Klassen sind immer automatic 495 496 497// gleichzeiteige Prozesse 498 type_of_block @(sensitivity_list) 499 fork 500 statement1; // zwei parallele Statements 501 statement2; 502 ... 503 join 504 505 fork 506 begin 507 statement1; // 1 Prozess mit zwei Statements 508 statement2; 509 ... 510 end 511 join 512 513 // join ... der Eltern-Prozess blockiert solange 514 // bis alle fork-Prozesse fertig sind 515 // join_any ... der Eltern-Prozess blockiert solange 516 // bis ein fork-Prozess fertig ist 517 // join_none ... der Eltern-Prozess setzt seine 518 // Abarbeitung ohne Warten fort 519 520 521// Events 522 program tb (...); 523 event e; 524 525 initial begin : doIt 526 #1ns -\u0026gt; e; 527 #2ns -\u0026gt; e; 528 end : doIt 529 530 initial begin : waitForEvent 531 do 532 begin 533 wait( executeModellEvent.triggered ); 534 535 $display (\u0026#34;@%0t -\u0026gt; executeModellEvent (cmd: %0d)\u0026#34;, 536 $time, opcodeCnt+1); 537 #1ns; 538 end 539 while(1); 540 end : waitForEvent 541 endprogram 542 543 // -\u0026gt; ... triggert ein Event 544 // -\u0026gt;\u0026gt; ... triggert ein Event non-blocking 545 @(event); // wartet auf ein Event 546 wait(event.triggered); // -,,- 547 wait_order(a, b, c); // wartet auf Events nach bestimmten 548 // Reihenfolge: zuerst a, dann b, dann c ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/system-verilog/system-verilog-reference/","section":"Code Schnipsel","summary":"","title":"System Verilog - Reference","type":"code-snippets"},{"content":"","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/vhdl/","section":"Code Schnipsel","summary":"","title":"VHDL","type":"code-snippets"},{"content":" 1-- Literatur: EDS4 Uebungsbeispiel von Markus Pfaff, Martina Zeinzinger, 2-- Friedrich Seebacher (FH-Hagenberg) 3 4--IfRs232Tx-p.vhd 5 library ieee; 6 use ieee.std_logic_1164.all; 7 use ieee.numeric_std.all; 8 9 use work.global.all; 10 11 package IfRs232Tx is 12 type acRs232Tx is record 13 DataBitWidth : natural; 14 end record; 15 16 constant cRs232Tx : acRs232Tx := ( 17 DataBitWidth =\u0026gt; 8 18 ); 19 20 type aiRs232Tx is record 21 ----------------------------------------------------------- 22 -- Control inputs 23 ----------------------------------------------------------- 24 -- Transmit if activated and stop transmission if not 25 -- activated, but finish transmission of the current data. 26 Transmit : std_ulogic; 27 -- Is data available which can be read with the next rising 28 -- edge of the clk and sent from then on? 29 DataAvailable : std_ulogic; 30 -- The baud rate for the bits which are sent out is 31 -- determined by an external unit called a baud rate 32 -- generator or simply strobe generator. The strobe we get 33 -- from this unit is input by the port 34 BitStrobe : std_ulogic; 35 ----------------------------------------------------------- 36 -- Data inputs 37 ----------------------------------------------------------- 38 Data : std_ulogic_vector(cRs232Tx.DataBitWidth-1 39 downto 0); 40 end record; 41 42 type aoRs232Tx is record 43 ----------------------------------------------------------- 44 -- Status outputs 45 ----------------------------------------------------------- 46 -- Clock egdge 1 47 -- The source of parallel data (e.g. a FIFO) feeding this 48 -- transmitter will offer a data word at its data output and 49 -- flag data validity at the same time via activation of a 50 -- control output (named DataValid or similar). 51 -- Clock edge 2 52 -- The transmitter reacts on the validity of the input data 53 -- by reading the data into an internal register flagging 54 -- that the data was read. 55 -- Clock edge 3 56 -- The transmitter deactivates the \u0026#34;data was read\u0026#34; flag 57 -- again. The data source may provide new valid data keeping 58 -- DataValid active or may run out of valid data for the 59 -- moment, thus deactivating DataValid. 60 DataWasRead : std_ulogic; 61 ----------------------------------------------------------- 62 -- Result outputs 63 ----------------------------------------------------------- 64 -- The serial data line carying the Tx signal. 65 Tx : std_ulogic; 66 end record; 67 68 end IfRs232Tx; 69 70 71-- Rs232Tx-e.vhd 72 library IEEE; 73 use IEEE.std_logic_1164.all; 74 use IEEE.numeric_std.all; 75 76 use work.Global.all; 77 use work.IfRs232Tx.all; 78 79 entity Rs232Tx is 80 port ( 81 inResetAsync : in std_ulogic; 82 iClk : in std_ulogic; 83 84 iRs232Tx : in aiRs232Tx; 85 oRs232Tx : out aoRs232Tx 86 ); 87 end Rs232Tx; 88 89 90-- Rs232Tx-Rtl-a.vhd 91 architecture Rtl of Rs232Tx is 92 93 constant cTxLineStartBitVal : std_ulogic := \u0026#39;0\u0026#39;; 94 constant cTxLineStopBitAndIdleVal : std_ulogic := \u0026#39;1\u0026#39;; 95 96 type aDataInputState is (CanAcceptNewData, 97 FreshDataArrived, 98 DataBufferBusy); 99 type aRegion is (StartBit, DataBits, 100 ParityBit, StopBit, 101 StopBitAndIdle); 102 103 -- Register structure of design 104 type aRegSet is record 105 DataInputState : aDataInputState; 106 Region : aRegion; 107 BitIdx : natural range 0 to cRs232Tx.DataBitWidth-1; 108 DataWasRead : std_ulogic; 109 Data : std_ulogic_vector(cRs232Tx.DataBitWidth-1 110 downto 0); 111 parity : std_ulogic; 112 Tx : std_ulogic; 113 end record; 114 115 constant cInitValR : aRegSet := ( 116 DataInputState =\u0026gt; CanAcceptNewData, 117 Region =\u0026gt; StopBitAndIdle, --Idle, 118 BitIdx =\u0026gt; 0, 119 DataWasRead =\u0026gt; cInactivated, 120 Data =\u0026gt; (others =\u0026gt; \u0026#39;0\u0026#39;), 121 parity =\u0026gt; cInactivated, 122 Tx =\u0026gt; cTxLineStopBitAndIdleVal 123 ); 124 125 -- All registers in design 126 signal R, NextR : aRegSet; 127 begin 128 129 Comb : process (R, iRs232Tx) 130 begin 131 -- Set the defaults. 132 NextR \u0026lt;= R; 133 134 -- Parallel data input part of transmitter . 135 NextR.DataWasRead \u0026lt;= cInactivated ; 136 case R.DataInputState is 137 when CanAcceptNewData =\u0026gt; 138 -- We are waiting for data to be transmitted . 139 if (( iRs232Tx.Transmit = cActivated ) and 140 ( iRs232Tx.DataAvailable = cActivated )) then 141 NextR.Data \u0026lt;= iRs232Tx.Data ; 142 NextR.DataInputState \u0026lt;= FreshDataArrived ; 143 NextR.DataWasRead \u0026lt;= cActivated ; 144 end if; 145 when FreshDataArrived =\u0026gt; 146 -- We have loaded new data into the send register . 147 if ( R.Region = StartBit ) then 148 NextR.DataInputState \u0026lt;= DataBufferBusy ; 149 end if; 150 when DataBufferBusy =\u0026gt; 151 -- The send register is still occupied . 152 if (R.Region = StopBitAndIdle ) then 153 NextR.DataInputState \u0026lt;= CanAcceptNewData ; 154 end if; 155 end case ; 156 157 -- Serial output part of transmitter . 158 case R.Region is 159 when StartBit =\u0026gt; 160 NextR.Tx \u0026lt;= cTxLineStartBitVal ; 161 if iRs232Tx.BitStrobe = cActivated then 162 NextR.Region \u0026lt;= DataBits ; 163 NextR.BitIdx \u0026lt;= 0; 164 end if; 165 when DataBits =\u0026gt; 166 NextR.Tx \u0026lt;= R.Data (R.BitIdx ); 167 if iRs232Tx.BitStrobe = cActivated then 168 if R.BitIdx = 0 then 169 NextR.parity \u0026lt;= R.Data (R.BitIdx); 170 else 171 NextR.parity \u0026lt;= R.parity xor 172 R.Data (R.BitIdx); 173 end if; 174 if R.BitIdx = cRs232Tx.DataBitWidth -1 then 175 -- All bits sent . 176 NextR.Region \u0026lt;= ParityBit ; 177 else 178 -- Send next bit . 179 NextR.BitIdx \u0026lt;= R.BitIdx + 1; 180 end if; 181 end if; 182 when ParityBit =\u0026gt; -- gerade Parit�t 183 NextR.Tx \u0026lt;= R.parity ; 184 if iRs232Tx.BitStrobe = cActivated then 185 NextR.Region \u0026lt;= StopBit ; 186 end if; 187 when StopBit =\u0026gt; 188 NextR.Tx \u0026lt;= cTxLineStopBitAndIdleVal ; 189 if iRs232Tx.BitStrobe = cActivated then 190 NextR.Region \u0026lt;= StopBitAndIdle ; 191 end if; 192 when StopBitAndIdle =\u0026gt; 193 NextR.Tx \u0026lt;= cTxLineStopBitAndIdleVal ; 194 if iRs232Tx.BitStrobe = cActivated then 195 if R.DataInputState = FreshDataArrived then 196 NextR.Region \u0026lt;= StartBit ; 197 end if; 198 end if; 199 end case; 200 end process Comb; 201 202 ---------------------- 203 -- Update register values 204 ---------------------- 205 Registering : process(iClk, inResetAsync) 206 begin 207 if (inResetAsync = cnActivated) then 208 R \u0026lt;= cInitValR; 209 elsif ((iClk\u0026#39;event) and (iClk = \u0026#39;1\u0026#39;)) then 210 R \u0026lt;= NextR; 211 end if; 212 end process; 213 214 ----------------------------- 215 -- Connect registers to ports 216 ----------------------------- 217 oRs232Tx.DataWasRead \u0026lt;= R.DataWasRead; 218 oRs232Tx.Tx \u0026lt;= R.Tx; 219 220 end Rtl; ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/vhdl/vhdl-fsmd/","section":"Code Schnipsel","summary":"","title":"VHDL - FSMD","type":"code-snippets"},{"content":" 1-- Literatur: Vorlesungsunterlagen EDS2 von Markus Pfaff (FH-Hagenberg) 2 3-- VHDL Vhsic Hardware Description Language 4-- VHSIC Very High Speed Integrated Circuits 5 6-- entity / architecture 7 entity PieceOfHw is 8 generic ( 9 gAddrWidth : integer := 10; 10 gDataWidth : integer := 8 11 ); 12 port ( 13 iClk : in bit; 14 inResAsync : in bit; 15 iCountUp : in bit; 16 oCounter : out integer 17 -- wie Signals zu behandeln 18 -- (durch in, out, inout eingeschraenkt) 19 ); 20 end entity PieceOfHw; 21 22 architecture PieceOfHwBhv of PieceOfHw is 23 -- Deklarationen 24 25 signal vTemp0 : integer; 26 begin 27 -- Struktur und/oder Verhaltensbeschreibung 28 29 CalcSomething: process is 30 -- lokale Deklarationen 31 32 variable vTemp1 : integer; 33 begin 34 vTemp1 := iTempInput + 2; -- von Ausserhalb 35 wait; 36 end process CalcOtherPeople; 37 38 end architecture PieceofHwBhv; 39 40 -- die Architektur sollte in einem separaten Datei abgelegt werden, 41 -- da es fuer eine Entity mehrere Implementierungen (Bhv, Rtl) 42 -- geben kann 43 44 45-- Entities \u0026#34;verdrahten\u0026#34; 46 library Work; -- Library bekannt machen 47 48 Timer1: entity Work.PieceOfHw(PieceOfHwBhv) 49 generic map( 50 gAddrWidth =\u0026gt; 10, 51 gDataWidth =\u0026gt; 16 52 ) 53 port map( 54 iClk =\u0026gt; sClk, 55 inResAsync =\u0026gt; snRes, 56 iCountUp =\u0026gt; sCntUp, 57 oCounter =\u0026gt; sCntr 58 ); 59 60 61-- diverse Deklarationen 62 variable vTemp2 : integer := 0; -- initiale Wert 63 constant vTemp3 : integer := 12; -- Konstante (muss initalisiert 64 -- werden, ist nicht schreibbar) 65 66 -- integer 0, -2, 1E6, 1000000 67 -- real 1.0, 0.0, 1.0E+30, -3.32E-10 68 -- character \u0026#39;a\u0026#39;, \u0026#39;B\u0026#39;, \u0026#39;1\u0026#39;, \u0026#39;@\u0026#39; 69 -- boolean false, true 70 -- string \u0026#34;many characters.\u0026#34; 71 -- bit \u0026#39;0\u0026#39;, \u0026#39;1\u0026#39; 72 -- time 10 ns, 20 hr, 30 ps, 40.3 s 73 74 -- character\u0026#39;(\u0026#39;0\u0026#39;) explizite Zuordnung 75 -- bit\u0026#39;(\u0026#39;0\u0026#39;) 76 77 type aOwnType1 is range -256 to 255; -- selbst definierte Typen 78 type aOwnType2 is (SideA, SideB, SideC); 79 type aOwnType3 is ( 80 \u0026#39;a\u0026#39;, 81 \u0026#39;1\u0026#39;, 82 a, 83 1, 84 asdf 85 ); 86 87 -- abgeleiteter Typ 88 subtype aSignedByte is integer range -128 to 127; 89 90 -- unconstrained array types - Array Typen ohne Bereichsangabe 91 type string is array (positive range \u0026lt;\u0026gt;) of character; 92 -- constrained array types - Array Typen mit Bereichsangaben 93 subtype aAddress is range (0 to 255); 94 type aByte is array (7 downto 0) of bit; 95 type aMemory is array (aAddress) of aByte; 96 97 98-- Zuweisung 99 type aRegister is array (1 to 4) of integer; 100 variable vXReg : aRegister := (0, 0, 0, 0); 101 vXReg := (1=\u0026gt;12, 2=\u0026gt;234, others=\u0026gt;0); 102 103 variable vBitVector1 : bit_vector(31 downto 0); 104 variable vBitVector2 : bit_vector(15 downto 0); 105 variable vBitVector3 : bit_vector(1 to 4); 106 vBitVector1(0) := vBitVector2(15); 107 vBitVector2 := vBitVector1(15 downto 0); 108 vBitVector2 := vBitVector1; -- Zuordnung von links nach rechts 109 -- (15) := (31) 110 -- (14) := (30) 111 -- ... 112 -- (0) := (16) 113 vBitVector3 := vBitVector2; -- (1) := (15) 114 -- (2) := (14) 115 -- (3) := (13) 116 -- (4) := (12) 117 118 119-- Rocord Typen 120 type aRecord is record 121 Description : string; 122 Code : bit_vector (7 downto 0); 123 NrOfAddressBytes : natural; 124 end record aRecord; 125 126 constant cRec1 : aRecord := ( 127 Description =\u0026gt; \u0026#34;asdf\u0026#34;, 128 Code =\u0026gt; \u0026#34;10011111\u0026#34;, 129 NrOfAddressBytes =\u0026gt; 0 130 ); 131 variable vRec2 : aRecord; 132 133 vActDescr := cRec1.Description; 134 vRec2 := cRec1; 135 136 137-- Zusammenstellungen (Concatenation) 138 variable vABus, vBBus, vCBus : bit_vector (3 downto 0); 139 variable vA, vB, vC, vD : bit; 140 vABus := vA \u0026amp; vB \u0026amp; vC \u0026amp; vD; -- von links nach rechts 141 vABus := vBBus(3 downto 2) \u0026amp; vCBus(1 downto 0); 142 vABus := (vBBus(3 downto 2), vCBus(1 downto 0)); 143 144 145-- logische Operatoren 146 -- and, or, nand, nor, xor, xnor, not 147 vBit1 := vBit2 and vBit3; 148 vBool1 := vBool2 nor vBool3; 149 -- vBool1 := vBit2 and vBit2; -- boolean und bit nicht mischen 150 151 152-- relationale Operatoren 153 -- \u0026gt;, \u0026gt;=, \u0026lt;, \u0026lt;=, =, /= liefert boolean 154 vBool1 := (1 \u0026lt; 3); 155 156 variable vShort : bit_vector(4 to 6) := (\u0026#39;1\u0026#39;, \u0026#39;0\u0026#39;, \u0026#39;1\u0026#39;); 157 variable vLong : bit_vecotr(0 to 7) := (1=\u0026gt;\u0026#39;1\u0026#39;, others=\u0026gt;\u0026#39;0\u0026#39;); 158 vBool2 := vShort \u0026gt; vLong; 159 -- von links nach rechts 160 -- 1 0 1 : groesser 161 -- 0 1 0 0 0 0 0 0 : kleiner 162 163 164-- arithmetische Operatoren 165 -- -, +, *, /, mod, rem, **(Hochfunktion), abs 166 -- fuer integer, real(nicht mod, rem), time 167 168 -- a mod b -\u0026gt; positiver Rest 169 -- a rem b -\u0026gt; Rest hat Vorzeichen von a 170 171 172-- Schiebeoperationen 173 sll -- shift left logical \u0026#34;11110000\u0026#34; sll 2 =\u0026gt; \u0026#34;11000000\u0026#34; 174 srl -- shift right logical \u0026#34;00001111\u0026#34; srl 2 =\u0026gt; \u0026#34;00000011\u0026#34; 175 sla -- shift left arithmetic \u0026#34;00001111\u0026#34; sla 2 =\u0026gt; \u0026#34;00111100\u0026#34; 176 sra -- shift right arithmetic \u0026#34;00111111\u0026#34; sra 2 =\u0026gt; \u0026#34;00001111\u0026#34; 177 -- bzw. \u0026#34;11110000\u0026#34; sra 2 =\u0026gt; \u0026#34;11111100\u0026#34; 178 rol -- rotate left \u0026#34;00110011\u0026#34; rol 2 =\u0026gt; \u0026#34;11001100\u0026#34; 179 ror -- rotate right \u0026#34;11001100\u0026#34; ror 2 =\u0026gt; \u0026#34;00110011\u0026#34; 180 181-- Attribute 182 subtype SmallInt is integer range 0 to 2356; 183 -- SmallInt\u0026#39;left = 0 184 -- SamllInt\u0026#39;right = 2356 185 -- SmallInt\u0026#39;range = 0 to 2356 186 187 signal BinNr : bit_vector (31 downto 0); 188 -- BinNr\u0026#39;left = 31 189 -- BinNr\u0026#39;right = 0 190 -- BinNr\u0026#39;low = 0 191 -- BinNr\u0026#39;high = 31 192 -- BinNr\u0026#39;range = 31 downto 0 193 -- BinNr\u0026#39;length = 32 194 195 signal Flag : bit; 196 -- Flag\u0026#39;event ... Event aufgetreten? 197 -- Flag\u0026#39;stable(T) ... waehrend des Zeitraums stabil? 198 -- Flag\u0026#39;active ... momentan aktiv? 199 -- Flag\u0026#39;delayed(T) ... Kopie von Flag, um T verzoegert 200 -- Flag\u0026#39;last_event, Flag\u0026#39;last_active, Flag\u0026#39;last_value 201 202 203-- diverse Ablauf-Statements 204 -- if 205 if (vA \u0026gt; vB) and (vA \u0026lt; vC) then 206 vGr := vA; 207 elsif (vD \u0026gt; vF) then 208 vGr := vD; 209 else 210 vGr := vB; 211 end if; 212 213 214 -- case 215 type aState is (stateA, stateB, stateC, stateD); 216 variable vActState : aState; 217 case vActState is 218 when stateA =\u0026gt; 219 vTemp1 := 12; 220 when stateB =\u0026gt; 221 vTemp1 := 24; 222 when others =\u0026gt; 223 null; 224 end case; 225 226 227 -- while Schleife 228 while (vIndex \u0026lt;= 3) loop 229 -- ... 230 vIndex := vIndex + 1; 231 end loop; 232 233 -- for Schleife 234 for vIndex in 8 downto 0 loop 235 -- ... 236 end loop; 237 238 -- endlos Schleife 239 loop 240 -- ... 241 end loop; 242 243 244-- Assertion / Report 245 assert (vSomethingGoesWrong = false) 246 report \u0026#34;output message\u0026#34; 247 severity warning; 248 -- note 249 -- warning 250 -- error 251 -- failure 252 253 report \u0026#34;output message\u0026#34; 254 severity warning; 255 256 257-- Funktion 258 -- Werte werden eingegeben und ein Ergebnis wird zurueck geliefert 259 -- Eingabewerte sind im Inneren konstant 260 function Larger (cVal1, cVal2 : integer) return integer is 261 variable vResult : integer; 262 begin 263 if cVal1 \u0026gt; cVal2 then 264 vResult := cVal1; 265 else 266 vResult := cVal2; 267 end if; 268 return vResult; 269 end function Larger; 270 271 vRes := Larger(vVar1, vVar2); 272 273 274-- Prozedur 275 -- Werte ein- oder ausgeben 276 procedure Swap ( variable vA, vB : inout integer; 277 constant cPermitSwap : boolean ) is 278 variable vTemporal : integer; 279 begin 280 if cPermitSwap then 281 vTemporal := vA; 282 vA := vB; 283 vB := vTemporal; 284 return; 285 end if; 286 end procedure Swap; 287 288 Swap(vVar1, vVar2, true); 289 290 291-- Simulationszeit 292 wait; -- fuer immer warten 293 wait for 14 ms; -- fuer 14ms warten 294 wait on sA, sB; -- auf Aenderung von sA oder sB warten 295 wait on sA for 14 sec; -- warte auf Event sA, max. 14 Sekunden 296 wait on sA until sA \u0026gt; 3; -- warte auf Event sA, mit Bedingung sA\u0026gt;3 297 wait until sA \u0026gt; 3; -- -,,- 298 wait on sA, sB until sA = 10 for 16 us; 299 300 sA \u0026lt;= transport sB after 14 us; -- Simulation von Verzoegerungs- 301 -- zeiten (propagation delay) 302 -- Simulation von Traegheitszeiten 303 -- (inertial delay) 304 -- Wert muss mindestens 5 ns lang 305 -- anders sein, um uebernommen 306 -- zu werden 307 sA \u0026lt;= reject 5 ns inertial sB after 10 ns; 308 309 sA \u0026lt;= reject 5 ns inertial sB after 5 ns; -- = 310 sA \u0026lt;= inertial sB after 5 ns; -- = 311 sA \u0026lt;= sB after 5 us; 312 sA \u0026lt;= 313 \u0026#39;0\u0026#39; after 10 ns, 314 \u0026#39;1\u0026#39; after 30 ns, 315 \u0026#39;0\u0026#39; after 90 ns; 316 317 318-- shared Variables (nicht brauchbar) 319 -- Ergebnis ist nicht definiert, kommt darauf an welcher Prozess 320 -- zuerst abgearbeitet wird. Es werden beide Variablen vA oder vB, 321 -- da shared varible den Wert immer direkt uebernehmen. 322 entity Swapper is 323 end entity Swapper; 324 architecture SwapperBhv of Swapper is 325 shared variable vA : integer := 10; 326 shared variable vB : integer := 13; 327 begin 328 MakeA2B: process is 329 begin 330 wait for 1 ms; 331 vA := vB; 332 end process MakeA2B; 333 334 MakeB2A: process is 335 begin 336 wait for 1 ms; 337 vB := vA; 338 end process MakeB2A; 339 end architecture SwapperBhv; 340 341 342-- signals 343 -- fuer eine bestimmte Zeit werden alle vorherigen Werte zwischen- 344 -- gespeichert und mit den gespeicherten Werten werden alle Signals 345 -- neu berechnet. 346 entity Swapper is 347 end entity Swapper; 348 architecture SwapperBhv of Swapper is 349 signal vA : integer := 10; 350 signal vB : integer := 13; 351 begin 352 MakeA2B: process is 353 begin 354 wait for 1 ms; 355 vA \u0026lt;= vB; 356 end process MakeA2B; 357 358 MakeB2A: process is 359 begin 360 wait for 1 ms; 361 vB \u0026lt;= vA; 362 end process MakeB2A; 363 end architecture SwapperBhv; 364 365 366-- postponed process 367 -- Wir sind nur fuer die stabilisierten Werte interessiert. 368 -- (ignoriert delta-Cycles) 369 TestFinalValues : postponed process is 370 begin 371 assert (A \u0026lt; B) 372 report \u0026#34;TM: A and B do not relate as desired !\u0026#34; 373 severity warning; 374 wait on A, B; 375 end postponed process TestFinalValues; 376 377 378-- Generate Statement 379 OthrStgs : for Stage in 380 FilteredThrough\u0026#39;left to 381 FilteredThrough\u0026#39;right-1 generate 382 begin 383 OneOtherStage : entity Work.Filter(SomehowElse) 384 port map ( 385 iNoisy =\u0026gt; FilteredThrough(Stage), 386 oCalm =\u0026gt; FilteredThrough(Stage+1) 387 ); 388 end generate OtherStages ; 389 390 391 MayDefuzzyfy : if DefuzzyfyIt generate 392 begin 393 Defuzzyfying : entity Work.Defuzzyfier(Anyhow) 394 port map ( 395 iFuzzy =\u0026gt; FilteredThrough(FilteredThrough\u0026#39;length), 396 oClean =\u0026gt; oFiltered 397 ); 398 end generate MayDefuzzify; 399 400 401-- Component Instantiation 402 architecture Structure of Any is 403 -- Komponente Deklarieren 404 component Stacker is 405 port ( 406 iClk : in bit; 407 inResAsync : in bit; 408 ... 409 ); 410 end component Stacker; 411 412 -- Konfiguration Spezifizieren 413 for TheStacker1 use entity work.AStack(Somehow) 414 port map ( 415 iClk =\u0026gt; iClk, 416 inResAsync =\u0026gt; inResAsync, 417 ... 418 ); 419 begin 420 -- Komponente Instanzieren 421 TheStacker1: Stacker 422 generic map (...) 423 port map (...); 424 end architecture Structure; 425 426 427-- Package Deklarieren 428 package ProjectGlobal is 429 constant cBitwidth : integer := 8; 430 type aBinaryNr is bit_vector (cBitWidth-1 downto 0); 431 subtype aIntNr is integer range 0 to 2**cBitwidth-1; 432 433 function Bin2Int (cBinary : aBinaryNr) return aIntNr; 434 procedure Swap (vBinary1, vBinary2 : inout aBinaryNr); 435 436 constant cDecidedOk : boolean; 437 end package ProjectGlobal; 438 439 440 package body ProjectGlobal is 441 constant cDecidedOk : boolean := true; 442 443 function Bin2Int (cBinaryNr : aBinaryNr) return aIntNr is 444 variable vAccumulated : integer := 0; 445 begin 446 for Digit in cBinaryNr\u0026#39;range loop 447 if cBinaryNr(Digit) = \u0026#39;1\u0026#39; then 448 vAccumulated := vAccumulated + 2**Digit; 449 end if; 450 end loop; 451 return vAccumulated; 452 end function Bin2Int; 453 454 procedure Swap (vBinary1, vBinary2 : inout aBinaryNr) is ... 455 end package body ProjectGlobal; 456 457 458-- Package nutzen 459 library IEEE; -- in welcher Lib. befinded sich Package 460 use IEEE.std_logic_1164; -- Package Deklarationen sichtbar machen 461 use IEEE.std_logic_1164.all; 462 463 library std; -- Standard Library fuer vordefinierte 464 -- Sprach-Umgebung 465 library work; -- Standard User Library 466 use std.standard.all; -- Deklaration von vordefinierten 467 -- Typen und Operationen 468 469 library IEEE; -- Standard Library fuer standardisierte 470 -- Sprach-Erweiterung 471 use IEEE.std_logic_1164.all;-- 9-wertige Logic Typen und 472 -- verfuegbare Operationen 473 -- \u0026#39;U\u0026#39; ... uninitialisiert 474 -- \u0026#39;X\u0026#39; ... Wert unbekannt (Fehler) 475 -- \u0026#39;-\u0026#39; ... egal ob durch \u0026#39;0\u0026#39; oder 476 -- \u0026#39;1\u0026#39; ersetzt wird 477 -- \u0026#39;0\u0026#39;, \u0026#39;1\u0026#39; 478 -- \u0026#39;Z\u0026#39; ... high Impedanz 479 -- \u0026#39;L\u0026#39; ... low 480 -- \u0026#39;H\u0026#39; ... high 481 -- \u0026#39;W\u0026#39; ... weak 482 std_ulogic_vector -- unresolved Datentyp (wird Signal an 483 -- mehreren Stellen geschrieben, so 484 -- wird Error gemeldet) 485 std_logic_vector -- resolved Datentyp 486 487 488-- Sensitivity List 489 DoIt: process is 490 begin 491 -- ... 492 wait on A, B, C, D, ... 493 end process DoIt; -- = 494 495 DoIt: process (A, B, C, D, ...) is 496 begin 497 -- ... 498 end process DoIt; 499 500 501-- Concurrent Assertion-Statement 502 TestIt: process is 503 begin 504 assert (A \u0026gt; B) 505 report \u0026#34;message\u0026#34; 506 severity warning; 507 wait on A, B; 508 end processs TestIt; -- = 509 510 assert (A \u0026gt; B) 511 report \u0026#34;message\u0026#34; 512 severity warning; 513 514 515-- Concurrent Signal-Assignment 516 LabelIt: process is 517 begin 518 SesamStreet \u0026lt;= Ernie and Bert after 20 us; 519 wait on Ernie, Bert; 520 end process TestIt; -- = 521 522 LabelIt: SesamStreet \u0026lt;= Ernie and Bert after 20 us; 523 524-- Concurrent Conditional Signal-Assignment 525 Labeled: process is 526 begin 527 if A \u0026lt; B then 528 SesamStreet \u0026lt;= Ernie and Bert; 529 elsif A = B then 530 SesamStreet \u0026lt;= Bibo; 531 else 532 SesamStreet \u0026lt;= Gonzo; 533 end if; 534 wait on A, B, Ernie, Bert, Bibo, Gonzo; 535 end process TestIt; -- = 536 537 Labeled: SesamStreet \u0026lt;= 538 Ernie and Bert when (A\u0026lt;B) else 539 Bibo when (A=B) else 540 Gonzo; 541 542 543-- Concurrent Selected Signal-Assignment 544 ALabel: process is 545 begin 546 case Month is 547 when May =\u0026gt; 548 SesamStreet \u0026lt;= Ernie and Bert; 549 when Jun | Oct =\u0026gt; 550 SesamStreet \u0026lt;= Bibo; 551 when others =\u0026gt; 552 SesamStreet \u0026lt;= Gonzo; 553 end case; 554 wait on Month, Ernie, Bert, Bibo, Gonzo; 555 end process TestIt; -- = 556 557 ALabel: with Month select 558 SesamStreet \u0026lt;= Ernie and Bert when May, 559 Bibo when Jun | Oct, 560 Gonzo when others; 561 562 563-- Concurrent Procedure-Call 564 Calling: process is 565 begin 566 CheckTiming (D, Clk, Reset, TSetup, THold); 567 wait on D, Clk, Reset; 568 end processs TestIt; -- = 569 570 Calling: CheckTiming (D, Clk, Reset, TSetup, THold); ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/vhdl/vhdl-reference/","section":"Code Schnipsel","summary":"","title":"VHDL - Reference","type":"code-snippets"},{"content":" 1-- Literatur: HSSE VHDL Style EDS2 von Markus Pfaff (FH-Hagenberg) 2 3-- Dateinamen 4 -- entity ... \u0026lt;e.id\u0026gt;-e.vhd 5 -- architecture ... \u0026lt;e.id\u0026gt;-\u0026lt;a.id\u0026gt;-a.vhd 6 -- entity \u0026amp; architecture ... \u0026lt;e.id\u0026gt;-\u0026lt;a.id\u0026gt;-ea.vhd 7 -- configuration ... \u0026lt;e.id\u0026gt;-\u0026lt;a.id\u0026gt;-\u0026lt;c.id\u0026gt;-c.vhd 8 -- entity \u0026amp; architecture \u0026amp; configuration ... \u0026lt;e.id\u0026gt;-\u0026lt;a.id\u0026gt;-\u0026lt;c.id\u0026gt;-eac.vhd 9 -- package header ... \u0026lt;package.id\u0026gt;-h.vhd 10 -- package body ... \u0026lt;package.id\u0026gt;-b.vhd 11 -- package header \u0026amp; body ... \u0026lt;package.id\u0026gt;-p.vhd 12 13 14-- Header 15 ----------------------------------------------------------------------- 16 -- Title : xxx 17 -- Project : xxx 18 ----------------------------------------------------------------------- 19 -- Abstract: 20 -- xxx 21 ----------------------------------------------------------------------- 22 -- Company : xxx (FH-Hagenberg/HSSE, Hagenberg/Austria) 23 -- Copyright (c) 24 ----------------------------------------------------------------------- 25 -- Author: xxx 26 -- Revision: xxx 27 -- Date: xxx 28 ----------------------------------------------------------------------- 29 30 31-- Kommentare 32 -- moeglichst auf Englisch verfassen 33 -- vor der Codezeile, da daneben meistens kein Platz 34 35 36-- Namenskonvention 37 -- Gemischte Gross-/Kleinschreibung: 38 -- StrobeBaudRate, SystemClk, AsyncGlobalReset 39 -- oder 40 -- Kleinschreibung mit underscores: 41 -- strobe_baud_rate, system_clk, async_global_reset 42 43 -- input port i iClk clk_i 44 -- output port o oReqDataPar req_data_par_o 45 -- bidirectional port b bParData par_data_b 46 -- signal keines BaudRateCtr baud_rate_ctr 47 -- constant c cActivated activated_c 48 -- generic g gBaudRate baud_rate_g 49 -- variable v vFraction fraction_v 50 -- type a, t aSignedByte SignedByte_t 51 -- file File BmpDryFile BmpDryFile 52 -- Negative Logik n nAckData ack_data_n 53 54 55-- gaengige Namen 56 -- Reset, Rst: Asynchrones Ruecksetzsignal. Findet 57 -- sich nach der Synthese an FlipFlop-Reset- 58 -- Eingaengen wieder. 59 -- Clk: Ein Taktsignal. Nach der Synthese wird 60 -- es sich am Takteingang von FlipFlops 61 -- wiederfinden. 62 -- Strobe: Zeichen fuer eine zyklische Aktivitaet. 63 -- Ueber die Laenge einer Taktperiode aktiv, 64 -- sonst inaktiv. Keinesfalls zu verwechseln 65 -- mit einem Taktsignal! 66 -- Sel: Funktionsauswahl an einer kombinatorischen 67 -- Einheit, wie einem Multiplexer oder einer 68 -- ALU. (Das Wort Select ist ein reserved 69 -- word in VHDL und kann daher nicht benutzt 70 -- werden.) 71 -- Selcd: Abkuerzung fuer Selected. Verwendung 72 -- beispielsweise in Konstanten die eine 73 -- bestimmte Mux-Stellung einstellen: 74 -- cStaD0Selcd. 75 -- Enable, En: Freigabesignal. 76 -- Request, Req: Anfrage fuer Daten. Eine Einheit A zeigt 77 -- der Einheit B, dass Daten erwuenscht sind. 78 -- Acknowledge, Ack: Bestaetigung, dass ein request verstanden 79 -- wurde und dass die Antwort bereitliegt. 80 -- Toggle, Tgl: Aktivitaet auf diesem Signal wird durch 81 -- einen Pegelwechsel angezeigt. 82 -- Asynchronous, Async: Dieses Signal ist nicht synchron zum Takt 83 -- dieser unit. Es ist also nicht ein- 84 -- syncronisiert. Taktsynchrone Signale 85 -- werden nicht gesondert gekennzeichnet. 86 -- Counter, Ctr: Zaehlerstand. 87 -- NrOf, Nr: Anzahl. 88 -- Delayed1, Del1: Delayed um einen (zwei, drei,. . . ) 89 -- Taktzyklen. 90 -- ReadWrite, Rw: Anwahl von Lese- oder Schreibbetrieb. 91 -- Default, Dft: Default-Wert, beispielsweise zur Belegung 92 -- von generics falls von aussen kein Wert 93 -- gewaehlt wird. 94 -- Mux: Ausgangssignal eines Multiplexers, 95 -- beispielsweise in einem Datenpfad. 96 -- Synchronized, Syncd: Einsynchronisierte Version eines 97 -- asynchronen Signals. 98 -- Metastable: Moeglicherweise metastabiles Signal, 99 -- beispielsweise das Ausgangssignal nach 100 -- der ersten Synchronisationsstufe. 101 -- Gibt es mehrere Synchronisationsstufen, 102 -- so setzt sich mit jeder Stufe die Wahr- 103 -- scheinlichkeit der Metastabilitaet herab. 104 -- Um dies zu kennzeichnen kann man an den 105 -- Begriff Metastable eine Zahl fuer die 106 -- Registerstufe anhaengen. 107 -- State: Statusregister einer FSM. 108 -- NextState: Eingang eines Statusregisters (einer FSM). 109 -- Bei einer FSMD kann es sich auch um einen 110 -- Zaehler handeln, z.B. NextCtr. 111 -- Waiting, HuntingStopBit: Die Zustandsnamen reflektieren Zustaende, 112 -- Situationen oder (derzeit laufende) 113 -- Taetigkeiten, nicht aber Befehle oder 114 -- dergleichen. Also etwa SendingData, 115 -- statt SendData. 116 -- Hunting: Beispielsweise das Durchforsten eines 117 -- Datenstroms auf ein betimmtes Datum hin. 118 -- WaitingOn: Warten auf ein bestimmtes Ereignis. 119 -- Ready: Einheit ist derzeit verfuegbar. 120 -- Busy: Einheit ist derzeit beschaeftigt. 121 -- Valid: Zeigt an, dass ein anderes Signal 122 -- (meist Datenbus, Adressbus,. . . ) 123 -- gueltig ist. 124 -- Frq: Frequency, meist als Namensteil eines 125 -- generics, z.B. gClkFrq := 48E6. 126 -- DividingClk, DoingThis: Typische labels fuer einen process. 127 -- Diese Namen druecken Taetigkeiten 128 -- unmittelbar aus. ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/vhdl/vhdl-styleguide/","section":"Code Schnipsel","summary":"","title":"VHDL - Style Guide","type":"code-snippets"},{"content":" 1-- Literatur: Vorlesungsunterlagen EDS3 von Markus Pfaff (FH-Hagenberg) 2 3-- fuer synthetisierbare Entities sind signed, unsigned dem integer Datentyp 4-- vorzuziehen, denn diese werden aus den mehrwertigen std_logic gebildet 5-- (\u0026#39;U\u0026#39;, \u0026#39;0\u0026#39;, \u0026#39;1\u0026#39;, ...) 6 7type UNSIGNED is array (NATURAL range \u0026lt;\u0026gt;) of STD_LOGIC; -- vorzeichenlos 8type SIGNED is array (NATURAL range \u0026lt;\u0026gt;) of STD_LOGIC; -- vorzeichenbehaftet 9 10-- Arithmetik Operationen 11-- \u0026#34;+\u0026#34;, \u0026#34;-\u0026#34;, \u0026#34;*\u0026#34;, \u0026#34;/\u0026#34;, \u0026#34;mod\u0026#34;, \u0026#34;rem\u0026#34;, \u0026#34;abs\u0026#34; 12 13-- Vergleichsoperationen 14-- \u0026#34;\u0026lt;\u0026#34;, \u0026#34;\u0026gt;\u0026#34;, \u0026#34;\u0026lt;=\u0026#34;, \u0026#34;\u0026gt;=\u0026#34;, \u0026#34;=\u0026#34;, \u0026#34;/=\u0026#34; 15-- std_match 16 17-- Logik Operationen 18-- \u0026#34;and\u0026#34;, \u0026#34;nand\u0026#34;, \u0026#34;or\u0026#34;, \u0026#34;nor\u0026#34;, \u0026#34;xor\u0026#34;, \u0026#34;xnor\u0026#34;, \u0026#34;not\u0026#34; 19 20-- Schiebe/Rotier Operationen 21-- \u0026#34;sll\u0026#34;, \u0026#34;sla\u0026#34;, \u0026#34;srl\u0026#34;, \u0026#34;sra\u0026#34;, \u0026#34;rol\u0026#34;, \u0026#34;ror\u0026#34; 22 23-- Resize Operatoinen 24 numeric_std std_logic_arith 25unsigned resize(arg,size) conv_unsigned(arg,size) 26signed resize(arg,size) conv_signed(arg,size) 27 28-- Konvertierungs Operationen 29-- unsigned -\u0026gt; natural 30 function TO_INTEGER (ARG: UNSIGNED) return NATURAL; 31-- signed -\u0026gt; integer 32 function TO_INTEGER (ARG: SIGNED) return INTEGER; 33-- natural -\u0026gt; unsigned 34 function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED; 35-- integer -\u0026gt; signed 36 function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED; 37 38-- Typen Konvertieren 39std_logic_vector -\u0026gt; unsigned unsigned(arg) numeric_std 40 unsigned(arg) std_logic_arith 41 42std_logic_vector -\u0026gt; signed signed(arg) 43 signed(arg) 44 45unsigned -\u0026gt; std_logic_vector std_logic_vector(arg) 46 std_logic_vector(arg) 47 48signed -\u0026gt; std_logic_vector std_logic_vector(arg) 49 std_logic_vector(arg) 50 51integer -\u0026gt; unsigned to_unsigned(arg,size) 52 conv_unsigned(arg,size) 53 54integer -\u0026gt; signed to_signed(arg,size) 55 conv_signed(arg,size) 56 57unsigned -\u0026gt; integer to_integer(arg) 58 conv_integer(arg) 59 60signed -\u0026gt; integer to_integer(arg) 61 conv_integer(arg) 62 63integer -\u0026gt; std_logic_vector integer 64 -\u0026gt; unsigned/signed 65 -\u0026gt; std_logic_vector 66 67std_logic_vector -\u0026gt; integer std_logic_vector 68 -\u0026gt; unsigned/signed 69 -\u0026gt;integer 70 71unsigned + unsigned -\u0026gt; std_logic_vector std_logic_vector(arg1 + arg2) 72 arg1 + arg2 73 74signed + signed -\u0026gt; std_logic_vector std_logic_vector(arg1 + arg2) 75 arg1 + arg2 76 77-- Literale fuer signed/unsigned 78to_unsigned(93, 8) 79\u0026#34;0011001100110011\u0026#34; -- bei signed mit Vorzeichen 80b\u0026#34;0011001100110011\u0026#34; -- Binaer 81x\u0026#34;F8C43E0\u0026#34; -- Hexadecimal 82 83 84-- synchron sequentielle Logik 85 ABCffs: process (Clk, nResAsync) is -- erzeugt pro gespeicherten 86 begin -- Signal ein flankenge- 87 if nResAsync = cnActivated then -- steuertes D-FF 88 A \u0026lt;= \u0026#39;0\u0026#39;; 89 B \u0026lt;= \u0026#39;0\u0026#39;; 90 C \u0026lt;= \u0026#39;0\u0026#39;; 91 elsif Clk\u0026#39;event and Clk=\u0026#39;1\u0026#39; then 92 A \u0026lt;= NextA; 93 B \u0026lt;= NextB; 94 C \u0026lt;= NextC; 95 end if; 96 end process ABCffs; 97 98 CalcNext: process (A, B, C) is -- rein kombinatorisch, 99 begin -- also kein Speicher und 100 NextA \u0026lt;= A and B; -- keine Latches! 101 NextB \u0026lt;= B and C; 102 NextC \u0026lt;= C and A; 103 end process CalcNext; 104 105 106 constant DefaultState : std_ulogic_vector(2 downto 0) := \u0026#34;000\u0026#34;; 107 108 StateReg: process (Clk, nResAsync) is 109 begin 110 if nResAsync = cnActivated then 111 State \u0026lt;= DefaultState; 112 elsif Clk\u0026#39;event and Clk=\u0026#39;1\u0026#39; then 113 State \u0026lt;= NextState; 114 end if; 115 end process StateReg 116 117 NextStateLogic: process (State) is 118 begin 119 case State is 120 when \u0026#34;000\u0026#34; =\u0026gt; NextState \u0026lt;= \u0026#34;100\u0026#34;; 121 when \u0026#34;100\u0026#34; =\u0026gt; NextState \u0026lt;= \u0026#34;010\u0026#34;; 122 when \u0026#34;010\u0026#34; =\u0026gt; NextState \u0026lt;= \u0026#34;001\u0026#34;; 123 when \u0026#34;001\u0026#34; =\u0026gt; NextState \u0026lt;= \u0026#34;011\u0026#34;; 124 when \u0026#34;011\u0026#34; =\u0026gt; NextState \u0026lt;= \u0026#34;111\u0026#34;; 125 when \u0026#34;111\u0026#34; =\u0026gt; NextState \u0026lt;= \u0026#34;000\u0026#34;; 126 when others =\u0026gt; NextState \u0026lt;= \u0026#34;XXX\u0026#34;; 127 end process CalcNextState; 128 129 130-- synchron sequentielle Logik (1 Prozess) 131 library ieee; 132 use ieee.std_logic_1164.all; 133 use ieee.numeric_std.all; 134 use work.global.all; 135 136 entity Counter is 137 port (iResetAsync : in std_ulogic; 138 iClk : in std_ulogic; 139 oCount : out Unsigned(3 downto 0)); 140 end entity Counter; 141 142 architecture Rtl of Counter is 143 signal Count : unsigned(3 downto 0); 144 begin 145 CountUp: process (iResetAsync, iClk) is 146 begin 147 if iResetAsync = cActivated then 148 Count \u0026lt;= (others =\u0026gt; \u0026#39;0\u0026#39;); 149 elsif iClk\u0026#39;event and iClk=\u0026#39;1\u0026#39; then 150 if Count=x\u0026#34;9\u0026#34; then 151 Count \u0026lt;= (others =\u0026gt; \u0026#39;0\u0026#39;); 152 else 153 Count \u0026lt;= Count + 1; 154 end if; 155 end if; 156 end process CountUp; 157 158 oCount \u0026lt;= Count; 159 end architecture Rtl; 160 161 162-- synchron sequentielle Logik (mit Eingaengen) 163 architecture Rtl of Counter is 164 signal Count : unsigned(3 downto 0); 165 begin 166 oCount \u0026lt;= Count; 167 Counting: process (iResetAsync, iClk) is 168 begin 169 if iResetAsync = c then 170 Count \u0026lt;= to_unsigned(0, Count\u0026#39;length); 171 elsif iClk\u0026#39;event and iClk=\u0026#39;1\u0026#39; then 172 if iZero = cActivated then 173 Count \u0026lt;= to_unsigned(0, Count\u0026#39;length); 174 elsif iCountUp = cActivated then 175 if Count = x\u0026#34;9\u0026#34; then 176 Count \u0026lt;= to_unsigned(0, Count\u0026#39;length); 177 else 178 Count \u0026lt;= Count + 1; 179 end if; 180 else 181 if Count = x\u0026#34;0\u0026#34; then 182 Count \u0026lt;= x\u0026#34;9\u0026#34;; 183 else 184 Count \u0026lt;= Count - 1; 185 end if; 186 end if; 187 end if; 188 end process Counting; 189 end architecture Rtl; 190 191 192-- Moore FSM 193 package Global is 194 constant cActivated : std_ulogic := \u0026#39;1\u0026#39;; 195 constant cInctivated : std_ulogic := \u0026#39;0\u0026#39;; 196 type aState is (Standing, WalkingForward, 197 WalkingBackwards, Thinking); 198 end package Global; 199 200 library IEEE; 201 use IEEE.std_logic_1164.all; 202 use work.global.all; 203 entity WalkAndThinkMachine is 204 port(iResetAsync : in std_ulogic; 205 iClk : in std_ulogic; 206 iForth, 207 iBack : in std_ulogic; 208 oBusy : out std_ulogic; 209 oState : out aState); 210 end entity WalkAndThinkMachine; 211 architecture Rtl of WalkAndThinkMachine is 212 signal State, NextState : aState; 213 begin 214 oState \u0026lt;= State; 215 216 NextStateAndOutput: process (State, iForth, iBack) is 217 begin 218 -- default settings 219 NextState \u0026lt;= State; 220 oBusy \u0026lt;= cInactivated; 221 222 case State is 223 when Standing =\u0026gt; 224 if iForth = cActivated then 225 NextState \u0026lt;= WalkingForward; 226 elsif iBack = cActivated then 227 NextState \u0026lt;= WalkingBackwards; 228 end if; 229 when WalkingForward =\u0026gt; 230 if iForth = cActivated then 231 NextState \u0026lt;= WalkingForward; 232 elsif iBack = cActivated then 233 NextState \u0026lt;= WalkingBackwards; 234 end if; 235 when WalkingBackwards =\u0026gt; 236 if iForth = cActivated then 237 NextState \u0026lt;= Thinking; 238 elsif iBack = cActivated then 239 NextState \u0026lt;= WalkingBackwards; 240 end if; 241 when Thinking =\u0026gt; 242 oBusy \u0026lt;= cActivated; 243 if iForth = cActivated then 244 NextState \u0026lt;= Standing; 245 end if; 246 end case; 247 end process NextStateAndOutput; 248 249 StateReg: process (iResetAsync, iClk) is 250 begin 251 if iResetAsync = cActivated then 252 State \u0026lt;= Standing; 253 elsif iClk\u0026#39;event and iClk=\u0026#39;1\u0026#39; then 254 State \u0026lt;= NextState; 255 end if; 256 end process StateReg; 257 end architecture Rtl; 258 259 260-- Mealy FSM 261 package Global is 262 constant cActivated : std_ulogic := \u0026#39;1\u0026#39;; 263 constant cInctivated : std_ulogic := \u0026#39;0\u0026#39;; 264 type aState is (WalkingForward, WalkingBackwards, Drinking); 265 end package Global; 266 267 library IEEE; 268 use IEEE.std_logic_1164.all; 269 use work.global.all; 270 271 entity WalkAndDrinkMachine is 272 port(iResetAsync : in std_ulogic; 273 iClk : in std_ulogic; 274 iForth, 275 iBack : in std_ulogic; 276 oGulp : out std_ulogic; 277 oState : out aState); 278 end entity WalkAndDrinkMachine; 279 280 architecture Rtl of WalkAndDrinkMachine is 281 signal State, NextState : aState; 282 begin 283 oState \u0026lt;= State; 284 285 NextStateAndOutput: process (State, iForth, iBack) is 286 begin 287 -- default settings 288 NextState \u0026lt;= State; 289 oGulp \u0026lt;= cInactivated; 290 291 case State is 292 when Drinking =\u0026gt; 293 oGulp \u0026lt;= cActivated; 294 if iForth = cActivated then 295 NextState \u0026lt;= WalkingForward; 296 elsif iBack = cActivated then 297 NextState \u0026lt;= WalkingBackwards; 298 end if; 299 when WalkingForward =\u0026gt; 300 if iForth = cActivated then 301 NextState \u0026lt;= WalkingForward; 302 elsif iBack = cActivated then 303 NextState \u0026lt;= Drinking; 304 oGulp \u0026lt;= cActivated; 305 end if; 306 when WalkingBackwards =\u0026gt; 307 if iForth = cActivated then 308 NextState \u0026lt;= Drinking; 309 oGulp \u0026lt;= cActivated; 310 end if; 311 end case; 312 end process NextStateAndOutput; 313 314 StateReg: process (iResetAsync, iClk) is 315 begin 316 if iResetAsync = cActivated then 317 State \u0026lt;= Drinking; 318 elsif iClk\u0026#39;event and iClk=\u0026#39;1\u0026#39; then 319 State \u0026lt;= NextState; 320 end if; 321 end process StateReg; 322 end architecture Rtl; ","date":"23 Jänner 2025","externalUrl":null,"permalink":"/code-snippets/vhdl/vhdl-synthese/","section":"Code Schnipsel","summary":"","title":"VHDL - Synthese","type":"code-snippets"},{"content":" Hardware Die Entscheidung für den Kauf des Bausatzes wurde durch den niedrigen Preis erleichtert. Der Bausatz stellt ideale Grundfunktionen bereit und ermöglicht die Entwicklung mit verschiedenen ICs der Firma Atmel. Der allgemeine Aufbau funktioniert extrem einfach, da der Bausatz mit einem gut beschriebenen Schaltplan ausgeliefert wird. Weiters wird der Aufbau durch die sehr gute Leiterplatter vereinfacht. Nach den Lötarbeiten kann man den ersten Test starten, indem ein IC eingesetzt und programmiert wird. Ich verwendete den kleinen ATiny2313, der gut für kleine Schaltungen geeignet ist. Programmiert kann er über den seriellen ISP werden, wobei die Software PonyProg eine gute Wahl ist.\nDie nächste Erweiterung war das LCD Board. Dieses kann mittels Flachbandkabel angeschlossen werden und ermöglicht den Einsatz verschiedener LCDs. Die LCDs werden einfach an eine Buchsenleiste eingesteckt. Die Unterscheidung der LCDs erfolgt nur in der Software. Den Kontrast kann man mit einem Poti einstellen und das Licht kann mit einem Druckschalter ein oder aus geschaltet werden.\nBilder Links Elektronik Versandhaus - RS Components Elektronik Versandhaus - Conrad Anbieter des Boards - Pollin ","externalUrl":null,"permalink":"/projects/projekt-006-atmelevalboard/","section":"Projekte","summary":"","title":"Atmel Evaluationsboard","type":"projects"},{"content":" Hardware Für weitere Entwicklungen und einfache Tests ist ein flexibles Entwicklungs-Board sehr nützlich. Darum nahm ich mir die Zeit ein Board zu erstellen, welches für verschieden PIC und AVR Microcontroller eingesetzt werden kann. Weiter Informationen finden Sie in der Beschreibung unter den Downloads.\nBilder Downloads DevBoard Report (PDF, 594.6 KB) ATMega32 LCD - Source (ZIP, 4.41 KB) ATMega32 Output Extension - Source (ZIP, 2.99 KB) PIC12F675 LCD - Source (ZIP, 6.23 KB) PIC16F628A LCD, UART - Source (ZIP, 12.59 KB) ","externalUrl":null,"permalink":"/projects/projekt-017-avrpicdevboard/","section":"Projekte","summary":"","title":"AVR/PIC Development Board","type":"projects"},{"content":"","externalUrl":null,"permalink":"/code-snippets/c/","section":"Code Schnipsel","summary":"","title":"C","type":"code-snippets"},{"content":" 1// Literatur: AVR uController Manuals 2 3 4/****************************************************** 5 * hal.h * 6 ******************************************************/ 7 #ifndef HAL_H 8 #define HAL_H 9 10 // UART baudrates 11 typedef enum UART_BR_e 12 {\t13 BR_4800, 14 BR_9600, 15 BR_19200, 16 BR_38400, 17 BR_57600, 18 BR_115200, 19 } UART_BR_t; 20 21 // UART receiver callback 22 typedef void (*UARTCALLBACK) (unsigned char data); 23 24 // UART signals 25 #define UART_PORT PORTE 26 #define UART_DDR DDRE 27 #define UART_RXD_PIN 0 28 #define UART_TXD_PIN 1 29 30 #define TX_BUFFER_SIZE\t512 31 #define UART_TX_BUFFER_MASK (TX_BUFFER_SIZE - 1) 32 33 #endif 34 35 36/****************************************************** 37 * uart.h * 38 ******************************************************/ 39 #ifndef UART_H 40 #define UART_H 41 42 #include \u0026lt;avr/pgmspace.h\u0026gt; 43 #include \u0026#34;hal.h\u0026#34; 44 45 void uart_init(tUART_BR Baudrate); 46 void uart_putHex(unsigned char); 47 void uart_putByte(unsigned char); 48 void uart_putInt(unsigned int); 49 void uart_putLong(unsigned long); 50 void uart_putStr(unsigned char *); 51 void uart_putData(unsigned char *, unsigned char); 52 void uart_putStrf(PGM_P); 53 void uart_putChar(unsigned char); 54 BOOL uart_dataAvailable(void); 55 56 void uart_registerCallback(UARTCALLBACK CallBack); 57 58 #endif 59 60 61/****************************************************** 62 * uart.c * 63 ******************************************************/ 64 #include \u0026lt;avr/io.h\u0026gt; 65 #include \u0026lt;avr/interrupt.h\u0026gt; 66 #include \u0026lt;stdio.h\u0026gt; 67 #include \u0026lt;string.h\u0026gt; 68 #include \u0026#34;uart.h\u0026#34; 69 70 // global variables 71 static volatile unsigned char uart_TxBuf[TX_BUFFER_SIZE]; 72 static volatile unsigned char uart_TxHead = 0; 73 static volatile unsigned char uart_TxTail = 0; 74 75 static volatile UARTCALLBACK UartRecCallback = NULL; 76 77 void UART0_RegisterCallback(UARTCALLBACK CallBack) 78 { 79 UartRecCallback = CallBack; 80 } 81 82 void uart_init(UART_BR_t Baudrate) 83 { 84 unsigned int UBRRVAL = 0; 85\t86 switch (Baudrate) 87 { 88 case BR_4800: 89 UBRRVAL = (F_CPU/(4800L*16L)-1); 90 break; 91 case BR_9600: 92 UBRRVAL = (F_CPU/(9600L*16L)-1); 93 break; 94 case BR_19200: 95 UBRRVAL = (F_CPU/(19200L*16L)-1); 96 break; 97 case BR_38400: 98 UBRRVAL = (F_CPU/(38400L*16L)-1); 99 break; 100 case BR_57600: 101 UBRRVAL = (F_CPU/(57600L*16L)-1); 102 break; 103 case BR_115200: 104 UBRRVAL = (F_CPU/(115200L*16L)-1); 105 break; 106 default: 107 UBRRVAL = (F_CPU/(9600L*16L)-1); 108 break; 109 }\t110 111 UBRR0H = (unsigned char)(UBRRVAL\u0026gt;\u0026gt;8); 112 UBRR0L = (unsigned char)UBRRVAL; 113\t114 // enable receiver and transmitter 115 UCSR0B = (1\u0026lt;\u0026lt;TXEN0)|(1\u0026lt;\u0026lt;RXEN0)|(1\u0026lt;\u0026lt;RXCIE0); 116 // set frame format: 8data, 1stop bit 117 UCSR0C = (3\u0026lt;\u0026lt;UCSZ00); 118\t119 UART0_TxHead = 0; 120 UART0_TxTail = 0; 121 } 122 123 // send hex character via serial 124 void uart_putHex(unsigned char data) 125 { 126 unsigned char buf[5]; 127 sprintf((char *)buf, \u0026#34;%02x\u0026#34;, data); 128 uart_putStr(buf); 129 } 130 131 // send a byte 132 void uart_putByte(unsigned char data) 133 { 134 unsigned char buf[5]; 135 sprintf((char *)buf, \u0026#34;%02u\u0026#34;, data); 136 uart_putStr(buf); 137 } 138 139 // send an integer 140 void uart_putInt(unsigned int data) 141 { 142 unsigned char buf[6]; 143 sprintf((char *)buf, \u0026#34;%5u\u0026#34;, data); 144 uart_putStr(buf); 145 } 146 147 // send a long value 148 void uart_putLong(unsigned long Value) 149 { 150 unsigned char Cnt; 151 unsigned char Buf[20]; 152 153 // convert 154 Cnt = 10; 155 do 156 { 157 Cnt--; 158 Buf[Cnt] = Value % 10; 159 Value /= 10; 160 } while (Value \u0026gt; 0); 161 162 // output 163 while (Cnt \u0026lt; 10) 164 { 165 uart_putChar(Buf[Cnt] + \u0026#39;0\u0026#39;); 166 Cnt++; 167 } 168 } 169 170 // send a string 171 void uart_putStr(unsigned char * pdata) 172 { 173 while (*pdata) 174 { 175 uart_putChar(*pdata++); 176 } 177 } 178 179 // send a string 180 void uart_putData(unsigned char * pdata, unsigned char Len) 181 { 182 while (Len--) 183 { 184 uart_putChar(*pdata++); 185 } 186 } 187 188 // send a string from flash-memory 189 void uart_putStrf(PGM_P pdata) 190 { 191 // while not 0 continue 192 while (pgm_read_byte(pdata)) 193 { 194 uart_putChar(pgm_read_byte(pdata++)); 195 } 196 } 197 198 // send a character via serial using a ringbuffer 199 void uart_putChar(unsigned char data) 200 { 201 unsigned char tmphead; 202 203 tmphead = (uart_TxHead + 1) \u0026amp; UART_TX_BUFFER_MASK; 204 205 uart_TxBuf[tmphead] = data; 206 uart_TxHead = tmphead; 207 208 // enable UDRE signal 209 UCSR0B |= (1\u0026lt;\u0026lt;UDRIE0); 210 } 211 212 213 // serial UART data register empty signal vector 214 SIGNAL (SIG_USART0_DATA) 215 { 216 unsigned char tmptail; 217 218 if (uart_TxHead != UART0_TxTail) 219 { 220 // calculate and store new buffer index 221 tmptail = (uart_TxTail + 1) \u0026amp; UART_TX_BUFFER_MASK; 222 uart_TxTail = tmptail; 223 224 // get one byte from buffer and write it to UART 225 UDR0 = uart_TxBuf[tmptail]; 226 } 227 else 228 { 229 // tx buffer empty, disable UDRE signal 230 UCSR0B \u0026amp;= ~(1\u0026lt;\u0026lt;UDRIE0); 231 } 232 } 233 234 // serial UART receive complete signal vector 235 SIGNAL (SIG_USART0_RECV) 236 { 237 if (UartRecCallback != NULL) 238 { 239 UartRecCallback(UDR0); 240 } 241 } ","externalUrl":null,"permalink":"/code-snippets/c/avr-uart-driver/","section":"Code Schnipsel","summary":"","title":"C - AVR UART Driver","type":"code-snippets"},{"content":" 1// List of Common Failures 2// ------------------------------------------------------------------------ 3// - mathematical overflows 4// - implement all available controller traps 5// - unexpected program states or values 6// - implement default branches 7// - make plausibility checks 8// - use greater-/smaller- instead equal-comparison 9// - invalid pointers 10// - memory failures 11// - overload 12// - make stress tests 13// - endless loops 14// - watchdog 15// - single reset inside main loop or idle task 16// - checks if all code segments were executed 17// can be made with flag-variables 18// - execution time observation 19// - stackoverflow 20// - detect by using stack-end-marker (magic-number) 21// - race condition 22// - control mutual used variables and resources 23// - dead lock 24 25 26// Basics Controller Mistakes 27// ------------------------------------------------------------------------ 28// - not initialized ports 29// - read/write (TRIS), analog/digital (ANSEL) 30// - floating unused I/O pins 31// - configured as output and driven to a logic-low state 32// - ISR executes too often 33// - clear interrupt flag 34// - execution stops or ends in unexpected behavior 35// - missing endless main-loop 36// - copied code segements 37// - changed only one code position instead of both 38// - wrong function qualifiers 39// - static/extern 40// - wrong variable qualifiers 41// - static/extern, volatile, const 42// - other register values after watchdog-reset compared to power-on-reset 43 44 45// Detailed Failure Descriptions 46// ------------------------------------------------------------------------ 47 48// Race Condition 49// -------------------------------------------------------------------- 50// - very hard to find, because they depends on the execution oder 51// from parallel code 52// - and furthermore very hard to locate 53// - debugging changes the runtime behavior of the program 54// execution and so also the RC occurrence probability 55// - example of two parallel executions (both codes uses the same 56// counter variable) 57// code 1: code 2: 58// ... ... 59// cnt = cnt + 1; cnt++; 60// ... ... 61// - race condition (e.g. assembler directives) 62// load cnt 63// --\u0026gt; load cnt 64// increase cnt 65// store cnt 66// increase cnt \u0026lt;-- 67// store cnt 68// 69// the counter will be incremented by 1, instead of 2 70// 71// - solution depends on available methods 72// - locks, mutex, critical section, semaphore, 73// disable interrupt (for uC purpose), ... 74// - transactional memory 75// 76// lock example: 77// global: 78 int var; 79 bool var_written; 80 81// main loop: 82 int var_buffer; 83 84 if (!var_written) // read value at single point 85 { // and use the buffer variable, 86 GID; // which is used only by this task 87 var_buffer = var; 88 GIE; 89 } 90 91 GID; // write buffer and set flag 92 var_buffer = x; 93 var_written = true; 94 GIE; 95 96 97// isr: 98 if (var_written) // take over value 99 { 100 var = var_buffer; 101 var_written = false; 102 } 103 104// transactional memory example: 105// - start tansaction 106// - execute transaction 107// - test if transaction was interrupted 108// - if yes redo 109// global: 110 int var; 111 bool var_valid; 112 113// main loop: 114 int var_buffer; 115 116 do // if transaction was interrupted 117 { // do it again 118 var_valid = true; // advantage: no interrupt disable necassary 119 var_buffer = var; 120 } 121 while (!var_valid); 122 123// isr: 124 var_valid = false; ","externalUrl":null,"permalink":"/code-snippets/c/common-failures/","section":"Code Schnipsel","summary":"","title":"C - Common Failures","type":"code-snippets"},{"content":" 1// Hersteller: MS Visual Studio 2// Borland 3// IBM 4// gcc 5 6 7// ---- GCC (Linux, Windows) ---- 8 9// Praeprozessor-Ausgaben ansehen 10// gcc -E main.c 11// gcc -E main.c \u0026gt; main.pre 12 13// Assembler-Ausgaben ansehen 14// gcc -S main.c \u0026gt; main.ass 15 16// Kompilieren 17// gcc -c main.c // Kompilieren 18// gcc -c module1.c 19// gcc -c module2.c 20// gcc -o main.exe main.o module1.o module2.o // Linken 21 22// Optimieren 23// gcc -o main.exe -O main.c 24// gcc -o main.exe -O1 main.c 25// gcc -o main.exe -O2 main.c 26// gcc -o main.exe -O3 main.c 27 28// Shared Object erstellen (dynamische Library) 29// gcc -shared -Wl,-soname,libtest.so -o libtest.so test.o 30// gcc -L. -o main.exe main.c -ltest 31// statische Library 32// ar rcs libtest-static.a test.o 33// gcc -L. -o main.exe main.c -ltest-static 34 35// weitere gcc Optionen: 36// -include File 37// -C ... Verbietet dem Praeprozessor Kommentare 38// zu verwerfen 39// -M ... Damit gibt der Praeprozessor eine fuer make 40// passende regel mit den Abhaengigkeiten fuer 41// jeden Objektfile aus 42// -H ... Gibt den Namen der benutzten Headerfiles aus 43// -dMakro ... Definiert Makro, mit String 1 als Definition 44// -dMakro=Definition ... Definiert Makro mit der Definition 45// -UMakro ... Hebt die Definition Makro wieder auf 46// -dM ... Laesst den Praeprozessor alle Makros ausgeben, 47// die nach dem Ende des Praeprozessorlaufes 48// vorhanden sind 49// -Iname ... Fuegt das Verzeichnis name zur Liste der 50// Verzeichnisse hinzu, die nach Headerfiles 51// durchsucht werden 52// -Lname ... Fuegt das Verzeichnis name zur Liste der 53// Verzeichnisse hinzu, die fuer die Linkeroption 54// -l (einbinden von Libraries) durchsucht werden 55// -b Typ ... Compiliert fuer die mit Typ angegebene 56// Architektur 57// -V Version ... Sind mehrere Versionen des GCC installiert, 58// laesst sich mit -V die Version spezifizieren, 59// die benutzt werden soll 60// -llibrary ... Angabe einer Library welche durchsucht 61// werden soll 62 63// weitere ar Optionen: 64// d ... Loescht Members von Archiv-Dateien 65// m ... Verschiebt Members in ein Archiv 66// p ... Druckt Members von Archiven 67// q ... Schnelles hinzufuegen von Members in ein Archiv 68// r ... Fuegt Members in ein Archiv ein (mit Ersetzung) 69// t ... Listet den Inhalt von Archiven auf 70// x ... Extrahiert Members aus einem Archiv 71 72// a ... Fuegt Dateien nach einem existierenden Member 73// in ein Archiv ein 74// b ... Fuegt Dateien vor einem existierenden Member 75// in ein Archiv ein 76// c ... Erzeugt ein Archiv 77// s ... Schreibt ein Object-File Index in das Archiv 78// S ... Generiert keine Archiv Symbol Tabelle 79// V ... Anzeige der Versionsnummer von ar 80 81 82// ---- MS Visual Studio ---- 83 84// Praeprozessor -Ausgaben ansehen 85// cl.exe /E main.c \u0026gt; main.pre ","externalUrl":null,"permalink":"/code-snippets/c/compiler-linker/","section":"Code Schnipsel","summary":"","title":"C - Compiler, Linker","type":"code-snippets"},{"content":" 1// Einbinden einer anderen Source-Datei 2#include \u0026lt;stdio.h\u0026gt; 3 4// definieren von Makros 5#define VERSION 1 6#define SQUARE(_x) ((_x)*(_x)) 7 8// zuruecknehmen von Definitionen 9#undef VERSION 10 11// bedingte Codestellen mittels Praeprozessor-Direktiven 12#if 13#ifdef 14#ifndef 15#else 16#elif 17#endif 18 19// Bsp.: 20#if DEBUG \u0026gt;= 1 21 #define dbPrintf(_fh, _str) fprintf(_fh, _str) 22#else 23 #define dbPrintf(_fh, _str) 24#endif 25 26// defines ueber mehrere Zeilen 27#define printXTimes(_str, _x) \\ 28 for (int i=0; i\u0026lt;_x; i++) \\ 29 { \\ 30 printf(_str); \\ 31 } 32 33// vordefinierte Makros 34// __LINE__ ... Ausgabe der aktuellen Zeile 35// __FILE__ ... Ausgabe des aktuellen Dateinamens 36// __DATE__ ... Ausgabe des aktuellen Datums 37// __TIME__ ... Ausgabe der aktuellen Zeit 38#define printWithDetails(_text) \\ 39 printf(\u0026#34;Datei [%s], Zeile %d: %s\\n\u0026#34;, \\ 40 __FILE__, __LINE__, text) 41 42// Verhinderung von mehreren gleichen Einbindungen 43#ifndef TEST_H 44#define TEST_H 45 // Header-Datei Source Code 46#endif 47 48// Veraenderung von Zeilennummerierungen 49#line 12 \u0026#34;file.h\u0026#34; 50 51// Praeprozessor Error Ausgabe 52#error \u0026#34;Version zu niedrig!\u0026#34; 53 54// Systemspezifische Optionen - Compiler Optionen aendern 55#pragma ","externalUrl":null,"permalink":"/code-snippets/c/defines/","section":"Code Schnipsel","summary":"","title":"C - Defines","type":"code-snippets"},{"content":"1#include \u0026lt;stdio.h\u0026gt; 2 3int main() 4{ 5 printf(\u0026#34;hello world!\u0026#34;); 6 7 return 1; 8} ","externalUrl":null,"permalink":"/code-snippets/c/hello-world/","section":"Code Schnipsel","summary":"","title":"C - Hello World","type":"code-snippets"},{"content":" 1# Makefile fuer automtische Kompilierung von Programmen 2 3Zieldatei: Quelldatei1 Quelldatei2 ... 4\u0026lt;TAB\u0026gt; Anweisung1 5\u0026lt;TAB\u0026gt; Anweisung2 6 7# Aufruf: make -f MakefileName 8# make ... falls Makefile-Name = \u0026#34;makefile\u0026#34; 9# oder \u0026#34;Makefile\u0026#34; 10# make build ... bestimmte Zieldatei waehlen 11# make clean ... bestimmte Zieldatei waehlen 12# make CC=gcc build ... Makros uebergeben 13 14 15# Beispiel (Aufruf: make prog1): 16 main: main.o module1.o module2.o 17 gcc -o main.exe main.o module1.o module2.o 18 main.o: main.c ; gcc -c main.c 19 module1.o: module1.c ; gcc -c module1.c 20 module2.o: module2.c ; gcc -c module2.c 21 clean: 22 rm -f *.o 23 24 25# Makros 26 OBJECTS = main.o module1.o module2.o 27 main: $(OBJECTS); gcc -o main.exe $(OBJECTS) ","externalUrl":null,"permalink":"/code-snippets/c/makefile/","section":"Code Schnipsel","summary":"","title":"C - Makefile","type":"code-snippets"},{"content":" 1// damit die Entwicklungsarbeiten aufgeteilt werden koennen bietet C 2// die Aufteilung in Module an -\u0026gt; Header- und Source-Datei 3 4 5// Modul: 6// Headerdatei - calc.h: 7 void calcSomething(int var1, int var2); 8 9// Sourcedatei - calc.c: 10 void calcSomething(int var1, int var2) 11 { 12 // do something 13 } 14 15 16// Programm: 17 #include \u0026#34;calc.h\u0026#34; 18 19 int main() 20 { 21 calcSomething(...); 22 } ","externalUrl":null,"permalink":"/code-snippets/c/modul/","section":"Code Schnipsel","summary":"","title":"C - Module","type":"code-snippets"},{"content":" 1// Literatur: 2// C++ Referenz (http://www.cplusplus.com) 3// C von A bis Z (http://openbook.galileocomputing.de/c_von_a_bis_z) 4 5 6// Programm Einsprung-Punkt 7 int main(int argc, char **argv) 8 { 9 return 0; 10 } 11 12 // argc ... Argumenten Counter 13 // argv ... Argumenten Liste 14 15 16// reservierte Schluesselwoerter 17 auto break case char complex const continue 18 default do double else enum extern float 19 for goto if imaginary inline int long 20 register restrict return short signed sizeof static 21 struct switch typedef union unsigned void volatile 22 while 23 24 25// Verfuegbare Zeichen 26 // Ziffern: 27 // 1 2 3 4 5 6 7 8 9 0 28 // Buchstaben: 29 // A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 30 // a b c d e f g h i j k l m n o p q r s t u v w x y z 31 // Sonderzeichen: 32 // ! \u0026#34; % \u0026amp; / ( ) [ ] { } \\ ? = \u0026#39; # + * ~ - _ . : ; , | \u0026lt; \u0026gt; ^ 33 // Steuerzeichen: 34 // \\a ... bell - akustisches Warnsignal 35 // \\b ... backspace - Cursor nach links 36 // \\f ... formfeed - Seitenvorschub durchfuehren 37 // \\n ... newline - Cursor zur naechsten Zeile 38 // \\r ... carriage return - Cursor zum Anfang der 39 // - aktuellen Zeile 40 // \\t ... horizontal tab - Cursor zur naechsten horizontalen 41 // Tabulatorposition 42 // \\v ... vertical tab - Cursor zur naechsten vertikalen 43 // Tabulatorposition 44 // \\\u0026#34; ... Ausgabe: \u0026#34; 45 // \\\u0026#39; ... Ausgabe: \u0026#39; 46 // \\? ... Ausgabe: ? 47 // \\\\ ... Ausgabe: \\ 48 // \\0 ... Stringabschluss (Byte-Wert 0 wird gespeichert) 49 // \\nnn ... Ausgabe eines Oktalwerts 50 // \\xhh ... Ausgabe eines Hexdezimalwerts 51 52 53// Kommentare 54 // Zeilenkommentar 55 /* Blockkommentar, 56 kann auch ueber mehrere Zeilen gehen */ 57 58 59// Datentypen 60 // Speicherorte 61 // Code ... Programmcode 62 // Daten ... statische und globale Variablen 63 // Stack ... lokale Variablen 64 // Heap ... dynamische Variablen 65 66 // Initialisierung 67 int wert; 68 int wert = 5; 69 int wert1, wert2 = 10; 70 int wert1 = wert1 = 10; 71 int wert1 = 20, wert2 = 30; 72 73 int wert; // globale Variable 74 void main() 75 { 76 int wert; // lokale Variable 77 78 if () 79 { 80 int wert; // blendet in diesem Anweisungsblock 81 } // andere lokale Variable aus 82 } 83 84 short // Ganzzahl ... Datentyp 85 // min 2 Byte ... ANSI-C 86 // -32.768 ... Min 87 // +32.767 ... Max 88 89 int // Ganzzahl (%d, %i) 90 // min 2 Byte 91 // -32.768 92 // +32.767 93 94 long // Ganzzahl (%ld, %li) 95 // min 4 Byte 96 // -2.147.483.648 97 // +2.147.483.647 98 99 long long // Ganzzahl 100 // min 8 Byte 101 // -9.223.372.036.854.755.807 102 // +9.223.372.036.854.755.807 103 104 float // Gleitkommazahl (%f) 105 // min 4 Byte 106 // 1.2E-38 107 // 3.4E+38 108 // Vorzeichen 1 Bit, Exponent 8 Bits, Mantisse 23 Bits 109 110 double // Gleitkommazahl (%lf) 111 // min 8 Byte 112 // 2.3E-308 113 // 1.7E+308 114 // 15-stellig 115 // Vorzeichen 1 Bit, Exponent 11 Bits, Mantisse 52 Bits 116 117 long double // Gleitkommazahl (%Lf) 118 // min 10 Byte 119 // 3.4E-4932 120 // 1.1E+4932 121 // 19-stellig 122 123 char // Zeichen (%c) 124 // 1 Byte 125 // -128 126 // +127 127 128 129 signed // ... negative und positive Zahl 130 unsigned // ... positive Zahl 131 const // ... Wert kann nicht veraendert werden 132 volatile // ... Variable kann sich auch asserhalb des Programms 133 // aendern (z.B. durch HW) 134 // -\u0026gt; Wert wird jedesmal neu eingelesen 135 static // ... bei Wiedereintritt bleibt Variable erhalten / 136 // Variable gilt nur im aktuellen Kontext 137 extern // ... Variable wurde in einer anderen Datei definiert 138 register // ... Variable sollte moeglichst lange in den internen 139 // Registern gehalten werden 140 (float) intVal // Typcast 141 float (intVal) // Typcast 142 143 int arr[10]; // Array-Definition (0-9) 144 arr[0] = *(arr + 0) // Zugriff auf Elemente 145 int arr[4][4]; // mehrdimensionale Arrays: 146 // [0][0] [0][1] [0][2] [0][3] 147 // [1][0] [1][1] ... 148 // ... 149 int Matrix[4][4] = {{1 ,2 ,3 ,4 }, 150 {4 ,5 ,6 ,7 }, 151 {8 ,9 ,10,11}, 152 {12,13,14,15}}; 153 sizeof(arr)/sizeof(int) // Array Elemente ermitteln 154 int memcmp(const void *ptr1, const void *ptr2, size_t num); 155 void *memcpy(void *destination, const void *source, size_t num); 156 157 char str[] = \u0026#34;hello world\\0\u0026#34;; 158 // String verbinden 159 char *strcat(char *destination, const char *source); 160 // Zeichen in String suchen 161 const char *strchr( const char *str, int character); 162 // String vergleichen 163 int strcmp(const char *str1, const char *str2); 164 // String kopieren 165 char *strcpy(char *destination, const char *source); 166 // Teilstring ermitteln 167 size_t strcspn(const char *str1, const char *str2); 168 // String-Laenge ermitteln 169 size_t strlen(const char *str); 170 // String mit n Zeichen verbinden 171 char *strncat(char *destination, char *source, size_t num); 172 // String mit n Zeichen vergleichen 173 int strncmp(const char *str1, const char *str2, size_t num); 174 // String mit n Zeichen kopieren 175 char *strncpy(char *destination, const char *source, size_t num); 176 // erste Auftreten eines Zeichens 177 const char *strpbrk(const char *str1, const char *str2); 178 // letzte Auftreten eines Zeichens 179 const char *strrchr(const char *str, int character); 180 // erstes Auftreten eines Zeichens, das nicht vorkommt 181 size_t strspn(const char *str1, const char *str2); 182 // String nach Teilstring durchsuchen 183 const char *strstr(const char *str1, const char *str2); 184 // String anhand bestimmter Zeichen zerlegen 185 char *strtok(char *str, const char *delimiters); 186 187 sizeof(int) // ... Groesse des Datentyps in Byte 188 189 #include \u0026lt;limits.h\u0026gt; 190 CHAR_BIT 191 SCHAR_MIN SCHAR_MAX 192 UCHAR_MAX 193 CHAR_MIN CHAR_MAX 194 SHRT_MIN SHRT_MAX 195 USHRT_MAX 196 INT_MIN INT_MAX 197 UINT_MAX 198 LONG_MIN LONG_MAX 199 ULONG_MAX 200 201 #include \u0026lt;float.h\u0026gt; 202 FLT_RADIX FLT_MANT_DIG FLT_DIG FLT_MIN_EXP FLT_MIN_10_EXP 203 FLT_MAX_EXP FLT_MAX_10_EXP FLT_MAX FLT_MIN FLT_EPSILON 204 205 DBL_MANT_DIG DBL_DIG DBL_MIN_EXP DBL_MIN_10_EXP DBL_MAX_EXP 206 DBL_MAX_10_EXP DBL_MAX DBL_MIN DBL_EPSILON 207 208 LDBL_MANT_DIG LDBL_DIG LDBL_MIN_EXP LDBL_MIN_10_EXP LDBL_MAX_EXP 209 LDBL_MAX_10_EXP LDBL_MAX LDBL_MIN LDBL_EPSILON 210 211 int integer = 0; 212 int *pInt; // Pointer auf Integer-Datentyp 213 pInt = \u0026amp;integer; // Zeiger auf Variable 214 *pInt = 1; // Dereferenzieren - Wert aendern 215 pInt = 1; // Zeiger-Wert aendern 216 217 const int *pInt // Pointer auf konstanten Integer 218 int const *pInt // konstanter Pointer auf Integer 219 const int const *pInt // konstanter Pointer auf konstanten Integer 220 221 int Int; 222 int *pInt = \u0026amp;Int; 223 int **ppInt = \u0026amp;pInt; 224 **ppInt = 10; 225 *pInt = 20; 226 227 // dynamischen Speicher anfordern 228 void *malloc(size_t size); 229 // dynamischen Speicher anfordern 230 void *calloc(size_t anzahl, size_t groesse); 231 // Speichergroesse anpassen 232 void *realloc(void *zgr, size_t neuegroesse); 233 // Speicher freigeben 234 free(void *p); 235 // Speicher vom Stack anfordern (braucht nicht freigegeben zu werden) 236 void *alloca(size_t size); 237 238 239// Typdefinitionen 240 typedef unsigned char BYTE; 241 typedef unsigned int WORD; 242 243 244// Strukturen, Unions, ... 245 struct Struct 246 { 247 int Value1; 248 char Value2; 249 }; 250 struct Struct Struct1; 251 Struct1.Value1 = 0; 252 Struct1.Value2 = \u0026#39;a\u0026#39;; 253 254 typedef struct Struct 255 { 256 ... 257 } Struct_t; 258 Struct_t Struct1; 259 260 struct Struct 261 { ... 262 } Struct1; 263 264 struct Struct 265 { ... 266 } Struct1 = {0, \u0026#39;a\u0026#39;}; 267 268 struct Struct 269 { 270 int *ptr; 271 } Struct1; 272 Struct1-\u0026gt;ptr = 10; 273 274 275 union Union 276 { 277 int Int; 278 long Long; // int und long werden am selben 279 }; // Speicherplatz abgelegt 280 281 282 enum Zahl {EINS, ZWEI}; 283 enum Zahl {EINS=1, ZWEI}; 284 enum Zahl nr = EINS; 285 286 typedef enum Zahl {EINS, ZWEI} Zahl_t; 287 Zahl_t nr = EINS; 288 289 290 typedef struct bit8struct 291 { 292 unsigned char b0:1; // Bit-weiser Zugriff 293 unsigned char b1:1; 294 unsigned char b2:1; 295 unsigned char b3:1; 296 unsigned char b4:1; 297 unsigned char b5:1; 298 unsigned char b6:1; 299 unsigned char b7:1; 300 } BITDEF8; 301 302 typedef union bit8union 303 { 304 BITDEF8 bit; 305 unsigned char byte; 306 } BIT8; 307 308 309// Operationen 310 // unaer ... ein Operanden 311 // binaer ... zwei Operanden 312 // ternaer ... drei Operanden 313 314 // infix ... Operand zwischen Operanden 315 // praefix ... Operand vor Operand 316 // postfix ... Operand nach Operand 317 318 // linksassoziativ ... a + b - c = (a + b) - c 319 // rechtsassoziativ ... a + b - c = a + (b - c) 320 321 // Berechnungsoperationen 322 a = a+b; // Addition 323 a = a-b; // Subtraktion 324 a = a*b; // Multiplikation 325 a = a/b; // Division 326 a = a%b; // Modulo (Rest) 327 328 a += b; 329 a -= b; 330 a *= b; 331 a /= b; 332 a %= b; 333 334 a++; // postfix - alte Wert wird ausgegeben und 335 // anschliessend wird incrementiert 336 ++a; // praefix - Wert wird inkrementier und 337 // anschliessend ausgegeben 338 b--; // dekrementieren 339 --b; 340 341 // Bitoperationen 342 \u0026amp; // bitweises Und 343 | // bitweises Oder 344 ^ // bitweises XOR 345 ~ // bitweises Komplement 346 \u0026gt;\u0026gt; // shift right 347 \u0026lt;\u0026lt; // shift left 348 349 // Vergleichsoperatoren 350 == // gleich 351 != // ungleich 352 \u0026lt; // kleiner 353 \u0026gt; // groesser 354 \u0026lt;= // kleiner gleich 355 \u0026gt;= // groesser gleich 356 357 ! // negation 358 || // Oder 359 \u0026amp;\u0026amp; // Und 360 361 362// Kontrollanweisungen 363 if (CONDITION) 364 {} 365 else if (CONDITION) 366 {} 367 else 368 {} 369 370 if (a\u0026gt;b) == c = (a\u0026gt;b) ? a : b; 371 c = a; 372 else 373 c = b; 374 375 switch(a) 376 { 377 case 0: 378 break; 379 default: 380 break; 381 } 382 383 while (CONDITION) 384 {} 385 386 do 387 {} 388 while (CONDITION); 389 390 for (i=0; i\u0026lt;MAX; i++) 391 {} 392 393 394// Funktionen 395 void FuncName (int Param); // Vorwaertsdeklaration 396 void FuncName (int Param) // Implementierung 397 {} 398 399 void FuncName (int Value) // call by value 400 {} // Kopie wird uebertragen, 401 // Aenderung wirkt sich ausserhalb 402 // nicht aus 403 404 void FuncName (int *Value) // call by reference 405 {} // Pointer wird uebertragen, 406 // Aenderung wirkt sich ausserhalb aus 407 408 void FuncName (int Arr[]) 409 { 410 Arr[0] = ... 411 } 412 void FuncName (int Arr[][10]) 413 { 414 Arr[0][0] = ... 415 } 416 417 int *FuncName () 418 { 419 int asdf = 0; 420 return asdf; // !Fehler! 421 // -\u0026gt; Variable nach Funktionsende 422 // nicht mehr am Stack 423 424 int *asdf = (int *) malloc(sizeof(int)); 425 *asdf = 0; 426 return asdf; // Richtig -\u0026gt; Variable bleibt erhalten 427 } 428 429 430// Funktionspointer 431 int (*FuncName)(void); 432 int (*FuncName)(int Value); 433 int (*FuncName)(int Value, ...); 434 FuncName pFunc = ... 435 436 int (*ptr[])(const char *, ...) = { scanf, printf }; 437 (*ptr[1])(\u0026#34;output\u0026#34;); 438 (*ptr[0])(\u0026#34;%d\u0026#34;,\u0026amp;value); 439 440 441// formatierte Ausgabe 442 printf(\u0026#34;hello world\u0026#34;); 443 printf(\u0026#34;hello \\ 444 world\u0026#34;); 445 446 printf(\u0026#34;%FW.GU\u0026#34;, \u0026amp;value); 447 // F ... Flags 448 // W ... Weite 449 // G ... Genauigkeit 450 // U ... Formatierungszeichen 451 452 // Flags: 453 // - ... linksbuendig 454 // 0 ... mit 0en fuellen 455 // + ... Vorzeichen ausgeben 456 // blank ... positive Zahlen mit Leerzeichen beginnen 457 // # ... verschiedene Bedeutung: 458 // %#o (Oktal) 0 Praefix einfuegen 459 // %#x (Hex) 0x Praefix einfuegen (Wert ungl. Null) 460 // %#X (Hex) 0X Praefix einfuegen (Wert ungl. Null) 461 // %#e Dezimalpunkt anzeigen 462 // %#E Dezimalpunkt anzeigen 463 // %#f Dezimalpunkt anzeigen 464 // %#g Dezimalpunkt immer anzeigen. 0en nach dem 465 // Dezimalpunkt werden nicht beseitigt 466 // %#G Dezimalpunkt immer anzeigen. 0en nach dem 467 // Dezimalpunkt werden nicht beseitigt 468 469 // Formatierungszeichen: 470 // %d, %i ... vorzeichenbehaftete ganze Dezimalzahl 471 // %o ... vorzeichenlose ganze Oktalzahl 472 // %u ... vorzeichenlose ganze Dezimalzahl 473 // %x, %X ... vorzeichenlose ganze Hexzahl 474 // (a,b,c,d,e,f) bei x; (A,B,C,D,E,F) bei X 475 // %f ... Gleitpunktzahl (ddd.dddddd) 476 // %e, %E ... Gleitpunktzahl (d.ddde+-dd, d.dddE+-dd) 477 // %g, %G ... float 478 // %c ... Zeichen 479 // %s ... Zeichenkette 480 // %p ... Zeigerwerte 481 // %% ... das Zeichen % 482 483 484// formatiere Eingabe 485 #include \u0026lt;stdio.h\u0026gt; 486 nrCorrect = scanf(\u0026#34;%d %c\u0026#34;,\u0026amp;i, \u0026amp;c); 487 // nrCorrect ... Nummer der korrekt eingelesenen Werte 488 489 // Suchmengen 490 %[Liste] // Zeichen welches in der Liste befindet 491 // %[A-Z] %[a-z] %[a-fA-F] 492 %[^Liste] // Zeichen welches nicht in der Liste befindet 493 494 fflush(stdin); // Eingabe-Puffer leeren 495 496 497// standard Libraries 498 // assert.h ... Fehlersuche und Debugging 499 // ctype.h ... Zeichentest und Konvertierung 500 // errno.h ... Fehlercodes 501 // float.h ... Limits/Eigenschaften fuer Gleitpunkttypen 502 // limits.h ... Implementierungskonstanten 503 // locale.h ... Laenderspezifische Eigenschaften 504 // math.h ... Mathematische Funktionen 505 // setjmp.h ... Unbedingte Spruenge 506 // signal.h ... Signale 507 // stdarg.h ... Variable Parameteruebergabe 508 // stddef.h ... Standard-Datentyp 509 // stdio.h ... Standard-I/O 510 // stdlib.h ... Nuetzliche Funktionen 511 // string.h ... Zeichenkettenoperationen 512 // time.h ... Datum und Uhrzeit 513 // complex.h ... Komplexe Arithmetik 514 // inttypes.h ... Fuer genauere Integer-Typen 515 // stdbool.h ... Boolschen Datentypen 516 // stdint.h ... Ganzzahlige Typen mit vorgegebener Breite 517 // tgmath.h ... Generische Mathematik-Funktionen 518 // wchar.h ... fuer den erweiterten Zeichensatz: 519 // - Umwandlung von Strings zu Zahlwerten 520 // - String- und Speicherbearbeitung 521 // - Ein- und Ausgabe 522 // wctype.h ... fuer den erweiterten Zeichensatz: 523 // - Zeichenuntersuchung 524 525 526// Dateioperationen 527 // Datenstrom oeffnen 528 FILE *fopen(const char *pfadname, const char *modus); 529 // r ... read 530 // w ... write (anlegen einer Datei) 531 // a ... write/add (falls nicht vorhanden -\u0026gt; NULL) 532 // r+ ... read+write 533 // w+ ... write (falls vorhanden -\u0026gt; zuvor loeschen) 534 // a+ ... write/add (falls nicht vorhanden -\u0026gt; anlegen) 535 // 536 // b ... Binaermodus 537 // t ... Textmodus 538 // 539 // stdin ... Standardeingabe 540 // stdout ... Standardausgabe 541 // stderr ... Standardfehlerausgabe 542 // Datenstrom schliessen 543 int fclose(FILE *stream); 544 // Testet auf Dateiende im Stream 545 int feof(FILE *stream); 546 // Testet auf Fehler im Stream 547 int ferror(FILE *stream); 548 // Leert den Puffer im Datenstrom 549 int fflush(FILE *stream); 550 // Zeichenweise lesen vom Stream 551 int fgetc(FILE *stream); 552 // Zeilenweise lesen vom Stream 553 char *fgets(char *str, int num, FILE *stream); 554 // Position im Stream ermitteln 555 int fgetpos(FILE *stream, fpos_t *position); 556 // Formatierte Ausgabe an Stream 557 int fprintf(FILE *stream, const char *format, ... ); 558 // Zeichenweise schreiben in den Stream 559 int fputc(int character, FILE *stream); 560 // Schreibt einen String in den Stream 561 int fputs(const char *str, FILE *stream); 562 // Datenstrom erneut oeffnen 563 FILE *freopen(const char *filename, const char *mode, FILE *stream); 564 // Formatierte Eingabe vom Stream 565 int fscanf(FILE *stream, const char *format, ... ); 566 // Dateizeiger neu positionieren 567 int fseek(FILE *stream, long int offset, int origin); 568 // Dateizeiger neu positionieren 569 int fsetpos(FILE *stream, const fpos_t *pos); 570 // Position im Stream ermitteln 571 long int ftell(FILE *stream); 572 573 // Zeichenweise lesen vom Stream 574 int getc(FILE *stream); 575 // Zeichenweise lesen von stdin 576 int getchar(void); 577 // Liest String von stdin (unsichereFunktion) 578 char *gets(char *str); 579 // Formatierte Ausgabe an stdout 580 int printf(const char *format, ... ); 581 // Zeichenweise schreiben in den Stream 582 int putc(int character, FILE *stream); 583 // Zeichenweise schreiben an stdout 584 int putchar(int character); 585 // Zeichenkette an Stream stdout 586 int puts(const char *str); 587 // Formatierte Eingabe von stdin 588 int scanf(const char *format, ... ); 589 // Streampuffer einrichten 590 void setbuf(FILE *stream, char *buffer); 591 // Streampuffer veraendern 592 int setvbuf(FILE *stream, char *buffer, int mode, size_t size); 593 // Formatierte Ausgabe in einem String 594 int sprintf(char *str, const char *format, ... ); 595 // Formatierte Eingabe aus einem String 596 int sscanf(const char *str, const char *format, ...); 597 // Zeichen zurueck in den Stream 598 int ungetc(int character, FILE *stream ); 599 600 601// Fehlercodes 602 \u0026lt;errno.h\u0026gt; 603 strerror(), perror() 604 // EDOM ... Unzulaessiges Argument fuer eine 605 // mathematische Funktion 606 // ERANGE ... Ergebnis ausserhalb des darstellbaren Bereichs 607 // EZERO ... Fehler 0 608 // EINVFNC ... Ungueltige Funktionsnummer 609 // ENOFILE ... Datei nicht gefunden 610 // ENOPATH ... Pfad nicht gefunden 611 // ECONTR ... Speicherbloecke zerstoert 612 // EINVMEM ... Ungueltige Speicherblockadresse 613 // EINVENV ... Ungueltiges Environment 614 // EINVFMT ... Ungueltiges Format 615 // EINVACC ... Ungueltiger Zugriffscode 616 // EINVDAT ... Ungueltige Daten 617 // EINVDRV ... Ungueltige Laufwerksangabe 618 // ECURDIR ... Versuch, das aktuelle Verzeichnis zu loeschen 619 // ENOTSAM ... Nicht das gleiche Geraet 620 // ENMFILE ... Keine weiteren Dateien mehr 621 // ENOENT ... Datei oder Verzeichnis existiert nicht 622 // EMFILE ... Zu viele geoeffnete Dateien 623 // EACCES ... Zugriff verweigert 624 // EBADF ... Ungueltiger Datei-Deskriptor 625 // ENOMEM ... Zu wenig Speicher 626 // ENODEV ... Geraet existiert nicht 627 // EINVAL ... Ungueltiges Argument 628 // E2BIG ... Argumentliste ist zu lang 629 // ENOEXEC ... Fehler beim Exec-Format 630 // EXDEV ... Kreuzverbindung von Geraeten 631 // EFAULT ... Unbekannter Fehler 632 // EEXIST ... Datei existiert bereits ","externalUrl":null,"permalink":"/code-snippets/c/c-reference/","section":"Code Schnipsel","summary":"","title":"C - Reference","type":"code-snippets"},{"content":" 1// Static Analyzer 2// ------------------------------------------------------------------------ 3 4// A static analyzer tool parses the source code and gives some information 5// ofknown programmer faults. With such tools you can find some critical 6// and security buggs very easy. The analyzer checks the code with 7// predefined rules and shows you many warnings and errors, also false 8// positive failures. To avoid the false positive warning/error output the 9// user can modify the rules. 10 11// PC-lint for C/C++ from Gimpel Software (http://www.gimpel.com/) 12// - static analyzer with defined rules for MISRA-standard 13// - command line tool, easy to integrate for many IDEs 14// (e.g. MPLAB from Microchip) 15// - Win, Dos, OS2 16// - *.lnt files for rule checker configuration 17// (e.g. co-picc.lnt for hitex C-compiler) 18// - usage: lint co-picc.lnt test.c 19 20// Splint for C (http://splint.org/) 21// - static analyzer 22// - command line tool 23// - Win, Source-Code available 24// - usage: splint test.c 25 26// Flawfinder for C/C++ (http://www.dwheeler.com/flawfinder/) 27// - reports possible security weaknesses - \u0026#34;flaws\u0026#34; 28// (race conditions, access violations, buffer overflows, ...) 29// - Linux, Source-Code available 30 31// RATS 32// - Rough Auditing Tool for Security 33// (https://www.fortify.com/ssa-elements/threat-intelligence/rats.html) 34// - analyzes C, C++, Perl, PHP and Python source code for 35// security weakness (race conditions, access violations, 36// weak random, buffer overflows, ...) 37// - Win, Source-Code available 38// - usage: rats --warning 1 --html test.c \u0026gt;output.html 39// 1 ... only major failures 40// 2 ... middle warning density 41// 3 ... show all failures 42// --html ... output html formated 43// --xml ... output xml formated 44 45// other useful tools: 46// - BLAST - Berkeley Lazy Abstraction Software Verification Tool 47// (http://mtc.epfl.ch/software-tools/blast/index-epfl.php) 48// - PScan (http://deployingradius.com/pscan/) 49// - ITS4 (http://www.cigital.com/its4/) 50// - Frama-C (http://frama-c.com/) ","externalUrl":null,"permalink":"/code-snippets/c/static-analyzer-tools/","section":"Code Schnipsel","summary":"","title":"C - Static Analyzer Tools","type":"code-snippets"},{"content":"Eine gute Erklärung von VOLATILE kann unter https://blog.regehr.org/archives/28 gefunden werden. Hier ein kleiner Auszug:\nFor every read from a volatile variable by the abstract machine, the actual machine must load from the memory address corresponding to that variable. Also, each read may return a different value. For every write to a volatile variable by the abstract machine, the actual machine must store to the corresponding address. Otherwise, the address should not be accessed (with some exceptions) and also accesses to volatiles should not be reordered (with some exceptions).\nDer generelle Gebrauch wird unter diesen Links gut beschrieben:\nhttps://barrgroup.com/Embedded-Systems/How-To/C-Volatile-Keyword https://www.embedded.com/electronics-blogs/programming-pointers/4025609/Place-volatile-accurately https://embeddedgurus.com/barr-code/2012/11/how-to-combine-volatile-with-struct/ https://blog.regehr.org/archives/28 1// NEGATIVE EXAMPLE 2 // Main 3 void main() 4 { 5 foo = 0; 6 7 for(;;) 8 { 9 while(!foo); // could be replace by while(true) 10 foo = 0; // -\u0026gt; endless loop 11 } 12 } 13 14 // ISR 15 int foo; // globally shared variable 16 17 void isr() 18 { 19 // ... 20 21 foo = 1; 22 } 23 24// BAD PROGRAMMING STYLE 25 // Main 26 /* The function would need to load the variable from the 27 original location in case of external function declaration. 28 It doesn\u0026#39;t know the preceding program code. Thus no 29 optimizations can be made. 30 Anyway in case the compiler optimization is more 31 sophisticated it may fail. 32 */ 33 void wait() 34 { 35 while(!foo); 36 } 37 38 // static void main() 39 // inline void wait() 40 /* In case of inline or static function declaration the 41 compiler already knows all preceding program code and 42 could optimize something. 43 */ 44 45 void main() 46 { 47 foo = 0; 48 49 for(;;) 50 { 51 wait(); 52 foo = 0; 53 } 54 } 55 56 // ISR 57 int foo; // globally shared variable 58 59 void isr() 60 { 61 // ... 62 63 foo = 1; 64 } 1// volatile integer 2 volatile int foo; 3 int volatile foo; 4 5// pointer to volatile integer 6 volatile int * pFoo; 7 int volatile * pFoo; 8 9// volatile pointer to volatile integer 10 volatile int * volatile pFoo; 11 int volatile * volatile pFoo; 12 13// pointer to volatile struct 14 // separate volatile declaration for each variable 15 typedef struct 16 { 17 } foo_s; 18 foo_s volatile *pFoo = 0x10000; 19 20 // disadvantage: have to be placed within 21 // function declarations too 22 void doSmth(foo_s volatile *pFoo); 23 24 // each variable declared volatile 25 typedef volatile struct 26 { 27 } foo_s; 28 foo_s *pFoo = 0x10000; 29 30 // advantage: automatically added at each declaration 31 void doSmth(foo_s *pFoo); 32 33// volatile struct member 34 typedef struct 35 { 36 volatile int a; 37 int b; 38 } foo_s; 39 40 typedef struct 41 { 42 int volatile a; 43 int b; 44 } foo_s; 45 46 // advantage: all other accesses can be optimized 47 48// volatile const variable 49 const volatile int * p; 50 51 // usage: the program isn\u0026#39;t allowed to store to it, 52 // however the register value may change from HW side Beispiel für einen non-volatilen Buffer-Zugriff zw. ISR und Main Bei einem Austausch über Double-Buffering passiert der Zugriff immer nur von einer Seite (Synchronisation vorausgesetzt). Das ermöglicht Compiler-Optimierungen, da ein direkter Lese/Schreib-Zugriff nicht mehr immer notwendig ist.\n1// Main 2 void main() 3 { 4 int * local; 5 6 collect = \u0026amp;a; 7 process = \u0026amp;b; 8 new_data = 0; 9 10 IE(); // interrupts enabled 11 12 for(;;) 13 { 14 while(!new_data); 15 local = process; 16 new_data = 0; 17 18 // read/write access 19 x = *local; 20 y = *local; // could be optimized 21 *local = x/2; 22 } 23 } 24 25// ISR 26 int a,b; // double buffering 27 int * volatile collect; 28 int * volatile process; 29 30 int volatile new_data; // sync variable 31 32 void isr() 33 { 34 int * local = collect; 35 36 // ... 37 38 *local = y; 39 *local += 2; // could be optimized 40 41 // ... 42 43 // swap buffer and inform main 44 // (main should already be within while-loop) 45 if (process == \u0026amp;a) 46 { 47 process = \u0026amp;b; 48 collect = \u0026amp;a 49 } 50 else 51 { 52 process = \u0026amp;a; 53 collect = \u0026amp;b; 54 } 55 new_data = 1; 56 } Beispiel für einen volatilen Zugriff von non-volatile Variablen Eine Variable, welche nur in der ISR verwendet wird, kann grundsätzlich non-volatile deklariert werden. Wird sie aber während der Initialisierung in der Main-Routine beschrieben, so muss sichergestellt werden, dass der Zugriff volatile passiert (direkter Zugriff an genau diesem Zeitpunkt) und die ISR noch nicht aufgerufen werden kann. Weiterführendes über volatile-casts kann unter https://bytes.com/topic/c/answers/221923-cast-volatile nachgelesen werden.\n1// Main 2 void main() 3 { 4 *((int volatile *)\u0026amp;foo) = 1; 5 6 IE(); // interrupts enabled 7 8 // ... 9 } 10 11// ISR 12 int foo = 0; // globally shared variable 13 14 void isr() 15 { 16 if (foo == 0) 17 { 18 foo = 1; 19 } 20 else 21 { 22 foo = 0; 23 } 24 25 // ... 26 } Unterschiede bei der Kernel-Programmierung:\nhttps://web.archive.org/web/20160304053622/https:/www.kernel.org/doc/Documentation/volatile-considered-harmful.txt ","externalUrl":null,"permalink":"/code-snippets/c/volatile/","section":"Code Schnipsel","summary":"","title":"C - Volatile","type":"code-snippets"},{"content":"","externalUrl":null,"permalink":"/en/categories/","section":"Categories","summary":"","title":"Categories","type":"categories"},{"content":" Software Bei diesem Projekt geht es um die Implementierung von einem Chat System mit Server und Client Funktionalitäten. Für die Implementierung wurde C-sharp herangezogen, deshalb ist es notwendig das .NET Framework am Zielrechner zu installieren. Nähere Informationen finden sie in der Report Datei unter den Downloads.\nBilder Links Microsoft .NET Framework Downloads Report Dokument (PDF, 1.13 MB) Package icon Source Dateien (ZIP, 31.04 KB) Package icon Binary Dateien (ZIP, 17.1 KB) ","externalUrl":null,"permalink":"/projects/projekt-013-chatmessanger/","section":"Projekte","summary":"","title":"Chat Messanger","type":"projects"},{"content":" Für einfache Prototypen von elektronischen Schaltungen verwendet man oft Lochraster-Platinen. Um mit diesen Platinen einen sauberen Aufbau zu erreichen, muss man während dem Löten immer genau überlegen, wie man die Bauteile platziert und die Leitungen am besten führt. Boards mit professionell gefertigten Leiterplatten sehen meistens besser aus. Bei professionell gefertigten Leiterplatten verlängert sich die Designphase, da die Leitungsführung bereits während dem Routing festgelegt wird. Damit reduziert sich die Lötarbeit zu einfachem Einlöten von Bauteilen.\nDa professionell gefertigte Leiterplatten für einfache Hobby-Projekte zu teuer wären und ich keine Chemikalien verwenden möchte, bleibt nur eine weitere Möglichkeit - eine CNC Fräse.\nÜberblick Eine Computer-gestützte Fräse benötigt folgende Komponenten:\neinen Frästisch, damit das zu bearbeitende Stück in X, Y und Z-Richtung verschoben werden kann eine Spindel, die die Fräsarbeiten übernimmt eine Steuerbox und Schrittmotoren und einen Computer mit geeigneter CNC Software Als Basisgerät verwende ich eine Proxxon MF70. Dieses Gerät ist eine fertig montierte einfache Fräse mit Handkurbeln. Damit habe ich einen Frästisch mit einer Arbeitsfläche von 134mm x 48mm und einer vertikalen Verstellmöglichkeit von 83mm. Pro Umdrehung einer Handkurbel verändert sich die Tisch-Position um 1mm. Des Weiteren ist auch eine Spindel mit variabler Drehzahl fix montiert.\nDamit der Tisch gesteuert werden kann, werden die Handkurbel durch Schrittmotoren ersetzt. Da die verwendeten Schrittmotoren 100 Schritte pro Umdrehung benötigen, fährt man pro Schritt 1/100mm. Die Ansteuerung der Motoren übernehmen L297/298 ICs, welche mit dem Parallel-Anschluss des Computers verbunden sind. Auf dem Computer läuft LinuxCNC.\nKomponenten Stück Beschreibung Typ 1 Frästisch mit Spindel Proxxon MF70 3 Schrittmotoren QSH-4218-41-10-035 1 Montagematerial für Schrittmotoren Aluwinkel + Kleinteile 1 Netzteil für Steuer-Elektronik und Motoren EI60 25VA 230V 24V, 7824A, TMA 2405S 1 Steuer-Elektronik L297, L298 6 End-Taster 1 Not-Aus-Taster 2 Relais für Spindelversorgung ALE14B24 1 Computer mit LPT Schnittstelle Netzteil Für die Versorgung der Elektronik und der Motoren verwende ich einen eigenen Aufbau. Die 230V-AC Netzspannung wird mit einem Transformator EI60 25VA 230V 24V auf 24V-AC und über einen Vollweg-Gleichrichter und Kondensatoren auf ca. 34V-DC transformiert. Diese Spannung wird direkt für die Schrittmotoren verwendet. Für die 24V Relais verwende ich einen 7824A Regler. Die 5V IC-Versorgung wird mit TMA 2405S Reglern erzeugt. Da die 5V Regler den Ausgang vom Eingang isolieren, muss man sämtliche DC-Grounds miteinander verbinden. Ein 5V Strang wird von den Schrittmotor-Treiber-ICs (max. 80mA für L297 und max. 36mA für L298) und ein paar Pull-Ups (30mA für 6 Stück 1k) belastet. Der maximale Strombedarf von 146mA ist somit unterhalb dem maximal erlaubten Ausgangsstrom (200mA) des 5V Reglers TMA 2405S. Ebenso ist die kapazitive Belastung mit ca. 33uF im erlaubten Bereich (max. 220uF).\nDer 24V Strang wird durch die 5V Regler (max. 55mA pro Regler) und durch die beiden Relais (je 17mA bei einer Spule mit 1440R) belastet. Der maximale Strombedarf von 254mA liegt unterhalb 1A des 24V Reglers 7824A. Da sich der Regler bei dieser Belastung bereits stark erwärmt wird ein Kühlkörper benötigt (65°C/W).\nDie 34V Versorgung wird durch den 24V Regler (254mA) und den Strömen der Schrittmotoren belastet. Somit sollten die Schrittmotoren maximal 786mA an Strom ziehen um den Transformator nicht zu überlasten (max. 1040mA).\nSteuer-Elektronik Die Ansteuerung der bipolaren Schrittmotoren übernehmen die ICs L297 und L298. Der L298 enthält eine H-Brücke um die Phasen in beiden Richtungen mit Strom zu versorgen. Die Freilauf-Dioden sind nicht integriert und müssen noch extern platziert werden. Der L297 übernimmt das Erzeugen der korrekten Signale für den L298. Als Eingangsparameter erhält er Steuersignale (Richtung und Schritt) und das Stromsensor-Signal. Die Arbeitsweise kann durch zusätzliche Steuerleitungen verändert werden. Bei meinem Aufbau verwende ich Halb-Schritte und \u0026ldquo;Phase-chopping\u0026rdquo;. Der Halb-Schritt-Modus fügt zwischen zwei Vollschritten noch einen weiteren Schritt ein. Der \u0026ldquo;Phase-chopping\u0026rdquo;-Modus gibt an, wie die Stromregelung vorgenommen wird. In diesem Modus wird nur der untere Transistor ausgeschaltet, sobald der Soll-Strom erreicht ist. Somit sinkt der Strom in den Phasen des Motors nur langsam. Im \u0026ldquo;Inhibit-chopping\u0026rdquo;-Modus werden beide Transistoren ausgeschaltet und der Strom sink schneller.\nDamit die Spindel über den Computer ein- und ausgeschaltet werden kann, werden zwei Relais (L, N) mit einem FET geschaltet. Beide FETs werden mit dem selben Signal angesteuert.\nDa die parallele Schnittstelle nur eine begrenzte Anzahl an Eingängen besitzt, werden die Endschalter einer Achse kombiniert. Somit ergeben sich vier Eingangs-Signale: X-Ende, Y-Ende, Z-Ende und Not-Aus-Betätigt. Die Endschalter werden so verwendet, dass sie im Normal-Zustand geschlossen sind. Somit wird im Falle eines Drahtbruches auch gestoppt.\nFür die Schrittmotor-Treiber werden Bauteile laut der der Tabelle unterhalb benötigt. Damit ich keine eigene Print anfertigen musste, bestellte ich mir bereits fertige von http://www.robotikhardware.de.\nAnzahl Referenz Wert Beschreibung 1 C1 3n3 10V Keramik Kondensator 1 C2 100n 10V Keramik Kondensator 1 C3 33u 10V Elko 1 C4 100n 60V Kermik Kondensator 1 C5 2m2 60V Elko 6 R1-R6 1k Widerstand 1 R7 6k2 Widerstand 1 R8 22k Widerstand 2 R9, R10 R56 Leistungswiderstand 1 RV1 10k Poti 8 D1-D8 BYV27 Diode 1 IC1 L297 Schrittmotor-Controller 1 IC2 L298 Vollbrücken-Treiber Software Die Steuerung auf der Computer-Seite übernimmt ein Linux Program LinuxCNC (http://www.linuxcnc.org/). Die Software generiert die notwendigen Steuersignale, welche über die parallele Schnittstelle ausgegeben werden. Des Weiteren verarbeitet sie G-Code und stellt die Fräsdaten grafisch dar.\nDie Grafik unterhalb stellt die Pinbelegung dar. Prinzipiell können die Pins in der Software frei konfiguriert werden.\nDie nächsten Printscreens stellen die gewählten EMC-Parameter dar. Die parallele Schnittstelle liegt auf der Adresse 0x378. Die Schrittpulsdauer und die Zwischenzeiten wurden auf 10us gesetzt. Die Voreinstellungen für L297 konnten nicht verwendet werden, da vor dem Motorcontroller noch etwas langsamere Transistoren platziert wurden.\nDie Schritt-Signale mussten nicht invertiert werden. Die Richtungs-Signale wurden nach einigen Tests so konfiguriert, damit der Tisch in die richtige Richtung fährt (bei diesem Aufbau: Y, Z Richtung negiert). Der Not-Aus Eingang musste auch noch invertiert werden.\nDie Motoren haben eine Schrittweite von 1.8°. Somit benötigt man für eine volle Umdrehung 200 Schritte. Betrieben werden sie im Halbschrittmodus. Eine komplette Umdrehung der Spindel bewegt den Tisch um 1mm.\nDa Layout Programme meistens keinen G-Code direkt erzeugen können, benötigt man noch ein Konvertierungs-Tool. Verwendet man KiCad, so kann man pcb2gcode verwenden. Verwendet man Eagle, so gibt es ein \u0026ldquo;user language program\u0026rdquo; (ULP), das die Brd-Dateien nach G-Code konvertiert (PCB-GCODE).\nDownloads Fräsdaten mit Inkscape erstellen (PDF, 985.98 KB) Fräsdaten mit KiCAD erstellen (PDF, 1.44 MB) G-Code Überblick Um die erzeugten G-Code Dateien etwas lesen zu können, hier ein kleiner Überblick verschiedener G-Code Befehle. Ausführlichere Liste vorhandener Befehle finden man im englischen Wikipedia.\nG-Code Beschreibung A absolute oder relative Positionsangabe A-Achse (Rotationsachse um X) B abs. oder rel. Positionsangabe B-Achse (Rotationsachse um Y) C abs. oder rel. Positionsangabe C-Achse (Rotationsachse um Z) F Angabe Vorschub (mm/min) I Angabe Kreismittelpunkt - X Position für Rotationsbewegungen J Angabe Kreismittelpunkt - Y Position für Rotationsbewegungen R Angabe Kreisradius für Rotationsbewegungen S Angabe Spindel Geschwindigkeit (rpm) T Auswahl Werkzeug X absolute oder relative Positionsangabe X-Achse Y abs. oder rel. Positionsangabe Y-Achse Z abs. oder rel. Positionsangabe Z-Achse G00 schnelle Positionierung (ohne Bearbeitung, nicht immer auf direktem Weg) G01 lineare Positionierung (mit Bearbeitung) G02 Rotationsbewegung im Uhrzeigersinn G03 Rotationsbewegung gegen Uhrzeigersinn G20 Angaben in Zoll G21 Angaben in mm G28 Rückkehr zur Nullposition G90 Angaben in Absolutpositionen G91 Angaben in Relativpositionen G92 Setzen der Nullposition M02 Programmende M03 Spindel ein (im Uhrzeigersinn) M04 Spindel ein (gegen Uhrzeigersinn) M05 Spindel aus Beispiele G00 X10.0 Y20.0 Z30.0\nlineare Positionierung mit X, Y und Z Angaben\nG00 X10.5\nlineare Positionierung mit X Angabe (Y, Z Position bleibt gleich)\nG02 I10 J10 X.. Y..\nzirkuläre Positionierung im Uhrzeigersinn mit Angabe des Kreismittelpunktes und des Endpunktes (Punkt am nächsten zu X, Y Position) G03 I10 J10 X.. Y..\nzirkuläre Positionierung gegen Uhrzeigersinn mit Angabe des Kreismittelpunktes und des Endpunktes (Punkt am nähesten zu X, Y Position) G02 R10 X.. Y.. zirkuläre Positionierung im Uhrzeigersinn mit Angabe des Radius und des Endpunktes (positiver Radius verwendet kürzere Kreisbahn, Mittelpunkt wird automatisch bestimmt) G02 R-10 X.. Y.. zirkuläre Positionierung im Uhrzeigersinn mit Angabe des Radius und des Endpunktes (negativer Radius verwendet längere Kreisbahn, Mittelpunkt wird automatisch bestimmt) ","externalUrl":null,"permalink":"/projects/projekt-020-cncfraese/","section":"Projekte","summary":"","title":"CNC Fräse","type":"projects"},{"content":"","externalUrl":null,"permalink":"/code-snippets/csharp/","section":"Code Schnipsel","summary":"","title":"Csharp / C#","type":"code-snippets"},{"content":" CRC Tool Viele Übertragungsprotokolle benutzen den CRC um Übertragungsfehler zu erkennen. Die Grundlagen habe ich in einem Dokument (siehe Anhang) zusammengefasst. Für schnelle Implementierungen befinden sich unter den Code-Schnipseln Beispiel-Implementierungen.\nDas CRC-Tool hilft dabei die eigenen CRC-Funktionen leichter zu überprüfen. Man kann unterschiedliche Generator-Polynome testen und die Implementierung (forward, reverse) auswählen. Des weiteren können für bestimmte Generator-Polynome dessen Look-Up-Tabellen generiert werden.\nRelease Verlauf 1.0.0.0 08.03.2013 Initiale Version mit fixer Berechnungsmethode 1.1.0.0 08.09.2020 Bit/Byte-Umkehr-Möglichkeit, Auswahl der Berechnung 1.1.1.0 16.02.2022 Bug-Fix der Hex-Zahl Konvertierungsfunktion Beispiel CRC Konfigurationen CRC16 Modbus\npolinomial 0xA001 start value 0xFFFF final XOR 0x0000 (=no final XOR) reverse CRC crc for 0x1234 is for example 0xC70C CRC16-CCITT (without preceding zeros)\npolinomial 0x1021 start value 0xFFFF final XOR 0x0000 (=no final XOR) forward CRC crc for 0x1234 is for example 0x0EC9 CRC16-CCITT (with preceding zeros)\npolinomial 0x1021 start value 0xFFFF final XOR 0x0000 (=no final XOR) forward CRC crc for 0x00001234 is for example 0x9706 CRC16-CCITT version 2 (with preceding zeros)\npolinomial 0x1021 start value 0x1D0F final XOR 0x0000 (=no final XOR) forward CRC crc for 0x1234 is for example 0x9706 Downloads CRC Einführung (PDF, 615.42 KB) CRC Tool - Source Dateien (ZIP, 12.39 KB) CRC Tool - Win32 Binary (ZIP, 1.38 MB) ","externalUrl":null,"permalink":"/projects/projekt-021-crc/","section":"Projekte","summary":"","title":"Cyclic Redundancy Code (CRC)","type":"projects"},{"content":" Hardware Zuerst überlegte ich mir die Beschaltung und Pinbelegung und machte mir eine Skizze mit allen Komponenten: Danach musste der Schrittmotor (Canon) durchgemessen werden. Er besitzt 5 Leitungen, das bedeutet dass er einen gemeinsamen Anschluss der 4 Spulen hat. So legte ich nach der Reihe 12V an und schaute zuerst wo sich der Mittelpunkt befindet. Bei diesem Motor war es die schwarze Leitung. Danach musste ich herausfinden in welcher Reihenfolge ich die anderen Leitungen anschließen muss, damit sich der Motor immer in die gleiche Richtung dreht. Bei meinem Schrittmotor ist es Gelb-\u0026gt; Weiß-\u0026gt; Rot-\u0026gt; Braun-\u0026gt; Gelb-\u0026gt; \u0026hellip; .\nNach dem Durchmessen des Schrittmotors werden die benötigten Pins der parallelen Schnittstelle festgelegt. Ich benötigte 4 Pins für die einzelen Spulen des Motors, 2 für die Endtaster und 1en für Masseanschluss. Für den Motor (A, B, C, D) nahm ich die ersten vier Datenregister und für die Taster die ersten zwei Steuerregister. Beim Masseanschluss ist es egal welcher verwendet wird (Bsp. Pin 25).\nAbschliessend kann die Schaltung aufgebaut und getestet werden.\nSoftware Das Programm ist einfach aufgebaut. Für die Programmierung wurde die CVI-Entwicklungsumgebung eingesetzt. Damit können einfache und dennoch attraktive Windows-Applikationen erstellt werden. Zuerst muss man die Benutzeroberfläche erstellen. Es wird ein Start-, Stopbutton, Timer, eine Anzeige und ein Button zum Beenden benötigt. Nach dem generieren des Codes bekommt man eine C-Datei mit den einzelnen Unterprogrammen. Den genauen Aufbau möchte ich hier nicht angeben, da es doch ein bisschen komplexer ist. Im Timer-Unterprogramm steht der eigentliche Programmablauf, im Start-Unterprogramm wird der Timer aktiviert und im Stopp-Unterprogrogramm wird er wieder zurück gesetzt. Im Timer wird je nach Auswahl der Richtung eine Zahlenreihenfolge ausgegeben {1,2,4,8 bzw. 8,4,2,1}. Für die ungefähre Positionsbestimmung wird ein Zähler inkrementiert bzw. dekrementiert. Bei den Endpositionen wird der jeweilige Endschalter betätigt, woraufhin der Schrittmotor gestoppt wird.\nBilder Links Elektronik Versandhaus - RS Components Elektronik Versandhaus - Conrad Downloads Programm - Sourcen (ZIP, 6.42 KB) Package icon Programm - Setup (ZIP, 1.32 MB) ","externalUrl":null,"permalink":"/projects/projekt-001-digicamausrichtung/","section":"Projekte","summary":"","title":"Digicam Ausrichtung","type":"projects"},{"content":"In diesem Bereich finden sie verschiedene Downloads (Dokumente, kleine Bsp. Programme, \u0026hellip;). Sämtliche Inhalte wurden von mir selbst erstellt oder es wurde eine Abmachung mit dem Urheber getroffen, dessen Inhalte anzubieten.\nDokumente - Elektronik Praktikums Bericht - Firma CDE (PDF, 469.22KB) Diplom Arbeit - Simulation, Modellierung und Tests von Antennen für NFC (PDF, 2.03MB) Leitungstheorie (PDF, 261.58KB) Schrittmotor Theorie (PDF, 1.28MB) CPLD Einführung (Xilinx XC9500XL) (PDF, 1.40MB) Mikrokontroller PWM-Ausgang (PDF, 471.62KB) Dokumente - Software Build Management mit Hudson (PDF, 452.65KB) Bildverarbeitung (PDF, 1.81MB) RTOS Einführung (PDF, 449.6KB) Dokumente - Technik Allgemein Planzeiger (Kartenlesen) (PDF, 37.09KB) Bachelor Arbeit - Hidden Markov Modelle (PDF, 674.99KB) Dokumente - English Englisch Grammatik (PDF, 126.16KB) Englisch Zeiten (PDF, 59.85KB) Source Code Komprimierung von Dateien (C++) (ZIP, 14.83KB) AJAX Beispiel 1 (ZIP, 940B) AJAX Beispiel 2 (ZIP, 946B) Website Formular - Autovervollständigung Perl (ZIP, 2.69KB) Website Formular - Autovervollständigung XML (ZIP, 1.62KB) LaserWriter 16600 PS - per Postscript Einstellungen ändern (ZIP, 100KB) Random Number Generator - CmdLine Tool (ZIP, 13.85KB) ","externalUrl":null,"permalink":"/downloads/","section":"Downloads","summary":"","title":"Downloads","type":"downloads"},{"content":" Server-Wechsel Wird z.B. der Web-Hoster gewechselt so muss die Drupal-Website zur Gänze verschoben werden (relocate). Zu Beginn sollte eine Sicherheitskopie von der Website gemacht werden. Der FTP-Ordner kann einfach kopiert und komprimiert (ZIP) werden und die Datenbank wird exportiert (SQL-Export mit ZIP-Komprimierung und utf-8-Kodierung).\nClean URLs deaktivieren (Home \u0026gt; Administer \u0026gt; Site configuration \u0026gt; Clean URLs)\nCaches leeren (Home \u0026gt; Administer \u0026gt; Site configuration \u0026gt; Performance)\nFTP-Ordner kopieren\nDatenbank exportieren (phpMyAdmin \u0026gt; Datenbanken \u0026gt; Datenbank auswählen \u0026gt; Exportieren)\nSQL-Statements mit utf-8-Kodierung Datenbank am Zielserver anlegen (phpMyAdmin \u0026gt; Datenbanken \u0026gt; Anlegen)\nNamen vergeben (z.B. datenbank) utf8_general_ci-Kodierung Benutzer am Zielserver anlegen (phpMyAdmin \u0026gt; Datenbanken \u0026gt; Datenbank auswählen \u0026gt; Rechte \u0026gt; Neuen Benutzer hinzufügen \u0026gt; OK)\nName (z.B. test) Passwort (z.B. test) Host: Lokal keine globalen Rechte gewähre alle Rechte auf Website-Datenbank Benutzer-Rechte ändern (phpMyAdmin \u0026gt; Rechte \u0026gt; Benutzer-Rechte ändern)\nglobal sämtliche Rechte entfernen Rechte für Website-Datenbank: SELECT, INSERT, UPDATE, DELETE, CREATE, ALTER, INDEX, DROP, CREATE TEMPORARY TABLES, LOCK TABLES *.sql-Datei anpassen (exportierte Datenbank-Datei)\n\u0026ldquo;C REATE D ATABASE \u0026lsquo;alteDatenbank\u0026rsquo; \u0026hellip;;\u0026rdquo; entfernen (falls vorhanden) \u0026ldquo;USE \u0026lsquo;alteDatenbank\u0026rsquo;;\u0026rdquo; entfernen (falls vorhanden) Daten in Ziel-Datenbank importieren (phpMyAdmin \u0026gt; Datenbanken \u0026gt; Datenbank auswählen \u0026gt; Importieren)\n*.sql-Datei laden utf-8-Zeichenkodierung Teilweiser Import deaktivieren Kopierte FTP-Daten anpassen (\u0026quot;\u0026hellip;/sites/default/settings.php\u0026quot;)\nneue Datenbank angeben: $db_url = \u0026lsquo;mysqli://test:test@localhost:3306/datenbank\u0026rsquo;; Kopierte FTP-Daten auf neuen Server hochladen\nClean URLs aktivieren (Home \u0026gt; Administer \u0026gt; Site configuration \u0026gt; Clean URLs)\nDrupal Minor-Updates Damit das Content-Management-System sicher und aktuell bleibt, sollten sämtliche Minor-Updates installiert werden. Die Module sollten auch immer auf aktuellem Stand gehalten werden.\nCache leeren, Clean URLs deaktivieren\nDaten kopieren (FTP-Ordner, Datenbank)\nUpdates downloaden (Home \u0026gt; Administer \u0026gt; Reports \u0026gt; Available updates)\nArchive entpacken\nDrupal Core nach \u0026ldquo;\u0026hellip;/tmp/\u0026rdquo; Module nach \u0026ldquo;\u0026hellip;/tmp/modules/\u0026rdquo; Website-Daten kopieren (Cache ist zuvor zu entleeren und Clean URLs zu deaktivieren)\nalte noch benötigte Module kopieren (\u0026quot;\u0026hellip;/websiteKopie/modules/\u0026quot;) altes Theme kopieren (\u0026quot;\u0026hellip;/websiteKopie/themes/\u0026quot;) Inhalt kopieren (\u0026quot;\u0026hellip;/websiteKopie/sites/*\u0026quot; kopieren nach \u0026ldquo;\u0026hellip;/tmp/sites/\u0026rdquo;) Update ohne Anmeldung erlauben\n\u0026ldquo;\u0026hellip;/tmp/sites/default/settings.php\u0026rdquo; \u0026gt; $update_free_access = TRUE; Alte Daten löschen und neue Daten hochladen\nUpdate durchführen\nupdate.php aufrufen (www.domain.at/update.php) Schritt für Schritt durchgehen Update nicht mehr erlauben\n\u0026ldquo;\u0026hellip;/tmp/sites/default/settings.php\u0026rdquo; \u0026gt; $update_free_access = FALSE; settings.php hochladen Drupal Major-Updates Wird Drupal z.B. von 6.x auf 7.x aktualisiert, so muss zuvor das letzt verfügbare 6.x Minor-Update durchgeführt werden, erst danach kann ein Major-Update erfolgen. Bei einem Major-Wechsel muss man immer genau kontrollieren, ob sämtliche verwendeten Module auch in der neueren Major-Version verfügbar sind. Des weiteren muss auch das verwendete Theme für die neue Version verfügbar sein.\nTheme auf ein Default-Theme umstellen (welches auch in der neuen Major-Version verfügbar ist)\nCache leeren, Clean URLs deaktivieren\nDaten kopieren (FTP-Ordner, Datenbank)\nDrupal Core und Module für gewünschte Major-Version herunterladen\nArchive entpacken\nDrupal Core nach \u0026ldquo;\u0026hellip;/tmp/\u0026rdquo; Module nach \u0026ldquo;\u0026hellip;/tmp/modules/\u0026rdquo; Website-Daten kopieren\nInhalt kopieren (\u0026quot;\u0026hellip;/websiteKopie/sites/*\u0026quot; kopieren nach \u0026ldquo;\u0026hellip;/tmp/sites/\u0026rdquo;) Update ohne Anmeldung erlauben\n\u0026ldquo;\u0026hellip;/tmp/sites/default/settings.php\u0026rdquo; \u0026gt; $update_free_access = TRUE; Alte Daten löschen und neue Daten hochladen\nUpdate durchführen\nupdate.php aufrufen (www.domain.at/update.php) Schritt für Schritt durchgehen Update nicht mehr erlauben\n\u0026ldquo;\u0026hellip;/tmp/sites/default/settings.php\u0026rdquo; \u0026gt; $update_free_access = FALSE; settings.php hochladen Update Probleme Datenbank Inkonsistenz Treten während des automatischen Updates Fehler auf, so sind diese oft schwer zu verstehen und vielleicht auch schwierig zu lösen. Der oben dargestellte Fehler (\u0026ldquo;SQLSTATE[23000]: Integrity constraint violation: 1062 Duplicate entry \u0026lsquo;public://FrontView.jpg\u0026rsquo; for key \u0026lsquo;uri\u0026rsquo; \u0026hellip; \u0026ldquo;) entstand z.B. durch einen Upload von zwei fast gleich lautenden Dateien (frontView.jpg und FrontView.jpg). Beim Upload der zweiten Datei wurde die erste gelöscht (damit versucht Drupal einen Konflikt zu umgehen), aber die Datenbank nicht aktualisiert. Somit blieben beide Einträge erhalten. Bei Drupal 6.x war das kein Problem, da der URI Eintrag kein Datenbank-Tabellen-Key war und somit gleich sein konnte. Versucht man aber auf Drupal 7.x zu aktualisieren, so wirft das Update-Script diesen Fehler. Denn bei Drupal 7.x wird der URI-Eintrag auch als Datenbank-Tabellen-Key verwendet.\nDie einzige Möglichkeit diesen Fehler zu beheben ist, dass man die Datenbank-Einträge mit phpMyAdmin selbst bearbeitet und zwei separate Datei-Namen verwendet (z.B. FrontView.jpg und FrontView2.jpg). Dann muss man auch noch im Upload-Ordner diese Dateien zur Verfügung stellen.\nAdmin-Seite nicht mehr verfügbar Da bei dem Server-Wechsel die Clean-Urls (Lesbare Urls) deaktiviert wurden, erreicht man den Admin Bereich nicht mehr über www.domain.at/admin sondern nur mit www.domain.at/?q=admin. Auch bei allen anderen Seiten muss nach dem Slash ?q= eingefügt werden.\nFalls die Clean-Urls am neuen Server nicht aktivierbar sind, könnte der Fehler am fehlenden mod_rewrite Apache-Modul liegen. Zum Aktivieren der Clean-Urls ohne das Admin-Menü zu benutzen können diese Urls verwendet werden:\nDrupal 7: www.domain.at/?q=admin/config/search/clean-urls\nDrupal 6: www.domain.at/?q=admin/settings/clean-urls\nDrupal speichert keine Seiteninhalte mit SQL Statements Falls nach dem Editieren einer Seite die Vorschau bzw. das Speichern nicht funktioniert (die leere Seite wird wieder gelade bzw. die Drupal-Start-Seite wird geladen) könnte das am mod_security Apache-Modul liegen. Dieses Modul ist eine sogenannte Application-Level-Firewall welche die Web-Seiten schützen sollte (z.B. vor SQL Injection).\nError Reporting aktivieren Damit laufende Web-Seiten keine unnötigen Fehlermeldungen anzeigen, werden üblicherweise sämtliche Error-Meldungen deaktiviert. Für Debug-Zwecke ist es aber hilfreich genau diese wieder zu aktivieren. Da man oft keinen Zugang zu der PHP-Konfigurations-Datei hat, kann in der php.ini nichts verändert werden. Für allgemeine Änderungen der PHP-Einstellungen kann man in der \u0026ldquo;\u0026hellip;/sites/default/settings.php\u0026rdquo; die Konfigurations-Werte durch hinzufügen von ini_set(\u0026lsquo;configuration\u0026rsquo;, \u0026lsquo;value\u0026rsquo;); verändern.\nDas Error-Reporting sollte aber bereits in der \u0026ldquo;\u0026hellip;/index.php\u0026rdquo; aktiviert werden. Nach \u0026lt;?php werden folgende Zeilen hinzugefügt:\nerror_reporting(E_ALL);\nini_set(\u0026lsquo;display_errors\u0026rsquo;, TRUE);\nini_set(\u0026lsquo;display_startup_errors\u0026rsquo;, TRUE);\n","externalUrl":null,"permalink":"/projects/projekt-019-drupalcms/","section":"Projekte","summary":"","title":"Drupal CMS","type":"projects"},{"content":" E-Reihen Kennwerte passiver Bauteile RMS Werte Logarithmische Skala 50-Ohm Messungen FET Transistor Überblick LED Multiplexing Leiterplatten Design E-Reihen E-Reihe Toleran Faktor E 6 ±20% sqrt(6, 10^0..5) E 12 ±10% sqrt(12, 10^0..11) E 24 ±5% sqrt(24, 10^0..24) E 48 ±2% sqrt(48, 10^0..47) E 96 ±1% sqrt(96, 10^0..96) E 192 ±0.5% sqrt(192, 10^0..191) Reihe E6 (±20%) 1.0 1.5 2.2 3.3 4.7 6.8 Reihe E12 (±10%) 1.0 1.2 1.5 1.8 2.2 2.7 3.3 3.9 4.7 5.6 6.8 8.2 Reihe E24 (±5%) 1.0 1.1 1.2 1.3 1.5 1.6 1.8 2.0 2.2 2.4 2.7 3.0 3.3 3.6 3.9 4.3 4.7 5.1 5.6 6.2 6.8 7.5 8.2 9.1 Reihe E48 (±2%) 1.00 1.05 1.10 1.15 1.21 1.27 1.33 1.40 1.47 1.54 1.62 1.69 1.78 1.87 1.96 2.05 2.15 2.26 2.37 2.49 2.61 2.74 2.87 3.01 3.16 3.32 3.48 3.65 3.83 4.02 4.22 4.42 4.64 4.87 5.11 5.36 5.62 5.90 6.19 6.49 6.81 7.15 7.50 7.87 8.25 8.66 9.09 9.53 Reihe E96 (±1%) 1.00 1.02 1.05 1.07 1.10 1.13 1.15 1.18 1.21 1.24 1.27 1.30 1.33 1.37 1.40 1.43 1.47 1.50 1.54 1.58 1.62 1.65 1.69 1.74 1.78 1.82 1.87 1.91 1.96 2.00 2.05 2.10 2.15 2.21 2.26 2.32 2.37 2.43 2.49 2.55 2.61 2.67 2.74 2.80 2.87 2.94 3.01 3.09 3.16 3.24 3.32 3.40 3.48 3.57 3.65 3.74 3.83 3.92 4.02 4.12 4.22 4.32 4.42 4.53 4.64 4.75 4.87 4.99 5.11 5.23 5.36 5.49 5.62 5.76 5.90 6.04 6.19 6.34 6.49 6.65 6.81 6.98 7.15 7.32 7.50 7.68 7.87 8.06 8.25 8.45 8.66 8.87 9.09 9.31 9.53 9.76 Reihe E192 (±0.5%) 1.00 1.01 1.02 1.04 1.05 1.06 1.07 1.09 1.10 1.11 1.13 1.14 1.15 1.17 1.18 1.20 1.21 1.23 1.24 1.26 1.27 1.29 1.30 1.32 1.33 1.35 1.37 1.38 1.40 1.42 1.43 1.45 1.47 1.49 1.50 1.52 1.54 1.56 1.58 1.60 1.62 1.64 1.65 1.67 1.69 1.72 1.74 1.76 1.78 1.80 1.82 1.84 1.87 1.89 1.91 1.93 1.96 1.98 2.00 2.03 2.05 2.08 2.10 2.13 2.15 2.18 2.21 2.23 2.26 2.29 2.32 2.34 2.37 2.40 2.43 2.46 2.49 2.52 2.55 2.58 2.61 2.64 2.67 2.71 2.74 2.77 2.80 2.84 2.87 2.91 2.94 2.98 3.01 3.05 3.09 3.12 3.16 3.20 3.24 3.28 3.32 3.36 3.40 3.44 3.48 3.52 3.57 3.61 3.65 3.70 3.74 3.79 3.83 3.88 3.92 3.97 4.02 4.07 4.12 4.17 4.22 4.27 4.32 4.37 4.42 4.48 4.53 4.59 4.64 4.70 4.75 4.81 4.87 4.93 4.99 5.05 5.11 5.17 5.23 5.30 5.36 5.42 5.49 5.56 5.62 5.69 5.76 5.83 5.90 5.97 6.04 6.12 6.19 6.26 6.34 6.42 6.49 6.57 6.65 6.73 6.81 6.90 6.98 7.06 7.15 7.23 7.32 7.41 7.50 7.59 7.68 7.77 7.87 7.96 8.06 8.16 8.25 8.35 8.45 8.56 8.66 8.76 8.87 8.98 9.09 9.20 9.31 9.42 9.53 9.65 9.76 9.88 Kennwerte passiver Bauteile Widerstände Bauform Verlustleistung [W] Nennspannung [V] 0402 0.0625 / 0.063 / 0.1 25 / 50 0603 0.063 / 0.1 / 0.2 50 / 75 / 150 0805 0.1 / 0.125 / 0.25 / 0.5 100 / 150 / 400 1206 0.125 / 0.25 / 0.66 200 / 500 X7R Kondensatoren Bauform Wert [F] Nennspannung [V] 0402 100p - 100n 10 - 50 0603 100p - 2.2u 6.3 - 200 0805 100p - 10u 6.3 - 500 1206 150p - 22u 6.3 - 1000 C0G / NP0 Kondensatoren Bauform Wert [F] Nennspannung [V] 0402 1p - 1n 10 - 200 0603 1p - 10n 10 - 250 0805 1p - 22n 10 - 500 1206 2.2p - 100n 25 - 1000 Gebräuchliche Zenerspannungen [V] 1.8 2.0 2.4 2.7 3.0 3.3 3.6 3.9 4.3 4.7 5.1 5.6 6.2 6.8 7.5 8.2 9.1 10 11 12 13 14 15 16 18 20 22 24 27 30 33 36 39 43 47 51 56 62 68 75 100 150 200 RMS Werte Ein komplexeres Signal mit einem bestimmten RMS-Wert (Root Mean Square) oder Effektiv-Wert erzeugt die gleiche Erwärmung in einem Leiter als ein gleich großes konstantes Signal mit einem bestimmten DC-Wert. Anders ausgedrückt ist der Effektiv-Wert eines veränderlichen Signals gleich groß mit dem Wert eines konstanten Signal, wo die gleiche elektrische Energie an einem ohmschen Verbraucher umgesetzt wird.\nLogarithmische Skala Bei einer logarithmischen Skala werden die Werte logarithmiert aufgetragen. Somit können Werte, welche sich über mehrere Zehner-Potenzen erstrecken, dargestellt werden. Viele Datenblätter von elektronischen Bauteilen enthalten Kurven mit logarthimscher Darstellung (z.B. Strom-Spannungs-Kurve von Varistoren).\nUnterhalb finden sie eine Darstellung der wichtigsten Werte. Somit findet man sich bei logarithmischen Kurven besser zurecht. Bei noch genaueren Betrachtungen können die unteren Berechnungsmethoden verwendet werden.\nFalls in einer Kurve ein Wert markiert oder eingetragen werden soll, muss der Wert zuerst logarithmiert (Logarithmus zu Basis 10) und im Anschluss auf die tatsächlichen Abmessungen umgerechnet werden. Beim Ablesen geht man umgekehrt vor. Zuerst wird die abgelesene Abmessung normiert und danach wird die Umkehrfunktion des Logarithmus für die Berechnung des Wertes verwendet. 50-Ohm Messungen 50-Ohm Messungen bis in den MHz-Bereich können einfach mit Hilfe von BNC T-Steckern durchgeführt werden. Die Abzweigleitung, zum hochohmigen Oszilloskop, sollte möglichst kurz gehalten werden, damit die Reflexionen möglichst gering ausfallen.\nEin 50-Ohm Abschluss am Oszilloskop bewirkt leider nicht den gewünschten Effekt. Da die beiden Widerstände, der Widerstand des zu testenden Gerätes (Device Under Test) und der Widerstand des Oszilloskopes, parallel liegen erhält man einen Summen-Widerstand von 25-Ohm.\nFalls die zu messenden Signale höhere Frequenzen enthalten bzw. die hochohmig abgeschlossene Stichleitung zu lang wird, sollte man einen HF-Splitter verwenden (+ 50-Ohm Abschluss am Oszilloskop). Dadurch sind sämtliche Abgänge 50-Ohm angepasst und es treten keine Reflexionen auf. Eine mögliche Ausprägung eines HF-Splitters sehen sie unterhalb. Dennoch muss man beachten, dass diese Splitter das Signal dämpfen. Die Dämpfung ist üblicherweise angegeben.\nFET Transistor Überblick JFET Typen sind selbstleitend und sperren in beiden Richtungen, wenn sie angesteuert werden. MOSFET Typen gibt es selbstleitend und auch selbstsperrend. Die Sperreigenschaft ist nur in einer Richtung gegeben. In der anderen Richtung wird die Diodenstrecke des internen Aufbaues leitend.\nJFET (depletion) MOSFET - depletion MOSFET - enhanced N P Die Simulation unterhalb wiederspiegelt das Verhalten der unterschiedlichen FET Typen. Im ersten Zeitabschnitt werden die Gates der Transistoren nicht angesprochen. Im zweiten Abschnitt werden sie mit einem positiven oder negativen Puls angesprochen.\nLED Multiplexing Bei vielen Elektronikprojekten ist die Anzahl der IO-Pins limitiert bzw. sind die Pins bereits durch andere Funktionen belegt. Daher werden Pins mit einfachen Ansteueraufgaben gerne mehrfach genutzt - gemultiplext. LED Multiplexing ist prinzipiell sehr einfach, kann im Detail aber dennoch herausfordernd werden. Das Multiplexing muss in Hardware und auch in Software berücksichtigt werden. Beispiele der Hardware-Lösungen sind unterhalb abgebildet. Die Software muss je nach HW-Lösung die Pins zeitversetzt ansprechen und schnell genug umschalten, damit der Benutzer von dem Ein-/Ausschalten nichts mitbekommt.\nBei dieser Konfiguration sollte die IO-Spannung und Versorgungsspannung deutlich größer als die Vorwärtsspannung der Diode sein. Somit lässt sich der LED Strom über den Widerstand einstellen. Die obere LED leuchtet bei einem High-Signal, die untere bei einem Low-Signal. Ist der Pin Hochohmig als Eingang konfiguriert, so sind beide LEDs dunkel. Ein sehr großer Nachteil bei dieser Schaltung ist der ständig fließende Strom durch die beiden Widerstände.\nBei dieser Konfiguration sollte die Spannung VCC deutlich kleiner als die beiden Vorwärtsspannungen der LEDs sein. Andernfalls leuchten die LEDs bereits ohne entsprechender Ansteurung durch den IO-Pin. Die LEDs beginnen bereits bei sehr kleinen Strömen leicht zu leuchten. Da die Vorwärtsspannung bei unterschiedlichen Dioden bzw. bereits bei gleichen Dioden von unterschiedlichen Chargen stark schwankt, lässt sich der Widerstand sehr schwierig dimensionieren. Für einzelne Testaufbauten und Prototypen wäre es noch sinnvoll diese Schaltung zu verwenden. Bei Serienprodukten sollte man diese Schaltung eher nicht verweden.\nDiese Schaltung ermöglicht den Betrieb bei mittleren Versorgungsspannungen. Sie sollte etwas höher als die beiden Vorwärtsspannungen der LEDs sein und niedrig genug, damit die LEDs im Aus-Zustand nicht leuchten. Da für beide LEDs ein separater Widerstand verwendet wird, können sich die Vorwärtsspannungen der LEDs unterscheiden.\nDiese etwas abgewandelte Charlieplexing Schaltung ermöglicht zuverlässige Zustände und doch mehrere LEDs an den IO Pins. Mit einem High Signal an Pin 1 kann man die gewünschten LEDs der ersten Spalte einschalten. Mit einem High an Pin 2 die LEDs der zweiten Spalte usw. Durch diesen geringfügig höheren Komponentenaufwand erhält man eine zuverlässige und einfache Lösung. Im Aus-Zustand fließt auch kein unnötiger Strom.\nLeiterplatten Design Beim Leiterplatten Design gibt es sehr viele Parameter zu beachten. Für einfache Prototypen bzw. Einzelstückanfertigungen für Zuhause, reichen die unterhalb aufgelisteten Parameter meistens aus.\nFür einfache Prototypen reicht meistens eine doppelseitige Platine aus. Hier wäre es am besten, eine Seite als Ground-Fläche auszuführen und die andere Seite für Signal- und Versorgungsleitungen zu verwenden. Die Ground-Fläche sollte sehr selten und möglichst klein/kurz unterbrochen werden. Ist es dennoch nicht anders möglich und es entsteht ein längerer Schlitz, dann sollten die beiden anliegenden Ground-Flächen über Vias und Verbindungen auf der Oberseite verbunden werden. Somit erreicht man möglichst kurze Ground-Rückpfade. Um mögliches Übersprechen von Signalleitungen zu vermeiden, sollten die Signalleitungen auseinander gelegt werden. Bei den Chip-Versorgungspins sollten die Entkoppel-Kondensatoren möglichst nahe platziert werden, um die Schleifen-Induktiviät klein zu halten. Der Kondensator sollte genügend groß gewählt werden, um die Strom-Peaks bedienen zu können (Q=CU=It). Hier reicht es meistens aus, die Beispiel-Beschaltung aus den Datenblättern zu verwenden. Werden Signale über Steckverbindungen geleitet, so sollte es ausreichend Rückpfade für den Ground geben. Ideal wäre es für jeden Signal-Pin auch einen Ground-Pin vorzusehen. Somit wird verhindert, dass der Ground-Pegel bei Strom-Peaks in die Höhe geht (Ground-Bouncing).\nBei Platinen mit Netzspannung bzw. Spannungen über 50VRMS sollten bei den Abständen die minimalen Luft- und Kriechstrecken laut DIN EN 60664 beachtet werden. Bei Spannungen kleiner gleich 50V ist die Mindestkriechstrecke 0,04mm ohne Lackierung und 0,025mm mit Lötstopplack. Die min. Luftstrecke ist bei Spannungen unter 50V nicht mehr ausschlaggebend.\nParameter Wert Bemerkung gängige Leiterbahnbreiten 0,25 / 0,5 / 1 / 2mm 0,254 / 0,508 / 1,27 / 2,54mm bei Zoll (Inch) als Basis Signalleitungen bei Prototypen 0,5mm Versorgungsleitungen bei Prototypen 1mm Durchkontaktierung (Via) für Versorgungsleitungen 1mm / 0,8mm Pad / Bohrung Durchkontaktierung (Via) für Signalleitungen 1 od. 0,8mm / 0,6mm Pad / Bohrung Durchkontaktierung (Via) für Flächen (z.B. GND) 1mm / 0,8mm Pad / Bohrung Flächen - Abstände zu Bauteilen, Leiterbahnen, \u0026hellip; 0,25 / 0,5mm Flächen - minimale Breite 0,25mm Wärmeentkoppelte Anbindung zu Flächen - Abstand 0,5mm Wärmeentkoppelte Anbindung zu Flächen - Leiterbahnbreite 0,5mm Bauteilgrößen bei Handlötung 0603 / 0805 \u0026hellip; R, L und C SOIC / DIP \u0026hellip; ICs SOD123 Dioden 2,54mm Stiftleisten Die generellen Anforderungen an die Produzierbarkeit hängt maßgeblich vom Leiterplatten-Hersteller ab. Auf den Hersteller Websiten findet man oft die Standard-Anforderungen übersichtlich aufgelistet. Die aufgelisteten Anforderungen unterhalb sollten weitestgehend von sämtlichen Herstellern produzierbar sein.\nParameter Wert Bemerkung Min. Leiterbahnbreite, -abstände, Restring 150 / 200um für 35um / 70um Kupfer Kleinste Bohrung 200um für Vias \u0026hellip; Min. Abstand Leiterb., Pad zu Via 250um Min. Abstand Leiterb., Pad zu Printkante 500um Min. Lötstopp Freistellung 50um Min. Lötstopp Stegbreite 100um Min. Lötstopp Abdeckung 100um Endkupferstärke außen 35 / 70um Endkupferstärke innen 18 / 70um Material FR4 Printstärke 0,8 / 1 / 1,2 / 1,55mm Max. Printgröße 100 x 160mm gängigste Europakarte Lagen 1 / 2 / 4 / 6 Lötstopp ein- / doppelseitig, grün Positionsdruck ohne / ein- / doppelseitig Im europäischen Raum gibt es mehrere PCB Hersteller. Eine kleine Übersicht mit Links zu den Hersteller-Websiten findet ihr unterhalb. Der letzte aufgelistete Hersteller ist aus dem asiatischem Raum.\nHersteller Website multi-cb Leiterplatten https://www.multi-circuit-boards.eu günstige Prototypen, Einzelanfertigungen für Zuhause AISLER https://aisler.net günstige Prototypen, Einzelanfertigungen für Zuhause PIU Printex https://piumail.piu-printex.at hochwertige Prototypen, Kleinserien KSG https://www.ksg-pcb.com hochwertige Serienprints AT\u0026amp;S https://ats.net hochwertige/günstigere Serienprints JLCPCB https://jlcpcb.com günstige Leiterplatten mit teils langen Lieferzeiten Links Seven Habits of Successful 2-layer Board Designers | Signal Integrity Journal The Myth of Three Capacitor Values | Signal Integrity Journal ","externalUrl":null,"permalink":"/projects/projekt-024-elektronikueberblick/","section":"Projekte","summary":"","title":"Elektronik Überblick","type":"projects"},{"content":" Software Bei diesem Projekt geht es um die Implementierung von Tetris für embedded Windows Devices. Für die Implementierung wurde C-sharp herangezogen, deshalb ist es notwendig das .NET Framework am Zielrechner zu installieren. Nähere Informationen finden sie in der Report Datei unter den Downloads.\nBilder Links Microsoft .NET Framework Downloads Report Dokument (348.33 KB) Source Dateien (39.89 KB) Binary Dateien (WinCE) (19.89 KB) Binary Dateien (WinXP) (21.02 KB) ","externalUrl":null,"permalink":"/projects/projekt-012-etetris/","section":"Projekte","summary":"","title":"embedded Tetris / eTetris","type":"projects"},{"content":" ESP32 Webradio Die Entwicklung eines einfachen Internetradios ist mit Hilfe eines ESP32 Audiokit Boards sehr einfach. Das Board enthält bereits sämtliche Komponenten, die für das Verbinden ins Internet (ESP32 WiFi Modul) und das Ausgeben der Audio-Signale benötigt werden (DAC, Audiobuchsen bzw. Verstärker für direkte Lautsprecherausgabe). Somit ist nur noch die Software notwendig. Hier werden bereits sämtliche SW-Komponenten durch Libraries abgedeckt. Somit beschränkt sich die Programmierung nur auf die generelle Ablaufsteuerung (LED ansteuern, Taster auswerten, WiFi Verbindung starten, Audiostream abspielen \u0026hellip;). Die Liste unterhalb enthält eine Schritt-für-Schritt Anleitung für das Projekt. Weiter unterhalb befindet sich der Source Code.\nDie ESP Softwareentwicklung startet man mit dem Download der Arduino IDE (bei mir war Version 2.1.0 aktuell). Danach muss der Board Manager um die ESP32 Boards erweitert werden. Unter \u0026ldquo;File \u0026gt; Preferences \u0026gt; Additional boards manager URLs\u0026rdquo; muss folgende URL eingetragen werden https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json. Danach kann man die EPS32 im Boards Manager installieren: \u0026ldquo;Tools \u0026gt; Board \u0026gt; Boards Manager \u0026gt; esp32 by Espressif \u0026gt; Install\u0026rdquo;. Für die serielle Verbindung zum Board wird noch der Silab USB UART Chip Treiber (CP210x Universal Windows Driver) benötigt. Beim ESP32 Audiokit Board wird zuerst die USB Schnittstelle für die Versorgung und danach erst die USB Schnittstelle der seriellen Schnittstelle angeschlossen. Innerhalb der Arduino IDE kann man das Board und die COM-Verbindung auswählen: \u0026ldquo;Tools \u0026gt; Board \u0026gt; esp \u0026gt; ESP32 Wrover Module, COM3\u0026rdquo;. Danach kann ein Projekt angelegt oder geöffnet werden (Projektordner und \u0026ldquo;Main\u0026rdquo;-Datei müssen gleich lauten, z.B. ./webradio/webradio.ino). Damit die benötigten Libraries gefunden werden werden sie mittels Library Manager installiert: \u0026ldquo;Sketch \u0026gt; Include Library \u0026gt; Library Manager\u0026rdquo;. Heruntergeladene ZIP Dateien können mittels separaten Menüpunkt installiert werden: \u0026ldquo;Sketch \u0026gt; Include Library \u0026gt; Add .ZIP Library\u0026rdquo;. Für das Webradio Projekt wurden folgende Libraries benötigt: ESP32-audioI2S-master.zip und es8388-main.zip. Nach dem Programmieren wird das Projekt einfach Compiliert \u0026ldquo;Sketch \u0026gt; Verify/Compile\u0026rdquo; und auf das Board gespielt \u0026ldquo;Sketch \u0026gt; Upload\u0026rdquo;. Die Debug Ausgabe kann im \u0026ldquo;Serial Monitor\u0026rdquo; Fenster angesehen werden. 1/* USED LIBRARIES 2 ESP32-audioI2S library - https://github.com/schreibfaul1/ESP32-audioI2S 3 ES8388 library - https://github.com/maditnerd/es8388 4*/ 5 6/* IDE BOARD SETTINGS 7 Arduino Board Settings: ESP32 WROVER Module 8 Port: COMx 9 Core Debug Level: None 10 Erase All Flash Before Sketch Upload: Disabled 11 Flash Frequency: 80MHz 12 Flash Mode: QIO 13 Partition Scheme: Huge APP (3MB No OTA/1MB SPIFFS) 14 Upload Speed: 921600 15 Programmer: Esptool 16*/ 17 18/* BOARD SETTINGS 19 Settings for ESP32-A1S v2.2 (ES8388) 20 Switch 2, 3 ON 21 1, 4, 5 OFF 22*/ 23 24// INCLUDES 25#include \u0026#34;Arduino.h\u0026#34; 26#include \u0026#34;WiFi.h\u0026#34; 27#include \u0026#34;Audio.h\u0026#34; 28#include \u0026#34;ES8388.h\u0026#34; 29#include \u0026#34;SPI.h\u0026#34; 30#include \u0026#34;SD.h\u0026#34; 31#include \u0026#34;FS.h\u0026#34; 32#include \u0026#34;CSV_Parser.h\u0026#34; 33 34 35// DEFINES 36// SD card SPI pins 37#define SD_CS 13 38#define SPI_MOSI 15 39#define SPI_MISO 2 40#define SPI_SCK 14 41 42// Power amplifier pins 43#define PA_EN 21 // low = enabled, high = disabled 44 45// DAC pins 46#define I2S_DSIN 26 47#define I2S_BCLK 27 48#define I2S_LRC 25 49#define I2S_MCLK 0 50#define I2S_DOUT 35 51 52#define IIC_CLK 32 53#define IIC_DATA 33 54 55// Button pins 56#define BTN_VOLUME_DOWN_PIN 19 // key 3 57#define BTN_VOLUME_UP_PIN 23 // key 4 58#define BTN_STATION_PREV_PIN 18 // key 5 59#define BTN_STATION_NEXT_PIN 5 // key 6 60 61#define BTN_DEBOUNCE_CNT 10 62 63// LED pins 64#define LED_WIFI_PIN 22 // LED 4 65#define LED_RADIO_PIN 22 // LED 4 66 67// Station list size 68#define STATIONS_DEFAULT 5 // size of default station list 69#define STATIONS_MAX 100 // max. stored stations 70 71// Volume step count 72#define VOLUME_STEPS 21 73 74// WiFi connection tries 75#define WIFI_CONNECTION_TRIES 10 76 77 78// GLOBAL VARIABLES 79static ES8388 dac; 80Audio audio; 81 82const char* ssid_file = \u0026#34;/ssid.txt\u0026#34;; // Configuration files 83const char* pwd_file = \u0026#34;/password.txt\u0026#34;; 84const char* ssid2_file = \u0026#34;/ssid2.txt\u0026#34;; 85const char* pwd2_file = \u0026#34;/password2.txt\u0026#34;; 86const char* stations_file = \u0026#34;/stations.csv\u0026#34;; 87 88String ssid = \u0026#34;wifi\u0026#34;; // Default WIFI settings 89String password = \u0026#34;123456789\u0026#34;; 90String ssid2 = \u0026#34;wlan\u0026#34;; 91String password2 = \u0026#34;password\u0026#34;; 92 93uint8_t btn_volume_down_cnt = 0; // Button debouncing counters 94uint8_t btn_volume_up_cnt = 0; 95uint8_t btn_station_prev_cnt = 0; 96uint8_t btn_station_next_cnt = 0; 97 98uint8_t connectionCnt = 0; // Connection trys counter 99uint8_t stationCnt = 0; // How many stations are available 100uint8_t stationNumber = 0; // Which station is currently used 101 102String stationUrls[STATIONS_MAX]; // Available radio stations 103String stationNames[STATIONS_MAX]; 104 105//const char* stationUrls[STATIONS] = { 106// Default radio station list 107const String stationUrls_default[STATIONS_DEFAULT] = { 108 \u0026#34;http://ors-sn05.ors-shoutcast.at/oe3-q1a\u0026#34;, 109 \u0026#34;http://ors-sn05.ors-shoutcast.at/oe1-q1a\u0026#34;, 110 \u0026#34;http://ors-sn05.ors-shoutcast.at/fm4-q1a\u0026#34;, 111 \u0026#34;http://ors-sn05.ors-shoutcast.at/noe-q1a\u0026#34;, 112 \u0026#34;http://ors-sn05.ors-shoutcast.at/wie-q1a\u0026#34; 113}; 114 115const String stationNames_default[STATIONS_DEFAULT] = { 116 \u0026#34;OE3\u0026#34;, 117 \u0026#34;OE1\u0026#34;, 118 \u0026#34;FM4\u0026#34;, 119 \u0026#34;Radio NOE\u0026#34;, 120 \u0026#34;Radio Wien\u0026#34; 121}; 122 123 124// FUNCTIONS 125// Read complete content of a file into a string 126bool readFile(fs::FS \u0026amp;fs, const char * path, String \u0026amp;content) { 127 File file = fs.open(path); 128 if(!file) { 129 Serial.printf(\u0026#34;\\n\u0026#34;); 130 Serial.printf(\u0026#34;File %s not found.\u0026#34;, path); 131 return false; 132 } 133 134 content = \u0026#34;\u0026#34;; 135 while(file.available()) { 136 content += char(file.read()); 137 } 138 139 file.close(); 140 return true; 141} 142 143// Read comma separated values from a file with 2 columns 144bool readCSV(const char * path, String column1[], String column2[], uint8_t \u0026amp;rows, uint8_t rows_max) { 145 uint8_t row = 0; 146 147 148 CSV_Parser cp(\u0026#34;ss\u0026#34;, false, \u0026#39;,\u0026#39;); // \u0026#34;string,string\u0026#34; with no header 149 if(!cp.readSDfile(path)) { 150 Serial.printf(\u0026#34;\\n\u0026#34;); 151 Serial.printf(\u0026#34;File %s not found.\u0026#34;, path); 152 return false; 153 } 154 155 // Debug output 156 //cp.print(); 157 158 rows = cp.getRowsCount(); 159 if (rows \u0026gt; rows_max) { 160 rows = rows_max; 161 } 162 163 for(row = 0; row \u0026lt; rows; row++) { 164 column1[row] = ((char **)(cp[0]))[row]; 165 column2[row] = ((char **)(cp[1]))[row]; 166 } 167 168 return true; 169} 170 171 172void setup() { 173 // Initialize debug terminal interface 174 Serial.begin(115200); 175 Serial.printf(\u0026#34;\\n\\n\u0026#34;); 176 Serial.printf(\u0026#34;ESP32 WIFI radio started.\u0026#34;); 177 178 179 // Initialize pins 180 digitalWrite(SD_CS, LOW); // Deselect SD card 181 pinMode(SD_CS, OUTPUT); 182 183 digitalWrite(PA_EN, HIGH); // Disable power amplifier 184 pinMode(PA_EN, OUTPUT); 185 186 digitalWrite(LED_WIFI_PIN, HIGH); // Disable LEDs 187 digitalWrite(LED_RADIO_PIN, HIGH); 188 pinMode(LED_WIFI_PIN, OUTPUT); 189 pinMode(LED_RADIO_PIN, OUTPUT); 190 191 pinMode(BTN_VOLUME_DOWN_PIN, INPUT_PULLUP); // Button pins used as input pins 192 pinMode(BTN_VOLUME_UP_PIN, INPUT_PULLUP); 193 pinMode(BTN_STATION_PREV_PIN, INPUT_PULLUP); 194 pinMode(BTN_STATION_NEXT_PIN, INPUT_PULLUP); 195 196 197 // Initialize SD card and read configuration 198 digitalWrite(SD_CS, HIGH); 199 SPI.begin(SPI_SCK, SPI_MISO, SPI_MOSI); 200 if(SD.begin(SD_CS)) { 201 String tmp_ssid; 202 String tmp_pwd; 203 204 if((readFile(SD, ssid_file, tmp_ssid)) \u0026amp;\u0026amp; 205 (readFile(SD, pwd_file, tmp_pwd))) { 206 ssid = tmp_ssid; 207 password = tmp_pwd; 208 209 Serial.printf(\u0026#34;\\n\u0026#34;); 210 Serial.printf(\u0026#34;Primary WIFI configuration loaded.\u0026#34;); 211 } else { 212 Serial.printf(\u0026#34;\\n\u0026#34;); 213 Serial.printf(\u0026#34;Use default primary WIFI configuration.\u0026#34;); 214 } 215 216 if((readFile(SD, ssid2_file, tmp_ssid)) \u0026amp;\u0026amp; 217 (readFile(SD, pwd2_file, tmp_pwd))) { 218 ssid2 = tmp_ssid; 219 password2 = tmp_pwd; 220 221 Serial.printf(\u0026#34;\\n\u0026#34;); 222 Serial.printf(\u0026#34;Backup WIFI configuration loaded.\u0026#34;); 223 } else { 224 Serial.printf(\u0026#34;\\n\u0026#34;); 225 Serial.printf(\u0026#34;Use default backup WIFI configuration.\u0026#34;); 226 } 227 228 if(readCSV(stations_file, stationNames, stationUrls, stationCnt, STATIONS_MAX)) { 229 Serial.printf(\u0026#34;\\n\u0026#34;); 230 Serial.printf(\u0026#34;Radio station list loaded.\u0026#34;); 231 Serial.printf(\u0026#34;\\n\u0026#34;); 232 Serial.printf(\u0026#34;Station count: %d\u0026#34;, stationCnt); 233 } else { 234 for (uint8_t i=0; i\u0026lt;STATIONS_DEFAULT; i++) { 235 stationUrls[i] = stationUrls_default[i]; 236 stationNames[i] = stationNames_default[i]; 237 stationCnt++; 238 } 239 } 240 } 241 else { 242 for (uint8_t i=0; i\u0026lt;STATIONS_DEFAULT; i++) { 243 stationUrls[i] = stationUrls_default[i]; 244 stationNames[i] = stationNames_default[i]; 245 stationCnt++; 246 } 247 248 Serial.printf(\u0026#34;\\n\u0026#34;); 249 Serial.printf(\u0026#34;Default WIFI and radio stations used.\u0026#34;); 250 } 251 252 253 // Initialize WIFI 254 // Set station mode 255 WiFi.disconnect(); 256 WiFi.mode(WIFI_STA); 257 258 // Connect to first WIFI network 259 WiFi.begin(ssid.c_str(), password.c_str()); 260 Serial.printf(\u0026#34;\\n\u0026#34;); 261 Serial.print(\u0026#34;Connecting \u0026#34;); 262 do { 263 connectionCnt++; 264 Serial.print(\u0026#34;.\u0026#34;); 265 delay(500); 266 } 267 while ((WiFi.status() != WL_CONNECTED) \u0026amp;\u0026amp; 268 (connectionCnt \u0026lt; WIFI_CONNECTION_TRIES)); 269 270 if (WiFi.status() == WL_CONNECTED) { 271 Serial.printf(\u0026#34;\\n\u0026#34;); 272 Serial.printf(\u0026#34;Connected WiFi: %s\\n\u0026#34;, ssid); 273 274 digitalWrite(LED_WIFI_PIN, LOW); 275 } 276 // In case of connection failures, connect to second WIFI 277 else { 278 connectionCnt = 0; 279 WiFi.disconnect(); 280 WiFi.begin(ssid2.c_str(), password2.c_str()); 281 282 do { 283 connectionCnt++; 284 Serial.print(\u0026#34;.\u0026#34;); 285 delay(500); 286 } 287 while ((WiFi.status() != WL_CONNECTED) \u0026amp;\u0026amp; 288 (connectionCnt \u0026lt; WIFI_CONNECTION_TRIES)); 289 290 if (WiFi.status() == WL_CONNECTED) { 291 Serial.printf(\u0026#34;\\n\u0026#34;); 292 Serial.printf(\u0026#34;Connected WiFi: %s\\n\u0026#34;, ssid2); 293 digitalWrite(LED_WIFI_PIN, LOW); 294 } 295 else { 296 ESP.restart(); 297 } 298 } 299 300 Serial.print(\u0026#34;IP-Address: \u0026#34;); 301 Serial.println(WiFi.localIP()); 302 303 delay(2000); 304 digitalWrite(LED_RADIO_PIN, HIGH); 305 while (!dac.begin(IIC_DATA, IIC_CLK)) { 306 Serial.println(\u0026#34;DAC connection failure!\u0026#34;); 307 delay(1000); 308 } 309 audio.i2s_mclk_pin_select(I2S_MCLK); 310 audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DSIN); 311 audio.setVolumeSteps(VOLUME_STEPS); 312 audio.setVolume((VOLUME_STEPS\u0026gt;\u0026gt;1) + (VOLUME_STEPS\u0026gt;\u0026gt;2)); 313 Serial.printf(\u0026#34;Volume [0-%d]: %d\\n\u0026#34;, VOLUME_STEPS-1, audio.getVolume()); 314 //audio.setTone(low, middle, high); 315 audio.connecttohost(stationUrls[stationNumber].c_str()); 316 Serial.printf(\u0026#34;Active station: %s\\n\u0026#34;, stationNames[stationNumber]); 317 digitalWrite(LED_RADIO_PIN, LOW); 318} 319 320void loop() 321{ 322 // Run audio player 323 audio.loop(); 324 325 // UI handling 326 if (LOW == digitalRead(BTN_VOLUME_DOWN_PIN)) { 327 btn_volume_down_cnt++; 328 329 if (btn_volume_down_cnt \u0026gt;= BTN_DEBOUNCE_CNT) { 330 btn_volume_down_cnt = 0; 331 332 uint8_t vol = audio.getVolume(); 333 if (vol \u0026gt; 0) { 334 vol--; 335 } 336 audio.setVolume(vol); 337 Serial.printf(\u0026#34;Volume [0-%d]: %d\\n\u0026#34;, VOLUME_STEPS-1, vol); 338 } 339 } 340 else { 341 btn_volume_down_cnt = 0; 342 } 343 344 345 if (LOW == digitalRead(BTN_VOLUME_UP_PIN)) { 346 btn_volume_up_cnt++; 347 348 if (btn_volume_up_cnt \u0026gt;= BTN_DEBOUNCE_CNT) { 349 btn_volume_up_cnt = 0; 350 351 uint8_t vol = audio.getVolume(); 352 if (vol \u0026lt; (VOLUME_STEPS-1)) { 353 vol++; 354 } 355 audio.setVolume(vol); 356 Serial.printf(\u0026#34;Volume [0-%d]: %d\\n\u0026#34;, VOLUME_STEPS-1, vol); 357 } 358 } 359 else { 360 btn_volume_up_cnt = 0; 361 } 362 363 364 if (LOW == digitalRead(BTN_STATION_PREV_PIN)) { 365 btn_station_prev_cnt++; 366 367 if (btn_station_prev_cnt \u0026gt;= BTN_DEBOUNCE_CNT) { 368 btn_station_prev_cnt = 0; 369 delay(500); 370 371 if (stationNumber \u0026gt; 0) { 372 stationNumber--; 373 } 374 else { 375 stationNumber = stationCnt-1; 376 } 377 audio.connecttohost(stationUrls[stationNumber].c_str()); 378 Serial.printf(\u0026#34;Active station: %s (nr. %d from %d)\\n\u0026#34;, 379 stationNames[stationNumber].c_str(), 380 stationNumber+1, stationCnt); 381 } 382 } 383 else { 384 btn_station_prev_cnt = 0; 385 } 386 387 388 if (LOW == digitalRead(BTN_STATION_NEXT_PIN)) { 389 btn_station_next_cnt++; 390 391 if (btn_station_next_cnt \u0026gt;= BTN_DEBOUNCE_CNT) { 392 btn_station_next_cnt = 0; 393 delay(500); 394 395 if (stationNumber \u0026lt; (stationCnt-1)) { 396 stationNumber++; 397 } 398 else { 399 stationNumber = 0; 400 } 401 audio.connecttohost(stationUrls[stationNumber].c_str()); 402 Serial.printf(\u0026#34;Active station: %s (nr. %d from %d)\\n\u0026#34;, 403 stationNames[stationNumber].c_str(), 404 stationNumber+1, stationCnt); 405 } 406 } 407 else { 408 btn_station_next_cnt = 0; 409 } 410} ","externalUrl":null,"permalink":"/projects/projekt-033-esp32/","section":"Projekte","summary":"","title":"ESP32","type":"projects"},{"content":" Hardware Die Schaltung ist schnell aufgebaut und stellt keine großen Löterfahrungen voraus. Damit manche Komponenten (OPV, Temperatur Sensor) leichter ausgetauscht werden können, bzw. damit sie beim Einlöten nicht beschädigt werden, werden sie gesockelt eingebaut. Für besseres Anbringen des Temperaturfühlers, an den gewünschten Messorten, wird er mit einem langen 3 poligen Kabel versehen.\nDer Operationsverstärker wird als Komperator verwendet, dieser schaltet durch wenn am - Eingang ein niedrigeres Potential als am + Eingang anliegt. Der + Eingang ist anfangs so beschalten, dass er niedriger ist. Der Temperatursensor gibt eine zur Temperatur proportionale Spannung aus, sinkt die Temperatur nahe dem Gefrierpunkt, so wird das Potential am - Eingang niedriger als am + Eingang. Der OPV schaltet durch und weiters wird auch die Spannung des + Einganges um einiges angehoben. Somit kann die Temperatur zwar wieder steigen, aber der OPV bleibt durchgeschalten. Mit einem Tastendruck auf den Reset wird das Potential des + Einganges kurz nach unten gedrückt und der OPV ist wieder im Ausgangszustand. Die LED gibt den Zustand der Schaltung bekannt, damit ein externes Signal geschalten werden kann wird weiters ein Relais mit einem npn-Transistor angesteuert.\nBilder Links Elektronik Versandhaus - RS Components Elektronik Versandhaus - Conrad ","externalUrl":null,"permalink":"/projects/projekt-008-frostwarner/","section":"Projekte","summary":"","title":"Frostwarner","type":"projects"},{"content":" Hardware Zu Beginn schraubte ich ein altes Spiel, damit ich geeignete Kontakte bekam, auf und lötete eine Lochrasterplatine darauf. Damit man den Speicherbaustein leichter wechseln kann verwendete ich einen Testsockel. Und für eine spätere Erweiterung legte ich alle Pins auf einen externen Stecker. Der Programmer für EPROMs bzw. EEPROMs wird im nächsten Projekt beschrieben. Fertige Geräte gibt es um ca. 100 Euro direkt bei RS-Components zum bestellen.\nSoftware Das Programm wurde mittels Editor und der GBDK Entwicklungsumgebung programmiert. Der Sourcecode besteht aus reinem C-Code. In der Main Routine wird ein Menue ausgegeben und mit den Auf-/Ab- Tasten kann ein Menüpunkt angewählt werden. Wird die A-Taste betätigt so wird das zugehörige Unterprogramm ausgeführt. Das Zeichen UP gibt alle verschiedenen Zeichen aus, die der Gameboy gespeichert hat. TilesBsp gibt einen Hintergrund und ein Smile aus. TilesBsp2 gibt eine mit den Cursortasten bewegbare Figur aus. Beim Aufruf des Hilfe Unterprogramm bekommt man nur einen kurzen Text auf das Display. Und mit Ende wird das Programm verlassen.\nCompiliert wird die C-Datei mit: \u0026ldquo;lcc inname.c -o outname.bin\u0026rdquo;\nDie mittels GBDK erstellte Bin-Datei brennt man mit einen E/EEPROM Programmer auf einen Speicherbaustein. Dieser wird danach in den Sockel des GameBoys gesteckt. Um die erzeugte Bin-Datei sofort probieren zu können, kann ein Gameboy Emulator verwendet werden.\nBilder Links Elektronik Versandhaus - RS Components Elektronik Versandhaus - Conrad Gameboy Developers Kit KGB - Gameboy Emulator Downloads Testprogramm - Sourcen (C, 14.36KB) Testprogramm - Binary (BIN, 32KB) ","externalUrl":null,"permalink":"/projects/projekt-003-gameboyprogr/","section":"Projekte","summary":"","title":"GameBoy Programmierung","type":"projects"},{"content":" Befehl Übersicht Befehl Beschreibung hugo hugo help Ausgabe der hugo Hilfe hugo version Ausgabe der hugo Programm Version hugo new site test-webseite Anlegen einer neuen hug Website hugo new _index.md Erstellen einer neuen Seite hugo serve Starten des lokalen Test-Servers hugo Generieren der finalen Website VSCode code . Öffnet VSCode im aktuellem Verzeichnis Git git init Anlegen eines Repositories im aktuellem Verzeichnis git add . Alles Hinzufügen mit Beachtung von .gitignore git status Status-Ausgabe des Repositories git commit -m \u0026lsquo;message\u0026rsquo; Speichern der Änderungen im lokalem Repository Static Website Generator Bei dynamischen Webseiten wird die Seite beim Aufruf am Server mittels PHP, ASP.NET \u0026hellip; generiert. Statische Webseiten sind bereits beim Abruf fertig. Sie verwenden HTML für den Inhalt, CSS für das Styling und JavaScript für etwaige Scripts, die aber nur am Client bzw. Webbrowser laufen. Statische Webseiten Generatoren generieren aus Projektdateien, bestehend aus Content-Dateien und Layout-Dateien, die statische Website. Somit kann nach einmaliger Einrichtung am Inhalt gearbeitet werden, ohne sich wieder um die Gestalltung kümmern zu müssen. Der Inhalt ist von der Gestaltung unabhängig, was wiederum bei einer Änderung der Gestalltung keine Rückwirkung auf den Inhalt hat.\nHugo ist ein Open-Source Static Website Generator geschrieben in Go. Er generiert HTML Seiten aus in markdown beschriebenen Inhalten. Ein großer Vorteil von Hugo ist die Geschwindigkeit beim Generieren der Seiten. Somit können Änderungen am Inhalt sofort betrachtet werden.\nVorbereitungen Zuerst muss Hugo installiert werden (https://gohugo.io/installation/). Unter Windows reicht es die aktuelle Hugo Version (https://github.com/gohugoio/hugo/releases) herrunter zu laden und in einen Ordner zu kopieren (z.B. \u0026ldquo;C:\\hugo\u0026quot;). Danach muss dieser Programm-Pfad in die Umgebungsvariable PATH eintragen werden. Einen Test kann man mittels hugo help oder hugo version vornehmen.\nAusgabe: 1hugo v0.143.1-0270364a347b2ece97e0321782b21904db515ecc+extended+withdeploy windows/amd64 BuildDate=2025-02-04T08:57:38Z VendorInfo=gohugoio\nFür das Bearbeiten der Konfigurations- und Markdown-Dateien kann man VSCode verwenden. VSCode kann als Installationsdatei heruntergeladen und einfach installiert werden.\nWebsite Erstellen und Öffnen Eine Hugo Projektstruktur kann mit hugo new site test-webseite angelegt werden (yaml anstatt toml Konfigurationsdatei: hugo new site test-website --format yaml).\nAusgabe: 1Congratulations! Your new Hugo site was created in C:\\Users\\asdf\\Desktop\\website\\test-webseite. 2 3Just a few more steps... 4 51. Change the current directory to C:\\Users\\asdf\\Desktop\\website\\test-webseite. 62. Create or install a theme: 7 - Create a new theme with the command \u0026#34;hugo new theme \u0026lt;THEMENAME\u0026gt;\u0026#34; 8 - Or, install a theme from https://themes.gohugo.io/ 93. Edit hugo.toml, setting the \u0026#34;theme\u0026#34; property to the theme name. 104. Create new content with the command \u0026#34;hugo new content \u0026lt;SECTIONNAME\u0026gt;\\\u0026lt;FILENAME\u0026gt;.\u0026lt;FORMAT\u0026gt;\u0026#34;. 115. Start the embedded web server with the command \u0026#34;hugo server --buildDrafts\u0026#34;. 12 13See documentation at https://gohugo.io/.\nDanach kann das Projekt mit VSCode geöffnet werden code . (im Ordner \u0026ldquo;test-webseite\u0026rdquo;). In Windows kann man auf dem Projektordner Rechtsclicken und mit \u0026ldquo;VSCode\u0026rdquo; öffnen. Die Ordner Struktur ist wiefolgt:\narchetypes/ default.md assets/ content/ data/ i18n/ layouts/ public/ static/ themes/ hugo.toml Archetypes Die Dateien in diesem Ordner dienen als Vorlagen für die Inhaltsdateien die mit \u0026ldquo;hugo new\u0026rdquo; angelegt werden. Für verschiedene Inhaltstypen können eigene Vorlagen angelegt werden (post/tutorials/arcticles/\u0026hellip;). Zu Begin gibt es eine Default-Vorlage (default.md). Beim Erstellen einer neuen Datei, z.B. eines neuen Posts (z.B. \u0026ldquo;hugo new posts/erster-post.md\u0026rdquo;) wird die markdown Datei bereits vorausgefüllt. Ist eine \u0026ldquo;posts.md\u0026rdquo; Datei vorhanden, so wird diese verwendet. Andernfalls wird die \u0026ldquo;default.md\u0026rdquo; Datei verwendet.\nAssets Dieser Ordner beinhaltet statischen Inhalt wie Stylesheets, Scripts oder Bilder (z.B. Fav-Icon, Wasserzeichen \u0026hellip;). Die Dateien werden beim Erstellen der Website mitverarbeitet und in den \u0026ldquo;public\u0026rdquo; Ordner kopiert. Diese Inhalte können unabhängig vom restlichen Inhalt und von Vorlagen organisiert werden. Das macht es einfacher diese statischen Inhalte zu Verwalten oder sie zu Aktualisieren.\nConfig Die \u0026ldquo;hugo.toml\u0026rdquo; Datei ist eine Konfigurationsdatei für die Hugo Website. Sie kann direkt im Projekt-Wurzelverzeichnis abgelegt werden oder unter \u0026ldquo;config/_default/hugo.toml\u0026rdquo;. Anstelle einer Konfigurationsdatei kann der \u0026ldquo;config/_default\u0026rdquo; Ordner auch mehrere Konfigurationsdateien beinhalten. Die Konfigurationsdateien beinhalten die Einstellungen und Optionen, womit das Verhalten der Website definiert wird. Beispiel Konfigurationswerte sind Titel, Base URL, Theme, Menü, \u0026hellip; (Übersicht der Variablen). Eine sehr interessante Option ist, dass man hugo mitteilen kann, welche Dateien und Ordner beim Verarbeiten ignoriert werden sollen ignoreFiles = ['TODO', 'OLD', 'IGNORE']. Somit werden sämtliche Dateien oder Verzeichnisse mit einem der aufgelisteten Wörter ignoriert und auch nicht in den \u0026ldquo;public\u0026rdquo; Ordner übernommen.\nContent In diesem Ordner werden alle Markdown Dateien inklusive Bilder und Mutlimedia Dateien abgelegt. Der Ordner beinhaltet den tatsächlichen Website Inhalt (Posts, Seiten, \u0026hellip;). Hugo verarbeitet diese Dateien und generiert damit die HTML Dateien. Mit Hilfe von Ordnern können die Inhalte in Bereiche/Sektionen eingeteilt werden (z.B.: /post für Blog-Posts, /tutorials für Tutorials, /articles für Artikel \u0026hellip;). Mit dem Ordner-Namen wird nach einer passenden Vorlage im \u0026ldquo;Archetypes\u0026rdquo; Ordner gesucht.\n\\content _index.md https://example.com/ \\about _index.md https://example.com/about/ \\post firstpost.md https://example.com/post/firstpost/ \\second post.md https://example.com/post/second/post/ thirdpost.md https://example.com/post/thirdpost/ Data Dieser Ordner beinhalted Daten welche zum Generieren der Website verwendet werden können. Sie werden in Konfigurationsdateien abgelegt (YAML, JSON oder TOML). Sie umfassen z.B. Seiten Konfigurationen, Angaben zum Author usw. Diese Daten können in den Vorlagen benützt und referenziert werden.\nI18n Wird die Website in mehreren Sprachen engeboten, so beinhaltet dieser Ordner die Übersetzungstabellen.\nLayouts Hier werden die HTML Vorlagen abgelegt, welche für die Gestaltung der Website verwendet werden. Diese Vorlagen werden beim Generieren der HTML Dateien für die Gestaltung jeder einzelnen Seite verwendet. Beim Verwenden von Themes müssen die Dateien oft nicht angelgt werden, es wird nur das Theme angepasst. Der Ordner kann Vorlagen für Listen-Seiten (list pages)(Liste der Posts \u0026hellip;), für die Start-Seite (homepage), für die einzelnen Seiten (single page), \u0026hellip; beinhalten.\nPublic In diesem Ordner werden die generierten statischen Website Dateien abgelegt. Er beinhaltet HTML, CSS, JavaScript, Bilder \u0026hellip; Ausgabedateien. Wird die Website mit \u0026ldquo;hugo server\u0026rdquo; generiert, so verwendet hugo lokale Pfadangaben. Diese Ausgabe ist nicht für den Upload zum Server gedacht. Wird die Website mit \u0026ldquo;hugo\u0026rdquo; erstellt, so wird die \u0026ldquo;baseURL\u0026rdquo; herangezogen. Diese Ausgabe kann direkt auf den Server hochgeladen werden.\nResources Dieser Ordner beinhaltet generierte Dateien die zwischengespeichert werden. Zum Beispiel werden bei der Verwendung von Bildverarbeitung die Bilder hier verarbeitet.\nStatic Der Static Ordner beinhaltet statische Dateien die von Hugo nicht weiter verarbeitet werden. Diese Dateien werden direkt übernommen, ohne dass Hugo sie verarbeitet oder verändert. Diese Dateien können einfach referenziert werden \u0026ldquo;{{.Site.BaseURL }}/images/logo.png}}\u0026rdquo;. In diesem Ordner können statische Bilder (ohne Weiterverarbeitung durch Hugo) oder Downloads verwaltet werden. Ein Beispiel ist die Ablage der Google-Authentifizierungsdatei welche direkt im Ausgabeordner gelangen soll.\nThemes Hier können eigene oder bereits vorbereitete Themes abgelegt werden. Diese werden für die Gestaltung der Website verwendet. In dem Ordner können auch mehrere Themes abgelegt werden. Das verwendete Theme wird in der Konfigurationsdatei definiert. Somit kann die Gestaltung einfach gewechselt werden, ohne den Inhalt zu modifizieren.\nTheme Verwenden Für Hugo gibt es sehr viele unterschiedliche Themes. Ein Theme wird installiert, indem man die Dateien in dem Themes Ordner kopiert oder mit Git verwendet.\nGit Clon: 1git clone https://github.com/adityatelange/hugo-PaperMod themes/PaperMod --depth=1 2cd themes/PaperMod 3git pull\nGit Submodul: 1git submodule add --depth=1 https://github.com/adityatelange/hugo-PaperMod.git themes/PaperMod 2git submodule update --init --recursive # needed when you reclone your repo (submodules may not get cloned automatically)\nFür meine Website interessante Themes:\nPaperMod blowfish beautifulhugo lotusdocs Nach dem Installieren des Themes kann man es in der Hugo Konfigurationsdatei aktivieren. Die anderen verfügbaren Einstellungen kann man auch gleich anpassen. 1baseURL = \u0026#39;https://werner.dichler.at/\u0026#39; 2languageCode = \u0026#39;de-DE\u0026#39; 3title = \u0026#39;WeDi\u0026#39; 4theme = \u0026#39;beautifulhugo\u0026#39;\nErste Seite Erstellen Die Index-Seite (Homepage) der Website kann man mit hugo new _index.md erstellen. Der Inhalt dieser Datei ist in Markdown verfasst und beinhaltet zu Begin den \u0026ldquo;Front Matter\u0026rdquo; Bereich. Weitere Markdown Zusammenfassungen findet man im Markdown Guide oder Markdown Cheatsheet.\n1+++ 2date = \u0026#39;2025-02-23T11:31:24+01:00\u0026#39; 3draft = false 4title = \u0026#39;WeDi\u0026#39; 5+++ 6 7# Überschrift 1 8Etwas Text um die Darstellung zu testen. 9 10## Überschrift 2 11 12Weiterer Test Text. 13Weiterer Test Text. Weiterer Test Text. Lokalen Server Starten Die Hugo Website kann lokal getestet werden indem man den in Hugo integrierten Server startet hugo server. Der Server liefert die Website unter \u0026ldquo;http://localhost:1313/\u0026rdquo; aus. Er überprüft im Hintergrund ob sich die Dateien ändern und aktualisiert gegebenenfalls sofort die Website Darstellung.\n1hugo serve 2Watching for changes in C:\\Users\\werne\\Desktop\\website\\wedi\\{archetypes,assets,content,data,i18n,layouts,static,themes} 3Watching for config changes in C:\\Users\\werne\\Desktop\\website\\wedi\\hugo.toml 4Start building sites … 5hugo v0.143.1-0270364a347b2ece97e0321782b21904db515ecc+extended+withdeploy windows/amd64 BuildDate=2025-02-04T08:57:38Z VendorInfo=gohugoio 6 7 | EN 8-------------------+------ 9 Pages | 10 10 Paginator pages | 0 11 Non-page files | 0 12 Static files | 184 13 Processed images | 0 14 Aliases | 2 15 Cleaned | 0 16 17Built in 123 ms 18Environment: \u0026#34;development\u0026#34; 19Serving pages from disk 20Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender 21Web Server is available at http://localhost:1313/ (bind address 127.0.0.1) 22Press Ctrl+C to stop Finale Website Generieren Um die Hugo Website für den Server Upload zu generieren (es werden zum Teil andere URLs verwendet) gibt man einfach hugo ein. Anschließend kann man sämtliche Dateien unter \u0026ldquo;public\u0026quot; auf den Server laden.\n1hugo 2Start building sites … 3hugo v0.143.1-0270364a347b2ece97e0321782b21904db515ecc+extended+withdeploy windows/amd64 BuildDate=2025-02-04T08:57:38Z VendorInfo=gohugoio Hugo Markdown Beispiele Links / Referenzen Interne absolute Links (z.B.: http://asdf.com/about/): 1{{\u0026lt; ref \u0026#34;document.md\u0026#34; \u0026gt;}} 2{{\u0026lt; ref \u0026#34;#anchor\u0026#34; \u0026gt;}} 3{{\u0026lt; ref \u0026#34;document.md#anchor\u0026#34; \u0026gt;}}\nInterne relative Links (z.B.: /about/): 1{{\u0026lt; relref \u0026#34;document.md\u0026#34; \u0026gt;}} 2{{\u0026lt; relref \u0026#34;#anchor\u0026#34; \u0026gt;}} 3{{\u0026lt; relref \u0026#34;document.md#anchor\u0026#34; \u0026gt;}}\nExterne Links: 1\u0026lt;https://www.muster.org\u0026gt; 2\u0026lt;max@muster.com\u0026gt; 3[Link Text](https://muster.com) 4[Link Text](https://muster.com \u0026#34;Hover Text\u0026#34;) 5 6Nicht verwendet werden sollte folgendes: 7[Link Text](https://muster.com/seite 1.html) 8 9Leerzeichen werden von Markdown nicht erkannt. 10[Link Text](https://muster.com/seite%201.html)\nBilder Einfügen Statische Bilder können z.B. unter \u0026ldquo;static/images/\u0026rdquo; abgelegt werden und per markdown einfach eingebettet werden. Werden Bilder noch weiterverarbeitet (z.B. für eine Gallerie \u0026hellip;), so speichert man sie am besten mit den Seiten im \u0026ldquo;content\u0026rdquo; Ordner.\n1Angabe mit Absolut-Pfad bezogen auf Base-URL: 2![Alternativ-Text](/images/test.jpg) 3 4Angabe mit Relativem Pfad bezogen auf Inhalt-Datei: 5![Alternativ-Text](../images/test.jpg) 6![Alternativ-Text](/images/test.jpg \u0026#34;Bildbeschreibung\u0026#34;) 7 8Bild mit Link: 9[![Alternativ-Text](/images/test.jpg \u0026#34;Bildbeschreibung\u0026#34;)](https://muster.com) Code Highlighting Hugo verwendet für Code-Highlighting Chroma. Details findet man unter anderem hier.\n1Interessanter Text mit ``inline code``. 2 3{{\u0026lt; highlight cpp \u0026#34;linenos=inline\u0026#34; \u0026gt;}} 4// ... code 5{{\u0026lt; / highlight \u0026gt;}} Besonderheiten Möchte man nur eine neue Zeile ohne einen neuen Absatz, so muss man die vorhergehende Zeile mit zwei Leerzeichen beenden. Damit Hugo mehrere Leerzeilen nicht wegoptimiert und als solche behält kann man Leerzeichen einfügen.\n1\u0026amp;nbsp; add single space 2\u0026amp;ensp; add two spaces 3\u0026amp;emsp; add four spaces Hugo parst selbst die Texte, welche als Code markiert sind. Somit ist es schwierig Hugo Code darzustellen. Um das Parsen zu verhindern kann man eine spezielle Zeichenfolge verwenden\n1{{\u0026lt;/* highlight cpp \u0026#34;linenos=inline\u0026#34; */\u0026gt;}} 2// ... code 3{{\u0026lt;/* / highlight */\u0026gt;}} Anpassung von Themes Für viele Themes gibt es eine gute Dokumentation mit Start-Anleitungen, z.B. für blowfish. Hier wird z.B. beschrieben, dass die von hugo erstellte Konfigurationsdatei im Projekt-Wurzelverzeichnis gelöscht werden kann und die Konfigurationsdateien von blowfish \u0026ldquo;themes/blowfish/config/_default\u0026rdquo; kopiert werden sollen \u0026ldquo;config/_default\u0026rdquo;. Diese Dateien werden im Anschluss zum Konfigurieren von der Website und von blowfish verwendet.\nSämtliche andere Änderungen an blowfish macht man, indem man die Original-Datei kopiert und an \u0026ldquo;gleicher\u0026rdquo; Stelle im Projekt einfügt (ohne \u0026ldquo;themes/blowfish\u0026rdquo; davor). Hugo verwendet beim Erstellen der Seite nur noch die Kopie.\nLokale Versionierung mit Git Damit Änderungen der Website nachverfolgt werden können und mögliche Verschlechterungen zurückgenommen werden können, verwendet man Versionierung mit Git oder SVN Repositories. Versionierung kann auch Helfen damit man nur die geänderten Dateien im \u0026ldquo;puglic\u0026rdquo; Ordner auf den Server hochladen kann.\nDie Versionierung startet mit dem Installieren von Git. Danach kann das Git-Kommandozeilenfenster im Projekt-Ordner geöffnet werden (Erweiterung im Rechts-Klick Menü). Damit nachfolgende Commits einem Benutzer zugeordnet werden können, kann man den Benutzer global definieren git config --global user.email \u0026quot;max.muster@mail.com. Danach kann im aktuellen Verzeichnis ein lokales Git Repository angelegt werden git init. Damit Git auch die selben Dateien und Verzeichnisse wie hugo ignoriert, kann man eine \u0026ldquo;.gitignore\u0026rdquo; Datei anlegen.\n*TODO*\r*OLD*\r*IGNORE* Danach kann man sämtliche Dateien und Verzeichnisse mit git add . hinzufügen und den ersten Commit speichern git commit -m 'message'. Nachfolgend kann man sich den Repository Status mit git status anzeigen lassen und Änderungen verfolgen.\nEine gute Git Kommando-Übersicht findet man in der Git Dokumentation oder in einem Git Cheat Sheet. Eine Übersicht über die Möglichkeiten in .gitignore findet man in einem .gitignore Tutorial.\nWeiterführende hugo Links https://hygraph.com/blog/hugo-static-site https://linz.coderdojo.net/uebungsanleitungen/programmieren/web/erste-schritte-mit-hugo/\nhttps://discourse.gohugo.io/t/storing-image-as-asset-or-page-resource/31692/3 https://discourse.gohugo.io/t/best-practices-assets-with-content/9984/2\nhttps://privat.albicker.org/blog/2017-02-03-hugo-die-plage-mit-den-urls.html\n","externalUrl":null,"permalink":"/projects/projekt-034-hugo/","section":"Projekte","summary":"","title":"Hugo","type":"projects"},{"content":" Informationspflicht lt. § 5 Abs. 1 E-Commerce Gesetz: Werner Dichler\nGroßotten, 8\nA-3922 Großschönau\n+43 (0) 680 / 210 20 50\nHaftungsausschluss: Haftung für Inhalte Die Inhalte dieser Website wurden mit größter Sorgfalt erstellt. Für die Richtigkeit, Vollständigkeit und Aktualität der Inhalte kann jedoch keine Gewähr übernommen werden. Als Diensteanbieter bin ich für eigene Inhalte auf diesen Seiten nach den allgemeinen Gesetzen verantwortlich. Gemäß Gesetz bin ich als Diensteanbieter jedoch nicht verpflichtet, übermittelte oder gespeicherte fremde Informationen zu überwachen oder nach Umständen zu forschen, die auf eine rechtswidrige Tätigkeit hinweisen. Verpflichtungen zur Entfernung oder Sperrung der Nutzung von Informationen nach den allgemeinen Gesetzen bleiben hiervon unberührt. Eine diesbezügliche Haftung ist jedoch erst ab dem Zeitpunkt der Kenntnis einer konkreten Rechtsverletzung möglich. Bei Bekanntwerden von entsprechenden Rechtsverletzungen werde ich diese Inhalte umgehend entfernen.\nHaftung für Links Dieses Angebot enthält Links zu externen Webseiten Dritter, auf deren Inhalte ich keinen Einfluss habe. Deshalb kann ich für diese fremden Inhalte auch keine Gewähr übernehmen. Für die Inhalte der verlinkten Seiten ist stets der jeweilige Anbieter oder Betreiber der Seiten verantwortlich. Die verlinkten Seiten wurden zum Zeitpunkt der Verlinkung auf mögliche Rechtsverstöße überprüft. Rechtswidrige Inhalte waren zum Zeitpunkt der Verlinkung nicht erkennbar. Eine permanente inhaltliche Kontrolle der verlinkten Seiten ist jedoch ohne konkrete Anhaltspunkte einer Rechtsverletzung nicht zumutbar. Bei Bekanntwerden von Rechtsverletzungen werde ich derartige Links umgehend entfernen.\nUrheberrecht Die durch die Seitenbetreiber erstellten Inhalte und Werke auf diesen Seiten unterliegen dem Urheberrecht. Die Vervielfältigung, Bearbeitung, Verbreitung und jede Art der Verwertung außerhalb der Grenzen des Urheberrechtes bedürfen der schriftlichen Zustimmung des jeweiligen Autors bzw. Erstellers. Downloads und Kopien dieser Seite sind nur für den privaten, nicht kommerziellen Gebrauch gestattet. Soweit die Inhalte auf dieser Seite nicht vom Betreiber erstellt wurden, werden die Urheberrechte Dritter beachtet. Insbesondere werden Inhalte Dritter als solche gekennzeichnet. Sollten Sie trotzdem auf eine Urheberrechtsverletzung aufmerksam werden, bitte ich um einen entsprechenden Hinweis. Bei Bekanntwerden von Rechtsverletzungen werde ich derartige Inhalte umgehend entfernen.\nDatenschutz Die Nutzung dieser Webseite ist in der Regel ohne Angabe personenbezogener Daten möglich. Soweit auf diesen Seiten personenbezogene Daten (beispielsweise Name, Anschrift oder eMail-Adressen) erhoben werden, erfolgt dies, soweit möglich, stets auf freiwilliger Basis. Diese Daten werden ohne Ihre ausdrückliche Zustimmung nicht an Dritte weitergegeben.\nWir weisen darauf hin, dass die Datenübertragung im Internet (z.B. bei der Kommunikation per E-Mail) Sicherheitslücken aufweisen kann. Ein lückenloser Schutz der Daten vor dem Zugriff durch Dritte ist nicht möglich.\nDer Nutzung von im Rahmen der Impressumspflicht veröffentlichten Kontaktdaten durch Dritte zur Übersendung von nicht ausdrücklich angeforderter Werbung und Informationsmaterialien wird hiermit ausdrücklich widersprochen. Ich behalte mir ausdrücklich rechtliche Schritte im Falle der unverlangten Zusendung von Werbeinformationen, etwa durch Spam-Mails, vor.\nGerichtsstand Österreich\nQuellen: Disclaimer von eRecht24, dem Portal zum Internetrecht von Rechtsanwalt Sören Siebert; durch den Betreiber der Webseite für Österreich modifiziert\n","externalUrl":null,"permalink":"/impressum/","section":"WeDi","summary":"","title":"Impressum","type":"page"},{"content":"Sämtliche Multimedia-Geräte können heutzutage über eine Fernbedienung gesteuert werden. Die verbreiteste Übertragung der Fernbedienungs-Codes erfolgt mittels Infrarot-Licht. Grund dafür ist die zuverlässige Bedienung und die extrem billige Produktion (billige ICs, wenige passive Komponenten). Die Fernbedienung sendet über eine IR-Diode den durchzuführenden Befehl. Dieser wird vom Multimedia-Gerät durchgeführt, wobei er zuvor über einen IR-Empfänger dekodiert wurde.\nBit-Kodierung:\nZwei-Phasen-Modulation Pulsabstandsmodulation Pulsweitenmodulation Trägerfrequenz:\nModulation mit einem Burst mit bestimmter Dauer (Vorteil: geringerer Energieverbrauch) Modulation mit Frequenz (Vorteil: störfester gegenüber Umgebungsstrahlung) Für ein besseres Verständnis analysierte ich einige Ausgangssignale von meinen vorhandenen Fernbedienungen. Im unteren Abschnitt kann man die Logic-Analyzer Aufnahmen mit den theoretischen Zeiten vergleichen.\nDas Signal in der 1. Reihe stellt den RC5-Code von Philips dar. Der High-Pegel steht für eine getaktete Ausgabe des IR-Lichtes, während dem Low-Pegel erfolgt keine IR-Licht-Ausgabe. Die Signale in den Reihen 2 bis 5 haben negierte Pegel. Also wird beim Low-Pegel IR-Licht mit der modulierten Frequenz detektiert.\nDas Signal in Reihe 2 wurde von einem Logic-Analyzer aufgenommen und für die weitere Verarbeitung in eine .csv-Datei exportiert. Die ersten 3 Pulsfolgen stammen vom ersten Tastendruck und die 3 Pulsfolgen am Ende von einem erneutem Tastendruck. Die weiteren Signale stellen immer einen vergrößerten Ausschnitt dar.\nDas Signal in Reihe 3 stellt die wiederholten Ausgaben einer gedrückten Taste dar. Die gemessene Wiederholungs-Zeit (repetition-time) ist 113,68ms.\nDas Signal in Reihe 4 repräsentiert folgende Bits: 11 1 01000 000000 (Drücken und Festhalten der Taste 0)\nDas Signal in Reihe 5 repräsentiert folgende Bits: 11 0 01000 000000 (nach erneutem Drücken auf die Taste 0 - geändertes Toggle-Bit)\nFernbedienungsempfänger Damit ich für meine zukünftigen Projekte die Möglichkeit der \u0026ldquo;Fernbedienbarkeit\u0026rdquo; habe baute ich auf Basis des Atmel AT90USBKey eine Empfänger-Domonstration auf. Als IR-Empfänger wurde der SFH 5110 verwendet. Dieser wurde mit Gnd und +5V verbunden und der IR-Ausgang über einen Spannungsteiler an den AT90USB1287 Mikrokontroller. Der Spannungsteiler ist nötig, da der uC mit 3,3V betrieben wird und somit sollten die Logik-Pegel diese Spannung auch nicht überschreiten. Damit das Signal leicht verarbeitet werden kann wurde ein PCI-Eingang verwendet (Pin Change Interrupt).\nDie Firmware ist so aufgebaut, dass bei einem Pegelwechsel des IR-Signals ein Interrupt ausgeführt wird. In diesem wird die Zeit eines 16-bit Timers gespeichert und überprüft ob sie mit dem RC5 Zeitverhalten übereinstimmt. Für die Dekodierung wurde eine kleine Zustandsmaschine verwendet wo je nach Zustand eine Aktion durchgeführt wird. Wurde ein komplettes Kommando empfangen, so wird dieses gespeichert und dem Hauptprogramm mit einem Flag mitgeteilt. Das Hauptprogram gibt die neu empfangenen Kommandos mit den empfangenen Bits auf ein LC-Display aus.\nLinks IR Remote Control Protocols IR Remote Control Protocols IR Remote Control Protocols IR Description Downloads IR codes.pdf (PDF, 51.86 KB) IR Receiver - Source (ZIP, 16.73 KB) ","externalUrl":null,"permalink":"/projects/projekt-018-infraredremote/","section":"Projekte","summary":"","title":"Infrared Remote Control","type":"projects"},{"content":" Aufbau Durch viele im Internet veröffentlichten POV (Point Of View) Projekte, wurde meine Neugier geweckt selbst solch ein Projekt in Angriff zu nehmen. Mein Projekt besteht aus einem ATiny2313, 8 LEDs, 9 Widerstände, 2 Kondensatoren und eine Lichtschranke. Für das Drehen des LED-Streifens wollte ich zu Beginn einen alten Festplatten-Motor verwendet, dieser wollte aber nicht funktionieren. Normalerweise funktioniert er ähnlich einem Schrittmotor, also probierte ich die Ansteuerung mittels Mikrokontroller und pro Wicklung einen Transistor. Nach stundenlangem Probieren verwendete ich doch einen einfachen DC Motor.\nDie Ansteuerung der LEDs erfolgt mittels Timer-Interrupt, welcher einen Zähler inkrementiert und die aktuelle Spalte berechnet. Der maximale Zählerwert wird beim Eintreten des Lichtschranken-Interrupts gespeichert, wobei der Zähler wieder zurück gesetzt wird.\nBilder Links Elektronik Versandhaus - RS Components Elektronik Versandhaus - Conrad Downloads Schematic (SCH, 102.93 KB) Lichtschrankentest - Source (C, 661 bytes) Lichtschrankentest - Binary (HEX, 823 bytes) POV Herz - Source (C, 6.61 KB) POV Herz - Binary (HEX, 2 KB) POV Laufschrift - Source (C, 4.32 KB) POV Laufschrift - Binary (HEX, 2.36 KB) POV Laufschrift - Video (3GP, 688.12 KB) ","externalUrl":null,"permalink":"/projects/projekt-011-ledpov/","section":"Projekte","summary":"","title":"LED Point Of View (POV)","type":"projects"},{"content":" Kurzeinführung in LTSpice PieceWise Linear (PWL) Datei oder Angaben Spannungsgesteuerter Schalter Zener Diode Transformator Spice-Modelle verwenden Erweiterte Messungen Rauschen Simulieren Frequenzgang mit Rauschsignal und FFT Bauteilwerte variieren Monte-Carlo bzw. Worst-Case Simulation Temperaturverhalten Zweitor-Messung Modell Parametrierung Downloads Kurzeinführung in LTSpice Eine Simulation in LTSpice beginnt mit der Erstellung des Schaltplanes. Dafür werden die Bauteile (resistor, capacitor, inductor, diode und andere Teile durch den Klick auf component) platziert und mit Leitungen (wire) miteinander verbunden. Die Bauteilwerte können durch Rechtsklick geändert werden. Bei jeder Schaltung muss mindestens ein Ground-Symbol platziert werden. Am Ende muss noch eine Simulationsmethode ausgewählt und richtig parametriert werden ([simulate -\u0026gt; edit simulation command] oder Drücken auf run).\nHinter dem graphischen Schaltplan verwendet LTSpice eine Netzliste (view -\u0026gt; spice netlist). Dabei kann man erkennen, das sämtliche Leitungen einfach durchnummeriert werden. Möchte man aussagekräftigere Namen verwenden, so kann man Labels (label net) vergeben.\nNachdem die Simulation gestartet und fertig durchlaufen wurde öffnet sich das Waveform-Fenster. Klickt man danach innerhalb der Schaltung auf eine Leitung, so kann man den Spannungsverlauf betrachten [V]. Für eine Spannungsdifferenz zweier Signale klickt man auf die erste Leitung, hält die Taste gedrückt und lässt sie bei der zweiten Leitung wieder los. Ein Klick auf ein Bauteil stellt den Strom dar [A]. Hält man auch die Alt-Taste gedrückt, so wird die Leistung dargestellt [W].\nZum Ablesen von Werten kann man Cursor hinzufügen (Klick auf Label im Waveform-Fenster). Für Differenzmessungen setzt man einfach den zweiten Cursor. Für ein grobes Ablesen reicht es auch aus, den Cursor auf den gewünschten Punkt zu positionieren und den X/Y-Wert in der Statusleiste abzulesen. Für die Anzeige einer Differenzzeit /-amplitude muss man ein Rechteck aufziehen und halten. Damit nach dem Loslassen der Taste die Anzeige nicht gezoomt wird, muss man die Auswahl mit Escape abbrechen.\nDurch Rechts-Klick auf die Signal-Bezeichnung öffnet sich ein Fenster zum Einstellen der Signal-Farbe und zur Auswahl eines Cursors. Des Weiteren kann das dargestellte Signal mit einer Spice-Direktive ausgewählt werden.\nStrg+Klick auf die Bezeichnung öffnet ein Fenster mit einfachen Berechnungs-Ergebnissen (Mittelwert, RMS)\nFür bestimmte Messpunkte /-werte kann man die .meas-Anweisung verwenden. Man kann beliebig viele Messpunkte angeben. Die Ausgabe erfolgt in der Error-Log-Ausgabe (view -\u0026gt; spice error log).\nUm Bauteilwerte nicht händisch berechnen zu müssen, kann man den Wert auch von LTSpice errechnen lassen. Dafür verwendet man die Funktion der Parametrierung. Innerhalb der Parameter-Angaben können auch Formeln platziert werden.\nPiecewise Linear (PWL) Datei Für Simulationen mit benutzerdefinierten Signalen (z.B. real gemessene Signale) kann man bei den Quellen eine PWL-Datei angeben. Die Datei enthält eine Auflistung von Werten für bestimmte Zeitpunkte. Zwei benachbarte Punkte werden linear verbunden (piecewise linear = stückweise linear).\nWie man bei der Beispiel-Datei sieht, kann die Zeit und die Amplitude unterschiedlich angegeben werden (Ganzzahl, Reele Zahl mit Punkt, Reele Zahl in Exponentialdarstellung und Reele Zahl mit SI-Präfix (\u0026hellip; T, G, Meg, k, m, u, n, p, f, \u0026hellip;)). Die Zeit wird von der Amplitude mit Leerzeichen bzw. mit Tabulatoren getrennt. Zur Verbesserung der Übersicht sollte jeder Zeit-Amplituden-Eintrag in einer neuen Zeile beginnen.\nBenötigt man nur einige PWL-Punkte, so kann man diese auch direkt bei der Quelle eintragen. PWL statt PWL FILE.\nSpannungsgesteuerter Schalter Um diverse Schaltvorgänge (Taster, Controller-Ausgänge, \u0026hellip;) einfach simulieren zu können, eignen sich spannungsgesteuerte Schalter als Nachbildung sehr gut. Diese Schalter findet man in der Komponenten-Bibliothek unter den Namen \u0026ldquo;sw\u0026rdquo;. Nach dem Hinzufügen des Symbols ändert man das Modell des Schalters durch Strg + Rechts-Klick auf ein Modell Namens \u0026ldquo;btn\u0026rdquo;.\nDas Modell \u0026ldquo;btn\u0026rdquo; definiert man mit dem Hinzufügen einer Spice-Direktive mit den Angaben für den Schalter (Ein-Widerstand, Aus-Widerstand, Schaltspannung, Schalthysterese, \u0026hellip;). Die Schaltzeitpunkte kann man durch eine Spannungsquelle defineren. Im unteren Beispiel wurde eine Quelle mit PWL Angaben (piecewise linear) verwendet.\nMit einer Transienten-Analyse kann man die Funktion des spannungsgesteuerten Schalters einfach kontrollieren. Das violette Signal gibt das Steuersignal des Schalters wieder. Das türkise Signal stellt das Signal an einem simulierten Taster mit Pullup-Widerstand und Entprellung dar.\nZener Diode Für die Simulation einer Zener Diode verwendet man das vorhandene Symbol in Kombination mit einer Spice Direktive. Bei den Modell Angaben für die Zener Diode kann unter anderem die Vorwärtsspannung und die Zener-Klemmspannung konfiguriert werden.\nNach einer einfachen Simulation des Arbeitspunktes erhält man das erwartete Resultat der Ausgangsspannung. Die Spannung an der Zener Diode wird mit 5V begrenzt. Dieses Verhalten kann als Fixspannungsquelle (einfach, aber nur für geringe Lasten) bzw. für den Überspannungsschutz verwendet werden.\nTransformator Ein Transformator wird simuliert, indem man zwei Spulen mit der Angabe einer Gegeninduktion koppelt (K1 L1 L2 1.0). Die letzte Zahl gibt den Kopplungsfaktor an (zwischen 0 und 1), also umgekehrt proportional zu den Streuverlusten über die Streuinduktivität. Das Übertragungsverhältnis wird über die Angabe der Induktivitäten festgelegt (siehe Kommentare in Simulation).\nSomit sind die Übertragungseigenschaften definiert. Die Spannung von Eingang zu Ausgang verhält sich wie die Windungszahl Primär zu Sekundär. Die Windungszahl Primär zu Sekundär zum quadrat ist gleich der Primär-Induktivität zur Sekundär-Induktivität. Die transformierte Impedanz ist gleich der Sekundär-Impedanz multipliziert mit dem Übertragungsverhältnis zum quadrat.\nDie Simulationsergebnisse wiederspiegeln das zuvor angegebene Verhalten:\nUpri / Usec = 1V / 0.5V = Isec / Ipri = 10mA / 5mA Z\u0026rsquo; = 2^2 Zsec = 200 → 1V / 200 = 5mA Spice-Modelle verwenden Viele Halbleiter-Hersteller stellen für die einfache Evaluierung ihrere Bauteile genaue Spice-Modelle zur Verfügung. Aufgrund vieler verschiedener Spice-Simulatoren können die Modelle nicht für sämtliche Spice-Anwendungen bereitgestellt werden. Daher konzentrieren sich die Halbleiter-Hersteller meistens auf einen Simulator. Da die Spice-Simulatoren eine große Kompatibilität aufweisen, kann man mit einigen Handgriffen die bereitgestellten Modelle für andere Spice-Simulatoren anpassen.\nAls Beispiel für die Verwendung von Spice-Modellen wird eine BAV99-Diode von NXP Semiconductor eingebunden. Der Hersteller stellt eine ZIP-Datei mit der Datei \u0026ldquo;BAV99.prm\u0026rdquo; zur Verfügung (http://www.nxp.com/products/diodes/switching_diodes/BAV99.html). Diese Datei wird für LTSpice einfach auf \u0026ldquo;BAV99.sub\u0026rdquo; unbenannt und mit Hilfe eines Texteditors von nicht benötigten Kommentaren befreit. Danach wird sie in den aktuellen Projekt-Ordner bzw. in den \u0026ldquo;sub\u0026rdquo;-Ordner innerhalb des Installationsverzeichnisses (C:\\Program Files (x86)\\LTC\\LTspiceIV\\lib\\sub) kopiert.\nDas Dioden-Modell wird mit einer Spice-Direktive eingebunden (\u0026quot;.lib \u0026ldquo;BAV99.sub\u0026rdquo;). Um sie danach verwenden zu können, muss zuerst eine Standard-Diode hinzugefügt werden. Danach wird bei den Parametern (Strg + Rechts-Klick) der Modell-Name eingetragen. Wichtig hierbei ist, dass bei Prefix ein X eingetragen wird. Da das Modell nur eine Diode modelliert, muss noch eine zweite Diode in Gegenrichtung platziert werden. Damit die Bezeichnung der zweiten Diode nicht weiter verwirrt, kann man unter den Parametern sämtliche Werte ausblenden (Spalte Visible).\nUm die Funktion von diversen Bauteilen sicherzustellen, sollte man eine Test-Schaltung simulieren. Für die Doppel-Diode reicht eine Schaltung mit Vorwiderständen und einer Sinus-Quelle.\nDie Signale der simulierten Schaltung können im Anschluss noch auf Korrektheit überprüft werden. Unterhalb sieht man, dass die Doppel-Diode die Spannung in beiden Richtungen korrekt begrenzt.\nErweiterte Messungen Nach dem Erstellen einer Spice-Simulation können die gewünschten Messwerte im Ausgabefenster abgelesen werden. Einfach erscheinende Messungen (Differenzwert bestimmter Punkte, Min./Max.-Werte, \u0026hellip;) sind über die Cursor-Messungen mit etwas Aufwand durchführbar. Eine einfachere Möglichkeit besteht darin die .meas-Funktion zu verwenden.\nRauschen Simulieren Für viele Schaltungen ist es hilfreich den Eingang mit Rauschen als Signalquelle zu simulieren. Eine Anwendung ist es z.B. den Frequenzgang eines Filters mit weißem Rauschen zu ermitteln.\nLTSpice stellt 3 Funktionen für Zufallszahlen zur Verfügung (rand, random, white). Die Zufallsgenerator-Funktionen können bei der Komponente \u0026ldquo;Arbitriary behavioral voltage source\u0026rdquo; verwendet werden. Die Funktionen liefern nur eine Zufallszahl. Damit sie sich über der Zeit verändern, muss man die Simulationszeit angeben. Mit 1k*time erhält man jede 1ms eine neue Zufallszahl.\nBei den Simulations-Ergebnissen kann man die Arbeitsweise der Rauschgeneratoren leicht nachvollziehen. Rand und random generieren Zufallszahlen zwischen 0 und 1, white zwischen -0.5 und +0.5 (deshalb wird das Signal bei der Darstellung um 0.5V verschoben). Die Zufallszahlen von rand haben einen steilen Übergang. Der Übergang von random ist etwas weicher und der bei white noch etwas mehr.\nFür die Simulation eines Frequenzganges ist die Funktion \u0026ldquo;white\u0026rdquo; am besten geeignet. Als Beispiel wird hier ein Tiefpass erster Ordnung simuliert. Damit die anschließende FFT-Analyse genügend Datenpunkte hat, wurde eine Mindest-Simulations-Schrittweite von 1ns verwendet. Die Simulation dauert aufgrund der hohen Datendichte ziemlich lange. Man sollte LTSpice währenddessen nicht zu anderen Aufgaben bewegen.\nFrequenzgang mit Rauschsignal und FFT Nach der Transienten-Analyse kann man nach der Auswahl des Ausgabefensters unter View-\u0026gt;FFT eine Fast-Fourier-Analyse starten. Bei den Parametern kann man die Analyse noch auf einen bestimmten Zeitbereich einschränken.\nDas Ergebnis der FFT-Analyse gleicht nahezu dem der AC-Analyse. Die -3dB Grenzfrequenz liegt ungefähr bei den theoretischen 1.6kHz. Der weitere Knick bei 500kHz wurde durch die Glättung verursacht (Binomial Smoothing - Number of Points: 3).\nBei der Transienten-Analyse mit einer Rauschquelle sieht man die tatsächliche Reduktion der Amplitude. Die AC-Analyse wiederum berechnet den DC-Arbeitspunkt und führt dann eine Kleinsignal-Analyse (Berechnung der Spannung an den Knotenpunkten bei unterschiedlichen Frequenzen) durch. Diese Simulation entspricht einer Transienten-Simulation bei jeder Frequenz mit einer Verweildauer einiger Perioden.\nBauteilwerte variieren Um eine gewünschte Schaltung mit verschiedenen Werten simulieren zu können, so verwendet man die .step-Anweisung. Verwendet man mehrere .step-Anweisungen, so werden sämtliche Wertekombinationen durchsimuliert (z.B.: Bauteil 1 Wert 1 mit sämtlichen Bauteil 2 Werten, Bauteil 1 Wert 2 mit sämtlichen Bauteil 2 Werten, usw.).\n.step param Rvar list 10 20 30 Angabe einer Liste 10, 20, 30 .step param Rvar 10 100 10 Start-/ Endwert Angabe mit Schrittweite 10, 20, 30, \u0026hellip; , 100 .step lin param Rvar 10 100 10 Start-/ Endwert Angabe mit Schrittweite 10, 20, 30, \u0026hellip; , 100 .step dec param Rvar 10 1k 2 Angabe Schritte pro Dekade 10, 32, 100, 316, 1k .step oct param Rvar 10 100 1 Angabe Schritte pro Oktave 10, 20, 40, 80, 100 Damit nicht sämtliche Kombinationen durchsimuliert werden, kann man auch Tabellen anlegen. Somit werden diese Wertepaare verwendet (Bauteil 1 Wert 1 mit Bauteil 2 Wert 1, Bauteil 1 Wert 2 mit Bauteil 2 Wert 2, usw.).\nMonte-Carlo bzw. Worst-Case Simulation Bei der Dimensionierung von Schaltungen ist es sehr wichtig die Toleranzen der Bauteile zu beachten. LTSpice bietet die Möglichkeit eine Monte-Carlo Simulation durchzuführen. Die Anweisung mc(10k, 0.1) gibt einen Nennwert von 10k mit einer 10% Toleranz (+/- 10%) an. Die Anzahl der Monte-Carlo Durchläufe gibt man mit dem run-Paramter an (1 100 1 weist run die Werte 1, 2, 3, \u0026hellip; 100 zu).\nBei der Berücksichtigung der Bauteil-Toleranzen ist es oft ausreichend, Simulationen mit den Randwerten einiger Bauteile durchzuführen. Diese Worst-Case Simulation ist in LTSpice nicht direkt enthalten. Mit einer Funktionsdefinition rüstet man diese Funktion einfach nach. Für 2 Bauteile benötigt man 4, für 3 Bauteile benötigt man 8, usw. Durchläufe. Mit einem weiteren Durchlauf kann man dann noch die Nominalwerte simulieren. Die Funktionsdefinition habe ich in einem Gästebuch-Eintrag unter k6jca.blogspot.co.at/\u0026hellip; entdeckt:\n.function bindigit(cnt, digit) floor(cnt(2*digit)) - 2*floor(cnt/(2**(digit+1)))\n.function wc(nom, tol, partnr) if(run==lastrun, nom, if(bindigit(run, partnr), nom*(1+tol), nom*(1-tol)))\nUm nach der Monte-Carlo Simulation weitere Analysen machen zu können, wäre es oft hilfreich die Bauteilwerte zu kennen. Da die Werte nicht aufgelistet werden, müssen sie über Mess-Anweisungen ermittelt werden. Einen Widerstandswert erhält man durch R=U/I. Den Wert einer Spule erhält man mittels L=(U/I)/(2 PI f). Und den Wert eines Kondensators mittels C=1/(2 PI f (U/I)).\n.meas R1 find mag((V(TP1)-V(TP2))/I(R1)) at 1Meg\n.meas L1 find mag((((V(TP2)-V(TP3))/I(L1))/(2*pi*frequency))) at 1Meg\n.meas C1 find abs(1/((V(TP3)/I(C1))*(2*pi*frequency))) at 1Meg\nMit Hilfe der Option meascplxfmt=polar stellt man die Darstellung innerhalb der Ausgabe um.\nTemperaturverhalten Das Temperaturverhalten vieler elektronischer Bauelemente beeinflusst das Verhalten von Schaltungen oft enorm. Um mögliche Designprobleme vorab feststellen zu können, kann die Simulation um den Parameter Temperatur erweitert werden. Das Beispiel unterhalb wiederspiegelt das Temperaturverhalten von NPN-Transistoren.\nZweitor-Messung Eine Zweitor-Messung kann mit der .net Spice-Funktion durchgeführt werden. Nach der Angabe des Eingangs- und Ausgangstors werden die H, S, Y und Z Parameter berechnet.\nNach der erfolgreichen Simulation können die Zweitor-Parameter den Plot-Ausgaben hinzugefügt werden (Plot-Fenster, Rechts-Klick -\u0026gt; Add Trace).\nModell Parametrierung Bei der Parametrierung eines Modells fügt man das Modell hinzu und gibt eine Liste mit den gewünschten Werten an (z.B. min./typ./max. DC-Verstärkung eines Transisors).\nDas mit .lib hinzugefügte Modell ergänzt man um den Parameter-Namen. Der Wert bei BF=\u0026hellip; wird mit dem Parameter-Namen {hFEvar} ersetzt.\nDownloads LTSpice Simulations-Dateien (ZIP, 12.09 KB) ","externalUrl":null,"permalink":"/projects/projekt-023-ltspice/","section":"Projekte","summary":"","title":"LTSpice Simulation","type":"projects"},{"content":"","externalUrl":null,"permalink":"/code-snippets/markdown/","section":"Code Schnipsel","summary":"","title":"Markdown","type":"code-snippets"},{"content":"\r1# Header 1 2## Header 2 3### Header 3 4### Header {#custom-id} 5 6 7 8 9 10Link to [Header](#custom-id). 11Other file link [Header](https://www.asdf.org/file#id) 12 13\u0026gt; citation 14\u0026gt;\u0026gt; citation 15\u0026gt;\u0026gt;\u0026gt; citation 16 17 18 19 20\u0026gt; Without data you\u0026#39;re just 21\u0026gt; another person with an opinion 22\u0026gt; 23\u0026gt; Line breaks need two blanks at the end 24 25\u0026lt;br /\u0026gt; 26\u0026lt;br /\u0026gt; 27\u0026lt;br /\u0026gt; 28 29 30give me a white char\u0026amp;nbsp;1 31give me two white chars\u0026amp;ensp;2 32give me four white char\u0026amp;emsp;4 33 341. item 1 352. item 2 363. item 3 37 38- item 1 39 - sub item 2 40 - sub item 3 41 - sub item 4 42 43 44 45 46* item 1 47 * sub item 2 48 49+ item 1 50 + sub item 2 51 52 53- [ ] unchecked 54- [x] checked 55 56 57--- 58 59 60 61 62:smiley: 63:smile: 64 65⚠️WARNING⚠️ 66❗IMPORTANT❗ 67🔥NEW🔥 68 69✅ true 70❌ false 71 72 73🔴 red: +5V 74🟠 orange: +3.3V 75⚫ black: ground 76⚪ white: ground (pull-down) 77🟣 purple: I2C signal 78🟢 green: clock signal 79🟡 yellow: SPI signal 80🔵 blue: analogue input 81Input by pressing \u0026#39;Win\u0026#39; + \u0026#39;.\u0026#39; and select emoji. 82 83 84| style |\tmarkdown | 85|---------|----------| 86italic\t| *italic1* _italic2_ 87bold\t| **bold1** __bold2__ 88stroke\t| ~~stroke~~ 89highlight\t| ==highlight1== \u0026lt;mark\u0026gt;highlight2\u0026lt;/mark\u0026gt; 90underline\t| \u0026lt;u\u0026gt;underline++\u0026lt;/u\u0026gt; 91 92 93 94 95\u0026lt;mark style=\u0026#34;color:#45B39D\u0026#34;\u0026gt; Marked text 1\u0026lt;/mark\u0026gt; 96\u0026lt;mark style=\u0026#34;background-color:#45B39D\u0026#34;\u0026gt; 97Marked text 2 \u0026lt;/mark\u0026gt; 98\u0026lt;font color=#0fb503\u0026gt; color \u0026lt;/font\u0026gt; 99 100\u0026lt;style\u0026gt; 101r { color: Red } 102o { color: Orange } 103g { color: Green } 104\u0026lt;/style\u0026gt; 105 106- \u0026lt;r\u0026gt;TODO:\u0026lt;/r\u0026gt; Important thing to do 107- \u0026lt;o\u0026gt;TODO:\u0026lt;/o\u0026gt; Less important thing to do 108- \u0026lt;g\u0026gt;DONE:\u0026lt;/g\u0026gt; Breath deeply and improve karma 109 110 111 112--- 113 114 115| Syntax | Description | 116| :--- | :----: | 117| Header | Title | 118| Paragraph | Text | 119 120--- 121 122 123The abbreviations (e.g. HTML, JS ...) can be used 124everywhere and they will be extended by a hover text. 125 126 127*[HTML]: HyperText Markup Language 128*[JS]: Java Script 129 130Footnote[^1] or longer footnote[^test]. 131 132[^1]: This is the first footnote. 133 134[^test]: Longer footnote text can be inserted using 135 indented text. 136 137 138--- 139H~2~0 140H\u0026lt;sub\u0026gt;2\u0026lt;/sub\u0026gt;O 141X^2^ 142X\u0026lt;sup\u0026gt;2\u0026lt;/sup\u0026gt; 143 144$$ 145\\sin^2(a)+\\cos^2(a) = 1 146$$ 147 148 149--- 150 151Automatic URL linking: http://www.asdf.com 152Prevent automatic URL linking: `http://www.asdf.com` 153URL using own text: [link](www.asdf.com) 154 155 156![image](picture.png) 157 158 159--- 160 161 162Inline ``code`` uses \\`\\` code \\`\\`. 163 164 Codeblocks uses \\`\\`\\` code block \\`\\`\\`: 165``` 166|-- \\folder 167 |-- file.txt 168 |-- \\sub folder 169 |-- file.txt 170 171``` 172 173```python 174def hello_world(): 175 print(\u0026#34;Hello world!\u0026#34;) 176``` 177 178\u0026lt;!-- comments --\u0026gt;\rHeader 1 Header 2 Header 3 Header Link to Header.\nLink from other file Header\ncitation\ncitation\ncitation\nWithout data you\u0026rsquo;re just\nanother person with an opinion\nLine breaks need two blanks at the end\ngive me a white char 1\ngive me two white chars 2\ngive me four white char 4\nitem 1 item 2 item 3 item 1 sub item 2 sub item 3 sub item 4 item 1 sub item 2 item 1 sub item 2 unchecked checked Github markdown emoji list from rxaviers\nVSCode Extension: Markdown Emoji, Matt Bierner \u0026#x1f603;\n\u0026#x1f604;\n⚠️WARNING⚠️\n❗IMPORTANT❗\n🔥NEW🔥\n✅ true\n❌ false\n🔴 red: +5V\n🟠 orange: +3.3V\n⚫ black: ground\n⚪ white: ground (pull-down)\n🟣 purple: I2C signal\n🟢 green: clock signal\n🟡 yellow: SPI signal\n🔵 blue: analogue input\nInput by pressing \u0026lsquo;Win\u0026rsquo; + \u0026lsquo;.\u0026rsquo; and select emoji.\nstyle markdown italic italic1 italic2 bold bold1 bold2 stroke stroke highlight ==highlight1== highlight2 underline underline++ Marked text 1\nMarked text 2 color TODO: Important thing to do TODO: Less important thing to do DONE: Breath deeply and improve karma Syntax Description Header Title Paragraph Text The abbreviations (e.g. HTML, JS \u0026hellip;) can be used everywhere and they will be extended by a hover text.\n*[HTML]: HyperText Markup Language\n*[JS]: Java Script\nFootnote1 or longer footnote2.\nH20\nH2O\nX^2^\nX2\n$$ \\sin^2(a)+\\cos^2(a) = 1 $$\nAutomatic URL linking: http://www.asdf.com\nPrevent automatic URL linking: http://www.asdf.com\nURL using own text: link\nInline code uses `` code ``.\nCodeblocks uses ``` code block ```:\n|-- \\folder\r|-- file.txt\r|-- \\sub folder\r|-- file.txt def hello_world(): print(\u0026#34;Hello world!\u0026#34;) This is the first footnote.\u0026#160;\u0026#x21a9;\u0026#xfe0e;\nLonger footnote text can be inserted using indented text.\u0026#160;\u0026#x21a9;\u0026#xfe0e;\n","externalUrl":null,"permalink":"/code-snippets/markdown/markdown-test/","section":"Code Schnipsel","summary":"","title":"Markdown - Test","type":"code-snippets"},{"content":" Software Bei diesem Projekt geht es um die Implementierung von einem Midi-Keyboard. Für die Implementierung wurde C-sharp herangezogen, deshalb ist es notwendig das .NET Framework am Zielrechner zu installieren. Nähere Informationen finden sie in der Report Datei unter den Downloads.\nBilder Links Microsoft .NET Framework Downloads Report Dokument (PDF, 626.31 KB) Source Dateien (ZIP, 180.04 KB) ","externalUrl":null,"permalink":"/projects/projekt-014-midikeyboard/","section":"Projekte","summary":"","title":"Midi-Keyboard","type":"projects"},{"content":"Vor kurzem habe ich mir ein günstiges Multimeter von Aneng für den Privatbereich zugelegt. Viele Testberichte im Internet beschreiben den Aufbau und die Verarbeitung und kommen grundsätzlich zu einem durchaus positiven Ergebnis. Da ich in der Arbeit auch Fluke Multimeter zur Verfügung habe interessierte mich der direkte Vergleich bei unterschiedlichen Messsignalen. Während dem Vergleich wurden sämtliche verfügbaren Multimeter an den Frequenzgenerator angeschlossen. Zur Überprüfung des Messsignals wurde ein Oszilloskop verwendet. Die theoretischen RMS, AC und DC Werte wurden mittels Taschenrechner ermittelt (Frequenzgenerator-Abweichungen nicht berücksichtigt).\nWährend der Messung viel mir auf, dass die Agilent Messbereichsautomatik bei Signalen mit kleinen Pulsen nicht immer richtig funktioniert (rot markiert). Bei Pulsen kleiner gleich 3ms wurde ein 5V Signal mit einem zu kleinen Mess-Eingangsbereich gemessen. Somit stimmte der angezeigte Wert überhaupt nicht. Nach manueller Auswahl war der Wert wieder korrekt.\nDie Aneng Geräte haben ein sehr gutes Preis/Leistungs-Verhältnis und überzeugen meiner Meinung nach auch bei den Messergebnissen. Dennoch würde ich sie eher nur für Kleinspannungen verwenden, da sie im Bereich Sicherheit nicht ganz durchdacht sind. Bei den tauschbaren Sicherungen handelt es sich um Standard-Schmelzsicherungen, welche für höhere Kurzschlussströme bei Netzspannung nicht ausgelegt sind. Des Weiteren sind die Luft- und Kriechstrecken im Vergleich zu Fluke-Geräten deutlich kleiner dimensioniert.\nFluke 189 Fluke 177 Norma NM 950 Agilent U1233A Agilent U1233A Aneng AN8008 Aneng AN8004 Workzone DT-118 AC Messung 20Hz bis 10kHz 20Hz bis 1kHz 20Hz bis 200kHz 20Hz bis 100kHz 20Hz bis 200kHz 20Hz bis 1kHz 20Hz bis 1kHz 20Hz bis 1kHz Frequenz Messung - 3Hz bis 90kHz 9Hz bis 240kHz 2Hz bis 230kHz 2Hz bis 240kHz 2Hz bis 70kHz - - Pulse T=20ms \u0026gt;=0.2ms \u0026gt;=0.5ms \u0026gt;=0.1ms \u0026gt;=0.2ms \u0026gt;=0.2ms \u0026gt;=0.5ms - - Dauer Puls=1ms\n\u0026lt;=50ms \u0026lt;=100ms \u0026lt;=100ms \u0026lt;=100ms \u0026lt;=100ms \u0026lt;=200ms - - AC Spannungsmessung mit 5Vpp Sinus (1.768V-AC)\n20Hz 1,7131 1,723 1,7193 1,714 1,710 1,727 1,705 1,724 50Hz 1,7246 1,730 1,7271 1,729 1,729 1,728 1,726 1,726 100Hz 1,7262 1,731 1,7282 1,731 1,731 1,727 1,728 1,726 1kHz 1,7269 1,714 1,7277 1,722 1,726 1,726 1,707 1,713 10kHz 1,7202 0,973 1,7155 1,705 1,726 0,000 0,914 1,126 100kHz 1,6758 71,8m 1,7631 1,742 1,766 0,000 0,000 0,373 200kHz 1,3243 0,3m 1,7463 1,681 1,753 0,000 0,000 0,376 500kHz 0,4143 0,2m 1,0253 0,636 1,086 0,000 0,000 0,000 Frequenzmessung mit 5Vpp Sinus\n10Hz - 9,97 9,97 9,97 9,97 9,984 - - 1kHz - 1,000k 999,9 999,9 1,000k 999,9 - - 10kHz - 10,00k 9,999k 10,00k 10,00k 9,999k - - 60kHz - 60,00k 59,99k 59,99k 59,99k 59,99k - - 70kHz - 70,00k 70,00k 69,99k 69,99k 69,89k - - 80kHz - 80,00k 79,99k 79,99k 80,00k 76,32k - - 100kHz - OL 99,99k 99,99k 99,99k 56,xxk - - 200kHz - OL 199,98k 199,9k 199,9k 0,000 - - 230kHz - OL 230,00k 229,9k 229,9k 0,000 - - 240kHz - OL 239,98k 143,6k 239.9k 0,000 - - 270kHz - OL --,--k 0,00 7,48 0,000 - - 50Hz Rechtecksignal, 5Vpp, 0V-DC (2.5V-AC)\nAC 2,4348 2,438 2,440 2,442 2,443 2,430 2,70 2,69 100Hz Rechtecksignal, 5Vpp, 0V-DC (2.5V-AC)\nAC 2,4363 2,433 2,441 2,443 2,445 2,422 2,71 2,69 50Hz, 5ms Puls, 5Vpp, Pulsdauer auf 2.5V, Rest auf -2.5V (2.165V-AC, -1.25V-DC, 2.5V-AC+DC)\nAC 2,1029 2,110 2,112 2,103 2,103 2,102 2,03 2,02 DC -1,1893 -1,189 -1,1892 -1,188 -1,188 -1,189 -1,189 -1,189 AC+DC 2,4172 - (2,422) 2,424 - (2,415) - (2,415) - (2,415) - (2,353) - (2,344) 50Hz, 1ms Puls, 5Vpp, Pulsdauer auf 5.5V, Rest auf 0.5V (0.968V-AC, 0.75V-DC, 1.225V-AC+DC)\nAC 1,0486 1,044 1,0583 274,1m 304,5m 1,044 0,512 0,510 DC 0,7379 0,738 0,7379 0,737 0,737 738,0m 0,738 0,737 AC+DC 1,2818 - (1,279) 1,2902 - (786,3m) - (797,4m) - (1,279) - (0,898) - (0,896) 50Hz, 0.1ms Puls, 5Vpp, Pulsdauer auf 5.5V, Rest auf 0.5V (0.314V-AC, 0.525V-DC, 0.612V-AC+DC)\nAC 0,1028 234,2m \u0026gt;129,79m 59,0m 67,1m 252,2m 0,053 0,051 DC 0,5185 0,519 0,5186 518,2m 518,2m 518,7m 0,518 0,518 AC+DC 0,5300 - (569,4m) 0,6193 - (521,5m) - (522,5m) - (576,8m) - (576,8m) - (520,5m) 10kHz, 10us Puls, 5Vpp, Pulsdauer auf 5.5V, Rest auf 0.5V (1.322V-AC, 1.0V-DC, 1.658V-AC+DC)\nAC 1,4089 456,7m 1,4357 1,387 1,409 000,0 0,377 0,523 DC 0,9824 0,982 0,9819 0,979 0,977 982,8m 0,982 0,982 AC+DC 1,7168 - (1,083) 1,7396 - (1,698) - (1,715) - (982,8m) - (1,052) - (1,113) AC Spannungsmessung bei Variation der Pulsbreite (T=20ms, 5Vpp, Pulsdauer auf 5.5V, Rest auf 0.5V)\n1ms (0.968V) 1,0485 1,044 1,0583 1,054 1,055 1,044 0,512 0,510 0,5ms (0,697V) 0,7470 0,734 0,7565 0,753 0,755 729,7m 0,263 0,260 0,2ms (0,444V) 0,4706 387,6m 0,4798 0,475 0,479 432,2m 0,106 0,105 0,1ms (0,316V) 0,1030 233,9m 0,3384 0,150 0,161 252,2m 0,053 0,051 AC Spannungsmessung bei Variation der Periodendauer (1ms Puls, 5Vpp, Pulsdauer auf 5.5V, Rest auf 0.5V)\n50ms (0,624V) 0,6503 0,664 0,6664 0,65 0,65 668,6m 0,211 0,210 100ms (0,444V) 0,3951 0,44 0,4491 0,40 0,40 475,0m 0,106 0,105 200ms (0,316V) 0,1130 0,25 \u0026gt;60m 0,12 0,12 310,0m 0,091 0,051 ","externalUrl":null,"permalink":"/projects/projekt-027-multimetervergleich/","section":"Projekte","summary":"","title":"Multimeter Vergleich","type":"projects"},{"content":" Software Nach langen Online-Recherchen, nach einen passenden Musik-Player für meine Musik-Sammlung, fand ich kein passendes Exemplar. Einige Player sind mit diversen Funktionen überladen und einige Player erfüllen zwar die geforderten Grundfunktionen, unterstützen aber wiederum keine Tastatur Kürzel. Kurze Zeit später machte ich mich an die Arbeit, den für mich perfekten Player zu programmieren. Damit ich die Grundfunktionen nicht selbst implementieren musste, verwendete ich eine Musik-Library. Für die graphische Oberfläche entschied ich mich für QT von der Firma Trolltech, damit ich das Programm auch auf Linux portieren kann.\nDer Player kann über die GUI per Buttons bedient werden, oder ebenfalls über Tastaturkuerzel die in der INI-Datei eingestellt werden können. Da bei der Initialisierung die standard Mediakeys verwendet werden, kann ich den Player auch mit der Fernbedienung meiner Soundkarte steuern. Die Musik-Dateien werden auf der rechten Seite in einer Explorer-Ansicht ausgewählt und werden mit dem Add-Button in die Playlist übernommen. Eine Playlist ist immer vorhanden, weitere können je nach Wunsch hinzugefügt bzw. entfernt werden. Nach dem Beenden des Players werden alle Playlists, ausser die standardmässig vorhandene, in eine INI-Datei abgespeichert. Somit sind sie beim nächsten Start wieder verfügbar. Damit der Player auch eine angenehme Erscheinung hat, kann er durch spezielle Style-Sheets angepasst werden. Da ich kein begabter Designer bin, habe ich nur eine halbwegs brauchbare Oberfläche erschaffen. Diese kann aber sehr leicht auf eigene Vorstellungen angepasst werden.\nLCD Erweiterung Damit der aktuelle Lied-Titel immer ideal angezeigt werden kann, entwickelte ich ein zusätzliches Display. Dieses LC-Display wird mittels USB an den Rechner angeschlossen. Das USB-Gerät emuliert eine Serielle Schnittstelle, welche für das Ansteuern des LCDs verwendet wird. Somit muss im Player Programm nur eine Serielle Kommunikation durchgeführt werden.\nVersionsinformationen Version 1.41\nPerformance-Probleme behoben Version 1.4\nzu einem Qt Creator Projekt portiert neueste FMOD Library (Library für Einlesen/Abspielen der Musikdateien) externe Display funktioniert im Win7 nicht, da kein Treiber verfügbar Version 1.3\nseparates Programm für LCD Display, somit können es andere Programme ebenfalls nutzen Ausgabe von Systeminformationen Version 1.2\nexternes LCD Display Version 1.1\nDrag and Drop Key Logger für Tastenzuordnung (INI-Datei) Version 1.0\nPlaylist Manager (mehrere Playlisten) speichern aller Playlisten (ausser actual) Tasten für Bedienung einstellbar (INI-Datei) standard Player Features Bilder Links Musik Library GUI Library original USB to Serial Projekt Downloads Wedi Player - Source Dateien\t(ZIP, 350.43 KB) Wedi Player - Windows Installer (externe Display wird benötigt) (ZIP, 4.71 MB) Wedi Player - Windows Installer (ohne Display) (ZIP, 4.62 MB) ","externalUrl":null,"permalink":"/projects/projekt-009-musikplayer/","section":"Projekte","summary":"","title":"Musikplayer / WeDi Player","type":"projects"},{"content":" Linux Befehle USB Stick FTP Server Internet Radio MQTT Server Linux Befehle Befehl Beschreibung ps Auflistung der Prozesse kill -9 Beenden des Prozesses mit ID Ctrl + z Stoppen der Ausführung bg Weitere Ausführung im Hintergrund stty -F /dev/ttyUSB0 -a Ausgabe der Terminal Einstellungen vi file.txt Datei bearbeiten :x Verlassen und Speichern der Änderungen :w Speichern (write) :w file Speichern mit Angabe des Datei Namens (write) :wq Speichern und danach Beenden (write, quit) :q Beenden falls keine Änderungen (quit) :q! Beenden ohne Änderungen zu speichern (quit) ESC Wechsel in den Befehlsmodus i Wechsel in den Einfügemodus - Einfügen vor dem Cursor (insert) a Wechsel in den Einfügemodus - Einfügen nach dem Cursor (append) USB Stick FTP Server Für das einfache Verteilen von USB Stick Daten habe ich mir einen kleinen WiFi Router als WiFi Daten Server konfiguriert. Somit können die Daten vom Handy oder auch von mehreren Rechnern ausgelesen werden. Da der Server nur temporär in Betrieb genommen wird, wenn USB Stick Daten ausgetauscht werden, habe ich mich bezüglich Sicherheit weniger gedanken gemacht.\nAls WiFi Daten Server habe ich beim TP-Link TL-MR3020 v3 das OpenWrt geflasht und konfiguriert. Die HW-Ausstattung ist gerade noch ausreichend um alles zu bedienen: MediaTek MT7628NN mit 575 MHz, 64MB RAM, 8MB Flash, WiFi, 1x Ethernet (100Mbps), 1x USB 2.0 und 1x UART (TP2 \u0026hellip; TX Out, TP1 \u0026hellip; RX In) Anschluss.\nFür das Image flashen wird der Recovery Mode im U-Boot verwendet. Hierfür benötigt man einen TFTP Server (z.B. TFTPD64), der das Image bereitstellt. Die Server IP-Adresse wird statisch auf 192.168.0.225/24 eingestellt. Das Image wird von \u0026ldquo;openwrt-22.03.3-ramips-mt76x8-tplink_tl-mr3020-v3-squashfs-tftp-recovery.bin\u0026rdquo; auf \u0026ldquo;tp_recovery.bin\u0026rdquo; umbenannt und in das TFTP Server Verzeichnis kopiert. Danach wird der Router mit dem Rechner verbunden und die Reset-Taste gedrückt. Mit der gedrückten Reset-Taste wird der Router mit Spannung versorgt. Die Reset-Taste wird danach noch weiter 6-7 Sekunden gedrückt. Erst nach dem Start des Downloads vom TFTP Server kann die Taste losgelassen werden. Nach dem Download schreibt der Router das Image in den Flash Speicher.\nFür das Erkennen des USB Sticks werden einige Packete benötigt. Zum Bereitstellen der Daten habe ich mich für FTP entschieden, da der Samba Server mehr Speicher benötigen würde. Die Packete können über das Webinterface oder über die Command Line (opkg update, opkg install \u0026hellip;) installiert werden.\nKernel Modification Packages kmod_usb_core - Kernel Support für USB kmod_usb_storage - Kernel Support für USB Speicher kmod_usb_storage_uas - Manche USB Sticks benötigen auch den UAS Treiber Packages usbutils - USB Command Line Tool vsftpd - FTP Server Ob der USB Stick erkannt wurde, kann man über Command Line feststellen (lusb -t). Danach kann man den Stick bereits mounten, indem man den Status der Block-Geräte (block detect) in die File-System-Tabelle einträgt (uci import fstab) (/etc/config/fstab). Mit dem nächsten Befehl wird das Mounten zum Start-Zeitpunkt konfiguriert. Hier entspricht \u0026ldquo;/dev/sda\u0026rdquo; dem \u0026ldquo;mount[0]\u0026rdquo; Element, \u0026ldquo;dev/sdb\u0026rdquo; \u0026ldquo;mount[1]\u0026rdquo; usw. Der letzte Befehl dient zum Testen ohne Neustart (/etc/init.d/fstab boot).\n1lsusb -t 2 ... 3 /: Bus 02.Port 1: Dev 1, Class=root_hub, Driver=xhci-mtk/1p, 5000M 4 /: Bus 01.Port 1: Dev 1, Class=root_hub, Driver=xhci-mtk/2p, 480M 5 |__ Port 1: Dev 5, If 0, Class=Mass Storage, Driver=usb-storage, 480M 6 ... 1block detect | uci import fstab 2uci set fstab.@mount[0].enabled=\u0026#39;1\u0026#39; \u0026amp;\u0026amp; uci set fstab.@global[0].anon_mount=\u0026#39;1\u0026#39; \u0026amp;\u0026amp; uci commit fstab 3/etc/init.d/fstab boot Als nächstes wurde der FTP Server konfiguriert. Das automatische Starten wurde in der Weboberfläche unter \u0026ldquo;System/Startup\u0026rdquo; eingestellt. Die Konfigurationsdatei befindet sich unter \u0026ldquo;/etc/vsftpd.conf\u0026rdquo;. Der FTP Ordner wird mittels \u0026ldquo;local_root=/mnt/sda1\u0026rdquo; angegeben. Bei meiner Konfiguration hat nur der root Benutzer Schreib- und Lese-Zugriff. Den anonymen Zugriff habe ich deaktiviert \u0026ldquo;anonymous_enable=NO\u0026rdquo;. Der Passiv-Modus wurde mit \u0026ldquo;pasv_enable=YES\u0026rdquo;, \u0026ldquo;pasv_min_port=40000\u0026rdquo; und \u0026ldquo;pasv_max_port=50000\u0026rdquo; aktiviert.\n1vi /etc/vsftpd.conf 2 background=YES 3 listen=YES 4 local_enable=YES 5 write_enable=YES 6 local_umask=022 7 local_root=/mnt/sda1/ 8 anonymous_enable=NO 9 # 10 pasv_enable=YES 11 pasv_min_port=40000 12 pasv_max_port=50000 13 # 14 userlist_enable=NO Damit die Ports von der Firewall nicht blockiert werden, müssen sie noch über das Webinterface freigegeben werden:\nErlaube eingehende IPv4 Verbindungen mit dem TCP Protokoll von \u0026ldquo;any zone\u0026rdquo; zu \u0026ldquo;this device\u0026rdquo; mit den Ports 20-21 Erlaube eingehende IPv4 Verbindungen mit dem TCP Protokoll von \u0026ldquo;any zone\u0026rdquo; zu \u0026ldquo;this device\u0026rdquo; mit dem Port 990 Erlaube eingehende IPv4 Verbindugne mit dem TCP Protokoll von \u0026ldquo;any zone\u0026rdquo; zu \u0026ldquo;this device\u0026rdquo; mit den Ports 40000-50000 Internet Radio Da bei der Terrasse ein schlechter UKW Radio Empfang ist, habe ich eine zuverlässige Internet Radio Lösung gesucht. Die meisten erwerbbaren Internet Radios konnte ich nicht verwenden, da sie mit Displays bestückt sind. Die meisten Displays würden keinen Winter mit Minustemperaturen standhalten. Somit blieben zwei \u0026ldquo;einfache\u0026rdquo; Möglichkeiten übrig: Linux Router mit OpenWrt oder WiFi Controller mit FreeRTOS (z.B. ESP32). Die Linux Router Variante erschien mir zuerst etwas einfacher.\nAls Hardware Platform entschied ich mich für den NanoPi R1 von Friendly Elec. Das Grundgerät mit 512MB RAM und SD Karte als Datenspeicher reicht bereits aus und ist z.B. über Amazon sehr günstig. Die weitere HW Ausstattung mit Quad-Core Cortex A7, BLE, WiFi, 2x Ethernet (1Gbps, 100Mbps), 2x USB 2.0 und 2 UART Anschlüsse ist ebenso beeindruckend. Weitere Informationen findet man auf der Friendly Elec Wiki Seite. Die Audio-Ausgabe kann man einfach über einen USB Klinkenadapter mit integrierter Soundkarte realisieren. Hier habe ich mich für ein Produkt von DUKABEL entschieden. Die genaue Modell Bezeichnung lautet DUSB351M-120B. Den Klinkenstecker verband ich direkt mit einem einfachen Verstärker, welcher die Lautsprecher ansteuert.\nAls Betriebssystem für den Router wird von Friendly Elec jeweils ein Image von UbuntuCore und OpenWRT im Downloadbereich bereitgestellt. Das Angebotene OpenWRT mit FriendlyWrt 19.07.1 ist bereits älter und könnte Sicherheitslücken haben. Da es hier \u0026ldquo;nur\u0026rdquo; als Internet Radio verwendet wird, sind die Sicherheitsupdates weniger kritisch und wurden hier nicht betrachtet. Wird ein aktuelles OpenWrt benötigt, so kann man die Images von der OpenWrt Seite verwenden. Diese Images beinhalten etwas weniger vorinstallierte Packages und sind somit vielleicht noch nicht so einfach zu verwenden. Für das Schreiben auf die SD Karte kann man unter Windows den Win32 Disk Imager verwenden.\nNach dem Schreiben des Images und dem Starten des Routers kann man die Weboberfläche über die LAN Schnittstelle erreichen. Hier sollte man sofort das Admin Passwort setzen. Als nächsten Schritt werden die benötigten Packages für das Internet Radio über die Weboberfläche installiert (siehe Liste unterhalb). Für die kmod-Pakete musste ich noch den Link für die kmod-Pakete in der opkg Konfiguration auskommentieren. Die Warnung, dass die Kernel-Version nicht übereinstimmt war bei mir kein Problem.\nKernel Modification Packages kmod_usb_core - Kernel Support für USB kmod_usb_audio - Kernel Support für USB Audio Karten Packages usbutils - USB Command Line Tool alsa_lib - Audiofunktion unter Linux, ALSA = Advanced Linux Sound Architecture alsa_utils - ALSA Command Line Tool mpd_mini - MPD = Music Player Daemon mpc - Command Line Tool für MPD Nach der Installation kann man den Internet Radio über die Command-Line Website (ttyd Package) bereits testen. Zuerst sollte man überprüfen, ob die USB-Soundkarte erfolgreich gefunden wurde (lusb, lusb -t, aplay -l). Für die MPD Konfiguration kann man sich gleich den Namen merken (Device). Für die MPD Lautstärken Regelung benötigt man auch noch die ALSA Mixer Information (amixer controls): die ID (numid=1) und den Interface-Typ (iface=MIXER).\n1lsusb 2 ... 3 Bus 008 Device 004: ID 1b3f:2008 Generalplus Technology Inc. 4 ... 5 6lsusb -t 7 ... 8 /: Bus 08.Port 1: Dev 1, Class=root_hub, Driver=ohci-platform/1p, 12M 9 |__ Port 1: Dev 4, If 0, Class=Audio, Driver=snd-usb-audio, 12M 10 |__ Port 1: Dev 4, If 1, Class=Audio, Driver=snd-usb-audio, 12M 11 |__ Port 1: Dev 4, If 2, Class=Audio, Driver=snd-usb-audio, 12M 12 |__ Port 1: Dev 4, If 3, Class=Human Interface Device, Driver=usbhid, 12M 13 ... 14 15aplay -l 16 **** List of PLAYBACK Hardware Devices **** 17 ... 18 card 4: Device [USB Audio Device], device 0: USB Audio [USB Audio] 19 Subdevices: 1/1 20 Subdevice #0: subdevice #0 21 ... 1amixer controls 2 numid=1,iface=MIXER,name=\u0026#39;Master Volume\u0026#39;; 3 ... Danach kann man direkt den MPD konfigurieren (vi /etc/mpd.conf, /etc/init.d/mpd restart) und testen (mpd \u0026amp;, mpc add \u0026hellip;, mpc volume 90, mpc play). Die angegebenen Ordner im root User-Verzeichnis musste ich vorher noch erstellen. Als \u0026ldquo;user\u0026rdquo; habe ich \u0026ldquo;root\u0026rdquo; eingetragen. Somit wird im Anschluss beim automatischen Starten über das init-Skript auch das root User-Verzeichnis verwendet. Aus Sicherheitsgründen sollte man hier einen eigenen User anlegen und ebenso die Verzeichnisse in dessen User-Verzeichnis anlegen und verwenden. Aufgrund der eingeschränkten Nutzungszeit des Radios habe ich den Admin-Benutzer direkt verwendet. Damit das Command Line Tool MPC den MPD steuern kann muss die Loopback Adresse 127.0.0.1 angegeben werden. Am Ende wird noch das Audio Interface und der Mischer bekannt gegeben.\n1vi /etc/mpd.conf 2 music_directory \u0026#34;~/music\u0026#34; 3 playlist_directory \u0026#34;~/.mpd/playlists\u0026#34; 4 db_file \u0026#34;~/.mpd/database\u0026#34; 5 log_file \u0026#34;~/.mpd/log\u0026#34; 6 user \u0026#34;root\u0026#34; 7 bind_to_address \u0026#34;127.0.0.1\u0026#34; 8 audio_output { 9 type \u0026#34;alsa\u0026#34; 10 name \u0026#34;USB Audio Device\u0026#34; 11 device \u0026#34;plughw:Device\u0026#34; 12 mixer_type \u0026#34;software\u0026#34; 13 mixer_control \u0026#34;MIXER\u0026#34; 14 mixer_index \u0026#34;1\u0026#34; 15 } 1mpd \u0026amp; 2mpc add http://ors-sn05.ors-shoutcast.at/oe3-q2a 3mpc volume 90 4mpc play Damit der Internet Radio sofort nach dem Boot-Vorgang startet, braucht man nur die Test-Befehle im Startup-Skript \u0026ldquo;/etc/rc.local\u0026rdquo; eintragen. Für einen Reibungslosen Start wird hier aber noch eine Pause von ca. 10 Sekunden eingefügt. Somit sind alle benötigten Treiber geladen und die Internetverbindung hergestellt bevor der MPD gestartet wird.\n1sleep 10 2mpd \u0026amp; 3mpc add http://ors-sn05.ors-shoutcast.at/oe3-q2a 4mpc volume 90 5mpc play Folgende URLs von Österreichischen Radio-Sendern können zum Testen verwendet werden:\nhttp://ors-sn05.ors-shoutcast.at/oe1-q1a OE1 128kbs http://ors-sn05.ors-shoutcast.at/oe1-q2a OE1 192kbs http://ors-sn05.ors-shoutcast.at/oe3-q1a OE3 128kbs http://ors-sn05.ors-shoutcast.at/oe3-q2a OE3 192kbs http://ors-sn05.ors-shoutcast.at/fm4-q1a FM4 128kbs http://ors-sn05.ors-shoutcast.at/fm4-q2a FM4 192kbs http://ors-sn05.ors-shoutcast.at/noe-q1a Radio NOE 128kbs http://ors-sn05.ors-shoutcast.at/noe-q2a Radio NOE 192kbs http://ors-sn05.ors-shoutcast.at/wie-q1a Radio Wien 128kbs http://ors-sn05.ors-shoutcast.at/wie-q2a Radio Wien 192kbs MQTT Server MQTT (Message Queuing Telemetry Transport) wird in vielen Bereichen und vor allem im Home Automation Bereich immer beliebter. Bei MQTT handelt es sich um ein klassisches Publish und Subscribe Protokoll. Die Daten werden vom Sensor einfach in einem bestimmten Topic bereitgestellt (z.B. sensors/nr1/temperature). Jeder Actor kann sich auf gewünschte Topics registrieren (subscribe) und erhält die Daten dadurch automatisch. Die Daten an sich werden in einem Server (broker) zwischengespeichert, der auch für die Verteilung zuständig ist.\nBeim klassischen MQTT werden bei jeder Transaktion die Topic Strings mit übertragen. Um diesen Overhead zu reduzieren wurde eine abgewandelte Variante mit MQTT-SN spezifiziert. SN steht hier für Sensor-Network und bedeutet eine schlankere und datensparsamere Übertragung für kleinere Sensor-Netzwerke wie z.B. Zigbee, 802.15.4/Thread \u0026hellip; Bei meiner Umgebung verwendete ich ein MQTT-SN Gateway für die Anbindung von Zigbee Geräten. Hierfür wird ein Zigbee-fähiger RF-Stick benötigt.\nMit der reinen MQTT Umgebung können die Daten bereits ausgetauscht werden. Sollen zusätzlich noch Aktionen gestartet werden oder die Daten grafisch aufbereitet werden, so kann man Node-RED verwenden. Mit Hilfe von Node-RED kann man gewünschte Abläufe (flows) einfach mit einer grafischen Oberfläche \u0026ldquo;programmieren\u0026rdquo; und mit dem Zusatzpaket \u0026ldquo;Dashboard\u0026rdquo; auch visualisieren.\nDen ersten Test-Server habe ich mit dem NanoPi R1S-H3 von Friendly Elec realisiert. Folgende Pakete werden für den MQTT Broker, den RF Stick, dem MQTT-SN Gateway und Node-RED benötigt. Für das Erkennen des USB Sticks werden einige Packete benötigt. Die Packete können über das Webinterface oder wieder über die Command Line (opkg update, opkg install \u0026hellip;) installiert werden.\nKernel Modification Packages kmod_usb_core - Kernel Support für USB kmod_usb_serial - Kernel Support für USB Serial Konverter kmod_usb_serial_ftdi - Treiber für FTDI USB Serial Chips Packages usbutils - USB Command Line Tool mosquitto-nossl - Mosquitto ohne SSL Verschlüsselung luci-app-mosquitto - Mosquitto Integration in die Weboberfläche (LuCi) node - NodeJS node-npm - NodeJS Package Manager Für die manuelle Installation der Kernel Mods findet ihr unterhalb ein Beispiel. Zuerst wird wieder überprüft, ob das angeschlossene USB FTDI Kabel grundsätzlich erkannt wurde (lsusb). Danach werden die zusätzlichen Pakete heruntergeladen (wget) und installiert (opkg install). Nach einem Neustart sollte das Gerät bereits untern \u0026ldquo;/dev/\u0026rdquo; als \u0026ldquo;ttyUSB*\u0026rdquo; gefunden werden.\n1lsusb 2wget https://downloads.openwrt.org/releases/19.07.1/targets/sunxi/cortexa7/packages/kmod-usb-serial_4.14.167-1_arm_cortex-a7_neon-vfpv4.ipk 3wget https://downloads.openwrt.org/releases/19.07.1/targets/sunxi/cortexa7/packages/kmod-usb-serial-ftdi_4.14.167-1_arm_cortex-a7_neon-vfpv4.ipk 4opkg install kmod-usb-serial_4.14.167-1_arm_cortex-a7_neon-vfpv4.ipk --force-depends 5opkg install kmod-usb-serial-ftdi_4.14.167-1_arm_cortex-a7_neon-vfpv4.ipk --force-depends 6reboot 7cd /dev/ 8ls Die Installation von Node-RED muss man über den NodeJS Paket Manager durchführen. Hierfür gibt es kein OpenWrt Paket. Mit den beiden Befehlen unterhalb wird Node-RED installiert und für erste Tests bereits gestartet. Der Zugriff erfolgt über die Geräte IP Adresse und Port 1880 (z.B. http://192.168.1.100:1880).\n1npm install -g --unsafe-perm node-red 2node-red 3 29 Apr 11:07:26 - [info] 4 5 Welcome to Node-RED 6 =================== 7 8 29 Apr 11:07:26 - [info] Node-RED version: v1.3.3 9 29 Apr 11:07:26 - [info] Node.js version: v8.16.1 10 29 Apr 11:07:26 - [info] Linux 4.14.111 arm LE 11 29 Apr 11:07:32 - [info] Loading palette nodes 12 29 Apr 11:07:38 - [info] Settings file : /root/.node-red/settings.js 13 29 Apr 11:07:38 - [info] Context store : \u0026#39;default\u0026#39; [module=memory] 14 29 Apr 11:07:38 - [info] User directory : /root/.node-red 15 29 Apr 11:07:38 - [warn] Projects disabled : editorTheme.projects.enabled=false 16 29 Apr 11:07:38 - [info] Flows file : /root/.node-red/flows_FriendlyWrt.json 17 29 Apr 11:07:38 - [info] Creating new flow file 18 29 Apr 11:07:38 - [info] Server now running at http://127.0.0.1:1880/ 19 29 Apr 11:07:38 - [info] Starting flows 20 29 Apr 11:07:38 - [info] Started flows 21 29 Apr 11:52:19 - [info] [mqtt-broker:Local Mosquitto] Verbindung zum Broker mqtt://127.0.0.1:1883 aufgebaut Für das automatische Starten im Anschluss wird ein Init-Skript installiert. Hierfür wird das Skript nach \u0026ldquo;/etc/init.d\u0026rdquo; heruntergeladen und mit Ausführ-Rechten versehen. Danach wird die Log-File GUI Integration für LuCI heruntergeladen. Nach einem Neustart sollte alles automatisch gestartet werden.\n1cd /etc/init.d/ 2wget https://github.com/dceejay/openwrt-node-red/raw/master/node-red 3chmod a+x node-red 4cd /usr/lib/lua/luci/view/admin_status 5wget https://raw.githubusercontent.com/dceejay/openwrt-node-red/master/luci/view/admin_status/nrlog.htm 6cd /usr/lib/lua/luci/controller/admin 7wget https://raw.githubusercontent.com/dceejay/openwrt-node-red/master/luci/controller/admin/status.lua 8reboot Für eine grafische Ausgabe der Daten bzw. mögliche Benutzer-Interaktionen benötigt man das Node-RED Dashboard. Dieses wird wieder mit den NodeJS Paket Manager installiert. Danach kann man das Dashboard unter dem Port 1800 und Sub-URL \u0026ldquo;ui\u0026rdquo; erreichen (z.B. http://192.168.1.100:1800/ui).\n1cd /usr/lib/node_modules/node-red/ 2npm install node-red-dashboard Das MQTT-SN Gateway muss man leider noch selbst kompilieren und als Paket verpacken (wird hier nicht beschrieben). Danach kann man es auf den Router mit Hilfe von Putty Secure Copy (pscp) vom Windows Rechner kopieren. Mit dem zweiten Befehl kann man auch Dateien vom Router zum Windows Rechner kopieren. Die Installation erfolgt wieder mit dem Paket Manager (opkg install). Für erste Tests startet man die Binär-Datei mit angegebener Konfigurationsdatei (MQTT-SNGateway). In der Konfigurationsdatei werden die Seriellen Parameter und die Verbindungsdaten vom MQTT Broker angegeben (/etc/mqttsn-gw/gateway.conf).\n1pscp -scp mqtt-sn_1.0.0-1_arm_cortex-a7_neon-vfpv4.ipk root@192.168.88.254:/tmp 2pscp -scp root@192.168.88.254:/etc/init.d/mqtt-sn ./ 1opkg install mqtt-sn_1.0.0-1_arm_cortex-a7_neon-vfpv4.ipk 2/usr/bin/MQTT-SNGateway -f /etc/mqttsn-gw/gateway.conf Für das automatische Starten wird wieder ein Init-Skript vorbereitet und unter \u0026ldquo;/etc/init.d/mqtt-sn\u0026rdquo; abgelegt. Die Befehle unterhalb dienen zum testen ohne Neustart (mqtt-sn start/stop/restart).\n1#!/bin/sh /etc/rc.common 2# Starts and stops MQTT-SN GW 3# /etc/init.d/mqtt-sn 4 5START=90 6STOP=10 7 8# PID and binary file for start-stop-daemon 9PIDFILE=/var/run/mqtt-sn.pid 10DAEMON=/usr/bin/MQTT-SNGateway 11 12# test if binary exists and execute permission is granted 13test -x ${DAEMON} || exit 0 14 15export PATH=\u0026#34;${PATH:+$PATH:}/usr/sbin:/sbin\u0026#34; 16 17start() { 18 echo \u0026#34;Starting MQTT-SN Gateway\u0026#34; 19 if start-stop-daemon -S -q -b -m -p ${PIDFILE} -x ${DAEMON} -- -f /etc/mqttsn-gw/gateway.conf ; then 20 exit 0 21 else 22 exit 1 23 fi 24} 25 26stop() { 27 echo \u0026#34;Stopping MQTT-SNGateway\u0026#34; 28 if start-stop-daemon -K -q -s SIGKILL -p ${PIDFILE}; then 29 rm -f ${PIDFILE} 30 exit 0 31 else 32 exit 1 33 fi 34} 35 36restart() { 37 echo \u0026#34;Restarting MQTT-SNGateway\u0026#34; \u0026#34;MQTT-SNGateway\u0026#34; 38 if start-stop-daemon -K -q -s SIGKILL -p ${PIDFILE}; then 39 rm -f ${PIDFILE} 40 fi 41 if start-stop-daemon -S -q -b -m -p ${PIDFILE} -x ${DAEMON} -- -f /etc/mqttsn-gw/gateway.conf ; then 42 exit 0 43 else 44 exit 1 45 fi 46} 1/etc/init.d/mqtt-sn start 2/etc/init.d/mqtt-sn restart 3/etc/init.d/mqtt-sn stop ","externalUrl":null,"permalink":"/projects/projekt-032-openwrt/","section":"Projekte","summary":"","title":"OpenWRT","type":"projects"},{"content":"Die Parrot Bebop Drone ermöglicht sehr schöne Luftaufnahmen. Die höchstmögliche Auflösung erhält man indem man die Bildaufnahme auf RAW konfiguriert. Dadurch werden die rohen Daten des Bildsensors abgespeichert. Das ermöglicht eine spätere Optimierung der Bilder. Eine weitere gute Einstellung ist JPG 180°. Bei dieser Einstellung wird auch das gesamte Bild des Sensors gespeichert, jedoch wird das Bild mit JPEG komprimiert.\nDie 180° Aufnahmen sind zwar auch sehr interessant anzusehen, dennoch bevorzuge ich eine etwas entzerrtere Darstellung. Eine von Parrot dargestellte Möglichkeit, die Bilder von den Linseneffekten zu befreien, wird mit Adobe Lightroom erreicht. Lightroom enthält für die Parrot Linse ein Linsenkorrekturprofil (LCP, lense correction profile). Da ich Luftaufnahmen nur gelegentlich mache, war es mir zu teuer Lightroom zu erwerben. Daher entschloss ich mich einen einfachen Entzerralgorithmus selbst zu implementieren.\nDas Resultat kann in den Beispielbildern betrachtet werden. Das C#-Programm steht unterhalb kostenfrei zur Verfügung.\nOriginal Aufnahme Entzerrtes Bild Downloads Programm - Fischaugen Entzerrung (ZIP, 6.99 KB) ","externalUrl":null,"permalink":"/projects/projekt-026-fisheyedeskew/","section":"Projekte","summary":"","title":"Parrot Bebop Drone - Fischaugen Entzerrung","type":"projects"},{"content":" E/EEPROM Programmer AVR ISP (In System Programmer) AVR JTAG (Joint Test Action Group) E/EEPROM Programmer Da ich für mein GameBoy Projekt dringendst einen EPROM/EEPROM Programmer benötigte, versuchte ich im Internet einen günstigen zu erstehen. Da diese aber ziemlich teuer waren, suchte ich nach einer Alternative und fand den WillemProgrammer bei Ebay. Dieser Bausatz beinhaltete alle Bauteile und die Software ist frei downloadar. Nachdem ich einen Bausatz von Silvotronic ersteigerte lötete ich ihn zusammen. Damit die Kontakte an der unteren Seite des Boards nicht kaputt gehen bestellte ich bei RS-Components ein Entwicklungsgehäuse.\nProbiert habe ich ihn mit einem alten UV-EPROM aus einem Mainboard. Die Daten wurden alle korrekt ausgelesen. Da ich aber kein UV Löschgerät besitze bestellte ich mir einen elektrisch löschbaren Speicher (EEPROM).\nBilder Links Elektronik Versandhaus - RS Components Elektronik Versandhaus - Conrad Leiterplatinentechnik für Willem-Programmer, \u0026hellip; - OFFLINE AVR ISP (In System Programmer) Für meine weiteren Projekte im Microcontroller Bereich erstellte ich mir einen handlichen ISP, welcher an die serielle Schnittstelle des PCs angeschlossen wird. Dieser Programmer besteht aus wenigen standard Bauteilen und kann schnell aufgebaut werden. Die Programmierung des Chips kann nicht mit dem AVR-Studio durchgeführt werden, sonder man benötigt ein separates Programm. Ich verwende PonyProg, welches frei erhältich ist.\nBilder Links Programmier Software AVR JTAG (Joint Test Action Group) Damit ich besser ausgestattete Controller auch debbugen kann, baute ich den Nachbau des AVR JTAG ICE MKI nach. Der verwendete ATMega16 wird mit einem Bootloader programmiert, der zwischen zwei Modi umgeschaltet werden kann. Im JTAG Modus nimmt er die ersten Sekunden (solange die JTAG LED blinkt) ein Firmware-Update aus dem AVR-Studio entgegen. Danach arbeitet er wie ein gewöhnlicher JTAG und kann mit dem AVR Studio verbunden werden. Im ISP Modus können die Microcontroller programmiert werden. Dabei ist zu beachten dass die Pinbelegung nicht mit dem standard ISP Stecker übereinstimmt. Der ISP Modus stimmt mit der AVR910 Application Note überein und kann mit dem im AVR Studio integrierten AVR Progr programmiert werden, bzw. man verwendet ein separates Tool: AvrOspII. Da viele modernen Computer oft keine serielle Schnittstelle mehr besitzen, entschied ich mich für einen USB auf Serial Adapter von FTDI. Der gewünschte Modus (JTAG, ISP) kann mittels Jumper eingestellt werden.\nBilder Links Bootloader HEX File - OFFLINE Opto-Isolated JTAG - OFFLINE ","externalUrl":null,"permalink":"/projects/projekt-004-programmer/","section":"Projekte","summary":"","title":"Programmer","type":"projects"},{"content":"In diesem Bereich finden sie verschiedene Projekte oder technische Zusammenfassungen. Die Liste unterhalb ist alphabetisch geordnet. Die Menü-Liste ist nach der Zeit der Erstellung sortiert. Sämtliche Inhalte wurden von mir selbst erstellt oder es wurde eine Abmachung mit dem Urheber getroffen, dessen Inhalte anzubieten.\nProjekte:\n","externalUrl":null,"permalink":"/projects/","section":"Projekte","summary":"","title":"Projekte","type":"projects"},{"content":"Mit Hilfe von Qucs (Quite Universal Circuit Simulator) kann das Ergebnis einer Schaltungssimulation mit einer Scriptsprache nachverarbeitet werden. Somit kann man z.B. echte Messdaten eines Sensors mit dem Schaltungssimulator analog aufbereiten (verstärken, filtern, \u0026hellip;) und danach mit Hilfe der Scriptsprache direkt Controler-mäßig verarbeiten.\nDie Programme findet man unter http://qucs.sourceforge.net/ und https://www.gnu.org/software/octave/. Qucs muss man nur entpacken und kann ohne Installation gestartet werden (qucs.bat). Der Projekt-Ordner wird automatisch unter \u0026ldquo;C:\\Users\\xxx.qucs\u0026quot; angelegt. Octave wird mit Hilfe des Installers installiert und legt danach ein Icon für die eigene Oberfläche am Desktop an. Damit Qucs die Octave Umgebung findet muss sie noch in den Einstellungen eingetragen werden. Dafür wird der Octave Pfad auf \u0026ldquo;C:\\Octave\\Octave-5.1.0.0\\mingw64\\bin\\octave.bat\u0026rdquo; gesetzt.\nDanach kann man bereits ein neues Projekt anlegen und den Schaltplan grafisch eingeben. Das Test-Projekt beinhaltet eine Datei basierende Spannungsquelle. Somit kann man das Signal durch die Daten einer csv-Datei vorgeben. Um die gewünschten Signale anschließend wiederzufinden werden noch Labels gesetzt.\nMit Hilfe des Data Displays können die Ergebnisse der Schaltungssimulation betrachtet werden.\nDas Octave Post-Processing Script kann unter den Schematic Einstellungen (Rechts-Klick \u0026gt; Document Settings) eingetragen werden. Des Weiteren kann hier auch das automatische Abarbeiten des Scripts ausgewählt werden.\nMit Hilfe von Qucs Funktionen können die Simulationsergebnisse eingelesen werden (loadQucsDataSet, getQucsVariable). Die weitere Verarbeitung kann mit dem Octave-Syntax und Funktionen erfolgen (sehr ähnlich zu Matlab).\n1% testing of Octave post processing 2 3function void = test() 4 % threshold parameters 5 thr_ris = 0.5; % rising threshold 6 thr_fal = 0.2; % falling threshold 7 8 9 data = loadQucsDataSet(\u0026#34;test.dat\u0026#34;); 10 11 if isempty(data) 12 printf(\u0026#34;no data available\u0026#34;); 13 else 14 %showQucsDataSet(data); 15 16 time = getQucsVariable(data, \u0026#34;time\u0026#34;); 17 sgnl = getQucsVariable(data, \u0026#34;Uout.Vt\u0026#34;); 18 19 % show filtered signal 20 figure(1) 21 AH(1) = subplot(4,1,1); 22 plot(time, sgnl); 23 grid on 24 25 26 %% tresholding of signal with hysteresis 27 sgnl_length = size(sgnl, 2); 28 sgnl_ris = double(sgnl \u0026gt; thr_ris); 29 sgnl_fal = double(sgnl \u0026lt; thr_fal); 30 31 sgnl_ris_edg = sgnl_ris - circshift(sgnl_ris, [0 1]); 32 sgnl_fal_edg = sgnl_fal - circshift(sgnl_fal, [0 1]); 33 34 % show thresholded signal 35 AH(3) = subplot(4,1,2); 36 plot(time, sgnl_ris_edg); 37 ylim([-0.5 1.5]) 38 grid on 39 40 AH(3) = subplot(4,1,3); 41 plot(time, sgnl_fal_edg); 42 ylim([-0.5 1.5]) 43 grid on 44 45 46 sgnl_edges = double(sgnl_ris_edg \u0026gt; 0) - ... 47 double(sgnl_fal_edg \u0026gt; 0); 48 sgnl_thr = cumsum(sgnl_edges); 49 50 while((max(sgnl_thr) \u0026gt; 1) || (min(sgnl_thr) \u0026lt; 0)) 51 first = find(sgnl_thr \u0026gt; 1, 1, \u0026#39;first\u0026#39;); 52 if (size(first,2) \u0026gt; 0) 53 sgnl_thr(1, first:sgnl_length) = ... 54 sgnl_thr(1, first:sgnl_length) - 1; 55 end 56 57 first = find(sgnl_thr \u0026lt; 0, 1, \u0026#39;first\u0026#39;); 58 if (size(first,2) \u0026gt; 0) 59 sgnl_thr(1, first:sgnl_length) = ... 60 sgnl_thr(1, first:sgnl_length) + 1; 61 end 62 end 63 64 % show threshoulded signal 65 AH(3) = subplot(4,1,4); 66 plot(time, sgnl_thr); 67 ylim([-0.5 1.5]) 68 grid on 69 70 end 71endfunction Nach Eingabe eines Fehlerfreien Scripts kann die Ausgabe betrachtet werden. Falls die Ausgabe aus irgendeinem Grund hängen bleibt, kann man das Ausgabe Toolkit ändern. Bei Eingabe von \u0026ldquo;graphics_toolkit\u0026rdquo; erhält man das aktuell verwendete Toolkit (bei mir z.B. \u0026ldquo;ans = fltk\u0026rdquo;). Mit \u0026ldquo;graphics_toolkit(\u0026lsquo;gnuplot\u0026rsquo;)\u0026rdquo; stellt man auf gnuplot um.\nDas original QUCS wird nicht mehr aktiv weiterentwickelt. Als Alternative kann man QUCS-S oder QUCS Studio verwenden. Einen Überblick erhält man mit diesem Artikel.\nLinks Qucs-S (Qucs with SPICE) QucsStudio Downloads Test Projekt - Source Dateien (ZIP, 154.17 KB) ","externalUrl":null,"permalink":"/projects/projekt-028-qucs/","section":"Projekte","summary":"","title":"QUCS","type":"projects"},{"content":" Laternen Radio Autoradio Box Lautsprecher Ständer Beton Lautsprecher Lautsprecher Umschaltbox Laternen Radio Für die geplante Sitzecke im Hof-Innenbereich sollte ein Radio verfügbar sein, welcher fix montiert werden kann. Da vor kurzem die Aussenlampe durch ein neueres Modell ersetzt wurde, war ein atraktives Gehäuse übrig. Dieses Gehäuse wurde zunächst Sandgestrahlen und mit weißem Lack besprüht (erledigte ein guter Freund: Christian H.). Danach wurden zwei Lautsprecher eingebaut. Diese besitzen eine Kunststoff-Membran, sollten also auch im Freien lange Zeit durch halten. Als Radio diente ein altes Kassetten-Walkman-Radio, welches für die Bedienung bereits Taster verwendet. Für die Verstärkung des Radiosignals wurde ein alter Verstärker aus Computer-Lautsprechern verwendet.\nSchaltet man den Radio separat aus, so kann man auch ein externes Audio-Signal einspeißen (z.B. MP3-Player). Das Kabel für diesen Audio-Eingang dient des weiteren auch als Antenne.\nBilder Autoradio Box Da ich noch einige Radio-Komponenten übrig hatte, entschloss ich mich diese sinnvoll zu lagern und baute eine Holzkiste. Diese Kiste beinhaltet sämtliche Lautsprecher, Verstärker und einen Autoradio. Die Box besteht aus dem Holz unseres Waldes und ist ziemlich massiv ausgefallen.\nBilder Lautsprecher Ständer Lautsprecher-Ständer, die zum Kauf angeboten werden, sind zwar meistens sehr gut gefertigt, kosten aber sehr viel Geld. Da die Lautsprecher am Boden auch nicht sehr dekorativ wirken, wollte ich zumindest einfache Ständer selbst bauen. Damit die Ständer einen stabilen Stand haben, besorgte ich mir metallene Tischfüße. Eine Seite der Tischfüße ist direkt dafür vorgesehen mit einer Platte verschraubt zu werden. Das andere Ende hat ein Plastik-Gewinde, welches eigentlich für die Höhenverstellung vorgesehen ist. Somit kann an beiden Enden eine Platte einfach montiert werden. Die Platten wurden einfach rechteckig ausgeschnitten, geschliffen und lackiert. Damit die Bodenplatte nicht direkt am Boden steht klebte ich noch Gummifüße daran.\nBilder Beton Lautsprecher Nach dem Durchblättern einer Zeitschrift bekam ich eine neue Projekt-Idee. Die Idee bestand darin, ein Lautsprechergehäuse aus Beton zu bauen. Für die Durchführung braucht man eine \u0026ldquo;Schalung\u0026rdquo;, eine Zement-Mischung, ein kleines Metall-Gitter und viel Geduld bei der Drocknung. Als Schalung habe ich günstige Plastigboxen verwendet. Für die zusätzliche Stabilität des Betons habe ich einen Hasenstall-Zaun zugeschnitten und mittig mit einbetoniert. Zur Befestigung der Frontplatten habe ich des Weiteren noch Schrauben mit einbetoniert. Nach dem Trocknen (ca. 2 Wochen) musste ich nur die Oberseiten abschleifen. Die Außenseiten habe ich ohne weitere Schleifarbeiten so belassen, wie sie nach dem Betonieren waren. Für die Montage der Lautsprecher verwendete ich Leimholzplatten aus Buche.\nBilder Lautsprecher Umschaltbox Für das einfache Einschalten eines Radios für die Terrassenlautsprecher bzw. Lautsprecher in der Werkstatt dahinter gab es keine fertige Lösung. Daher entschied ich mich die Elektronik selbst zu bauen. Mit der Box kann man von zwei verschiedenen Schaltern, die auch von unterschiedlichen Phasen gespeist werden können, den Radio aufdrehen und die gewünschten Lautsprecher auswählen. Sind beide Schalter eingeschaltet, so gibt es ein bevorzugtes Lautsprecher-Paar.\nBilder Downloads Lautsprecher Umschaltbox KiCAD Dateien (ZIP, 55.72 KB) Laustprecher Umschaltbox Gerber Dateien (ZIP, 18.44 KB) ","externalUrl":null,"permalink":"/projects/projekt-015-laternenradio/","section":"Projekte","summary":"","title":"Radio, Lautsprecher Projekte","type":"projects"},{"content":" Hardware Für einen schnellen Aufbau eines Controllers mit LAN Anschluss fehlte mir die Zeit. Da ich ein aufmerksamer Leser der Computerzeitschrift ct bin, wurde mir diese Arbeit abgenommen. Denn das hier verwendete Modul PortX, der die Konvertierung von RS232 auf LAN uebernimmt, war ideal für mein Einsatzgebiet. Somit googlete ich kurz und fand gleich ein passendes Board. Das Board wurde ebenfalls von der ct-Redaktion entwickelt und konnte über Segor bezogen werden. Der Aufbau war rasch vollzogen. Die Platinen und die Schaltungsbeschreibungen waren sehr gut.\nLinks Elektronik Versandhaus - RS Components Elektronik Versandhaus - Conrad Anbieter des Bausatzes - Segor Entwickler des Boards - Heise ","externalUrl":null,"permalink":"/projects/projekt-007-rs232tolan/","section":"Projekte","summary":"","title":"RS232 to LAN Converter","type":"projects"},{"content":" Übertragungsfunktion Die Übertragungsfunktion (Transfer Function … TF) oder Systemfunktion beschreibt mathematisch den Bezug zwischen Eingangssignal und Ausgangssignal eines Systems. Mit Hilfe der Systemfunktion lässt sich zu jedem Eingangssignal das Ausgangssignal ermitteln. Das hier betrachtete System besteht aus einer elektronischen Schaltung, im speziellen ein Zwei-Tor (1 Eingangs- und 1 Ausgangs-Tor … 2 Eingangs- und 2 Ausgangsanschlüsse).\nS-Parameter Die Streuparameter (Scattering Parameter … S-Parameter) beschreiben den Amplituden- und Phasen-Bezug zwischen einer eingehenden und übertragenen/reflektierten Welle. In der HF-Technik werden sie oft verwendet um ein Zwei-Tor zu beschreiben bzw. zu vermessen (z.B. mittels VNWA (Vector Network Analyzer)).\nZwei-Tor Übertragungsfunktion aus S-Parameter Mit S21 erhält man den Bezug von Eingangswelle und Ausgangswelle, wobei die reflektierte Welle nicht betrachtet wird. Bei korrekt abgeschlossenem Eingang (Zin = Z0) stimmt S21 mit der Übertragungsfunktion überein. Falls Zin ungleich Z0 ist, wird am Eingang eine Welle reflektiert. S21 beschreibt aber weiterhin den Übertragungsfaktor mit korrekt abgeschlossenem Eingang. Somit muss man die reflektierte Welle noch selbst einbeziehen, um wieder auf die Übertragungsfunktion schließen zu können.\nS-Paramter aus Übertragungsfunktion Durch Umformen der oberen Formeln kann man auch die S-Parameter aus Werten der Übertragungsfunktion und Eingangsimpedanz berechnen.\nBeweis durch Simulation Beim ersten Plot-Fenster sieht man, dass S21 mit der Übertragungsfunktion nicht übereinstimmt. Bei dem zweiten Plot-Fenster wird die Übertragungsfunktion dargestellt. Hierbei ist erkenntlich, dass die berechnete Ausgabe aus den S-Parametern komplett übereinstimmt. Die Kurven überlagern sich vollständig. Bei dem dritten Plot-Fenster wird S21 dargestellt. Wieder stimmen die berechneten Ausgaben aus der Übertragungsfunktion und der Eingangsimpedanz überein.\nEntkoppelung des Ausganges Damit das Zwei-Tor am Ausgang nicht mit 50Ω belastet wird, kann man die Messung auch mit einem Spannungsfolger durchführen. Die Operationsverstärker-Schaltung besitzt einen sehr hohen Eingangswiderstand und belastet den Zwei-Tor fast nicht. Des Weiteren könnte vor dem Spannungsfolger auch ein anderer Lastwiderstand angebracht werden. Somit käme das Verhalten dieser Messung dem Verhalten im realen Einsatz bereits ziemlich nahe.\nVollständige Entkoppelung Durch das Entkoppeln des Einganges erhält man mit der S21 Messung direkt die Übertragungsfunktion. Die VNWA Ausgangsbuchse wird mit 50Ω belastet. Die Entkoppelung wird wieder mit einem Spannungsfolger erreicht. Dadurch wird die Eingangswelle nicht reflektiert und Vin ist gleich Vin-matched. Der Spannungsfolger vor der VNWA Eingangsbuchse dient zum Entkoppeln des Zwei-Tor Ausganges. Somit wird der Zwei-Tor Ausgang nicht mit dem VNWA Eingangswiderstand belastet.\nLinks National Instruments - Network Analyzer Introduction Keysight - Measuring Frequency Response with the LF Network Analyzer Downloads Artikel zum Downloaden (PDF, 576.98 KB) LTSpice Simulations-Dateien (ZIP, 3.26 KB) ","externalUrl":null,"permalink":"/projects/projekt-029-sparam/","section":"Projekte","summary":"","title":"S-Parameter vs. Übertragungsfunktion","type":"projects"},{"content":" Hardware Wird für dieses Projekt ein ausgemusteter Schrittmotor verwendet, so muss zu Beginn der interne Spulenaufbau des Motors analysiert werden. Bei meinem Motor wars einfach, es gab 6 Kabeln, drei davon gehören zusammen. Für die Beschaltung als Generator werden von den drei Kabeln jeweils die beiden äußeren benötigt (gesehen aus der Spulenanordnung).\nNachdem ich die vier benötigten Kabeln hatte, schloss ich sie an einen Gleichrichter an. Die Pluspole und Minuspole werden miteinander verbunden. Der Minuspol wird direkt an den Kondensator und an die Led angelötet. Man muss aber auf die Polung vom Kondensator und der Led achten. Den Pluspol lötet man auf den Kondensator und den Widerstand an. Das andere Ende des Wid. wird an das Potentiometer gelötet und dessen andere Ende an die Led. Jetzt braucht nur mehr gedreht werden und die Led sollte leuchten. Der Potentiometer dient zum Einstellen der Helligkeit und der Leuchtdauer. Bei meinen Aufbauten ist das Gehäuse oft das größere Problem, da meistens kein passendes zur Verfügung steht. Deshalb bekam die Schaltung eine Isolierband Umhüllung.\nBilder Links Elektronik Versandhaus - RS Components Elektronik Versandhaus - Conrad ","externalUrl":null,"permalink":"/projects/projekt-002-schrittmotorleuchte/","section":"Projekte","summary":"","title":"Schrittmotor Leuchte","type":"projects"},{"content":" ISO / OSI Modell IP Adressen Versionsverwaltung (SVN, GIT) ISO / OSI Modell Nr. OSI Schicht Einordnung TCP/IP Protokolle Einheiten Hardware 7 Anwendung Anwendungsorientiert Anwendung DHCP Daten Gateway (Application) DNS Proxy 6 Darstellung FTP Layer 4-7 Switch (Presentation) HTTP 5 Sitzung MQTT (Session) 4 Transport Transportorientiert Transport TCP Segmente (TCP) (Transport) UDP Datagramme (UDP) 3 Vermittlung Internet ICMP Pakete Router (Network) IGMP Layer-3 Switch IP 2 Sicherung Netzzugriff IEEE 802.3 Ethernet Frames Bridge (Data Link) IEEE 802.11 WLAN Access Point MAC Layer-2 Switch 1 Bitübertragung 1000BASE-T Bits, Symbole Kabel (Physical) Token Ring Repeater Hub 1. Bitübertragungsschicht / Physical Layer (z.B.: Ethernet - 100BASE-T) In dieser Schicht werden die mechanischen, elektrischen und physikalischen Eigenschaften definiert, um Bits über ein Transportmedium übertragen zu können. Durch die Verwendung verschiedener Modulationsverfahren können auch mehrere Bits pro Zustand in Symbolen codiert und übertragen werden.\n2. Sicherungsschicht / Data Link Layer (z.B.: Ethernet - IEEE 802.3) Diese Schicht übernimmt die Sicherstellung einer zuverlässigen und weitgehend fehlerfreien Übertragung. Meistens ist auch eine Zugriffsregelung auf das Übertragungsmedium (Media Access Control MAC), eine Datenflusskontrolle für die dynamische Steuerung der Geschwindigkeit, das Aufteilen des Datenstromes in Frames und das Hinzufügen von Prüfsummen für eine Fehlererkennung bzw. -korrektur inkludiert. Das wiederholte Senden verworfener Frames wird von höheren Schichten übernommen.\n3. Vermittlungsschicht / Network Layer (z.B.: Internet Protocol) Diese Schicht sorgt für die Vermittlung von Paketen über das gesamte Kommunikationsnetz. Bei der Vermittlung sind die Stauvermeidung (Congestion Avoidance), das Fragmentieren von Datenpaketen (Aufteilen der Pakete, falls die Größe die max. Übertragungseinheit der Netzwerkschnittstelle überschreitet), die Wegesuche (Routing) und das Bereitstellen netzwerkübergreifender Adressen inkludiert.\n4. Transportschicht / Transport Layer (z.B.: TCP / UDP) Die Aufgaben dieser Schicht ist das Segmentieren des Datenstromes (Segmentgröße wird vom Sender und Empfänger ausgehandelt), die Flusssteuerung bzw. Staukontrolle und gegebenenfalls das Sicherstellen einer fehlerfreien Übertragung (TCP mit garantierter Zustellung, UDP ohne). Die Adressierung innerhalb dieser Schicht erfolgt über Port-Nummern.\n5. Sitzungsschicht / Session Layer (z.B.: FTP / HTTP / MQTT) In dieser Schicht werden die logischen Verbindungen gesteuert und so für eine Prozesskommunikation zwischen zwei Systemen gesorgt. Somit können ausgefallene Transportverbindungen wieder synchronisiert werden, ohne bei der Übertragung von vorne beginnen zu müssen.\n6. Darstellungsschicht / Presentation Layer (z.B.: FTP / HTTP / MQTT) Diese Schicht sorgt für das Umsetzen von einer systemabhängigen Darstellung in eine unabhängige Form, sowie für die Datenkompression und Verschlüsselung. Damit wird ein syntaktisch korrekter Datenaustausch zwischen unterschiedlichen Systemen garantiert.\n7. Anwendungsschicht / Application Layer Diese Schicht stellt Funktionen für die Anwendung zur Verfügung und stellt die Verbindung zu den unteren Schichten her. Hier findet die Daten Ein- und Ausgabe für die Anwendung statt. Die Anwendung selbst ist kein Teil dieser Schicht.\nIP Adressen IPv4 4 Blöcke mit jeweils 8 Bit / 1 Dezimalzahl durch „.“ getrennt 192.168.0.10 Netznotation 192.168.0.0/24 entspricht 192.168.0.0 bis 192.168.0.255 Netzwerk Angabe 192.168.0.10/24 beinhaltet IPv4 Adresse 192.168.0.10 und Subnetzmaske 255.255.255.0 Die Subnetzmaske wird verwendet, um zu entscheiden, ob ein Paket an den Provider oder einen anderen Router im eigenen Netz oder überhaupt nicht weitergeleitet wird.\n0.0.0.0/8 Standard Route 127.0.0.0/8 Loopback Adressen 10.0.0.0/8 Link Local Adressen - Netzklasse A 172.16.0.0/12 Link Local Adressen - Netzklasse B 192.168.0.0/16 Link Local Adressen - Netzklasse C 169.254.0.0/16 Link Local Adressen, falls DHCP fehlgeschlagen ist IPv6 8 Blöcke mit jeweils 16 Bit / 4 Hexadezimalstellen durch „:“ getrennt 2001:0db8:85a3:08d3:0000:ffff:c0a8:000a Führende Nullen innerhalb eines Blockes dürfen weggelassen werden 2001:db8:85a3:8d3:0:ffff:c0a8:a Ein oder mehrere Blöcke mit Wert 0 dürfen vereinfacht mit „::“ dargestellt werden, aber maximal einmal 2001:db8:85a3:8d3::ffff:c0a8:a Für die letzten beiden Blöcke darf die herkömmliche dezimale Notation verwendet werden 2001:db8:85a3:8d3::ffff:192.168.0.10 Netznotation 2001:db8:85a3:8d3::/64 entspricht 2001:0db8:85a3:08d3:0000:0000:0000:0000 bis 2001:0db8:85a3:08d3:ffff:ffff:ffff:ffff Der Internet Service Provider ISP bekommt mit den ersten 32 Bit ein Netz zugewiesen 2001:db8::/32 Der ISP weist dem Endkunden ein Netz von typ. 2001:db8:85a3::/48 bis 2001:db8:85a3:8d3::/64 zu\n::/128 bzw. 0:0:0:0:0:0:0:0/128 nicht spezifizierte Adresse / Adresse falls noch nicht initialisiert ::/0 bzw. 0:0:0:0:0:0:0:0/0 Standard Route ::1/128 bzw. 0:0:0:0:0:0:0:1/128 Loopback Adresse (entspricht bei IPv4 127.0.0.1/32) fe80::/64 Link Local (Unicast) Adressen (LLA) lokales Netz mit Hubs/Switches bis zum ersten Router, wird nicht weiter geroutet fc00::/7 Unique Local (Unicast) Adressen (ULA) fc00::/8 für global zugewiesene / zentral verwaltete Adressen fd00::/8 für lokal zugewiesene / verwaltete Adressen ff00::/8 Multicast Adressen nach ff folgen 4 Bits für Flags und 4 Bits für den Gültigkeitsbereich Flag-Kombinationen 0: Permanent definierte wohlbekannte Multicast-Adressen 1: (T-Bit gesetzt) Transient (vorübergehend) oder dynamisch zugewiesene Multicast-Adressen 3: (P-Bit gesetzt, erzwingt T) Unicast-Prefix-based Multicast-Adressen 7: (R-Bit gesetzt, erzwingt P und T) Multicast-Adressen, welche die Adresse des Rendezvous-Points enthalten Gültigkeitsbereiche 1: interface-lokal – diese Pakete verlassen die Schnittstelle nicht (Loopback) 2: link-lokal – werden von Routern grundsätzlich nicht weitergeleitet und können deshalb das Subnetz nicht verlassen 4: admin-lokal – der kleinste Bereich, dessen Abgrenzung in den Routern speziell administriert werden muss 5: site-lokal – dürfen zwar geroutet werden, jedoch nicht von Border-Routern 8: organisations-lokal – die Pakete dürfen auch von Border-Routern weitergeleitet werden, bleiben jedoch „im Unternehmen“ e: globaler Multicast, der überallhin geroutet werden darf 0, f: reservierte Bereiche die restlichen Bereiche sind nicht zugewiesen und dürfen von Administratoren benutzt werden, um weitere Multicast-Regionen zu definieren Beispiele für wohlbekannte Multicast-Adressen ff01::1, ff02::1: All-Nodes Adressen, entspricht dem Broadcast in einem Bereich ff01::2, ff02::2: All-Routers Adressen, adressiert alle Router in einem Bereich ff01::101, ff02::101 All-NTP Adressen, adressiert alle Zeitserver 0:0:0:0:0:ffff::/96 IPv4 mapped IPv6 Adressen – letzten 32 Bit enthalten die IPv4 Adresse 2000::/3 IANA vergebene globale Unicast Adressen (GUA) – routbar, weltweit 2001::/32 Adressen für Tunnelmechanismus Teredo 2001:db8::/32 Adressen für Dokumentationszwecken Versionsverwaltung (SVN, GIT) Damit man bei Software-Projekten die vergangenen Änderungen und die Übersicht nicht verliert, verwendet man gerne Versionsverwaltungssysteme wie Subversion oder Git. Bei der Verwendung solcher Systeme können sämtliche Änderungen am Source-Code nachverfolgt und auch verglichen werden. Des Weiteren können unterschiedliche Entwicklungspfade (z.B. unterschiedliche Versionen für unterschiedliche Betriebssysteme bzw. Hardware-Systeme) einfach verwaltet werden.\nDas wichtigste bei der Verwendung von Subversion oder Git ist, dass beim Einpflegen eines neuen SW-Standes immer auch Kommentare eingetragen werden. Somit kann man Änderungen folgen, ohne gleich den Source Code durchsehen zu müssen. Damit Projekte mit mehreren Entwicklern tatsächlich übersichtlich bleiben, muss man sich zuvor gut überlegen, wie man die Versionsverwaltungs-Funktionen verwendet. D.h. für gewisse Vorgänge (Tagging, Branching, Submodule Handling) sollte es einen definierten Prozess geben.\nSubversion Bei Subversion (SVN) handelt es sich um ein zentrales Versionsverwaltungssystem. Jeder Benutzer arbeitet mit einer lokalen Kopie und muss sich beim Einpflegen von Änderungen mit dem Server verbinden. Ein lokales Einpflegen von Änderungen ist nicht möglich. Solange man offline arbeitet, gibt es keine Möglichkeit, Änderungen mit Kommentaren einzupflegen. Somit fehlt zu dieser Zeit auch die Möglichkeit bereits funktionierenden Code sicher abzulegen und gegebenenfalls wieder zurück zu holen.\nDeutsch:\nzentrale Versionsverwaltung Einpflegen, \u0026hellip; benötigt Verbindung zum Repository jeder Benutzer arbeitet mit einer Kopie vom Repository die History ist nur zentral verfügbar Verzweigen und Zusammenführen ist zeitaufwändiger Revisionsnr. wird für einen bestimmten Zustand des Repositorys vergeben, der sich über die Zeit nicht mehr verändert Inhalte werden in Dateien abgelegt Inhalt wird nicht gehashet um Datenfehler vorzubeugen Englisch:\ncentralized version control must be connected to commit, \u0026hellip; each user has a copy of the repository local copy doesn\u0026rsquo;t contain the history branching and merging is time-consuming revision nr. is a snapshot of the repository at any given time content is stored within files doesn\u0026rsquo;t have hashed content Weitere nützliche Subversion Informationen findet man unter:\nBuch geschrieben von Subversion-Entwickler Git Bei Git handelt es sich um ein verteiltes Versionsverwaltungssystem. Die Benutzer arbeiten mit einer kompletten Kopie (Klon) des Repositories, History usw. mit eingeschlossen. Somit können Repository Änderungen auch lokal und offline erfolgen. Diese Möglichkeit erfordert dadurch eine unterschiedliche Arbeitsweise. Anstelle von den Subversion Basis-Kommandos Commit und Update, gibt es Commit (lokal), Push (remote) und Pull (remote).\nDeutsch:\nverteilte Versionsverwaltung Einpflegen, \u0026hellip; auch lokal/offline möglich jeder Benutzer arbeitet mit einem Klon des Repositorys die History ist auch offline verfügbar Verzweigen und Zusammenführen einfacher keine globale Revisionsnr. verfügbar Inhalte werden als Metadaten abgelegt Inhalte werden kryptographisch mit SHA-1 Checksumme versehen Englisch:\ndistributed version control can work locally/offline each user has a copy of the full repository local copy contains the complete repository, incl. the history easy to fork/branch and merge no global revision nr. available content is stored as metadata content is cryptographically check-summed using SHA-1 hash algorithm Bei Git gibt es vier Arbeitsbereiche: die lokale Arbeitskopie, den Index Bereich für das nächste Commit, das lokale Repository und das remote Repository. Mit der Grafik unterhalb sieht man die unterschiedlichen Wirkungsbereiche der Befehle.\nFür das Abzweigen innerhalb eines Projektes für zusätzliche Features, Bugfixing, \u0026hellip; gibt es unterschiedliche Ansätze. Ein möglicher Ansatz ist git-flow (siehe Grafik unterhalb). Diese Methode ist aber bereits sehr komplex und erfordert viel Disziplin bei den Software-Entwicklern. Für viele kleine Projekte bzw. kleinere Entwicklungsteams reichen vereinfachte Methoden.\nFür das lokale Versionieren kann Git folgendermaßen verwendet werden:\ngit init Anlegen eines Repositories im aktuellem Verzeichnis git add . Alles Hinzufügen mit Beachtung von .gitignore git status Status-Ausgabe des Repositories git commit -m 'message' Speichern der hinzugefügten Dateien im lokalem Repository Nach Dateiänderungen git add . Hinzufügen aller Änderungen für den nächsten Commit git add asdf.txt Hinzufügen einzelner Änderungen für den nächsten Commit git status Repository Status (Änderungen, Staged Dateien) git commit -m 'message' Speichern der Änderungen im lokalem Repository git commit -a -m 'message' Hinzufügen und Speichern aller Änderungen im lokalem Repository (inkl. gelöschter, exkl. hinzugef. Dateien) Nachträgliches Verbinden mit einem Remote Server git remote add origin https://gitlab.com/path/repo.git Hinzufügen eines Remote Servers als \u0026ldquo;origin\u0026rdquo; Für das Arbeiten mit einem Repository Server braucht man folgende Kommandos:\ngit clone https://user@gitlab.com/path/repo.git Klonen eines Repositories ins Verzeichnis \u0026ldquo;repo\u0026rdquo; (ins lokale Repository) git clone https://gitlab.com/path/repo.git ./proj Klonen eines Repositories ins Verzeichnis \u0026ldquo;proj\u0026rdquo; --branch \u0026lt;branch\u0026gt; Klonen eines bestimmten Branches -depth=1 Klonen mit Angabe der Tiefe (hier z.B. aktueller Commit) Übernahme möglicher Remote Änderungen git fetch Abrufen aller Änderungen des getrackten Branches des Remote Repositories git fetch --all Abrufen aller Änderungen aller Branches aller konfigurierten Remote Repositories git fetch \u0026lt;remote\u0026gt; Abrufen aller Änderungen aller Branches von einem bestimmten Remote Repository git fetch \u0026lt;remote\u0026gt; \u0026lt;branch\u0026gt; Abrufen aller Änderungen eines Branches von einem bestimmten Remote Repository git fetch https://user@gitlab.com/path/repository.git Abrufen aller Änderungen aller Branches des Remote Repositories origin Standard Remote Repository origin main Standard Main Branch des Standard Remote Repositories git pull --no-commit Übernehmen der Remote Änderungen des getrackten Branches in die lokale Kopie ohne Merge und Commit git pull Übernehmen der Remote Änderungen inklusive Merge und Commit git pull --rebase Übernehmen der Remote Änderungen inklusive Rebase und Commit git pull \u0026lt;remote\u0026gt; Übernehmen der Remote Änderungen von einem bestimmten Remote inklusive Merge und Commit git pull \u0026lt;remote\u0026gt; \u0026lt;branch\u0026gt; Übernehmen der Remote Änderungen von einem bestimmten Remote und Branch inklusive Merge und Commit Branches verwalten (wechseln, erstellen oder löschen) git branch Ausgabe aller lokalen Branches git branch -r Ausgabe aller Remote Branches git branch -a Ausgabe aller lokalen und Remote Branches git branch -d \u0026lt;branch\u0026gt; Löschen eines Branches (nur wenn er gemerged wurde) git branch -D \u0026lt;branch\u0026gt; Erzwingtes Löschen eines Branches git checkout \u0026lt;branch\u0026gt; Wechsel zu einem Branch git checkout -b \u0026lt;branch\u0026gt; Erstellen eines Branches, mit Wechsel dahin git branch \u0026lt;branch\u0026gt; Erstellen eines Branches, ohne Wechsel dahin Nach Dateiänderungen git add . Hinzufügen aller Änderungen für den nächsten Commit git add asdf.txt Hinzufügen einzelner Änderungen für den nächsten Commit git status Repository Status (Änderungen, Staged Dateien) git commit -m 'message' Speichern der Änderungen ins lokale Repository git commit -a -m 'message' Hinzufügen und speichern aller Änderungen ins lokale Repo (inkl. gelöschter, exkl. hinzugefügter Dateien) git push Übernehmen der lokalen Kopie in das Remote Repository git push \u0026lt;remote\u0026gt; \u0026lt;branch\u0026gt; Übernehmen der lokalen Kopie in das Remote Repository Weitere nützliche Git Informationen findet man unter:\nGit Einführung Handhabung von Submodulen Branching Modell ","externalUrl":null,"permalink":"/projects/projekt-030-softwareueberblick/","section":"Projekte","summary":"","title":"Software Überblick","type":"projects"},{"content":"","externalUrl":null,"permalink":"/en/tags/","section":"Tags","summary":"","title":"Tags","type":"tags"},{"content":" Aufbau Das Projekt entstand durch die notwendige Überwachung der Pumpwasser-Temperatur, da die Pumpe in einer isolierten Box im Aussenbereich angebracht ist. Der Temperatur Server ermöglicht das Betrachten von drei Temperaturen (aussen, innen, Pumpe) und löst beim Unterschreiten einer einstellbaren Temperatur einen Alarmton aus, des weiteren wird auch eine E-Mail versendet. Das Projekt beruht auf den LAN to RS232 Adapter, der mit einem LCD und drei Temperatur Eingängen erweitert wurde.\nDas Gerät ist über vier Tasten vor Ort zu steuern. Eine Taste aktiviert bzw. deaktiviert das Licht des Displays, die zweite Taste schaltet zwischen den Display Darstellungen um und die letzten beiden Tasten dienen zum Erhöhen bzw. Erniedrigen der Temperatur-Schwelle. Die Website, welche auch zur Darstellung der Temperaturen dient, ist unter der Geräte IP-Adresse erreichbar. In dieser Seite sind sämtliche Temperaturen ersichtlich und weiters kann das LCD-Licht aktiviert und die minimale Temperatur verändert werden.\nBilder Links Elektronik Versandhaus - RS Components Elektronik Versandhaus - Conrad Anbieter des Bausatzes - Segor Entwickler des Boards - Heise Downloads Temperatur Client - Source Datein (ZIP, 6.6 KB) Temperatur Client - Binary Datein (ZIP, 11.09 KB) Temperatur Server - Source Datein (ZIP, 12.55 KB) Temperatur Server - Binary Datein (ZIP, 7.83 KB) ","externalUrl":null,"permalink":"/projects/projekt-010-tempserver/","section":"Projekte","summary":"","title":"Temperatur Server","type":"projects"},{"content":" Einige Informationen Name: Werner Dichler Beruf: HW/SW Architect, Technical Project Manager, Lead Electronic Engineer, Lead Embedded Software Engineer Bereich: Schutzschaltgeräte, Building Automation, IoT Hobbies: Elektronik, Programmieren, Holzbearbeitung, Ausflüge mit der Familie Wohnort: Waldviertel - Niederösterreich Ausbildung: Studium, Bundesheer, Matura mit Ingenieursausbildung, Hauptschule, Volksschule Frau: Barbara Tochter: Mara Geschwister: Wolfgang, Michaela Ferialjobs Nach dem ersten Ausbildungsjahr an der HTL Hollabrunn besorgte ich mir einen Ferialjob im Lagerhaus Zwettl, in der Elektronikabteilung. Meine Tätigkeiten lagen in der Verkabelung von Neubauten, wobei auch das Stämmen und Aufräumen Teil der Arbeit waren. Ich machte große Erfahrungen im Elektroinstallations-Bereich.\nDen nächsten Ferienjob nahm ich im Lagerhaus Gmünd, ebenfalls in der Elektronik-Abteilung, an. Hauptaufgaben lagen im Zusammenbauen von Verteilerkästen und in der Programmierung einiger SPSen.\nIm anschließenden Jahr war ich wieder bei der selben Firma. Dieses Mal benutzte ich CAD Programme um Schaltpläne zu zeichnen.\nNach dem Erfolgreichen Abschluss der HTL mit Matura, hatte ich noch ca. ein halbes Jahr bis zum Einrückungstermin. Deshalb ging ich wieder auf Jobsuche. Es war nicht so einfach einen Job in der IT Braunche zu finden, da die Zeit einfach zu kurz war. Zu meinem Glück bekam ich eine Stelle bei den Elk-Fertigteilhäusern als Wasserinstallateur. Ich war zwar nur als Hilfsarbeiter angestellt, aber das war der ideale Job bis zum Heer.\nZwischen dem Studium war ich als GUI Entwickler bei Profactor in Steyr tätig. Ich erstellte eine graphische Oberfläche für die Bearbeitung von Bildern. Die Oberfläche sollte einfach mit Algorithmen für die Bildbearbeitung ergänzt werden können. Für die GUI wurden die Microsoft Fundation Classes (MFCs) verwendet.\nEbenfalls zwischen dem Studium, arbeitete ich bei der Firma CDE in Hagenberg. Ich war bei der Entwicklung von Medizin-Geräten tätig, wobei die Programmierung von Mikrokontrollern, die Entwicklung der elektronischen Schaltung und die Programmierung von Embedded Software für Windows XP Embedded zu meinen Aufgaben gehörten.\nFachhochschule Im September 2005 begann ich mein Studium an der FH Hagenberg. Im Juni 2008 schloss ich das Bachelor-Studium HSSE (Hardware Software System Engineering) mit einem ausgezeichneten Erfolg ab. Das anschließende Master-Studium ESD (Embedded Systems Design) beendete ich im Juni 2010 mit einem guten Erfolg.\nFH Hagenberg FH Oberösterreich\nHöhere Technische Lehranstallt In den Jahren 1999 bis 2004 besuchte ich die HTBLA in Hollabrunn - Fachrichtung Technische Informatik. Neben allgemeinen Fächern, wie Geographie, Geschichte, \u0026hellip;, wurden viele technische Lehrinhalte übermittelt. Die Ausbildung stand auf einem hohen Niveau und ermöglichte das weitere Computer-bezogene Studium.\nHTL Hollabrunn\nBundesheer Eingerückt bin ich in der Lichtenstein-Kaserne bei Allentsteig. Das Wetter war zu Beginn noch wunder schön, doch ein/zwei Tage später begann es zu schneien. Die Grundausbildung hatte ich nach 3 Wochen hinter mir, da ich mir eine Schleimbeutelentzündung (Knie) zuzog. Nach der Grundausbildung und der Zeit im Heeres-Spital kam ich zum Erkundungs- und Vermessungs-Trupp (EVT). Das war eine gute Position mit interessanten Tätigkeiten - messen, rechnen und Pläne zeichnen. Dabei lernte ich das Vermessen von Strecken. Des weiteren war mein Kollege ein lustiger Typ, so hatten wir immer eine \u0026ldquo;Gaudi\u0026rdquo;. In den ersten Wochen machten wir einen ABC-Abwehr Kurs, welcher ebenfalls sehr interessant war. Zum Glück hatte es immer Minus-Grade, da wir mit dem schweren Schutzanzug herum maschieren mussten. Zirka in der Mitte vom Grundwehrdienst hatten wir den Grenzeinsatz im Burgenland und kurz vor dem Abrüsten hatten wir noch einen Katastropheneinsatz in Tirol (Hochwasser). Also, insgesammt war das Bundesheer eine schöne und auch sinnvoll genutzte (Einsätze) Zeit.\n","externalUrl":null,"permalink":"/myself/","section":"WeDi","summary":"","title":"Über Mich","type":"page"},{"content":" Welcome My name is Werner Dichler, and I am passionate about electronics and software development. On this website, I share some of my personal tech projects — initiated during my studies and continuously expanded with new ideas and developments.\nAdditionally, this website serves as a documentation platform for fascinating technical topics that interest me.\nCurrently, the website is only available in German. Due to time constraints, a translation is not planned at the moment.\n","externalUrl":null,"permalink":"/en/","section":"WeDi","summary":"","title":"WeDi","type":"page"},{"content":" Hardware Für viele Projekte oder Versuchsaufbauten benötigt man oft verschiedene Spannungen, z.B. für Operationsverstärker +-12V. Da ich kein Labornetzteil in meinem Besitz habe, überlegte ich mir schon länger, wie ich ein eigenes einfach aufbauen könnte. Nach einen kurzen Blick ins Internet kam ich auf die Idee ein altes Computernetzteil umzubauen. Diese Netzteile liefern viele verschiedene Spannungen (+-5V, +-12V, GND), somit sind sie optimal, für den Einsatz im Labor, geeignet. Um das Netzteil zur gänze vom Strom zu nehmen baute ich einen 2 poligen Schalter bei der Versorgungsleitung ein. Damit der Einschaltzustand zu erkennen ist, wird an der PWRGood-Leitung ein LED mit Vorwiderstand angelötet. Die einzelnen Spannungen werden direkt von den Kabeln abgegriffen, welche mit den Buchsen verlötet werden. Da ältere Netzteile vielleicht nicht Kurzschlussfest sind, habe ich eine Sicherungshalterung zwischen der GND-Buchse und der GND-Leitung montiert. Diese Sicherung sorgt also nur für Sicherheit, wenn das GND Potential verwendet wird.\nSpannungen: 5V (+5, 0), 7V (+12, +5), 10V (+5, -5), 12V (+12, 0), 17V (+5, -12), 24V (+12, -12)\nTip: Manche ATX-Netzteile brauchen immer eine mindest Belastung um eingeschalten zu bleiben, für diesen Zweck kann man einen Leistungswiderstand als Verbraucher direkt im inneren anschließen.\nPinnbelegungen XT Stecker Pin Funktion Kabelfarbe 1 PWR Good Orange 2 +5V Rot 3 +12V Gelb 4 -12V Blau 5 Masse Schwarz 6 Masse Schwarz 7 Masse Schwarz 8 Masse Schwarz 9 -5V Weiß 10 +5V Rot 11 +5V Rot 12 +5V Rot ATX Stecker Pin Funktion Kabelfarbe 1 +3,3V Orange 2 +3,3V Orange 3 Masse Schwarz 4 +5V Rot 5 Masse Schwarz 6 +5V Rot 7 Masse Schwarz 8 Power OK Grau 9 +5V STB Violett 10 +12V Gelb 11 +3,3V Orange 12 -12V Blau 13 Masse Schwarz 14 PS-ON Grün 15 Masse Schwarz 16 Masse Schwarz 17 Masse Schwarz 18 -5V Weiß 19 +5V Rot 20 +5V Rot Bilder Links Elektronik Versandhaus - RS Components Elektronik Versandhaus - Conrad ","externalUrl":null,"permalink":"/projects/projekt-005-labornetzteil/","section":"Projekte","summary":"","title":"XT Netzteil \u003e Labornetzteil","type":"projects"}]