[HaBo]

#!/usr/bin/env perl
use warnings;
use strict;
use Tk;

my $mw = MainWindow->new(
    -title      => "binary-clock 10111",
    -background => "black",
);

$mw->geometry('150x120');
$mw->resizable(0, 0);

my $secFrame = $mw->Frame(
    -width       => 50,
    -height      => 100,
    -borderwidth => 10,
    -background  => "black"
);
my $minFrame = $mw->Frame(
    -width       => 50,
    -height      => 100,
    -borderwidth => 10,
    -background  => "black"
);
my $hourFrame = $mw->Frame(
    -width       => 50,
    -height      => 100,
    -borderwidth => 10,
    -background  => "black"
);

my %LED = setupLEDS($secFrame, $minFrame, $hourFrame);
my $decTime;
$mw->repeat(1000, [\&myMainLoop, \$decTime, \%LED]);
myMainLoop(\$decTime, \%LED);

$mw->Label(
    -textvariable => \$decTime,
    -background   => "black",
    -foreground   => "grey"
)->grid();
Tk::grid($hourFrame, $minFrame, $secFrame);

MainLoop();

sub myMainLoop {
    my ($timeVarRef, $LED) = @_;
    updateTime($timeVarRef);
    my ($hours, $min, $sec) = $$timeVarRef =~ /^(\d{2}):(\d{2}):(\d{2})$/;
    updateLEDS($hours, $min, $sec, $LED);
    return;
}

sub updateTime {
    my ($timeVarRef) = @_;
    my ($sec, $min, $hours) = localtime;
    $$timeVarRef = sprintf "%02d:%02d:%02d", ($hours, $min, $sec);
    return;
}

sub separateTenOne {
    my ($decimal) = @_;
    my ($ten, $one) = (0, 0);
    $ten = int $decimal / 10;
    $one = $decimal - $ten * 10;
    return ($ten, $one);
}

sub updateLEDS {
    my ($hour, $min, $sec, $LED) = @_;
    my ($secTen,  $secOne)  = separateTenOne($sec);
    my ($minTen,  $minOne)  = separateTenOne($min);
    my ($hourTen, $hourOne) = separateTenOne($hour);

    # seconds:
    for my $i (1, 2, 4) {
        my $color = ($i & $secTen) ? "blue" : "black";
        $$LED{"sec10_$i"}->configure(-background => $color);
    }
    for my $i (1, 2, 4, 8) {
        my $color = ($i & $secOne) ? "blue" : "black";
        $$LED{"sec1_$i"}->configure(-background => $color);
    }

    # minutes:
    for my $i (1, 2, 4) {
        my $color = ($i & $minTen) ? "green" : "black";
        $$LED{"min10_$i"}->configure(-background => $color);
    }
    for my $i (1, 2, 4, 8) {
        my $color = ($i & $minOne) ? "green" : "black";
        $$LED{"min1_$i"}->configure(-background => $color);
    }

    # and finally hours:
    for my $i (1, 2) {
        my $color = ($i & $hourTen) ? "red" : "black";
        $$LED{"hour10_$i"}->configure(-background => $color);
    }
    for my $i (1, 2, 4, 8) {
        my $color = ($i & $hourOne) ? "red" : "black";
        $$LED{"hour1_$i"}->configure(-background => $color);
    }

}

