DefCon Projects - User contributions [en]

Ramdisk unter Linux

2025-10-19T06:46:10Z

Webmaster: Remove file

Eine Ramdisk ist ein Teil des Arbeitsspeichers der für das PC-System wie eine Festplatten Partition aussieht. Das erstellen einer Ramdisk kann unter bestimmten umständen Hilfreich sein, wenn man z.B. möchte das bestimmte Daten, Logdateien, etc. nach einem Neustart des Rechners nicht mehr existent sind (siehe Quellen). Mittels einer Ramdisk lässt sich aber auch ein Geschwindigkeitvorteil erreichen, wenn Webserver wie Apache komplett in der Ramdisk gestartet werden.

== Skript ==

Das Skript prüft zunächst ob ein entsprechendes Ramdisk-Device exisiert. Ist das der Fall wird ein
Ordner erstellt auf dem dann die Ramdisk, nach entsprechenden erstellen eines Dateisystems (in diesem Fall ext2), gemountet wird.

Das Skript erstellt je nach Einstellung des System ein Ramdisk mit unterschiedlicher Größe. Bei RHEL6 ist die Ramdisk in der
Standardkonfiguration 15Mb groß.

<syntaxhighlight lang="c">
#! /bin/bash

# Prüfen ob ramdisk-Gerät schon erstellt wurde
if [ -e /dev/ram0 ]
then
echo [+] Ramdisk Gerät /dev/ram0 existiert schon
else
echo [-] Ramdisk Gerät /dev/ram0 existiert nicht
fi

# Prüfen ob der Ordner schon existiert
if [ -e "/mnt/ramdisk" ] && [ -d "/mnt/ramdisk" ]
then
echo [+] Ordner /mnt/ramdisk existiert schon
else
mkdir /mnt/ramdisk
echo [-] Ordner /mnt/ramdisk erstellen
fi

echo [+] Ramdisk mit ext2 Dateisystem formatieren
/sbin/mke2fs -q -m 0 /dev/ram0

echo [+] Ramdisk mounten
/bin/mount /dev/ram0 /mnt/ramdisk

echo [+] Berechtigungen setzen
/bin/chmod 0750 /mnt/ramdisk
</syntaxhighlight>

== Quellen ==