sub setupLEDS {
    # now i'll put the "LED"s (label widgets) into a hash and grid them.
    my ($secFrame, $minFrame, $hourFrame) = @_;
    my %LED;

    # seconds first:
    for my $i (1, 2, 4, 8) {
        $LED{"sec1_$i"} = $secFrame->Label(
            -text       => ' ',
            -background => "blue",
            -relief     => "groove"
        );
    }
    for my $i (1, 2, 4) {
        $LED{"sec10_$i"} = $secFrame->Label(
            -text       => ' ',
            -background => "blue",
            -relief     => "groove"
        );
    }
    Tk::grid("x",             $LED{"sec1_8"});
    Tk::grid($LED{"sec10_4"}, $LED{"sec1_4"});
    Tk::grid($LED{"sec10_2"}, $LED{"sec1_2"});
    Tk::grid($LED{"sec10_1"}, $LED{"sec1_1"});

    # now minutes:
    for my $i (1, 2, 4, 8) {
        $LED{"min1_$i"} = $minFrame->Label(
            -text       => ' ',
            -background => "green",
            -relief     => "groove"
        );
    }
    for my $i (1, 2, 4) {
        $LED{"min10_$i"} = $minFrame->Label(
            -text       => ' ',
            -background => "green",
            -relief     => "groove"
        );
    }
    Tk::grid("x",             $LED{"min1_8"});
    Tk::grid($LED{"min10_4"}, $LED{"min1_4"});
    Tk::grid($LED{"min10_2"}, $LED{"min1_2"});
    Tk::grid($LED{"min10_1"}, $LED{"min1_1"});

    # and hours:
    for my $i (1, 2, 4, 8) {
        $LED{"hour1_$i"} = $hourFrame->Label(
            -text       => ' ',
            -background => "red",
            -relief     => "groove"
        );
    }
    for my $i (1, 2) {
        $LED{"hour10_$i"} = $hourFrame->Label(
            -text       => ' ',
            -background => "red",
            -relief     => "groove"
        );
    }
    Tk::grid("x",              $LED{"hour1_8"});
    Tk::grid("x",              $LED{"hour1_4"});
    Tk::grid($LED{"hour10_2"}, $LED{"hour1_2"});
    Tk::grid($LED{"hour10_1"}, $LED{"hour1_1"});

    return %LED;
}

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pygame
import sys
import time

SIZE = 10

def dec2bin(n):
    return ((n >> i) % 2 for i in range(6)[::-1])

def hms_time():
    return map(int, map(time.strftime, ("%H", "%M", "%S")))
    
if __name__ == "__main__":
    pygame.display.init()
    screen = pygame.display.set_mode((6 * SIZE, 3 * SIZE))
    pygame.display.set_caption("Binaeruhr")
    clock = pygame.time.Clock()
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
        hms = hms_time()
        for y, value in enumerate(hms):
            for x, b in enumerate(dec2bin(value)):
                color = 0, 0, 255 * b
                pygame.draw.rect(screen, color, (SIZE * x, SIZE * y, SIZE, SIZE))
                pygame.draw.rect(screen, (0, 0, 0), (SIZE * x, SIZE * y, SIZE, SIZE), 2)
        pygame.display.update()
        clock.tick(1)

'Binäruhr von Spyx


'Variablen definieren
DIM AS INTEGER kreisbreite, kreishoehe
DIM AS UBYTE stunden, minuten, sekunden, i, farbe
DIM uhrzeit AS STRING * 8
DIM key AS STRING * 2

'Grafikmodus initialisieren
SCREENRES 92, 175
Color 15,0

'Beim drücken der Escapetaste oder des Kreuzes oben rechts Schleife beenden
WHILE (key<>CHR(27)) and key<>(Chr(255, 107))
    'Bildschirm leeren
    CLS
    
    'Zeit als String abrufen
    uhrzeit = TIME
    'Stunden, Minuten, Sekunden als unsigned Byte speichern
    stunden = 10*CAST(BYTE,CHR(uhrzeit[0])) + CAST(BYTE,CHR(uhrzeit[1]))
    minuten = 10*CAST(BYTE,CHR(uhrzeit[3])) + CAST(BYTE,CHR(uhrzeit[4]))
    sekunden = 10*CAST(BYTE,CHR(uhrzeit[6])) + CAST(BYTE,CHR(uhrzeit[7]))
    
    'Anzeige
    FOR i = 0 to 5
        
        'Stunden anzeigen
        IF BIT(stunden, i) THEN
            farbe = 15
        ELSE
            farbe = 8
        ENDIF
        CIRCLE (14,31+i*25), 10,farbe,,,1.2,F
        DRAW STRING (8,5),STR(stunden)
        
        'Minuten anzeigen
        IF BIT(minuten, i) THEN
            farbe = 15
        ELSE
            farbe = 8
        ENDIF
        CIRCLE (45,31+i*25), 10,farbe,,,1.2,F
        DRAW STRING (39,5),STR(minuten)
        
        'Sekunden anzeigen
        IF BIT(sekunden, i) THEN
            farbe = 15
        ELSE
            farbe = 8
        ENDIF
        CIRCLE (76,31+i*25), 10,farbe,,,1.2,F
        DRAW STRING (70,5),STR(sekunden)
    NEXT

    'Tastaturabfrage
    key = INKEY

    'Flimmern reduzieren
    SCREENSYNC
WEND
END

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <windows.h>

using namespace std;
void bin(time_t secs);

int main(){
	time_t seconds;
	time_t old;
	old=time(NULL);
	while(1){
		seconds=time(NULL);
		seconds+=(2*3600);
		if(seconds>old){
			system("cls");
			cout<<"Dezimal : "<<(seconds/3600)%24<<":"<<(seconds/60)%60<<":"<<seconds%60<<endl;
			cout<<"Binaer : "<<endl;
			cout<<"hour mins secs"<<endl;
			bin(seconds);
			old=seconds;
		}		
	}
	return 0;
}
void bin(time_t in){
	char feld[3][6];
	for(int i=0; i<3; i++){
		for(int j=0; j<6; j++){
			feld[i][j]='0';
		}
	}
	double hour=(double) ((in/3600)%24);
	for(double i=32.0; i>=1.0; i=i/2){
		if(hour/i>=1.0){
			switch((int) i){
				case 32:
					feld[0][0]='1';
					hour-=32.0;
					break;
				
				case 16:
					feld[0][1]='1';
					hour-=16.0;
					break;

				case 8:
					feld[0][2]='1';
					hour-=8.0;
					break;

				case 4:
					feld[0][3]='1';
					hour-=4.0;
					break;

				case 2:
					feld[0][4]='1';
					hour-=2.0;
					break;

				case 1:
					feld[0][5]='1';
					break;

				default:
					break;

			}
		}
	}
	
	double mins=(double) ((in/60)%60);
	for(double i=32.0; i>=1.0; i=i/2){
		if(mins/i>=1.0){
			switch((int) i){
				case 32:
					feld[1][0]='1';
					mins-=32.0;
					break;
				
				case 16:
					feld[1][1]='1';
					mins-=16.0;
					break;

				case 8:
					feld[1][2]='1';
					mins-=8.0;
					break;

				case 4:
					feld[1][3]='1';
					mins-=4.0;
					break;

				case 2:
					feld[1][4]='1';
					mins-=2.0;
					break;

				case 1:
					feld[1][5]='1';
					break;

				default:
					break;

			}
		}
	}
	double secs=(double) ((in)%60);
	for(double i=32.0; i>=1.0; i=i/2){
		if(secs/i>=1.0){
			switch((int) i){
				case 32:
					feld[2][0]='1';
					secs-=32.0;
					break;
				
				case 16:
					feld[2][1]='1';
					secs-=16.0;
					break;

				case 8:
					feld[2][2]='1';
					secs-=8.0;
					break;

				case 4:
					feld[2][3]='1';
					secs-=4.0;
					break;

				case 2:
					feld[2][4]='1';
					secs-=2.0;
					break;

				case 1:
					feld[2][5]='1';
					break;

				default:
					break;

			}
		}
	}
	for(int y=0; y<6; y++){
		for(int x=0; x<3; x++){
			cout<<"  "<<feld[x][y]<<"  ";
		}
		cout<<endl;
	}
}