[http://www.netzwelt.de/news/73686-razorback2-razzia-abgeschaltet.html Razorback2 abgeschaltet]

Main Page

2025-02-03T06:21:29Z

Webmaster: /* Artikelübersicht */

[[File:Daniel Duesentrieb.jpg]]

Willkommen in meinem Wiki!
Hier dreht sich alles um (Elektronik)projekte die ich mal durchgeführt habe.
Ich werde hier in unregelmäßigen Abstände mal das ein oder andere
Projekt beschreiben.

Viel Spaß



== Artikelübersicht ==
[[RWE-Wallbox]] - [[Pollin AVR-NetIO PHP Wrapper]] - [[Ätzmaschine]] - [[Ramdisk unter Linux]] - [[RS232/RS485-Wandler]] - [[Nulldurchgangserkennung]] - [[Lötrauchabsaugung]] - [[PC-Maus als Drehzahlmesser]] - [[GPS Laptimer]] - [[Platinenfräsmaschine]] - [[WLAN Richtfunkantenne]] - [[Laptimer]] - [[OsmocomBB]] - [[SDR mit DVB-T Stick]] - [[ESP8266]] - [[Sonoff POW]] - [[Samsung Galaxy Ace disassembled]] - [[Cafissimo Picco Hack]] - [[LED-Tisch]] - [[Mail bei YUM Updates]] - [[Mail bei dmesg Output]]

Mail bei dmesg Output

2025-02-03T06:20:47Z

Webmaster: Created page with "Manchmal ist es praktisch wenn man bei neuen Kernel-Meldungen informiert wird. Dieses Skript informiert euch per Mail wenn es zu einem neuen Eintrag im dmesg Protokoll gekommen ist. == Skript == <syntaxhighlight lang="c"> #!/bin/bash # Email configuration TO_ADDRESS="admin@example.com" SUBJECT="New dmesg Entry Detected for $(hostname)" MAIL_CMD="/usr/bin/mail" # Make sure the mail command is installed # Temporary file to store the last state of dmesg DMESG_LAST="/tmp/..."

Manchmal ist es praktisch wenn man bei neuen Kernel-Meldungen informiert wird. Dieses Skript informiert euch per Mail wenn es zu einem neuen Eintrag im
dmesg Protokoll gekommen ist.

== Skript ==
<syntaxhighlight lang="c">
#!/bin/bash

# Email configuration
TO_ADDRESS="admin@example.com"
SUBJECT="New dmesg Entry Detected for $(hostname)"
MAIL_CMD="/usr/bin/mail" # Make sure the mail command is installed

# Temporary file to store the last state of dmesg
DMESG_LAST="/tmp/dmesg_last"

# Initialize the dmesg_last file if it doesn't exist
if [ ! -f "$DMESG_LAST" ]; then
dmesg > "$DMESG_LAST"
exit 0
fi

# Capture the current state of dmesg
DMESG_CURRENT=$(dmesg)

# Compare with the last state
if ! diff "$DMESG_LAST" <(echo "$DMESG_CURRENT") > /dev/null; then
# Get the new entries
NEW_ENTRIES=$(diff "$DMESG_LAST" <(echo "$DMESG_CURRENT") | grep '>' | sed 's/^> //')

# Send an email with the new entries
echo "$NEW_ENTRIES" | $MAIL_CMD -s "$SUBJECT" "$TO_ADDRESS"

# Update the last state
echo "$DMESG_CURRENT" > "$DMESG_LAST"
fi
</syntaxhighlight>

Main Page

2025-02-02T10:33:51Z

Webmaster: /* Artikelübersicht */

Mail bei YUM Updates

2025-02-02T10:33:18Z

Webmaster: Created page with "Ich habe mehrere Server im Betrieb für die ich ein BASH-Skript benötigt habe das mich informiert wenn neue YUM Updates zu verfügung stehen. Ich möchte hier mit euch das BASH-Skript teilen: == Skript == <syntaxhighlight lang="c"> #!/bin/bash EMAIL="admin@example.com" STATE_FILE="/tmp/update_count.state" # Execute yum check-update and capture the output UPDATES=$(yum check-update --quiet 2>/dev/null) # Filter out empty lines and count the number of updates UPDATE..."

Ich habe mehrere Server im Betrieb für die ich ein BASH-Skript benötigt habe das mich informiert wenn neue YUM Updates
zu verfügung stehen. Ich möchte hier mit euch das BASH-Skript teilen:

== Skript ==
<syntaxhighlight lang="c">
#!/bin/bash
EMAIL="admin@example.com"
STATE_FILE="/tmp/update_count.state"

# Execute yum check-update and capture the output
UPDATES=$(yum check-update --quiet 2>/dev/null)

# Filter out empty lines and count the number of updates
UPDATES=$(echo "$UPDATES" | grep -v "^$")
UPDATES_COUNT=$(echo -n "$UPDATES" | wc -l)

# Read the previous update count, if any
if [[ -f "$STATE_FILE" ]]; then
PREVIOUS_COUNT=$(cat "$STATE_FILE")
else
PREVIOUS_COUNT=0
fi

# Compare update counts
if [[ $UPDATES_COUNT -ne $PREVIOUS_COUNT ]]; then
echo "$UPDATES" | mail -s "Updates for $(hostname): ${UPDATES_COUNT}" "$EMAIL"
# Update the state file with the new count
echo "$UPDATES_COUNT" > "$STATE_FILE"
fi
</syntaxhighlight>

SDR mit DVB-T Stick

2022-01-27T07:58:38Z

Webmaster:

In diesem Projekt geht es darum einen Terratec Cinergy T USB-Stick mit einem RealTek RTL2832U-Chip als SDR (Software Defined Radio) zu nutzen. Als SDR versteht man ein Funktelekommunikationssystem das möglichst einen großen Teil der De- / Modulation in Software durchführt. Nur ein kleiner Teil ist in Hardware realisiert (Antenne, Verstärker + Frontend). Ein bekanntes SDR sind das im universitären Einsatz weit verbreitete USRP<ref>[http://home.ettus.com/ Ettus Research Homepage]</ref> von Ettus Research das allerdings für einen Hobbybastler recht teuer ist.
Die meißten DVB-T Sticks bieten allerdings für den Hobbybereich einen akzeptablen abdeckbaren Frequenzbereich, mehrer Informationen dazu gibt es auf der Seite von osmocomSDR<ref>[https://osmocom.org/projects/rtl-sdr/wiki/Rtl-sdr osmocomSDR]</ref>

== Hardware ==

[[File:SDR DVB T Cinergy.jpg|300px|right|HV Warning]]

Zum Einsatz kommt ein Terratec Cinergy T Stick RC mit einem Elonics E4000 Tuner für ca. 16€.

== Software ==

Als Software setze ich zurzeit SDR#<ref>[http://sdrsharp.com/ SDR# Homepage]</ref> ein.

== Bilder ==

<gallery>
File:SDR DVB T Cinergy Elonics.jpg
</gallery>

== Einzelnachweise ==

<references>

PC-Maus als Drehzahlmesser

2022-01-24T19:10:22Z

Webmaster: /* Download */

Wer brauchte nicht schon immer einen einfachen Drehzahlmesser, hatte aber keinen zur Hand. Hier beschreibe ich eine Möglichkeit mittels einer einfachen PC-Maus mit Scrollrad. Ich wollte die Drehzahl von zwei Gleichstrommotoren erfassen die ich im Rahmen eines Balancierenden Roboter (Prinzip des inversen Pendels) einsetzen wollte.
Die Gleichstrommotoren hatte ich mit einen PWM-Signal und einer kleinen Treiberschaltung angesteuert. Hinter jedem Motor befand sich ein dahintergschaltetes Getriebe.
Ich habe beide Motoren mit dem selben PWM-Signal angeseteuert aber es kam mir so vor, dass diese sich unterschiedlich schnell drehten. Nur ohne Drehzahlmesser ist das schwer nachzuweisen. Dann kam mir die Idee die Drehzahl mit dem Scrollrad einer Maus zu erfassen. Dafür habe ich ein kleines Programm geschreiben das ihr im Download-Bereich der Artikels findet. Quelltext ist auch verfügbar und kann nach belieben erweitert werden. Über die Genauigkeit kann ich nichts sagen, da ich keinen Drehzahlmesser für Vergleichsmessungen besitze.

== Benutzung ==

[[File:MouseScrollCounter.jpg|400px|thumb|right]]

Einfach das Programm starten und am Scrollrad drehen. Um das Program zu beenden die Linke und Rechte Maustaste gedrückt halten.

== Quelltext ==

Zu dem Quelltext gibt es nicht allzuviel zu erzählen.

<syntaxhighlight lang="c">
/***********************************************
***
*** eeeeee eeeee eeeee eeeee eeeeee eeeeee
*** 8 8 8 8 8 8 88 8 8
*** 8e 8 8 8 8 8 8 8 8
*** 88 8 8eee 8eee 8e 8 8 8e 8
*** 88 8 8e 8e 88 8 8 88 8
*** 88 e 88 88 88 8 e 88 8
*** 88eee8 88eee 88 88eee 88eee8 88 8
*** ----------------------------------------
*** defcon-cc.dyndns.org
***
************************************************
************************************************
*** Programm: MouseScrollCounter ***
*** Autor: Patrick Langosch ***
*** erstellt: 12.08.14 ***
*** Version: 0.1 ***
***********************************************/

#include <math.h>
#include <stdio.h>
#include <iostream>
#include <windows.h>

#define DIAMETER_WHEEL 0.023 // in meters
#define COUNTS_PER_REVOLUTION 24 // no dimension
#define DISTANCE_PER_REVOLUTION (M_PI * DIAMETER_WHEEL) // in meters

using namespace std;

int counts = 0;

HHOOK g_Hook;
HANDLE g_evExit;

/******************************** LowLevelMouseProc ********************************/
LRESULT CALLBACK LowLevelMouseProc(int code, WPARAM wParam, LPARAM lParam)
{
if(code == HC_ACTION)
{
const char *msg;
char msg_buff[128];

switch(wParam)
{
case WM_LBUTTONDOWN:
msg = "WM_LBUTTONDOWN";
break;

case WM_LBUTTONUP:
msg = "WM_LBUTTONUP";
break;

case WM_MOUSEMOVE:
msg = "WM_MOUSEMOVE";
break;

case WM_MOUSEWHEEL:
msg = "WM_MOUSEWHEEL";
counts++;
break;

case WM_RBUTTONDOWN:
msg = "WM_RBUTTONDOWN";
break;

case WM_RBUTTONUP:
msg = "WM_RBUTTONUP";
break;

default:
sprintf(msg_buff, "Unknown msg: %u", wParam);
msg = msg_buff;
break;
}

const MSLLHOOKSTRUCT *p = reinterpret_cast<const MSLLHOOKSTRUCT*>(lParam);

static bool left_down = false;
static bool right_down = false;

switch(wParam)
{
case WM_LBUTTONDOWN:
left_down = true;
break;

case WM_LBUTTONUP:
left_down = false;
break;

case WM_RBUTTONDOWN:
right_down = true;
break;

case WM_RBUTTONUP:
right_down = false;
break;
}

if(left_down && right_down)
{
SetEvent(g_evExit);
}

}

return CallNextHookEx(g_Hook, code, wParam, lParam);
}

/******************************** MAIN ********************************/
int main(int argc, char *argv[])
{
int n = 0;
int rpm = 0;
int rps = 0;
float speed = 0.0;
char buffer[64];
DWORD startTime = 0;
DWORD diffTime = 0;

// remove scrollbar
HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); // get handle of console window
CONSOLE_SCREEN_BUFFER_INFO info;

GetConsoleScreenBufferInfo(handle, &info);

COORD new_size =
{
info.srWindow.Right - info.srWindow.Left + 1,
info.srWindow.Bottom - info.srWindow.Top + 1
};

SetConsoleScreenBufferSize(handle, new_size); // set new size
SetConsoleTitle("DefCon - MouseScrollCounter"); // set title

g_evExit = CreateEvent(0, TRUE, FALSE, 0);

if(!g_evExit)
{
cerr << "CreateEvent failed, le = " << GetLastError() << endl;
return 1;
}

g_Hook = SetWindowsHookEx(WH_MOUSE_LL, &LowLevelMouseProc, GetModuleHandle(0), 0);

if(!g_Hook)
{
cerr << "SetWindowsHookEx() failed, le = " << GetLastError() << endl;
return 1;
}

cout << "Press both left and right mouse buttons to exit..." << endl;

MSG msg;
DWORD status;

/******************************** LOOP ********************************/
while(1)
{
while(PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
DispatchMessage(&msg);
}

status = MsgWaitForMultipleObjects(1, &g_evExit, FALSE, INFINITE, QS_ALLINPUT);

if(status == (WAIT_OBJECT_0 + 1))
{
// check if the wheel is reached a revolution
if(counts >= COUNTS_PER_REVOLUTION)
{
if(startTime != 0)
{
diffTime = GetTickCount() - startTime; // get time between two calls
}

startTime = GetTickCount();

if(diffTime != 0)
{
// get radiation per second and minute
rps = 1000 / (int)(diffTime);
rpm = 60000 / (int)(diffTime);
}

speed = DISTANCE_PER_REVOLUTION * rps; // in m/s

system("cls");
n = snprintf(buffer, 64, "%c DIFF:%ims --> %i rpm --> %.2f m/s %c", 186, diffTime, rpm, speed, 186);

// ********** draw border **********
printf("%c", 201);

for(int i = 0; i < n-2; i++)
{
printf("%c", 205);
}

printf("%c\n", 187);
printf("%s\n", buffer);
printf("%c", 200);

for(int i = 0; i < n-2; i++)
{
printf("%c", 205);
}

printf("%c\n", 188);

counts = 0; // reset counter
}

continue; // there are messages to process, eat em up
}

else
{
break; // assume g_evExit is signaled
}
}

cout << "Exiting..." << endl;
UnhookWindowsHookEx(g_Hook);
CloseHandle(g_evExit);

return 0;
}
</syntaxhighlight>

== Download ==
[[File:MouseScrollCounter.zip]]

File:MouseScrollCounter.zip

2022-01-24T19:09:42Z

Webmaster:

Pollin AVR-NetIO PHP Wrapper

2022-01-24T19:07:00Z

Webmaster: /* Download */

Bei mir bestand irgendwann einmal das Bedürfnis mein Pollin AVR-NetIO Board über einen
Webserver mit Befehlen zu füttern. Daraus entstanden einige PHP-Funktionen die eine
Kommunikation mit dem NetIO-Board bewerkstelligen.

== Benutzung ==

Die Benutzung gestaltet sich relativ einfach. Dazu einfach die
PHP-Datei "wrapper.php", mittels PHP-Befehl <code>include("wrapper.php");</code> einbinden. Nachdem dann über die Funktion <code>function wrapper_open($server, $port)</code> unter Angabe der IP-Adresse und des Ports mit dem NetIO-Board eine Verbindung aufgebaut werden. Als Rückgabewert der Funktion erhält man einen Zeiger auf die aufgebaute Verbindung. Diesen muss man bei Funktionaufrufen immer mit angeben. Die Verbindung kann dann nach getaner Arbeit mittels <code>function wrapper_close($fp)</code> beendet werden.

== Beispiel ==

Ein einfaches Beispiel, zum auslesen der Ausgänge. Dafür muss sich die Datei "wrapper.php" im selben
Ordner wie die Beispiel PHP-Datei befinden.

<syntaxhighlight lang="php">
<?
include("wrapper.php");

$fp = wrapper_open("192.168.0.90", 50290); // NetIO Standard IP & Port
$data = get_dig_output_status($fp);

echo $data;
?>
</syntaxhighlight>

== Quelltext ==
<syntaxhighlight lang="php">
<?
/***********************************************
***
*** eeeeee eeeee eeeee eeeee eeeeee eeeeee
*** 8 8 8 8 8 8 88 8 8
*** 8e 8 8 8 8 8 8 8 8
*** 88 8 8eee 8eee 8e 8 8 8e 8
*** 88 8 8e 8e 88 8 8 88 8
*** 88 e 88 88 88 8 e 88 8
*** 88eee8 88eee 88 88eee 88eee8 88 8
***
*** Coded by Crashdemon....
*** HAVE A LOT OF PHUN!
***
*** AVR-NetIO Wrapper
*** ver 0.1
***
***********************************************/

$BUFFER_SIZE = 16384;

// Establishes a connection to the Pollin AVR-NetIO
// Parameters: $server -> IP of AVR-NetIO
// $port -> Port running the AVR-NetIO
// Return: The file description pointer of the established connection
function wrapper_open($server, $port)
{
$errno = $errstr = "";

$fp = fsockopen($server, $port, $errno, $errstr, 30);

if(!$fp)
{
printf("Error: %s (%s)", $errstr, $errno);
$data = 0;
}

return($fp);
}

// Shows the current Info about NetIO
// Parameters: $fp -> file description pointer of the established connection
// Return: the Info as a String
function get_version($fp)
{
fputs($fp, "VERSION\r\n");
$data = fread($fp, $BUFFER_SIZE);

return($data);
}

// Status of given digital Pin
// Parameters: $fp -> file description pointer of the established connection
// $number -> number of the pin
// Return: status auf the pin HIGH = 1 ; LOW = 0, false if fails
function get_dig_input($fp, $number)
{
if($number > 0 and $number <=4)
{
fputs($fp, "GETPORT ".$number."\r\n");
$data = fread($fp, $BUFFER_SIZE);

return($data);
}

else
{
return(false);
}
}

// Value of the ADC Input Pin
// Parameters: $fp -> file description pointer of the established connection
// $number -> number of the pin
// Return: decimal value from the AD-Conversion, false if fails
function get_adc_input($fp, $number)
{
if($number > 0 and $number <=4)
{
fputs($fp, "GETADC ".$number."\r\n");
$data = fread($fp, $BUFFER_SIZE);
//printf("%s", $data);

return($data);
}

else
{
return(false);
}

}

// Set output pin
// Parameters: $fp -> file description pointer of the established connection
// $number -> number of the pin
// $set -> HIGH or LOW level set on output pin
// Return: true if everthing went well, false if fails
function set_dig_output($fp, $number, $set)
{
if($number > 0 and $number <=8 and ($set == 0 || $set == 1))
{
fputs($fp, "SETPORT ".$number.".".$set."\r\n");
$data = fread($fp, $BUFFER_SIZE);

if(strcmp($data, "ACK"))
{
return(true);
}

else
{
return(false);
}
}

else
{
return(false);
}
}

// Get the current status of the digital output
// Parameters: $fp -> file description pointer of the established connection
// Return: status auf the output pins HIGH = 1 ; LOW = 0
function get_dig_output_status($fp)
{
fputs($fp, "GETSTATUS\r\n");
$data = fread($fp, $BUFFER_SIZE);

return($data);
}

// Get the IP of AVR NetIO
// Parameters: $fp -> file description pointer of the established connection
// Return: the IP as a string
function get_ip($fp)
{
fputs($fp, "GETIP\r\n");
$data = fread($fp, $BUFFER_SIZE);

return($data);
}

// Sets a new IP on AVR NetIO
// Parameters: $fp -> file description pointer of the established connection
// $new_ip -> The new IP as a string
// Return: true if everthing went well, false if fails
function set_ip($fp, $new_ip)
{
$ip = explode('.', $new_ip);

if($ip[0] <= 255 and $ip[1] <= 255 and $ip[2] <= 255 and $ip[3] <= 255 and
preg_match("!^([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$!", $new_ip))
{
fputs($fp, "SETIP ".$new_ip."\r\n");
$data = fread($fp, $BUFFER_SIZE);

if(strcmp($data, "ACK"))
{
return($data);
}

else
{
return(false);
}
}

else
{
return(false);
}
}

// Gets the current Subnetmask of AVR NetIO
// Parameters: $fp -> file description pointer of the established connection
// Return: subnetmask as a string
function get_mask($fp)
{
fputs($fp, "GETMASK\r\n");
$data = fread($fp, $BUFFER_SIZE);

return($data);
}

// Sets new subnetmask on AVR NetIO
// Parameters: $fp -> file description pointer of the established connection
// $new_mask -> the new mask as a string
// Return: true if everthing went well, false if fails
function set_mask($fp, $new_mask)
{
$mask = explode('.', $new_mask);

if($mask[0] <= 255 and $mask[1] <= 255 and $mask[2] <= 255 and $mask[3] <= 255 and
preg_match("!^([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$!", $new_mask))
{
fputs($fp, "SETMASK ".$new_mask."\r\n");
$data = fread($fp, $BUFFER_SIZE);

if(strcmp($data, "ACK"))
{
return($data);
}

else
{
return(false);
}
}
}

// Get the Gateway of AVR-NetIO
// Parameters: $fp -> file description pointer of the established connection
// Return: the gateway as a string
function get_gateway($fp)
{
fputs($fp, "GETGW\r\n");
$data = fread($fp, $BUFFER_SIZE);

return($data);
}

// Set the Gateway on AVR-NetIO
// Parameters: $fp -> file description pointer of the established connection
// $new_gw -> The new Gateway adress as a string
// Return: true if everthing went well, false if fails
function set_gateway($fp, $new_gw)
{
$gw = explode('.', $new_mask);

if($gw[0] <= 255 and $gw[1] <= 255 and $gw[2] <= 255 and $gw[3] <= 255 and
preg_match("!^([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$!", $new_gw))
{
fputs($fp, "SETGW ".$new_gw."\r\n");
$data = fread($fp, $BUFFER_SIZE);

if(strcmp($data, "ACK"))
{
return($data);
}

else
{
return(false);
}
}
}

// Initializes the LCD, do this first before write to it
// Parameters: $fp -> file description pointer of the established connection
// Return: true if everthing went well, false if fails
function init_lcd($fp)
{
fputs($fp, "INITLCD\r\n");
$data = fread($fp, $BUFFER_SIZE);

if(strcmp($data, "ACK"))
{
return($data);
}

else
{
return(false);
}
}

// Print text on LCD
// Parameters: $fp -> file description pointer of the established connection
// $row -> number of the row
// $text -> the text which we would show
// Return: true if everthing went well, false if fails
function write_lcd($fp, $row, $text)
{
if($row > 0 and $row <=2)
{
fputs($fp, "WRITELCD ".$row.".".$text."\r\n");
$data = fread($fp, $BUFFER_SIZE);

if(strcmp($data, "ACK"))
{
return($data);
}

else
{
return(false);
}
}
}

// Clear the given row on the LCD
// Parameters: $fp -> file description pointer of the established connection
// $row -> number of the row
// Return: non
function clear_lcd($fp, $row)
{
if($row > 0 and $row <=2)
{
fputs($fp, "CLEARLCD ".$row."\r\n");
}
}

// Closes the network connection to AVR-NetIO
// Parameters: $fp -> file description pointer of the established connection
// Return: non
function wrapper_close($fp)
{
fclose($fp);
}
?>
</syntaxhighlight>

== Download ==
[[File:Netio_wrapper.zip]]

File:Netio wrapper.zip

2022-01-24T19:05:43Z

Webmaster:

Ramdisk unter Linux

2022-01-24T18:59:42Z

Webmaster: /* Anhang */

Pollin AVR-NetIO PHP Wrapper

2022-01-24T18:58:40Z

Webmaster: /* Download */

PC-Maus als Drehzahlmesser

2022-01-24T18:58:04Z

Webmaster: /* Download */

RWE-Wallbox

2021-02-12T19:53:28Z

Webmaster:

Ich bin durch Zufall in den Besitz einer RWE-Wallbox gekommen und möchte euch deren Innenleben nicht vorenthalten.
Vorgefunden habe ich:

* FI-Schalter,
* Leitungsschutzschalter
* Schütz
* Netzteil (12V)
* Montageplatte zum nachrüsten eines eHz Zählers (ABB BKE-I).

Weiterhin befindet sich auch ein wenig Digitalelektronik dadrin, nämlich
zwei Hutschienengeräte der Firma INSYS:

* INSYS RWE e-Mobility LSG
* INSYS e-Mobility PLC

Main Page

2021-02-08T10:40:10Z

Webmaster: /* Artikelübersicht */

RWE-Wallbox

2021-02-08T10:39:41Z

Webmaster:

Ich bin durch zufall in den Besitz einer RWE-Wallbox gekommen und möchte euch deren Innenleben nicht vorenthalten.
Vorgefunden habe ich:

* FI-Schalter,
* Leitungsschutzschalter
* Schütz
* Netzteil (12V)
* Montageplatte zum nachrüsten eines eHz Zählers (ABB BKE-I).

Weiterhin befindet sich auch ein wenig Digitalelektronik dadrin, nämlich
zwei Hutschienengeräte der Firma INSYS:

* INSYS RWE e-Mobility LSG
* INSYS e-Mobility PLC

RWE-Wallbox

2021-02-08T10:19:43Z

Webmaster: Created page with "tbd"

tbd

Main Page

2020-10-12T06:53:46Z

Webmaster:

[[File:Daniel Duesentrieb.jpg]]

Willkommen in meinem Wiki!
Hier dreht sich alles um (Elektronik)projekte die ich mal durchgeführt habe.
Ich werde hier in unregelmäßigen Abstände mal das ein oder andere
Projekt beschreiben.

Viel Spaß



== Artikelübersicht ==
[[Pollin AVR-NetIO PHP Wrapper]] - [[Ätzmaschine]] - [[Ramdisk unter Linux]] - [[RS232/RS485-Wandler]] - [[Nulldurchgangserkennung]] - [[Lötrauchabsaugung]] - [[PC-Maus als Drehzahlmesser]] - [[GPS Laptimer]] - [[Platinenfräsmaschine]] - [[WLAN Richtfunkantenne]] - [[Laptimer]] - [[OsmocomBB]] - [[SDR mit DVB-T Stick]] - [[ESP8266]] - [[Sonoff POW]] - [[Samsung Galaxy Ace disassembled]] - [[Cafissimo Picco Hack]] - [[LED-Tisch]]

Laptimer

2019-04-30T04:39:22Z

Webmaster: /* Einzelnachweise */

In diesen Artikel stelle ich vor, wie ein einfacher Laptimer realisiert werden kann.
Ich habe ihn Primär dafür eingesetzt die Rundenzeit meines Rennkarts zu erfassen. Er kann aber auch individuell für diverse Einsatzzwecke adaptiert werden.
Für den Einsatzbereich im Kart gibt es schon einige fertige Lösungen (MyChron, Alfano, etc..), diese sind aber recht teuer weswegen ich zu einem Selbstbau übergegangen bin. Außerdem ist bei einem Selbstbau der Lerneffekt um einiges größer.

== Hardware ==

Die Grundlage bildet der 8-Bit Mikrocontroller ATmega8 der Firma ATMEL der mit einer Taktfrequenz von 4 MHz betrieben wird. Dieser übernimmt alle Aufgaben der Steuerung und Berechnung. Das sind im großen und ganzen die Erfassung von:

* Drehzahl
* Geschwindigkeit
* Rundenzeit

sowie die Steuerung der

* LCD-Anzeige
* Hintergrundbeleuchtung
* Bestzeit-LED

Zur Anzeige wird ein alphanummerisches 4x20 Zeilen LCD verwendet (HD44780 kompatibel). Die Stromversorgung wird noch über einen 9V-Block realisiert der über einen Schaltregler die 5V erzeugt. Im Schaltplan ist noch die Möglichkeit vorgesehen über eine Z-Diode die für den Mikroconroller notwendigen 5V zu erzeugen. Davon sollte aber in der Praxis abgesehen werden. In Zukunft gedenke ich den 9V Block durch einen alten Handy-Akku zu ersetzen.
Mittels eines NPN-Transistors besteht die Möglichkeit die Hintergrundbeleuchtung des LCD's über den Mikrocontroller einzuschalten. Das sollte beim Batteriebetrieb aber nur für kurze Zeit, z.B. beim beenden einer Runde geschehen. Weiterhin wird über eine LED angezeigt ob eine neue Bestzeit gefahren wurde.

=== Eckdaten ===

Nachfolgend einige Eckdaten des Laptimers:

* Rundenzeitmessung von 15 sec. bis 12 min. Auflösung 10ms.
* Drehzahlmessung von 0 bis 240000 U/min. Auflösung 100 U/min.
* Geschwindigkeitsmessung von 0 bis 240 km/h. Auflösung 1 km/h.

=== Pinbelegung ===

Pin Description Connected with
-----------------------------------------
1 PC6(RESET) RC-Network
2 PD0(RXD) Connector (Bootloader)
3 PD1(TXD) Connector (Bootloader)
4 PD2(INT0) Drehzahl
5 PD3(INT1) Geschwindigkeit
6 PD4(XCK/T0) -
7 VCC +5V
8 GND GND
9 PB6(XTAL1) 4Mhz Quarz
10 PB7(XTAL2) 4Mhz Quarz
11 PD5(T1) -
12 PD6(AIN0) -
13 PD7(AIN1) Bestzeit-LED
14 PB0(ICP) Rundenzeit (Reed-Kontakt)
15 PB1(OC1A) Transistor(LCD_BACKGRND)
16 PB2(SS) Taster "Hoch"
17 PB3(MOSI) Taster "Runter"
18 PB4(MISO) Taster "OK/EXIT"
19 PB5(SCK) -
20 AVCC +5V
21 AREF -
22 AGND GND
23 PC0(ADC0) LCD(DB7)
24 PC1(ADC1) LCD(DB6)
25 PC2(ADC2) LCD(DB5)
26 PC3(ADC3) LCD(DB4)
27 PC4(ADC4) LCD(Enable)
28 PC5(ADC5) LCD(RS)

Außerdem gibt es noch eine vierpolige Stiftleiste. Diese dient zum Flashen der Firmware auf den
Mikrocontroller, zum Debuggen oder zum Senden von Messwerten die dann bequem Protokolliert werden können.
Die Schnittstelle hat die folgende Belegung (5V Pegel, nur über Pegelwandler an serielle Schnittstelle anschließen):

Pin Connected with
-----------------------------------------
1 +5V
2 GND
3 RXD
4 TXD

=== Stromverbrauch ===

Aktuell betreibe ich den Laptimer mit einem Wald-und-Wiesen 9V-Block, der Kapazität von ungefähr
600 mAh haben müsste. Dabei ergeben sich für verschiedene Zustände in denen sich der Laptimer befindet
auch verschiedene Laufzeiten die ich nachfolgend in einer Tabelle aufgeführt habe (für einen 9V-Block a 600mAh):

{| class="wikitable" style="float:left; margin-right:1em"
! Zustand || Stromaufnahme (mA) || Laufzeit (std)
|-
| Standardanzeige (*) + LCD-Hintergrundbeleuchtung an || 44 mA || 13 std (**)
|-
| Standardanzeige (*) + LCD-Hintergrundbeleuchtung aus || 16 mA || 37 std (**)
|-
| Rundenzeitmessung läuft || 44 mA || 13 std (**)
|-
| Standby || 16 mA || 37 std (**)
|-
|}
<div style="clear:both"></div>

(*) Anzeige der Messwerte nach dem Einschalten des Laptimers (keine Messung läuft)

(**) Die Berechnung gehen von einer vollständigen Entladung aus. Mitunter schafft es der Schaltregler aber
nicht mehr die 5V-Versorgungsspannung aufrecht zu halten. Die Zeiten sind als Best-Case anzunehmen.

Den größten Anteil am Stromverbrauch hat sicherlich die LCD-Hintergrundbeleuchtung<ref>[http://www.abacom-online.de/div/LCD20x4.pdf Datenblatt LCD 20x4 (PCM2004A)]</ref> mit aktuelle 80 mA. Dieser kann natürlich
noch über den Vorwiderstand R17 gesenkt werden.

<math>I_f = \frac{U_{VCC} - U_f}{R_{17}} = \frac{5~V - 4,2~V}{10~\Omega} = 80~mA</math>

Bedenken sollte man allerdings das dann mitunter die Erkennbarkeit des Displays, bei starker Sonneneinstrahlung, darunter leidet.

== Software ==

=== Parameter ===

Über Software defines können eine fülle von Einstellungen an dem Laptimer vorgenommen werden ohne Teile im Code ändern zu müssen.
Zurzeit habe ich die folgenden Parameter implementiert

<syntaxhighlight lang="c">
N_STROKE_ENGINE 2 // 2-Takt oder 4-Takt Motor? Zwei oder Vier eintragen!
SEC_LOCK_ICP 1 // Zeit die der ICP nach auslösen gesperrt bleibt, in Sekunden.
STANDBY_AFTER_MIN 6 // Zurücksetzen der Rundenzeitmessung und Standby (Runde nach x Minuten noch nicht beendet)
MAX_INTERIM_TICKS 12000 // Schwelle für Differenz zu Best-Zwischenzeiten (ganze Minuten!!)
AVG_N_ORDER 8 // Ordnung der gleitenden Mittelwertberechnung
AMOUNT_MAGNETIC_LOOPS 3 // Anzahl der Magnetschleifen auf der Rennstrecke
KPH_TO_MPS 3.6 // Umrechnung km/h <-> m/s
PERIMETER_TYRE 0.86 // Reifenumfang in Meter
FRONT_SPROCKET 11 // Zähnezahl Ritzel
REAR_SPROCKET 86 // Zähnezahl Kettenrad
SEC_SHOW_LAPTIME 5 // Zeit in Sekunden, bei der die alte Rundenzeit angezeigt wird
</syntaxhighlight>

=== Zeiten ===

Der Atmega8 besitzt drei Timer die alle genutzt werden. Nachfolgend ist aufgelistet welchen Zweck die der jeweilige Timer genutzt wird und
welches Zeitnormal er erzeugt.

{| class="wikitable" style="float:left; margin-right:1em"
! TimerX || Wird benutzt für || Zeitnormal
|-
| Timer0 || Geschwindigkeits- und Drehzahlmessung || 100µs
|-
| Timer1 || Rundenzeit || 10ms
|-
| Timer2 || PWM für LCD Hintergrundbeleuchtung || -
|-
|}
<div style="clear:both"></div>

Die Berechnung der Zeiten gestaltet sich im ganzen Programm nach dem selben Schema. Ausgehend von den "overflow_ticks_10ms" die über den
internen Timer des Atmegas alle 10ms erhöht wird, werden die daraus folgenden Zeiten abgeleitet.

<syntaxhighlight lang="c">
void splitTicks(uint16_t ticks, volatile struct myTime* result)
{
uint16_t centiSec = 0;
uint16_t seconds = 0;

centiSec = ticks; // Zenti-Sekunden (10ms)
seconds = centiSec / 100; // Sekunden berechnen

result->ticks = ticks;
result->csec = centiSec % 100; // Rest bei der Berechnung der Sekunden --> Zenti-Sekunden
result->min = seconds / 60; // Minuten berechnen
result->sec = seconds % 60; // Rest bei der Berechnung der Minuten -- > Sekunden
}
</syntaxhighlight>

Dabei wird eine eigens angelegte Struktur "myTime" genutzt, die wie folgt definiert ist:

<syntaxhighlight lang="c">
// Struktur für die diversen Zeiten
struct myTime
{
uint8_t min;
uint8_t sec;
uint8_t csec;
uint16_t ticks;
uint16_t interim[AMOUNT_MAGNETIC_LOOPS];
};
</syntaxhighlight>

=== Interrupt Service Routinen ===

==== Timer0 ====

<syntaxhighlight lang="c">
/******** ISR des Overflow von Timer0 ********/
ISR(TIMER0_OVF_vect)
{
TCNT0 = -50; // Timer Register wird mit einem Wert vorbelegt, 2^8 - 206 = 50 als Rest
// somit ist mit jedem Aufruf der ISR 0.1ms vergangen

overflow_ticks_100us++; // Mit jedem Aufruf der ISR sind 100µs vergangen
}
</syntaxhighlight>

==== Timer1 ====

<syntaxhighlight lang="c">
/******** ISR des Input Capture (Rundenzeit)(Timer1 / 16Bit) ********/
ISR(TIMER1_CAPT_vect) // Aufruf bei steigender Flanke an ICP
{
TIMSK &= ~(1 << TICIE1); // Input Capture Interrupt deaktivieren
TIFR &= (1 << ICF1); // Zur Sicherheit das IC-Flag löschen, durch schreiben einer eins

if(initial_start == FALSE) // Kein Erststart wenn = 0
{
loop_crossed = TRUE; // Flag signalisiert das soeben eine Magnetschleife überfahren wurde
act.interim[run_over_magnetic_loops] = overflow_ticks_10ms; // Zwischenzeit speichern

run_over_magnetic_loops++; // Anzahl der überfahrenen Magnetschleifen hochzählen
}

else // Wenn Magnetschleife das erste mal überfahren wird = 1
{
ICR1 = TCNT1 - ICR1; // Wert für Input Capture Register berechnen, die Takte die zwischen aufruf der ISR und dem setzen von ICR1 vergangen sind
TCNT1 = -5000 + (ICR1 + 6); // Takte die zwischen vorherigen Befehl ablaufen werden dazuaddiert

initial_start = FALSE;
}

// Wenn alle Magnetschleifen auf der Rennstrecke überfahren wurden
// d.h. eine Runde abgeschlossen wurde
if(run_over_magnetic_loops == AMOUNT_MAGNETIC_LOOPS)
{
run_over_magnetic_loops = 0; // Überfahrene Magnetschleifen zurücksetzen

ICR1 = TCNT1 - ICR1; // Wert für Input Capture Register berechnen, die Takte die zwischen aufruf der ISR und dem setzen von ICR1 vergangen sind
TCNT1 = -5000 + (ICR1 + 2); // Takte die zwischen vorherigen Befehl ablaufen werden dazuaddiert
lap_complete = TRUE; // Flag setzen wenn Runde beendet

lap = act; // Werte übertragen
overflow_ticks_10ms = 0; // Overflow Zähler auf Null setzen
}

// Sorgt dafür das Pegeländerungen welche durch Prellen des Reed-Kontaktes
// hervorgerufen werden nicht an den ICP1 Pin gelangen können
temp = act.sec;
}

/******** ISR des Overflow von Timer1 ********/
ISR(TIMER1_OVF_vect)
{
TCNT1 = -5000; // Timer Register wird mit einem Wert vorbelegt, 2^16 - 60536 = 5000 als Rest
// somit ist mit jedem Aufruf der ISR 10^-2 Sekunden (0.01) vergangen

if(initial_start == FALSE) // Erstüberfahrt einer Magnetschleife
{
// d.h jedes mal wenn overflow_ticks_10ms um eins inkrementiert wird,
// sind 10ms vergangen
overflow_ticks_10ms++; // max. 65536 da 16Bit Variable
}

// Timeout Zähler der Drehzahl und Geschwindigkeit
if(timeout_ticks_rpm < (TIMEOUT_RPM / 100))
{
timeout_ticks_rpm++;
timeout_rpm = FALSE;
}

else timeout_rpm = TRUE;

if(timeout_ticks_kph < (TIMEOUT_KPH / 100))
{
timeout_ticks_kph++;
timeout_kph = FALSE;
}

else timeout_kph = TRUE;
}
</syntaxhighlight>

==== Timer2 ====

<syntaxhighlight lang="c">
/******** ISR des Compare Match von Timer2 ********/
ISR(TIMER2_COMP_vect)
{
PORTB &= ~(1 << PB1); // LCD-Hintergrundbeleuchtung (PWM)
}

/******** ISR des Overflow von Timer2 ********/
ISR(TIMER2_OVF_vect)
{
PORTB |= (1 << PB1); // LCD-Hintergrundbeleuchtung (PWM)
}
</syntaxhighlight>

=== Fuses ===

[[File:Laptimer_Fuses.jpg|right|thumb|400px|Fuses Einstellungen des Atmega8]]

Die Fuses sind dazu da dem Mikrocontroller bestimmte Einstellungen mitzugeben. Das sind dinge wie "Welche Takquelle wird benutzt?".
Diese Informationen benötigt der Mikrocontroller um richtig zu laufen. Nähere Informationen dazu hier<ref>[http://www.mikrocontroller.net/articles/AVR_Fuses AVR Fuses einstellen]</ref>.

Ich habe meinen Atmega8 mit folgenden Fuses programmiert:

* High Fuses: 0xD4
* Low Fuses: 0x1C

Kurz zusammengefasst:

* BOOTRST und BOOTSZ0 müssen gesetzt sein wenn der Bootloader benutzt wird
* BODLEVEL und BODEN aktivieren den Brownout<ref>[http://www.mikrocontroller.net/articles/Brownout Brownout]</ref> und setzen die Grenzspannung auf 4V
* EESAVE sorgt dafür das die Einstellungen im EEPROM auch nach dem übertragen einer neuen Firmware erhalten bleiben

=== Flashen ===

[[File:Laptimer_Bootloader_Flash_FW.jpg|right|thumb|400px|Flashen mittels FastBoot Bootloader]]

Um das Programm auf den Mikrocontroller zu bekommen gibt es mehrere möglichkeiten, aber für alle wird zunächst
einmal ein ISP-Programmer benötigt. Da es diese recht günstig (~10€) in der Bucht gibt gehe ich im weiteren nicht mehr darauf ein.

Zum Flashen muss der entsprechende ISP-Programmer mit den Pins Reset, MISO, MOSI sowie SCK verbunden werden. Diese
Möglichkeit habe ich in meinem Layout allerdings nicht vorgesehen, deswegen bietet es sich an den Mikrocontroller
extern zu Programmieren. Im Layout gibt es die Möglichkeit den Mikrocontroller über einen Bootloader zu Flashen (nur Flash kein EEPROM) allerdings muss dafür auch zunächst der Bootloader über einen ISP-Programmer in den Chip geschrieben werden.

Im Grunde kann dafür jeder Bootloader benutzt werden, ich benutze zurzeit den Bootloader FastBoot von Peter Dannegger.<ref>[http://www.mikrocontroller.net/articles/AVR_Bootloader_FastBoot_von_Peter_Dannegger AVR Bootloader FastBoot von Peter Dannegger]</ref>

Das Flashen geschieht mittels eines Bootloader über die serielle Schnittstelle (UART) des Atmega8 (Pins PD0 und PD1). Nutzt man diese Möglichkeit sollte man darauf achten, dass der Mikrocontroller auch keinen Fall direkt mit der seriellen Schnittstelle des PCs verbunden werden darf. Beachtet man das nicht zerschießt man sich die entsprechenden Eingangspins des Atmega.
Es muss also zwingend eine Pegelwandlung (± 12V PC <> 0-5V µC) z.B. mit einem MAX232 (es gibt in der Bucht auch schon fertige Schaltungen direkt mit USB/Seriell-Wandler für ~2€) durchgeführt werden. Die Belegung der Stiftleiste kann unter [[Laptimer#Pinbelegung|Pinbelegung]] nachgelesen werden.

=== Protokollierung ===

Über die serielle Schnittstelle erfolgt nicht nur das Flashen des Mikrocontrollers. Die Schnittstelle kann unter anderem auch zum Debuggen bei der Fehlersuche
genutzt werden. Ein weiteres nettes Feature ist das Protokollieren von Messwerten wie z.B. Drehzahl, Geschwindigkeit, Rundenzeit um nur einige Beispiele zu nennen.
Zum Protokollieren benutze ich zur Zeit den Datenlogger "Openlog" von Sparkfun<ref>[https://www.sparkfun.com/products/9530 Sparkfun - Openlog]</ref>. Der Datenlogger protokolliert die Messwerte auf eine microSD-Karte und kommt erstaunlicherweise direkt mit den 5V-Pegel der seriellen Schnittstelle zurecht (Datennlogger wird intern mit 3,3V betrieben). Um den Datenlogger nutzen zu können muss man lediglich die CONFIG.TXT auf die richtige Baudrate einstellen (Ich benutze per Default 19200 baud/sek).

Hier noch ein Beispiel wie die Ausgabe über die serielle Schnittstelle mit dem Mikrocontroller durchgeführt werden kann. Das Senden erfolgt zurzeit in der main-Routine
mit jedem Schleifen durchlauf ist also in keinem Fall zeit-deterministisch. Möchte man die Ausgabe immer in gleich Zeitabständen durchführen muss das mit Hilfe eines Timers erfolgen.

<syntaxhighlight lang="c">
USART_send(utoa(pre_rpm, buffer, 10)); // Drehzahl ausgeben
USART_send(",");
USART_send(utoa(kph, buffer, 10)); // Geschwindigkeit ausgeben
USART_send("\n");
</syntaxhighlight>

Die Ausgabe über die serielle Schnittstelle erfolgt in diesem Beispiel als CSV (comma seperated value) mit anschließenden Newline.

=== EEPROM ===

Das EEPROM dient dazu diverse Werte im Mikrocontroller zu speichern die auch nach einem Spannungsverlust erhalten bleiben sollen.
Aktuell werden die folgenden Daten im EEPROM des Mikrocontrollers gespeichert:

* Einstellungen (Anzahl der Magnetschleifen, Reifenumfang, Ritzel- und Kettenradzahl)
* Bestzeit + dazugehörige Zwischenzeiten

Möchte man die Daten die im EEPROM gespeichert sind zurücksetzen (um z.B. den Laptimer auf einer anderen Rennstrecke
einzusetzen) muss man den Ok/Exit-Taster bei einschalten des Laptimers gedrückt halten. Die nun erfolgte
Inititialisierung wird durch den Text "Init. EEPROM!" auf dem Display und dem Blinken des Bestzeit-LED signalisiert.

Nachfolgend sind die Standardwerte angegeben die nach der erfolgten Initialiserungen für die Einstellungen im EEPROM stehen:

* Magnetschleifen = 3
* Reifenumfang = 0.86
* Ritzel = 10
* Kattenrad = 86

=== Bugs ===

In der Version 1.0:

* Funktion "EEPROM_readBesttime()" ließt falsche ticks ein.

<syntaxhighlight lang="c">
// EEPROM leer --> Defaultwert übernehmen
if(temp_word == EEPROM_WORD_DEF) besttime->ticks = EEPROM_WORD_DEF;
else besttime->ticks = temp_byte;
</syntaxhighlight>

ersetzen durch

<syntaxhighlight lang="c">
// EEPROM leer --> Defaultwert übernehmen
if(temp_word == EEPROM_WORD_DEF) besttime->ticks = EEPROM_WORD_DEF;
else besttime->ticks = temp_word;
</syntaxhighlight>

== Genauigkeit ==

Da alle alle Zeiten aus dem externen Quarz abgeleitet werden, hängt die Genauigkeit (Rundenzeiten, ...) maßgeblich von der Genauigkeit des verwendeten Quarz ab. Dieser ist natürlichen Schwankungen aufgrund von Temperatureinflüssen und Alterung unterlegen. Der von mir eingesetzte 4 MHz Quarz im HC-49/US Gehäuse weist einen Temperaturkoeffizient von ± 30 ppm und eine Frequenztoleranz von ebendfalls ± 30 ppm auf. Bei der Verschaltung des Quarz ist außerdem auf die richtige Lastkapazität zu achten entspricht diese nicht genau der vom Hersteller angebenen Kapazität kommt eine weitere Fehlerquelle hinzu. Dabei gilt: Bei kleinere Last schwingt der Quarz schneller und bei größerer Last langsamer.
Ausgehend von

<math>F_r=\left(\frac{f_{ist}}{f_{soll}} - 1 \right) \cdot 10^6</math>

umgestellt nach

<math>f_{ist}=\left(\frac{F_r}{10^6} + 1\right)\cdot f_{soll} = \left(\frac{30~ppm}{10^6} + 1\right)\cdot 4~MHz = 4~MHz \pm 120~Hz</math>

ergibt sich für einen 4 Mhz Quarz eine Gangabweichung von 120 Hz bei einer Frequenztoleranz von ± 30 ppm.

{| class="wikitable" style="float:left; margin-right:1em"
! Quarz-Typ || Frequenzfehler (25°C) || Abweichung (min/jahr) || Abweichung (s/tag) || Abweichung (s/h) || Abweichung (ms/min) || Frequenabw. bei 4 MHz
|-
| Standardquarz (Grundtton) || 30 ppm || 16 min/jahr || 2,6 s/tag || 108 ms/h || 1,8 ms/s || 120 Hz
|-
|}
<div style="clear:both"></div>

Das bedeutet konkret das man bei einer Rundenzeit von ca. 10 min mit einen Fehler von 18 ms rechnen muss. Lässt man auch noch Temperatureinflüsse mit in die
Rechnung einfließen kann sich das ganze im Worst-Case noch verdoppeln. Alterungseffekte wurden dabei außer acht gelassen.

=== Abstimmen des Quarz ===

Möchte man diese einflüsse so gut es geht kompensieren bietet es sich an zunächst einmal zu schauen mit welcher Frequenz der Quarz den
tatsächlich schwingt. Das gestaltet sich allerdings nicht so einfach wie es auf den ersten Blick aussieht. Da der Quarz schon durch geringe Kapazitäten von einigen pF messbar verstimmt wird, würde ein direktes Messen den Quarz messbar verstimmen. Um das Problem zu umgehen kann man den Takt über den Vorteiler eines Timers auf einen
IO-Pin ausgeben und dann dort messen.<ref>[http://www.mikrocontroller.net/articles/AVR_-_Die_genaue_Sekunde_/_RTC#Echtzeituhr_mit_Uhrenquarz AVR - Die genaue Sekunde – Echtzeituhr mit Uhrenquarz]</ref>

Zum Abstimmen erstzt man einen Lastkondensator durch einen Trimmkondensator (0-47pF). Dieser wird dann so lange verdreht bis die gewünschte Frequenz auf dem Display des Frequenzzählers angezeigt wird.<ref>[http://sprut.de/electronic/mess/frequenz.htm Das Quarzproblem]</ref>

== Funktionsweise ==

In den nachfolgenden Kapiteln wird ausführlich auf einzelnen Komponenten des Laptimers eingegangen.

=== Magnetstreifen ===
In die Kartbahn sind in der Regel an bestimmten stellen Magnetstreifen eingelassen. Dazu werden einfache Permanent-Magneten genutzt (siehe Quelle Patenschrift). Ein Magnetstreifen sollte sich auf jedenfall auf der Start-/Ziellinie befinden. Je nach Kartbahn gibt es aber auch mehrere Magnetstreifen auf der Strecke die es ermöglichen Zwischenzeiten zu erfassen. Die Magnetstreifen sind i.d.R. ca. 1,8cm breit und umfassen die ganze Länge der Kartbahn. Ein Reed-Kontakt schaltet in ca. 2cm Abstand, von den Permanent-Magneten wobei dieser Wert stark von der Empfindlichkeit des Reed-Kontaktes abhängt.

=== Rundenzeit erfassen ===

Um die Rundenzeit zu erfassen, muss zunächst einmal das Magnetfeld des Magnetstreifens beim überfahren erfasst werden. Dazu kann man einen Hallsensor oder Hallschalter einsetzen. Es sollte aber auch eine Reed-Kontakt reichen. Beim überfahren des Magnetstreifens wird der Reed-Kontakt für kurze Zeit geschlossen. Der dadurch entstehende Pegelwechsel wird über den Mikrocontroller über den ICP-Pin (Input Capture) erfasst.

=== Drehzahl erfassen ===

Die Drehzahl wird Potentialfrei gemessen was kapazitiv über einen Draht geschieht der um das Zündkabel (Verbindung Zündkerze <> Zündspule) gewickelt wird.

=== Geschwindigkeit erfassen ===

Bei der Erfassung der Geschwindigkeit gibt es zwei möglichkeiten. Die Drehzahl der hinteren Achse kann direkt erfasst werden, was z.B. ebendfalls mittels eines
Reed-Kontaktes und Magnet (wie beim Fahrrad) geschehen kann. Es besteht aber auch die Option die Geschwindigkeit aus der Drehzahl und dem Übersetzungsverhältnis (Ritzel <> Kettenrad) zu berechnen.

== Berechnungen ==

=== Rundenzeit ===
Zunächst berechne ich wielange der Reed-Kontakt Zeit hat um im "Worst-Case" zu schließen. Dazu nehme ich eine Geschwindigkeit von
<math>v = 100~km/h = 27,78~m/s </math>
beim überfahren der Magnetschleife, an.

<math> s = v \cdot t \rightarrow t = \left( \frac{s}{v} \right) = \left( \frac{1,8 \cdot 10^-2~m}{27,78~m/s} \right) = 0,65~ms </math>

Der Reed-Kontakt hat also ca. 0,65 ms Zeit um zu schließen. Bei 50 km/h dementsprechend doppelt so viel (1,3 ms).

=== Drehzahl / Geschwindigkeit ===

Das ermitteln der Drehzahl bzw. der Geschwindigkeit gestaltet sich ähnlich. Es wird bei beiden zu messenden Größen die Zeitdifferenz die zwischen zwei
Impulsen gemessen und daraus dann die entsprechende Geschwindkeit bzw. Drehzahl berechnet. Da sich Drehzahl und Geschwindigkeit grob nur in dem Übersetzungsverhältnis
zwischen Ritzel und Kettenrad unterscheiden, kann mitunter von einer expliziten zusätzlichen Erfassung der Geschwindigkeit oder Drehzahl abgesehen werden.

Eine Umrechnung der Geschwindigkeit aus der Drehzahl erfolgt nach der folgenden Gleichung:

<math>v = n \cdot \frac{x_{Ritzel}}{x_{Kettenrad}} \cdot U \cdot 0,06 \frac{km}{min}</math><br><br>
<math>v~\textrm{in}~\frac{km}{h}</math><br>
<math>n~\textrm{in}~min^{-1}</math>

Berechnungen die ich dazu angestellt habe befinden sich im nachfolgenden Bild oder in dem dazugehörigen PDF im Anhang.

[[File:Berechnungen_Drehzahl_Geschwindigkeit.gif]]

'''Anmerkung: Nach jedem "Tick" sind 100µs vergangen.'''

== Steuerung ==

Die (Menü-)Steuerung des Laptimers geschieht über drei auf der Vorderseite angebrachte Taster (Ok/Exit, Hoch, Runter).
Die Taster dienen zum einem dazu das Navigieren durch das Menü zu ermöglichen zum anderen aber auch zum zurücksetzen von
gespeicherten Rundenzeiten oder zum zurücksetzen des Laptimers.

=== Einstellungen ===

Durch drücken des Ok/Exit-Tasters kommt man ins Einstellungen-Menü. In dem Menü können die folgenden
Einstellungen vorgenommen werden:

* Anzahl der Magnetschleifen (1...6)
* Reifenumfang in Meter (0.01...2.50)
* Anzahl der Zähne des Ritzels (0...25)
* Anzahl der Zähne des Kettenrades (0...100)

Durch drücken des Hoch- oder Runter-Tasters kann der jeweilige Menüpunkt ausgewählt werden, was durch ein
Symbol (>) vor dem Menüpunkteintrag kenntlich gemacht wird. Durch drücken der Ok/Exit-Taste kann der Wert ausgewählt
und über den Hoch- oder Runter-Taster editiert werden. Durch drücken der Ok/Exit-Taste wird der Wert übernommen.

Bei der Ermittlung der Geschwindigkeit gibt es die Möglichkeit diese aus der Drehzahl des Motors zu berechnen oder
diese über den Sensor an der Hinterachse zu bestimmen. Durch die Wahl der Ritzel-/Kettenradzahl kann man aus einen
der beiden Optionen wählen.

Sind für Ritzel und Kettenrad Werte ungleich Null eingestellt, wird die Geschwindigkeit aus der Drehzahl des Motors
berechnet (Belastet den Mikrocontroller mit zusätzlichen Berechnungen). Wurde für die Ritzel- und Kettenradzahl hingegen
Null eingestellt wird die Geschwindigkeit mittels des Geschwindigkeitssensors direkt an der Hinterachse ermittelt.
Die zweite Option ist deutlich weniger Rechenintensiv und sollte deswegen wenn möglich bevorzugt werden.

Durch längeres Drücken (>3sek) des Ok/Exit-Tasters werden die geänderten Werte ins EEPROM des Mikrocontrollers geschrieben.
Das schreiben wird durch eine Nachricht "Save to EEPROM" auf dem Display und durch Blinken der Bestzeit-LED signalisiert.
Die Änderungen sind dann dauerhaft in dem Mikrocontroller gespeichert.

== Bilder ==

<gallery>
File:Laptimer_Rev_E_1.jpg
File:Laptimer_Rev_E_2.jpg
File:Laptimer_RevE_1_New.jpg
File:Laptimer_RevE_2_New.jpg
File:Laptimer_RevE_3_New.jpg
File:Laptimer_Laptime_Reed_Switch_1.jpg
File:Laptimer_Laptime_Reed_Switch_2.jpg
File:Laptimer_Laptime_Reed_Switch_3.jpg
File:Laptimer_Laptime_Reed_Switch_4.jpg
File:Laptimer_Velocity_Sensor.jpg
File:Laptimer_Laptime_Sensor.jpg
File:Laptimer_RevF_1.jpg
File:Laptimer_RevF_OpenLog.jpg
</gallery>

== Schaltplan ==

[[File:Laptimer_RevE_sch.pdf]]

== Quelltext ==
Aktuelle Version: 1.1

Quelltext ver1.1: [[File:Laptimer Code_ver1.1.pdf]] <br>
Laptimer Project Files ver1.1 (AVR-Studio 4): [[File:Laptimer_ver1.1.zip]]

Quelltext ver1.0: [[File:Laptimer Code_ver1.0.pdf]] <br>
Laptimer Project Files ver1.0 (AVR-Studio 4): [[File:Laptimer_ver1.0.zip]]

== TODO ==

* THT-Layout verbessern (kleiner, integrierte Spannungsversorgung)
* SMD-Layout erstellen
* Menü-Auswahl Drehzahl 2-Takt / 4-Takt
* Kommunikation über RS232 mit anderer Peripherie (GPS, Accelerometer, Lenkwinkel, ...)
* Praktischer Test: Drehzahl schwankt sehr stark? (Einstreuungen)
* Praktischer Test: Geschwindigkeit erreicht irgendwann einen Endwert.
* Kontrast des Display schlecht bei Sonneneinstrahlung
* Ablesen durch Vibrationen teilweise schwierig
* Grafik-Display Unterstützung

== Quellen ==

[http://www.mikrocontroller.net/attachment/27580/spark_l.JPG Schaltplan Drehzahlteil] <br>
[http://www.google.com/patents/EP0632350B1?cl=de Patentschrift Alfano E.P.0632350]<br>
[[File:Laptimer_Drehzahl_Geschwindigkeit.pdf]]

== Einzelnachweise ==

<references />

Sonoff POW

2019-04-30T04:39:11Z

Webmaster: /* Einzelnachweise */

Ich wollte von diversen Geräten in meiner Wohnung den Energieverbrauch erfassen und bin dabei auf die vergleichsweise günstigen
IoT WLAN-Schalter von Itead gestoßen. Mit dem Sonoff POW R2 habe ich das gefunden was ich brauchte um diverse Messwerte
von meiner Geschirrspülmaschine, Waschmaschine, ... zu erfassen. Ich beschreibe hier ein bisschen wie die Hardware des Sonoff POW
aufgebaut ist und welche alternative Firmware es gibt (eigentlich gibt es noch mehr) um den Funktionsumfang zu erweitern.

== Hardware ==

* Wifi-Chip: ESP8266
* Chip für die Erfassung der Messwerte: CHIPSEA CSE7766 <ref>[https://dl.itead.cc/S31/CSE7766.pdf CHIPSEA CSE7766]</ref>

== Software ==

=== Alternative Firmware flashen ===

Als alternative Firmware setze ich Tasmota <ref>[https://github.com/arendst/Sonoff-Tasmota/ Tasmota]</ref> ein was die funktionen der Hersteller-Firmware erheblich erweitert und auch
wenn notwedig nach dem eigenen belieben verändert werden kann.

# ESPEasyFlasher-Tool herunterladen <ref>[https://github.com/BattloXX/ESPEasyFlasher ESPEasyFlasher]</ref> und entpacken
# Sonoff POW entsprechend Pinbelegung (RX und TX kreuzen, VDD an 3,3V) mit einem USB<>Seriell-Wandler verbinden.
# Entsprechend neustes Release <ref>[https://github.com/arendst/Sonoff-Tasmota/releases Tasmota Releases]</ref> von Tasmota herunterladen und in den Ordner vom ESPEasyFlasher-Tool verschieben (sonoff.bin)
# ESPEasyFlasher-Tool starten und COM-Port des USB<>Seriell-Wandler auswählen
# Taster am Sonoff POW gedrück halten (versetzt den POW in den Flashmode)
# POW mit 3,3V versorgen (im Idealfall direkt über den USB<>Seriell-Wandler)
# Mittels drücken auf "Flash" im ESPEasyFlasher-Tool den Flashvorgang einleiten
# Warten bis der Flashvorgang erfolgreich beendet wurde
# Um die WLAN-Zugangsdaten einzutragen muss jetzt eine serielle Verbindung (z.B. mittels PuTTY<ref>[https://www.putty.org/ PuTTY]</ref>) zu dem POW aufgebaut werden

[[File:Tasmota_Flashing.png]]

[[File:Tasmota Flashing Complete.png]]

[[File:Tasmota_Wifi_Settings.png]]

== Bilder ==

<gallery>
File:Sonoff_POW_PCB_Top.jpg
File:Sonoff_POW_PCB_Bottom.jpg
</gallery>

== Quellen ==
[https://www.itead.cc/wiki/Sonoff_Pow#Hardware Sonoff POW Hardware] <br>

== Einzelnachweise ==

<references />

Sonoff POW

2019-04-29T17:46:21Z

Webmaster:

Sonoff POW

2019-04-29T16:15:35Z

Webmaster: /* Software */

Ich wollte von diversen Geräten in meiner Wohnung den Energieverbrauch erfassen und bin dabei auf die vergleichsweise günstigen
IoT WLAN-Schalter von Itead gestoßen. Mit dem Sonoff POW R2 habe ich das gefunden was ich brauchte um diverse Messwerte
von meiner Geschirrspülmaschine, Waschmaschine, ... zu erfassen. Ich beschreibe hier ein bisschen wie die Hardware des Sonoff POW
aufgebaut ist und welche alternative Firmware es gibt (eigentlich gibt es noch mehr) um den Funktionsumfang zu erweitern.

== Hardware ==

== Software ==

=== Alternative Firmware flashen ===

Als alternative Firmware setze ich Tasmota <ref>[https://github.com/arendst/Sonoff-Tasmota/ Tasmota]</ref> ein was die funktionen der Hersteller-Firmware erheblich erweitert und auch
wenn notwedig nach dem eigenen belieben verändert werden kann.

# ESPEasyFlasher-Tool herunterladen <ref>[https://github.com/BattloXX/ESPEasyFlasher ESPEasyFlasher]</ref> und entpacken
# Sonoff POW entsprechend Pinbelegung (RX und TX kreuzen, VDD an 3,3V) mit einem USB<>Seriell-Wandler verbinden.
# Entsprechend neustes Release <ref>[https://github.com/arendst/Sonoff-Tasmota/releases Tasmota Releases]</ref> von Tasmota herunterladen und in den Ordner vom ESPEasyFlasher-Tool verschieben (sonoff.bin)
# ESPEasyFlasher-Tool starten und COM-Port des USB<>Seriell-Wandler auswählen
# Taster am Sonoff POW gedrück halten (versetzt den POW in den Flashmode)
# POW mit 3,3V versorgen (im Idealfall direkt über den USB<>Seriell-Wandler)
# Mittels drücken auf "Flash" im ESPEasyFlasher-Tool den Flashvorgang einleiten
# Warten bis der Flashvorgang erfolgreich beendet wurde
# Um die WLAN-Zugangsdaten einzutragen muss jetzt eine serielle Verbindung (z.B. mittels PuTTY<ref>[https://www.putty.org/ PuTTY]</ref>) zu dem POW aufgebaut werden

[[File:Tasmota_Flashing.png]]

[[File:Tasmota Flashing Complete.png]]

[[File:Tasmota_Wifi_Settings.png]]

== Bilder ==

<gallery>
File:Sonoff_POW_PCB_Top.jpg
File:Sonoff_POW_PCB_Bottom.jpg
</gallery>

== Quellen ==

== Einzelnachweise ==

<references>

File:Tasmota Wifi Settings.png

2019-04-29T16:14:52Z

Webmaster:

Sonoff POW

2019-04-29T15:55:51Z

Webmaster: /* Alternative Firmware flashen */

Ich wollte von diversen Geräten in meiner Wohnung den Energieverbrauch erfassen und bin dabei auf die vergleichsweise günstigen
IoT WLAN-Schalter von Itead gestoßen. Mit dem Sonoff POW R2 habe ich das gefunden was ich brauchte um diverse Messwerte
von meiner Geschirrspülmaschine, Waschmaschine, ... zu erfassen. Ich beschreibe hier ein bisschen wie die Hardware des Sonoff POW
aufgebaut ist und welche alternative Firmware es gibt (eigentlich gibt es noch mehr) um den Funktionsumfang zu erweitern.

== Hardware ==

== Software ==

=== Alternative Firmware flashen ===

Als alternative Firmware setze ich Tasmota <ref>[https://github.com/arendst/Sonoff-Tasmota/ Tasmota]</ref> ein was die funktionen der Hersteller-Firmware erheblich erweitert und auch
wenn notwedig nach dem eigenen belieben verändert werden kann.

# ESPEasyFlasher-Tool herunterladen <ref>[https://github.com/BattloXX/ESPEasyFlasher ESPEasyFlasher]</ref> und entpacken
# Sonoff POW entsprechend Pinbelegung (RX und TX kreuzen, VDD an 3,3V) mit einem USB<>Seriell-Wandler verbinden.
# Entsprechend neustes Release <ref>[https://github.com/arendst/Sonoff-Tasmota/releases Tasmota Releases]</ref> von Tasmota herunterladen und in den Ordner vom ESPEasyFlasher-Tool verschieben (sonoff.bin)
# ESPEasyFlasher-Tool starten und COM-Port des USB<>Seriell-Wandler auswählen
# Taster am Sonoff POW gedrück halten (versetzt den POW in den Flashmode)
# POW mit 3,3V versorgen (im Idealfall direkt über den USB<>Seriell-Wandler)
# Mittels drücken auf "Flash" im ESPEasyFlasher-Tool den Flashvorgang einleiten
# Warten bis der Flashvorgang erfolgreich beendet wurde
# Um die WLAN-Zugangsdaten einzutragen muss jetzt eine serielle Verbindung (z.B. mittels PuTTY<ref>[https://www.putty.org/ PuTTY]</ref>) zu dem POW aufgebaut werden

[[File:Tasmota_Flashing.png]]

[[File:Tasmota Flashing Complete.png]]

== Bilder ==

<gallery>
File:Sonoff_POW_PCB_Top.jpg
File:Sonoff_POW_PCB_Bottom.jpg
</gallery>

== Quellen ==

== Einzelnachweise ==

<references>

Sonoff POW

2019-04-29T15:53:32Z

Webmaster: /* Alternative Firmware flashen */

Ich wollte von diversen Geräten in meiner Wohnung den Energieverbrauch erfassen und bin dabei auf die vergleichsweise günstigen
IoT WLAN-Schalter von Itead gestoßen. Mit dem Sonoff POW R2 habe ich das gefunden was ich brauchte um diverse Messwerte
von meiner Geschirrspülmaschine, Waschmaschine, ... zu erfassen. Ich beschreibe hier ein bisschen wie die Hardware des Sonoff POW
aufgebaut ist und welche alternative Firmware es gibt (eigentlich gibt es noch mehr) um den Funktionsumfang zu erweitern.

== Hardware ==

== Software ==

=== Alternative Firmware flashen ===

Als alternative Firmware setze ich Tasmota <ref>[https://github.com/arendst/Sonoff-Tasmota/ Tasmota]</ref> ein was die funktionen der Hersteller-Firmware erheblich erweitert und auch
wenn notwedig nach dem eigenen belieben verändert werden kann.

# ESPEasyFlasher-Tool herunterladen <ref>[https://github.com/BattloXX/ESPEasyFlasher ESPEasyFlasher]</ref> und entpacken
# Sonoff POW entsprechend Pinbelegung (RX und TX kreuzen, VDD an 3,3V) mit einem USB<>Seriell-Wandler verbinden.
# Entsprechend neustes Release <ref>[https://github.com/arendst/Sonoff-Tasmota/releases Tasmota Releases]</ref> von Tasmota herunterladen und in den Ordner vom ESPEasyFlasher-Tool verschieben (sonoff.bin)
# ESPEasyFlasher-Tool starten und COM-Port des USB<>Seriell-Wandler auswählen
# Taster am Sonoff POW gedrück halten (versetzt den POW in den Flashmode)
# POW mit 3,3V versorgen (im Idealfall direkt über den USB<>Seriell-Wandler)
# Mittels drücken auf "Flash" im ESPEasyFlasher-Tool den Flashvorgang einleiten
# Warten bis der Flashvorgang erfolgreich beendet wurde
# Um die WLAN-Zugangsdaten einzutragen muss jetzt eine serielle Verbindung zu dem POW aufgebaut werden

[[File:Tasmota_Flashing.png]]

[[File:Tasmota Flashing Complete.png]]

== Bilder ==

<gallery>
File:Sonoff_POW_PCB_Top.jpg
File:Sonoff_POW_PCB_Bottom.jpg
</gallery>

== Quellen ==

== Einzelnachweise ==

<references>

Sonoff POW

2019-04-29T15:52:03Z

Webmaster: /* Alternative Firmware flashen */

Ich wollte von diversen Geräten in meiner Wohnung den Energieverbrauch erfassen und bin dabei auf die vergleichsweise günstigen
IoT WLAN-Schalter von Itead gestoßen. Mit dem Sonoff POW R2 habe ich das gefunden was ich brauchte um diverse Messwerte
von meiner Geschirrspülmaschine, Waschmaschine, ... zu erfassen. Ich beschreibe hier ein bisschen wie die Hardware des Sonoff POW
aufgebaut ist und welche alternative Firmware es gibt (eigentlich gibt es noch mehr) um den Funktionsumfang zu erweitern.

== Hardware ==

== Software ==

=== Alternative Firmware flashen ===

Als alternative Firmware setze ich Tasmota <ref>[https://github.com/arendst/Sonoff-Tasmota/ Tasmota]</ref> ein was die funktionen der Hersteller-Firmware erheblich erweitert und auch
wenn notwedig nach dem eigenen belieben verändert werden kann.

# ESPEasyFlasher-Tool herunterladen <ref>[https://github.com/BattloXX/ESPEasyFlasher ESPEasyFlasher]</ref> und entpacken
# Sonoff POW entsprechend Pinbelegung (RX und TX kreuzen, VDD an 3,3V) mit einem USB<>Seriell-Wandler verbinden.
# Entsprechend neustes Release <ref>[https://github.com/arendst/Sonoff-Tasmota/releases Tasmota Releases]</ref> von Tasmota herunterladen und in den Ordner vom ESPEasyFlasher-Tool verschieben (sonoff.bin)
# ESPEasyFlasher-Tool starten und COM-Port des USB<>Seriell-Wandler auswählen
# Taster am Sonoff POW gedrück halten (versetzt den POW in den Flashmode)
# POW mit 3,3V versorgen (im Idealfall direkt über den USB<>Seriell-Wandler)
# Mittels drücken auf "Flash" im ESPEasyFlasher-Tool den Flashvorgang einleiten
# Warten bis der Flashvorgang erfolgreich beendet wurde

[[File:Tasmota_Flashing.png]]

[[File:Tasmota Flashing Complete.png]]

== Bilder ==

<gallery>
File:Sonoff_POW_PCB_Top.jpg
File:Sonoff_POW_PCB_Bottom.jpg
</gallery>

== Quellen ==

== Einzelnachweise ==

<references>

Sonoff POW

2019-04-29T15:49:15Z

Webmaster: /* Software */

Ich wollte von diversen Geräten in meiner Wohnung den Energieverbrauch erfassen und bin dabei auf die vergleichsweise günstigen
IoT WLAN-Schalter von Itead gestoßen. Mit dem Sonoff POW R2 habe ich das gefunden was ich brauchte um diverse Messwerte
von meiner Geschirrspülmaschine, Waschmaschine, ... zu erfassen. Ich beschreibe hier ein bisschen wie die Hardware des Sonoff POW
aufgebaut ist und welche alternative Firmware es gibt (eigentlich gibt es noch mehr) um den Funktionsumfang zu erweitern.

== Hardware ==

== Software ==

=== Alternative Firmware flashen ===

Als alternative Firmware setze ich Tasmota <ref>[https://github.com/arendst/Sonoff-Tasmota/ Tasmota]</ref> ein was die funktionen der Hersteller-Firmware erheblich erweitert und auch
wenn notwedig nach dem eigenen belieben verändert werden kann.

# ESPEasyFlasher-Tool herunterladen <ref>[https://github.com/BattloXX/ESPEasyFlasher ESPEasyFlasher]</ref> und entpacken
# Sonoff POW entsprechend Pinbelegung (RX und TX kreuzen, VDD an 3,3V) mit einem USB<>Seriell-Wandler verbinden.
# Entsprechend neustes Release <ref>[https://github.com/arendst/Sonoff-Tasmota/releases Tasmota Releases] von Tasmota herunterladen und in den Ordner vom ESPEasyFlasher-Tool verschieben (sonoff.bin)
# ESPEasyFlasher-Tool starten und COM-Port des USB<>Seriell-Wandler auswählen
# Taster am Sonoff POW gedrück halten (versetzt den POW in den Flashmode)
# POW mit 3,3V versorgen (im Idealfall direkt über den USB<>Seriell-Wandler)
# Mittels drücken auf "Flash" im ESPEasyFlasher-Tool den Flashvorgang einleiten
# Warten bis der Flashvorgang erfolgreich beendet wurde

[[File:Tasmota_Flashing.png]]

[[File:Tasmota Flashing Complete.png]]

== Bilder ==

<gallery>
File:Sonoff_POW_PCB_Top.jpg
File:Sonoff_POW_PCB_Bottom.jpg
</gallery>

== Quellen ==

== Einzelnachweise ==

<references>

Sonoff POW

2019-04-29T15:48:57Z

Webmaster:

Ich wollte von diversen Geräten in meiner Wohnung den Energieverbrauch erfassen und bin dabei auf die vergleichsweise günstigen
IoT WLAN-Schalter von Itead gestoßen. Mit dem Sonoff POW R2 habe ich das gefunden was ich brauchte um diverse Messwerte
von meiner Geschirrspülmaschine, Waschmaschine, ... zu erfassen. Ich beschreibe hier ein bisschen wie die Hardware des Sonoff POW
aufgebaut ist und welche alternative Firmware es gibt (eigentlich gibt es noch mehr) um den Funktionsumfang zu erweitern.

== Hardware ==

== Software ==

=== Alternative Firmware flashen ===

Als alternative Firmware setze ich Tasmota <ref>[https://github.com/arendst/Sonoff-Tasmota/ Tasmota]</ref> ein was die funktionen der Hersteller-Firmware erheblich erweitert und auch
wenn notwedig nach dem eigenen belieben verändert werden kann.

# ESPEasyFlasher-Tool herunterladen <ref>[https://github.com/BattloXX/ESPEasyFlasher ESPEasyFlasher]</ref> und entpacken
# Sonoff POW entsprechend Pinbelegung (RX und TX kreuzen, VDD an 3,3V) mit einem USB<>Seriell-Wandler verbinden.
# Entsprechend neustes Release <ref>[https://github.com/arendst/Sonoff-Tasmota/releases Tasmota Releases] von Tasmota herunterladen und in den Ordner vom ESPEasyFlasher-Tool verschieben (sonoff.bin)
# ESPEasyFlasher-Tool starten und COM-Port des USB<>Seriell-Wandler auswählen
# Taster am Sonoff POW gedrück halten (versetzt den POW in den Flashmode)
# POW mit 3,3V versorgen (im Idealfall direkt über den USB<>Seriell-Wandler)
# Mittels drücken auf "Flash" im ESPEasyFlasher-Tool den Flashvorgang einleiten
# Warten bis der Flashvorgang erfolgreich beendet wurde

[[File:Tasmota_Flashing.png]]
[[File:Tasmota Flashing Complete.png]]

== Bilder ==

<gallery>
File:Sonoff_POW_PCB_Top.jpg
File:Sonoff_POW_PCB_Bottom.jpg
</gallery>

== Quellen ==

== Einzelnachweise ==

<references>

Sonoff POW

2019-04-29T15:48:28Z

Webmaster:

Ich wollte von diversen Geräten in meiner Wohnung den Energieverbrauch erfassen und bin dabei auf die vergleichsweise günstigen
IoT WLAN-Schalter von Itead gestoßen. Mit dem Sonoff POW R2 habe ich das gefunden was ich brauchte um diverse Messwerte
von meiner Geschirrspülmaschine, Waschmaschine, ... zu erfassen. Ich beschreibe hier ein bisschen wie die Hardware des Sonoff POW
aufgebaut ist und welche alternative Firmware es gibt (eigentlich gibt es noch mehr) um den Funktionsumfang zu erweitern.

== Hardware ==

== Software ==

=== Alternative Firmware flashen ===

Als alternative Firmware setze ich Tasmota <ref>[https://github.com/arendst/Sonoff-Tasmota/ Tasmota]</ref> ein was die funktionen der Hersteller-Firmware erheblich erweitert und auch
wenn notwedig nach dem eigenen belieben verändert werden kann.

# ESPEasyFlasher-Tool herunterladen <ref>[https://github.com/BattloXX/ESPEasyFlasher ESPEasyFlasher]</ref> und entpacken
# Sonoff POW entsprechend Pinbelegung (RX und TX kreuzen, VDD an 3,3V) mit einem USB<>Seriell-Wandler verbinden.
# Entsprechend neustes Release <ref>[https://github.com/arendst/Sonoff-Tasmota/releases Tasmota Releases] von Tasmota herunterladen und in den Ordner vom ESPEasyFlasher-Tool verschieben (sonoff.bin)
# ESPEasyFlasher-Tool starten und COM-Port des USB<>Seriell-Wandler auswählen
# Taster am Sonoff POW gedrück halten (versetzt den POW in den Flashmode)
# POW mit 3,3V versorgen (im Idealfall direkt über den USB<>Seriell-Wandler)
# Mittels drücken auf "Flash" im ESPEasyFlasher-Tool den Flashvorgang einleiten

[[File:Tasmota_Flashing.png]]

# Warten bis der Flashvorgang erfolgreich beendet wurde

[[File:Tasmota Flashing Complete.png]]

== Bilder ==

<gallery>
File:Sonoff_POW_PCB_Top.jpg
File:Sonoff_POW_PCB_Bottom.jpg
</gallery>

== Quellen ==

== Einzelnachweise ==

<references>

File:Tasmota Flashing Complete.png

2019-04-29T15:47:26Z

Webmaster:

Sonoff POW

2019-04-29T15:44:56Z

Webmaster: /* Alternative Firmware flashen */

Ich wollte von diversen Geräten in meiner Wohnung den Energieverbrauch erfassen und bin dabei auf die vergleichsweise günstigen
IoT WLAN-Schalter von Itead gestoßen. Mit dem Sonoff POW R2 habe ich das gefunden was ich brauchte um diverse Messwerte
von meiner Geschirrspülmaschine, Waschmaschine, ... zu erfassen. Ich beschreibe hier ein bisschen wie die Hardware des Sonoff POW
aufgebaut ist und welche alternative Firmware es gibt (eigentlich gibt es noch mehr) um den Funktionsumfang zu erweitern.

== Hardware ==

== Software ==

=== Alternative Firmware flashen ===

Als alternative Firmware setze ich Tasmota <ref>[https://github.com/arendst/Sonoff-Tasmota/ Tasmota]</ref> ein was die funktionen der Hersteller-Firmware erheblich erweitert und auch
wenn notwedig nach dem eigenen belieben verändert werden kann.

# ESPEasyFlasher-Tool herunterladen <ref>[https://github.com/BattloXX/ESPEasyFlasher ESPEasyFlasher]</ref> und entpacken
# Sonoff POW entsprechend Pinbelegung (RX und TX kreuzen, VDD an 3,3V) mit einem USB<>Seriell-Wandler verbinden.
# Entsprechend neustes Release <ref>[https://github.com/arendst/Sonoff-Tasmota/releases Tasmota Releases] von Tasmota herunterladen und in den Ordner vom ESPEasyFlasher-Tool verschieben (sonoff.bin)
# ESPEasyFlasher-Tool starten und COM-Port des USB<>Seriell-Wandler auswählen
# Taster am Sonoff POW gedrück halten (versetzt den POW in den Flashmode)
# POW mit 3,3V versorgen (im Idealfall direkt über den USB<>Seriell-Wandler)
# Mittels drücken auf "Flash" im ESPEasyFlasher-Tool den Flashvorgang einleiten

[[File:Tasmota_Flashing.png|right|thumb|400px|Flashen mittels ESPEasy Flasher]]

== Bilder ==

<gallery>
File:Sonoff_POW_PCB_Top.jpg
File:Sonoff_POW_PCB_Bottom.jpg
</gallery>

== Quellen ==

== Einzelnachweise ==

<references>

Sonoff POW

2019-04-29T15:43:45Z

Webmaster: /* Alternative Firmware flashen */

Ich wollte von diversen Geräten in meiner Wohnung den Energieverbrauch erfassen und bin dabei auf die vergleichsweise günstigen
IoT WLAN-Schalter von Itead gestoßen. Mit dem Sonoff POW R2 habe ich das gefunden was ich brauchte um diverse Messwerte
von meiner Geschirrspülmaschine, Waschmaschine, ... zu erfassen. Ich beschreibe hier ein bisschen wie die Hardware des Sonoff POW
aufgebaut ist und welche alternative Firmware es gibt (eigentlich gibt es noch mehr) um den Funktionsumfang zu erweitern.

== Hardware ==

== Software ==

=== Alternative Firmware flashen ===

Als alternative Firmware setze ich Tasmota <ref>[https://github.com/arendst/Sonoff-Tasmota/ Tasmota]</ref> ein was die funktionen der Hersteller-Firmware erheblich erweitert und auch
wenn notwedig nach dem eigenen belieben verändert werden kann.

# ESPEasyFlasher-Tool herunterladen <ref>[https://github.com/BattloXX/ESPEasyFlasher ESPEasyFlasher]</ref> und entpacken
# Sonoff POW entsprechend Pinbelegung (RX und TX kreuzen, VDD an 3,3V) mit einem USB<>Seriell-Wandler verbinden.
# Entsprechend neustes Release <ref>[https://github.com/arendst/Sonoff-Tasmota/releases Tasmota Releases] von Tasmota herunterladen und in den Ordner vom ESPEasyFlasher-Tool verschieben (sonoff.bin)
# ESPEasyFlasher-Tool starten und COM-Port des USB<>Seriell-Wandler auswählen
# Taster am Sonoff POW gedrück halten (versetzt den POW in den Flashmode)
# POW mit 3,3V versorgen (im Idealfall direkt über den USB<>Seriell-Wandler)
# Mittels drücken auf "Flash" im ESPEasyFlasher-Tool den Flashvorgang einleiten

[[File:Tasmota_Flashing.png]]

== Bilder ==

<gallery>
File:Sonoff_POW_PCB_Top.jpg
File:Sonoff_POW_PCB_Bottom.jpg
</gallery>

== Quellen ==

== Einzelnachweise ==

<references>

File:Tasmota Flashing.png

2019-04-29T15:42:40Z

Webmaster:

Sonoff POW

2019-04-29T15:24:15Z

Webmaster: /* Alternative Firmware flashen */

Sonoff POW

2019-04-29T15:10:17Z

Webmaster: /* Alternative Firmware flashen */

Sonoff POW

2019-04-29T15:09:12Z

Webmaster: /* Software */

Sonoff POW

2019-04-29T15:08:34Z

Webmaster: /* Software */

Sonoff POW

2019-04-29T15:06:23Z

Webmaster: /* Software */

Sonoff POW

2019-04-29T15:04:07Z

Webmaster:

Sonoff POW

2019-04-29T04:58:05Z

Webmaster:

Sonoff POW

2019-04-25T04:57:12Z

Webmaster: /* Bilder */

== Hardware ==

== Software ==

== Bilder ==

<gallery>
File:Sonoff_POW_PCB_Top.jpg
File:Sonoff_POW_PCB_Bottom.jpg
</gallery>

== Quellen ==

== Einzelnachweise ==

<references>

File:Sonoff POW PCB Top.jpg

2019-04-25T04:51:36Z

Webmaster:

File:Sonoff POW PCB Bottom.jpg

2019-04-25T04:50:12Z

Webmaster:

Main Page

2019-04-23T04:48:04Z

Webmaster: /* Neue Artikel */

[[File:Daniel Duesentrieb.jpg]]

Willkommen in meinem Wiki!
Hier dreht sich alles um (Elektronik)projekte die ich mal durchgeführt habe.
Ich werde hier in unregelmäßigen Abstände mal das ein oder andere
Projekt beschreiben.

Viel Spaß



== Artikelübersicht ==
[[Pollin AVR-NetIO PHP Wrapper]] - [[Ätzmaschine]] - [[Ramdisk unter Linux]] - [[RS232/RS485-Wandler]] - [[Nulldurchgangserkennung]] - [[Lötrauchabsaugung]] - [[PC-Maus als Drehzahlmesser]] - [[GPS Laptimer]] - [[Platinenfräsmaschine]] - [[WLAN Richtfunkantenne]] - [[Laptimer]] - [[OsmocomBB]] - [[SDR mit DVB-T Stick]] - [[ESP8266]]

== Neue Artikel ==
[[Sonoff POW]] - [[Samsung Galaxy Ace disassembled]] - [[Cafissimo Picco Hack]] - [[LED-Tisch]]

Sonoff POW

2019-04-23T04:47:20Z

Webmaster: Created page with " == Hardware == == Software == == Bilder == == Quellen == == Einzelnachweise == <references>"

== Hardware ==

== Software ==

== Bilder ==

== Quellen ==

== Einzelnachweise ==

<references>

LED-Tisch

2019-04-23T04:43:39Z

Webmaster: /* Bilder */

Irgendwann hatte ich mal die Idee einen LED-Tisch Tisch zu bauen, da ich im Internet<ref>[http://hackedgadgets.com/2009/06/05/64-rgb-led-color-table/ Hacked Gadgets - 64 RGB-LED Color Table]</ref> viele schöne Umsetzungen
gesehen habe. Ich habe mich dazu entschieden einen LED-Tisch mit 64-RGB-Leds aufzubauen.

== Hardware ==

Zur Ansteuerung der RGB-Leds wird der äußerst weit verbreitete LED-Treiber TLC5940 Chip genutzt. Dieser Chip hat den Vorteil,
dass er in Reihe geschaltet werden und somit fast unbegrenzt viele LEDs angesteuert werden können. Begrenzender Faktor ist
fast ausschließlich die Taktfrequenz der seriellen Übertragung. Ein weiterer Vorteile des LED-Treibers ist die mögliche Korrektor von Fertigungstoleranzen (Helligkeitsunterschied) zwischen den Leds mittels DOT Correction.

=== Eckdaten ===

* Maße: ca. 50x50x20cm
* LED-Treiber: TLC5940
* µC: Atmel Atmega16
* LED: 64x RGB-Led 5mm

== Software ==

== Bilder ==

<gallery>
File:LED_Tisch_Frame.jpg
File:LED_Tisch_Matrix.jpg
File:LED_Tisch_LEDs.jpg
File:LED_Tisch_Wiring.jpg
File:LED_Tisch_PCB.jpg
</gallery>

== Schaltplan ==



== Quelltext ==

== Quellen ==



== Einzelnachweise ==

<references>

File:LED Tisch PCB.jpg

2019-04-23T04:42:49Z

Webmaster:

File:LED Tisch Wiring.jpg

2019-04-23T04:41:49Z

Webmaster:

Main Page

2017-12-28T08:51:11Z

Webmaster: /* Neue Artikel */

[[File:Daniel Duesentrieb.jpg]]

Willkommen in meinem Wiki!
Hier dreht sich alles um (Elektronik)projekte die ich mal durchgeführt habe.
Ich werde hier in unregelmäßigen Abstände mal das ein oder andere
Projekt beschreiben.

Viel Spaß



== Artikelübersicht ==
[[Pollin AVR-NetIO PHP Wrapper]] - [[Ätzmaschine]] - [[Ramdisk unter Linux]] - [[RS232/RS485-Wandler]] - [[Nulldurchgangserkennung]] - [[Lötrauchabsaugung]] - [[PC-Maus als Drehzahlmesser]] - [[GPS Laptimer]] - [[Platinenfräsmaschine]] - [[WLAN Richtfunkantenne]] - [[Laptimer]] - [[OsmocomBB]] - [[SDR mit DVB-T Stick]] - [[ESP8266]]

== Neue Artikel ==
[[Samsung Galaxy Ace disassembled]] - [[Cafissimo Picco Hack]] - [[LED-Tisch]]

LED-Tisch

2017-12-28T08:50:09Z

Webmaster: /* Bilder */

Irgendwann hatte ich mal die Idee einen LED-Tisch Tisch zu bauen, da ich im Internet<ref>[http://hackedgadgets.com/2009/06/05/64-rgb-led-color-table/ Hacked Gadgets - 64 RGB-LED Color Table]</ref> viele schöne Umsetzungen
gesehen habe. Ich habe mich dazu entschieden einen LED-Tisch mit 64-RGB-Leds aufzubauen.

== Hardware ==

Zur Ansteuerung der RGB-Leds wird der äußerst weit verbreitete LED-Treiber TLC5940 Chip genutzt. Dieser Chip hat den Vorteil,
dass er in Reihe geschaltet werden und somit fast unbegrenzt viele LEDs angesteuert werden können. Begrenzender Faktor ist
fast ausschließlich die Taktfrequenz der seriellen Übertragung. Ein weiterer Vorteile des LED-Treibers ist die mögliche Korrektor von Fertigungstoleranzen (Helligkeitsunterschied) zwischen den Leds mittels DOT Correction.

=== Eckdaten ===

* Maße: ca. 50x50x20cm
* LED-Treiber: TLC5940
* µC: Atmel Atmega16
* LED: 64x RGB-Led 5mm

== Software ==

== Bilder ==

<gallery>
File:LED_Tisch_Frame.jpg
File:LED_Tisch_Matrix.jpg
File:LED_Tisch_LEDs.jpg
</gallery>

== Schaltplan ==



== Quelltext ==

== Quellen ==



== Einzelnachweise ==

<references>