function display(number, column)
{
  led3 = Math.floor(number / 8);
  led2 = Math.floor((number % 8) / 4);
  led1 = Math.floor((number % 4) / 2);
  led0 = Math.floor(number % 2);

  if (column == 0)
    end = 2;
  else if (column % 2 != 0)
    end = 4;
  else
    end = 3;

    for (i = 0; i < end; i++)
    {
      if (eval ("led"+i))
        document.getElementById("led" + column + i).checked = true;
      else
        document.getElementById("led" + column + i).checked = false;
    }
}

function clock()
{
  var time = new Date();
  
  var hrs = time.getHours();
  display(Math.floor(hrs/10),0);
  display(hrs%10,1);
  
  var min = time.getMinutes();
  display(Math.floor(min/10),2);
  display(min%10,3);

  var sec = time.getSeconds();
  display(Math.floor(sec/10),4);
  display(sec%10,5);

  setTimeout("clock()",1000);
}

clock();

import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;
import java.util.BitSet;
import java.util.Date;

public class Binaryclock extends Applet{
	public Date heute = new Date(System.currentTimeMillis());
	
	public static BitSet convertDez2bin(int dez, int bits) {
		BitSet bit = new BitSet(bits);
		for (int i = 0; i < bits; i++) {
			bit.set(bits-i, (dez%2 == 1)?true:false);
			dez = dez/2;
		}
		return bit;	
	}
	public static Graphics rect(Graphics e, int x, int y){
		e.drawOval(x, y, 10, 10);
		return e ;
	}
	public static Graphics rectf(Graphics e, int x, int y){
		e.fillOval(x, y, 12, 12);
		return e ;
	}
	public static Graphics bin2rect(Graphics e, BitSet b,int bits, int offsety ,int offsetx){
		for (int i = 1; i <= bits; i++) {
			if(b.get(i)) rectf(e, 10+offsetx-1, 12*i+offsety);
			else rect(e, 10+offsetx, 12*i+offsety);
		}
		return e;
	}
	@SuppressWarnings("deprecation")
	public void paint(Graphics e) {
			e.setColor(Color.ORANGE);
			e.drawString("Hour", 30, 10);
			e.drawString("Minute", 70, 10);
			e.drawString("Second", 120, 10);
			e.drawString(heute.toString(), 5 ,130);
			e.drawString("1", 15, 105);
			e.drawString("2", 15, 93);
			e.drawString("4", 15, 81);
			e.drawString("8", 15, 69);
			e.drawString("16", 15, 57);
			e.drawString("32", 15, 45);
			bin2rect(e, convertDez2bin(heute.getHours(), 6), 6, 20, 30);
			bin2rect(e, convertDez2bin(heute.getMinutes(), 6), 6, 20, 70);
			bin2rect(e, convertDez2bin(heute.getSeconds(), 6), 6, 20, 120);
			heute.setTime(System.currentTimeMillis());
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
			super.repaint();
	}
	public void init() {
		setBackground(Color.BLACK);
		setSize(200, 150);
		super.init();
	}
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;

namespace BinaryClock
{
	public partial class BinaryClock : Form
	{
		Image img0 = Image.FromFile(Path.GetDirectoryName(Application.ExecutablePath) + @"\gfx\0.jpg");
		Image img1 = Image.FromFile(Path.GetDirectoryName(Application.ExecutablePath) + @"\gfx\1.jpg");

		bool[] zHours = new bool[2];
		bool[] eHours = new bool[4];
		bool[] zMinutes = new bool[3];
		bool[] eMinutes = new bool[4];
		bool[] zSeconds = new bool[3];
		bool[] eSeconds = new bool[4];

		BackgroundWorker bgw = new BackgroundWorker();

		public BinaryClock()
		{
			InitializeComponent();
			bgw.DoWork += new DoWorkEventHandler(bgw_DoWork);
			bgw.WorkerSupportsCancellation = true;
			bgw.RunWorkerAsync();
		}

		void bgw_DoWork(object sender, DoWorkEventArgs e)
		{
			DateTime dt	= DateTime.Now.ToLocalTime();

			while (true)
			{
				if (dt == DateTime.Now.ToLocalTime())
					continue;

				dt	= DateTime.Now.ToLocalTime();

				#region zHours

				int zHour = dt.Hour;

				zHours[0] = false;
				zHours[1] = false;

				if (zHour >= 20)
				{
					zHours[0] = true;
					zHours[1] = false;
				}
				else if (zHour >= 10)
				{
					zHours[0] = false;
					zHours[1] = true;
				}

				#endregion

				#region eHours

				int eHour = dt.Hour % 10;

				eHours[0] = false;
				eHours[1] = false;
				eHours[2] = false;
				eHours[3] = false;

				if (eHour >= 8)
				{
					eHours[0] = true;
					eHour -= 8;
				}
				if (eHour >= 4)
				{
					eHours[1] = true;
					eHour -= 4;
				}
				if (eHour >= 2)
				{
					eHours[2] = true;
					eHour -= 2;
				}
				if (eHour >= 1)
				{
					eHours[3] = true;
				}
				
				#endregion

				#region zMinutes

				int zMinute = dt.Minute;

				zMinutes[0] = false;
				zMinutes[1] = false;
				zMinutes[2] = false;

				if (zMinute >= 40)
				{
					zMinutes[0] = true;
					zMinute -= 40;
				}
				if (zMinute >= 20)
				{
					zMinutes[1] = true;
					zMinute -= 20;
				}
				if (zMinute >= 10)
				{
					zMinutes[2] = true;
				}

				#endregion

				#region eMinutes

				int eMinute = dt.Minute % 10;

				eMinutes[0] = false;
				eMinutes[1] = false;
				eMinutes[2] = false;
				eMinutes[3] = false;

				if (eMinute >= 8)
				{
					eMinutes[0] = true;
					eMinute -= 8;
				}
				if (eMinute >= 4)
				{
					eMinutes[1] = true;
					eMinute -= 4;
				}
				if (eMinute >= 2)
				{
					eMinutes[2] = true;
					eMinute -= 2;
				}
				if (eMinute >= 1)
				{
					eMinutes[3] = true;
				}

				#endregion

				#region zSeconds

				int zSecond = dt.Second;

				zSeconds[0] = false;
				zSeconds[1] = false;
				zSeconds[2] = false;

				if (zSecond >= 40)
				{
					zSeconds[0] = true;
					zSecond -= 40;
				}
				if (zSecond >= 20)
				{
					zSeconds[1] = true;
					zSecond -= 20;
				}
				if (zSecond >= 10)
				{
					zSeconds[2] = true;
				}

				#endregion

				#region eSeconds

				int eSecond = dt.Second % 10;

				eSeconds[0] = false;
				eSeconds[1] = false;
				eSeconds[2] = false;
				eSeconds[3] = false;

				if (eSecond >= 8)
				{
					eSeconds[0] = true;
					eSecond -= 8;
				}
				if (eSecond >= 4)
				{
					eSeconds[1] = true;
					eSecond -= 4;
				}
				if (eSecond >= 2)
				{
					eSeconds[2] = true;
					eSecond -= 2;
				}
				if (eSecond >= 1)
				{
					eSeconds[3] = true;
				}

				#endregion

				doubleBufferedPanel.Invalidate();
			}
		}

		private void BinaryClock_FormClosing(object sender, FormClosingEventArgs e)
		{
			bgw.CancelAsync();
		}

		private void doubleBufferedPanel_Paint(object sender, PaintEventArgs e)
		{
			//198 Breit
			//132 Hoch

			for (int i = 0; i < 2; i++)
			{
				if (zHours[i] == true)
				{
					e.Graphics.DrawImage(img1, new Point(0, (i + 2) * 33));
				}
				else
				{
					e.Graphics.DrawImage(img0, new Point(0, (i + 2) * 33));
				}
			}

			for (int i = 0; i < 4; i++)
			{
				if (eHours[i] == true)
				{
					e.Graphics.DrawImage(img1, new Point(33, i * 33));
				}
				else
				{
					e.Graphics.DrawImage(img0, new Point(33, i * 33));
				}
			}

			for (int i = 0; i < 3; i++)
			{
				if (zMinutes[i] == true)
				{
					e.Graphics.DrawImage(img1, new Point(66, (i + 1) * 33));
				}
				else
				{
					e.Graphics.DrawImage(img0, new Point(66, (i + 1) * 33));
				}
			}

			for (int i = 0; i < 4; i++)
			{
				if (eMinutes[i] == true)
				{
					e.Graphics.DrawImage(img1, new Point(99, i * 33));
				}
				else
				{
					e.Graphics.DrawImage(img0, new Point(99, i * 33));
				}
			}

			for (int i = 0; i < 3; i++)
			{
				if (zSeconds[i] == true)
				{
					e.Graphics.DrawImage(img1, new Point(132, (i + 1) * 33));
				}
				else
				{
					e.Graphics.DrawImage(img0, new Point(132, (i + 1) * 33));
				}
			}

			for (int i = 0; i < 4; i++)
			{
				if (eSeconds[i] == true)
				{
					e.Graphics.DrawImage(img1, new Point(165, i * 33));
				}
				else
				{
					e.Graphics.DrawImage(img0, new Point(165, i * 33));
				}
			}
		}
	}
}

namespace BinaryClock
{
	partial class BinaryClock
	{
		/// <summary>
		/// Erforderliche Designervariable.
		/// </summary>
		private System.ComponentModel.IContainer components = null;

		/// <summary>
		/// Verwendete Ressourcen bereinigen.
		/// </summary>
		/// <param name="disposing">True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False.</param>
		protected override void Dispose(bool disposing)
		{
			if (disposing && (components != null))
			{
				components.Dispose();
			}
			base.Dispose(disposing);
		}

		#region Vom Windows Form-Designer generierter Code

		/// <summary>
		/// Erforderliche Methode für die Designerunterstützung.
		/// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
		/// </summary>
		private void InitializeComponent()
		{
			this.doubleBufferedPanel = new DoubleBufferedPanel();
			this.SuspendLayout();
			// 
			// doubleBufferedPanel
			// 
			this.doubleBufferedPanel.BackColor = System.Drawing.Color.Black;
			this.doubleBufferedPanel.ForeColor = System.Drawing.SystemColors.Control;
			this.doubleBufferedPanel.Location = new System.Drawing.Point(0, 0);
			this.doubleBufferedPanel.Name = "doubleBufferedPanel";
			this.doubleBufferedPanel.Size = new System.Drawing.Size(198, 132);
			this.doubleBufferedPanel.TabIndex = 0;
			this.doubleBufferedPanel.Paint += new System.Windows.Forms.PaintEventHandler(this.doubleBufferedPanel_Paint);
			// 
			// BinaryClock
			// 
			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
			this.ClientSize = new System.Drawing.Size(198, 132);
			this.Controls.Add(this.doubleBufferedPanel);
			this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.Fixed3D;
			this.MaximizeBox = false;
			this.Name = "BinaryClock";
			this.Text = "BinaryClock";
			this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.BinaryClock_FormClosing);
			this.ResumeLayout(false);

		}

		#endregion

		private DoubleBufferedPanel doubleBufferedPanel;
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace BinaryClock
{
	public class DoubleBufferedPanel : Panel
	{
		public DoubleBufferedPanel()
		{
			this.DoubleBuffered = true;
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace BinaryClock
{
	static class Program
	{
		/// <summary>
		/// Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		static void Main()
		{
			Application.EnableVisualStyles();
			Application.SetCompatibleTextRenderingDefault(false);
			Application.Run(new BinaryClock());
		}
	}
}