Turret from portal 2

All parts printet , some elektronic done

item used

arduino nano
vibration sensor
MP3 serial board / 1gb sd
2 x laser
2 x LED
1 Neopixel
1 lipo charge board

one tiny lipo battery so the bot can come with a dying sound / shutting down sound
and a lot of wires

Fire lamp

a friend om mine asked me : can you make a led lamp look like fire burning…..

well ill give it a try..

8 x 8 neopixel sticks
1 x Arduino Nano
1 x pot meter 10kohm

skript file: Neopixel_Fire

 

90x90CM Clock with 60 NeoPixel

New Project : Clock with 60 NeoPixel Diameter 80cm getting time from GPS or Radiosignal

Hardware in this build is :
Arduino Uno
GPS or RadioReciver
60 NeoPixel
A giant 90x90cm Plexiglass plate (pictures will be uploaded)

Updated 1. feb-17
all done just need the frame

I have made a tiny ed. of it with a 24NeoPixel Ring with out the GPS or Radio signal

item in the 24 Pixel Build:
1 Arduino Nano
1 Tiny RTC
1 24NeoPixelRing

Red : Hour ,Green : Minuts ,Blue : Seconds

The code i used: NeoPixelClock_24px_v1

HeadPhoneStand

Yep yet another project……

This time ill make a headphonestand yes for my headphones…

Usually I put my headphones on my desk but I have become tired of the mess with all the wires. I saw a video on youtube where there was one who had made a stand for his headphones … I’ll will go one step further …. I want to use an Arduino as a VU meter and light control.

HeadPhoneStand1  HeadPhoneStand2

more will come.

DeathStar Lamp

im using :

Lamp from IKEA IKEA PS 2014 is is the small one for now , but i hope to buy the big one and do the samr with that.
How it looks IKEA Lamp

WeMos D1

MotorShield / Stepmotor

20 NeoPixels

what i should end with is : customized deathstar IKEA

When im done ill post the code and a video and a link to all parts

UPDATE 30/1-17
WELL WELL
August 4 hmm ok, i just got some of the parts…
the stepper with spindel on is hard to track down… and is expensive (500dkk)
im not using WeMOS D1 (need to know more about it before i use it.)

Here is the new part list: (ill link to the items when im done)
arduino nano
some kind of motor controler
remotecontroll (IR)
10 NeoPixel strip (8x)
BlueTooth Controler for NeoPixel
stepper with spindel on

64×16 Led Matrix

this works 99% still some issues at the end where the text spawns on top of the other text

code is from this project link

// Arduino 1.0.5 UNO R3
//#include <pgmspace.h>

//#include "ascii.h"

// Connections to board
const byte latchPin = 8; // LT/LAT
const byte clockPin = 12; // SK/CLK
const byte data_R1 = 10; // R1
const byte data_R2 = 11; // R2 if code dont work remove this line
const byte en_74138 = 2; // EN/OE
const byte la_74138 = 3; // LA
const byte lb_74138 = 4; // LB
const byte lc_74138 = 5; // LC
const byte ld_74138 = 6; // LD
byte ScanRow = 0;
unsigned long counter;

//Insert message here ("message ")
const char message[] = "All support is handled by Bertram, if he is not here send him an email       <<<<<<<<<<      ";

byte buffer[256] = { // Display buffer (which is scanned by the interrupt timer) of 8x32 bytes
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
};
// ---------------------------------------------------------------------------------------------------
// FONTS sourced from various locations on the internet
// full ASCII character set (8x16) (1520 bytes)
const uint8_t font8x16_basic[] PROGMEM = {
  /*   (32) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  
  /* ! (33) */ 0x00, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,
  /* " (34) */ 0x00, 0x00, 0x66, 0x66, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  /* # (35) */ 0x00, 0x00, 0x00, 0x00, 0x6C, 0x6C, 0xFE, 0x6C, 0x6C, 0x6C, 0xFE, 0x6C, 0x6C, 0x00, 0x00, 0x00,
  /* $ (36) */ 0x00, 0x18, 0x18, 0x7C, 0xC6, 0xC2, 0xC0, 0x7C, 0x06, 0x06, 0x86, 0xC6, 0x7C, 0x18, 0x18, 0x00,  
  /* % (37) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xC2, 0xC6, 0x0C, 0x18, 0x30, 0x60, 0xC6, 0x86, 0x00, 0x00, 0x00,
  /* & (38) */ 0x00, 0x00, 0x00, 0x38, 0x6C, 0x6C, 0x38, 0x76, 0xDC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00,
  /* ' (39) */ 0x00, 0x00, 0x30, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  /* ( (40) */ 0x00, 0x00, 0x00, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0C, 0x00, 0x00, 0x00,
  /* ) (41) */ 0x00, 0x00, 0x00, 0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x18, 0x30, 0x00, 0x00, 0x00,
  /* * (42) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00,
  /* + (43) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
  /* , (44) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00,
  /* - (45) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  /* . (46) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,
  /* / (47) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0x80, 0x00, 0x00, 0x00,
  /* 0 (48) */ 0x00, 0x00, 0x00, 0x3C, 0x66, 0xC3, 0xC3, 0xDB, 0xDB, 0xC3, 0xC3, 0x66, 0x3C, 0x00, 0x00, 0x00,
  /* 1 (49) */ 0x00, 0x00, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x00, 0x00, 0x00,
  /* 2 (50) */ 0x00, 0x00, 0x00, 0x7C, 0xC6, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0xC6, 0xFE, 0x00, 0x00, 0x00,
  /* 3 (51) */ 0x00, 0x00, 0x00, 0x7C, 0xC6, 0x06, 0x06, 0x3C, 0x06, 0x06, 0x06, 0xC6, 0x7C, 0x00, 0x00, 0x00,
  /* 4 (52) */ 0x00, 0x00, 0x00, 0x0C, 0x1C, 0x3C, 0x6C, 0xCC, 0xFE, 0x0C, 0x0C, 0x0C, 0x1E, 0x00, 0x00, 0x00,
  /* 5 (53) */ 0x00, 0x00, 0x00, 0xFE, 0xC0, 0xC0, 0xC0, 0xFC, 0x06, 0x06, 0x06, 0xC6, 0x7C, 0x00, 0x00, 0x00,
  /* 6 (54) */ 0x00, 0x00, 0x00, 0x38, 0x60, 0xC0, 0xC0, 0xFC, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00,
  /* 7 (55) */ 0x00, 0x00, 0x00, 0xFE, 0xC6, 0x06, 0x06, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00,
  /* 8 (56) */ 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00,
  /* 9 (57) */ 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0x7E, 0x06, 0x06, 0x06, 0x0C, 0x78, 0x00, 0x00, 0x00,
  /* : (58) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
  /* ; (59) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00,
  /* < (60) */ 0x00, 0x00, 0x00, 0x00, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x00, 0x00, 0x00,
  /* = (61) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  /* > (62) */ 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x00, 0x00, 0x00,
  /* ? (63) */ 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0x0C, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,
  /* @ (64) */ 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xDE, 0xDE, 0xDE, 0xDC, 0xC0, 0x7C, 0x00, 0x00, 0x00,
  /* A (65) */ 0x00, 0x00, 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00,
  /* B (66) */ 0x00, 0x00, 0x00, 0xFC, 0x66, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x66, 0x66, 0xFC, 0x00, 0x00, 0x00,
  /* C (67) */ 0x00, 0x00, 0x00, 0x3C, 0x66, 0xC2, 0xC0, 0xC0, 0xC0, 0xC0, 0xC2, 0x66, 0x3C, 0x00, 0x00, 0x00,
  /* D (68) */ 0x00, 0x00, 0x00, 0xF8, 0x6C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x6C, 0xF8, 0x00, 0x00, 0x00,
  /* E (69) */ 0x00, 0x00, 0x00, 0xFE, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x62, 0x66, 0xFE, 0x00, 0x00, 0x00,
  /* F (70) */ 0x00, 0x00, 0x00, 0xFE, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00,
  /* G (71) */ 0x00, 0x00, 0x00, 0x3C, 0x66, 0xC2, 0xC0, 0xC0, 0xDE, 0xC6, 0xC6, 0x66, 0x3A, 0x00, 0x00, 0x00,
  /* H (72) */ 0x00, 0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00,
  /* I (73) */ 0x00, 0x00, 0x00, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00,
  /* J (74) */ 0x00, 0x00, 0x00, 0x1E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0xCC, 0xCC, 0xCC, 0x78, 0x00, 0x00, 0x00,
  /* K (75) */ 0x00, 0x00, 0x00, 0xE6, 0x66, 0x66, 0x6C, 0x78, 0x78, 0x6C, 0x66, 0x66, 0xE6, 0x00, 0x00, 0x00,
  /* L (76) */ 0x00, 0x00, 0x00, 0xF0, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x62, 0x66, 0xFE, 0x00, 0x00, 0x00,
  /* M (77) */ 0x00, 0x00, 0x00, 0xC3, 0xE7, 0xFF, 0xFF, 0xDB, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x00, 0x00, 0x00,
  /* N (78) */ 0x00, 0x00, 0x00, 0xC6, 0xE6, 0xF6, 0xFE, 0xDE, 0xCE, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00,
  /* O (79) */ 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00,
  /* P (80) */ 0x00, 0x00, 0x00, 0xFC, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00,
  /* Q (81) */ 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xD6, 0xDE, 0x7C, 0x0C, 0x0E, 0x00,
  /* R (82) */ 0x00, 0x00, 0x00, 0xFC, 0x66, 0x66, 0x66, 0x7C, 0x6C, 0x66, 0x66, 0x66, 0xE6, 0x00, 0x00, 0x00,
  /* S (83) */ 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0x60, 0x38, 0x0C, 0x06, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00,
  /* T (84) */ 0x00, 0x00, 0x00, 0xFF, 0xDB, 0x99, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00,
  /* U (85) */ 0x00, 0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00,
  /* V (86) */ 0x00, 0x00, 0x00, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x66, 0x3C, 0x18, 0x00, 0x00, 0x00,
  /* W (87) */ 0x00, 0x00, 0x00, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xDB, 0xDB, 0xFF, 0x66, 0x66, 0x00, 0x00, 0x00,
  /* X (88) */ 0x00, 0x00, 0x00, 0xC3, 0xC3, 0x66, 0x3C, 0x18, 0x18, 0x3C, 0x66, 0xC3, 0xC3, 0x00, 0x00, 0x00,
  /* Y (89) */ 0x00, 0x00, 0x00, 0xC3, 0xC3, 0xC3, 0x66, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00,
  /* Z (90) */ 0x00, 0x00, 0x00, 0xFF, 0xC3, 0x86, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0xC3, 0xFF, 0x00, 0x00, 0x00,
  /* [ (91) */ 0x00, 0x00, 0x00, 0x3C, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3C, 0x00, 0x00, 0x00,
  /* \ (92) */ 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x06, 0x02, 0x00, 0x00, 0x00,
  /* ] (93) */ 0x00, 0x00, 0x00, 0x3C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x3C, 0x00, 0x00, 0x00,
  /* ^ (94) */ 0x00, 0x10, 0x38, 0x6C, 0xC6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  /* _ (95) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00,
  /* ` (96) */ 0x00, 0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  /* a (97) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00,
  /* b (98) */ 0x00, 0x00, 0x00, 0xE0, 0x60, 0x60, 0x78, 0x6C, 0x66, 0x66, 0x66, 0x66, 0x7C, 0x00, 0x00, 0x00,
  /* c (99) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC0, 0xC0, 0xC0, 0xC6, 0x7C, 0x00, 0x00, 0x00,
  /* d (100) */ 0x00, 0x00, 0x00, 0x1C, 0x0C, 0x0C, 0x3C, 0x6C, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00,
  /* e (101) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xFE, 0xC0, 0xC0, 0xC6, 0x7C, 0x00, 0x00, 0x00,
  /* f (102) */ 0x00, 0x00, 0x00, 0x38, 0x6C, 0x64, 0x60, 0xF0, 0x60, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00,
  /* g (103) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xCC, 0x78,
  /* h (104) */ 0x00, 0x00, 0x00, 0xE0, 0x60, 0x60, 0x6C, 0x76, 0x66, 0x66, 0x66, 0x66, 0xE6, 0x00, 0x00, 0x00,
  /* i (105) */ 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00,
  /* j (106) */ 0x00, 0x00, 0x00, 0x06, 0x06, 0x00, 0x0E, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x66, 0x66, 0x3C,
  /* k (107) */ 0x00, 0x00, 0x00, 0xE0, 0x60, 0x60, 0x66, 0x6C, 0x78, 0x78, 0x6C, 0x66, 0xE6, 0x00, 0x00, 0x00,
  /* l (108) */ 0x00, 0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00,
  /* m (109) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE6, 0xFF, 0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0x00, 0x00, 0x00,
  /* n (110) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xDC, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00,
  /* o (111) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00,
  /* p (112) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xDC, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60, 0xF0,
  /* q (113) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0x0C, 0x1E,
  /* r (114) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xDC, 0x76, 0x66, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00,
  /* s (115) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0x60, 0x38, 0x0C, 0xC6, 0x7C, 0x00, 0x00, 0x00,
  /* t (116) */ 0x00, 0x00, 0x00, 0x10, 0x30, 0x30, 0xFC, 0x30, 0x30, 0x30, 0x30, 0x36, 0x1C, 0x00, 0x00, 0x00,
  /* u (117) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00,
  /* v (118) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0xC3, 0xC3, 0xC3, 0x66, 0x3C, 0x18, 0x00, 0x00, 0x00,
  /* w (119) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0xC3, 0xC3, 0xDB, 0xDB, 0xFF, 0x66, 0x00, 0x00, 0x00,
  /* x (120) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0xC3, 0x00, 0x00, 0x00,
  /* y (121) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7E, 0x06, 0x0C, 0xF8,
  /* z (122) */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xCC, 0x18, 0x30, 0x60, 0xC6, 0xFE, 0x00, 0x00, 0x00,
  /* { (123) */ 0x00, 0x00, 0x00, 0x0E, 0x18, 0x18, 0x18, 0x70, 0x18, 0x18, 0x18, 0x18, 0x0E, 0x00, 0x00, 0x00,
  /* | (124) */ 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
  /* } (125) */ 0x00, 0x00, 0x00, 0x70, 0x18, 0x18, 0x18, 0x0E, 0x18, 0x18, 0x18, 0x18, 0x70, 0x00, 0x00, 0x00,
  /* ~ (126) */ 0x00, 0x00, 0x00, 0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  /* BLK(127)*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};

// Routine to print a single character in one of 8 columns
// Inputs:
// x is one of (0,16,24,32,40,48,56),
// y (0 to 16 or 24 depending upon font size),
// n is either (0 to 9) or an ascii value,
// font=0 for big font, 2 for small font,
// inverse is true for an inverted character
void drawChar(uint16_t x, uint16_t y, byte n, byte font, boolean inverse) {
  byte charbytes[16], fontrows, xover8 = x >> 3;
  int index;
  if (0 != (x % 8)) return;    // x not a multiple of 8
  if ((n > 9) && (n < 32)) return; // invalid character
  if (font == 0) fontrows = 16; else fontrows = 8;
  if ((n >= 1) && (n <= 9)) index = (n + 16) * fontrows; else index = (n - 32) * fontrows; // go to the right code for this character

  // addressing start at buffer and add y (rows) * (WIDTH is 64 so WIDTH/8) is 8 plus (x / 8) is 0 to 7
  byte *pDst = buffer + (y << 3) + xover8;
  for (byte i = 0; i < fontrows; i++) { // fill up the charbytes array with the right bits
    if (font == 0) charbytes[i] = pgm_read_byte(&(font8x16_basic[index + i]));
    // reverse bit order for fonts 0 and 1
    if (font != 0) {
      charbytes[i] = (charbytes[i] & 0xF0) >> 4 | (charbytes[i] & 0x0F) << 4;
      charbytes[i] = (charbytes[i] & 0xCC) >> 2 | (charbytes[i] & 0x33) << 2;
      charbytes[i] = (charbytes[i] & 0xAA) >> 1 | (charbytes[i] & 0x55) << 1;
    };
    if (inverse) charbytes[i] = ~charbytes[i]; //~
  };
  const byte *pSrc = charbytes; // point at the first set of 8 pixels
  for (byte i = 0; i < fontrows; i++) {
    *pDst = *pSrc;     // populate the destination byte
    pDst += 8;         // go to next row on buffer
    pSrc++;            // go to next set of 8 pixels in character
  }
};

void moveLeft(byte pixels, byte rowstart, byte rowstop) { // routine to move certain rows on the screen "pixels" pixels to the left
  byte row, column;
  short unsigned int address;
  for (column = 0; column < 8; column++) {
    for (row = rowstart; row < rowstop; row++) {
      address = (row << 3) + column; /// right here!
      if (false) {
      //if (column == 7) {
        buffer[address] = buffer[address] << pixels; // shuffle pixels left on last column and fill with a blank
      }
      else {                // shuffle pixels left and add leftmost pixels from next column
        byte incomingchar = buffer[address + 1];
        buffer[address] = buffer[address] << pixels;
        for (byte x = 0; x < pixels; x++) {
          buffer[address] += ((incomingchar & (128 >> x)) >> (7 - x)) << (pixels - x - 1);
        };
      }
    }
  }
};



void shiftOut(byte row) { // fast routine to shove out 8 columns into two rows via board's shift registers
  for (byte column = 0; column < 8; column++) {
    byte index = column + (row << 3);
    for (byte i = 0; i < 8; i++) {
      PORTB &= ~(3 << (data_R1 - 8));                            // data_R2 is LOW; data_R1 is LOW;
      PORTB &= ~(1 << (clockPin - 8));                           // digitalWrite(clockPin,LOW);
      PORTB |= !((buffer[index + 0] >> (7 - i)) & 0x01) << (data_R1 - 8); // top set of rows
      PORTB |= !((buffer[index + 128] >> (8 - i)) & 0x01) << (data_R2 - 8); // bottom set of rows
      PORTB |= 1 << (clockPin - 8);                              // digitalWrite(clockPin,HIGH);
    };
  };
};

ISR(TIMER2_COMPA_vect) {
  cli();
  digitalWrite(en_74138, HIGH);     // Turn off display
  shiftOut(ScanRow);                // Shift out 8 columns
  digitalWrite(latchPin, LOW);
  digitalWrite(latchPin, HIGH);
  PORTD = (ScanRow << 3) | (PORTD & 0X87); // Highlight row: pins 3 4 5 6 (la_74138 lb_74138 lc_74138 ld_74138)
  digitalWrite(en_74138, LOW);     // Turn on display
  ScanRow++;                       // Do the next pair of rows next time this routine is called
  if (ScanRow == 16) ScanRow = 0;  // if (ScanRow==16) ScanRow=0;
  sei();
};

void setup() {

  // Set up Timer2 as the scanning interrupt timer
  cli(); // clear interrupts
  TCCR2A = 0; TCCR2B = 0; TCNT2  = 0;
  TCCR2B |= (1 << CS12) |(1 << CS11) | (0 << CS10);     // Set 1024 prescaler
  // 160Hz scan rate = 10 frames/second (16 pairs of rows)
  OCR2A = 47;  // 97 = (16,000,000 / 1024) * 160) - 1
  TCCR2A |= (1 << WGM21); TIMSK2 |= (1 << OCIE2A);

  pinMode(latchPin, OUTPUT);  pinMode(clockPin, OUTPUT);
  pinMode(data_R1, OUTPUT);   pinMode(data_R2, OUTPUT);

  pinMode(en_74138, OUTPUT);
  pinMode(la_74138, OUTPUT);  pinMode(lb_74138, OUTPUT);
  pinMode(lc_74138, OUTPUT);  pinMode(ld_74138, OUTPUT);

  digitalWrite(en_74138, LOW);
  digitalWrite(data_R1, HIGH); //digitalWrite(data_R2, HIGH);
  counter = millis();
  sei(); //allow interrupts
};

void loop() {
  static int count = 0;
  int d=70;




  // display next character of message
  drawChar(56, 0, message[count % (sizeof(message) - 1)], 0, true); // true=almindelig false=inverted
  count = (count + 1);
  // move the text 7 pixels (not 8 because it looks better) to the left
  for (byte i = 0; i < 4; i++) {
    
    delay(d);
    
    moveLeft(2, 1, 24);
    
  };
  
};

RFiD Scanner

So i needed a RFiD scanner, well for about $5 you get RC522 breakoutboard.
The data i on the card/brick i needed was the SerialNumber.

The security system i need to use is kinda backwards so i needed to get key “0” from the card it returns 228 50 26 220 16 = E4 32 1A DC A1 in HEX
i only needed 4bit and in reverse DC 1A 32 E4 = 3692704484 in DEC
the first data can be used in the code to grant access if you mount a door magnet/servo.
The HEX just data
The 10DEC code you can use i pro systems.

as i said i needed a RFiD scanner just to get the 10DEC code.

RFiD-Scanner

In this build i use :

Arduino UNO, The finished build i used an Arduino Nano
RC522 (RFID scanner/writer)
Nokia 2110 LCD

Connections:
RC522 -> Arduino

MOSI : Pin 11 ICSP-4
MISO : Pin 12 ICSP-1
SCK : Pin 13 ISCP-3
SS : Pin 10
RST : Pin 9

Nokia LCD -> Arduino

Standard Im Using
SCLK : Pin 8 Pin 2
DN : Pin 9 Pin 3
DC : Pin 10 Pin 4
SCE : Pin 11 Pin 5
RST : Pin 12 Pin 7
BL : Pin 6 Pin 6

RFID Librairy

#include <SPI.h>
#include <RFID.h>
#include <LCD5110_Basic.h>

#define SS_PIN 10
#define RST_PIN 9

RFID rfid(SS_PIN,RST_PIN);
LCD5110 myGLCD(2,3,4,7,5);
extern uint8_t SmallFont[];

int startAlarm = false;
int serNum[5];
//char cAll2[10];
int cards[][11] = 
{
  {1234567890},
  {2345678901},
  {3456789012}
};

bool access = false;

void setup(){

    Serial.begin(9600);
    SPI.begin();
    rfid.init();
    myGLCD.InitLCD();
    myGLCD.setFont(SmallFont);
    myGLCD.setContrast(70);
    analogWrite(6, 1);
}

void loop(){
    myGLCD.print("Arduino", CENTER, 0);
    myGLCD.print("RFiD Scanner", CENTER, 15);
    myGLCD.print("ID:", LEFT, 25);
    myGLCD.print(" Ready To scan ", CENTER, 40);
    analogWrite(6, 180);
    
    if(rfid.isCard()){
        if(rfid.readCardSerial()){
            Serial.print("3 Door Code     : ");
             char cAll[8];
             char *cAllP = cAll;
                cAllP += sprintf(cAllP,"%X",rfid.serNum[3]);
                cAllP += sprintf(cAllP,"%X",rfid.serNum[2]);
                cAllP += sprintf(cAllP,"%X",rfid.serNum[1]);
                cAllP += sprintf(cAllP,"%X",rfid.serNum[0]);
             unsigned long cAll1 = strtoul(cAll, NULL, 16);
             Serial.println(cAll1);
             char cAll3[11];
             String str;
             str=String(cAll1);
             str.toCharArray(cAll3,11);
             myGLCD.print(cAll3, RIGHT, 25);
            
            for(int x = 0; x < sizeof(cards); x++){
              for(int i = 0; i < sizeof(cAll3); i++ ){
                  if(cAll3[i] != cards[x][i]) {
                      access = false;
                      break;
                  } else {
                      access = true;                 }
              }
              if(access) break;
            }
           
        }
        
       if(access){
          myGLCD.print("  Scanned ok  ", CENTER, 45);
          //digitalWrite(greenPin, HIGH);
          //digitalWrite(redPin, LOW);          
       } else {
          myGLCD.print("  Not in use  ", CENTER, 45);
          //digitalWrite(redPin, HIGH);
          //digitalWrite(greenPin, LOW);         
       }        
    }
    
    if(startAlarm) {
       //digitalWrite(alarm, HIGH); 
    } else {
      //digitalWrite(alarm, LOW); 
    }
    
    rfid.halt();

}

void reset_alarm(){
    //startAlarm = false;
}

Simpel MorseCode with a LED

Her is a simple code for making a LED send Morse code

What you need to make it:

Arduino UNO/NANO
LED
Morse.h

this code will morse : Hej spejdere velkommen til dysten mon

#include <Morse.h>

Morse morse(8);

void setup()
{
}

void loop()
{
morse.dot(); morse.dot(); morse.dot(); morse.dot(); // H
morse.dot(); // E
morse.dot(); morse.dash(); morse.dash(); morse.dash(); // J
delay(3000);

morse.dot(); morse.dot(); morse.dot(); // S
morse.dot(); morse.dash(); morse.dash(); morse.dot(); // P
morse.dot(); // E
morse.dot(); morse.dash(); morse.dash(); morse.dash(); // J
morse.dash(); morse.dot(); morse.dot(); // D
morse.dot(); // E
morse.dot(); morse.dash(); morse.dot(); // R
morse.dot(); // E
delay(3000);

morse.dot(); morse.dot(); morse.dot(); morse.dash(); // V
morse.dot(); // E
morse.dot(); morse.dash(); morse.dot(); morse.dot(); // L
morse.dash(); morse.dot(); morse.dash(); // K
morse.dash(); morse.dash(); morse.dash(); // O
morse.dash(); morse.dash(); // M
morse.dash(); morse.dash(); // M
morse.dot(); // E
morse.dash(); morse.dot(); // N
delay(3000);

morse.dash(); // T
morse.dot(); morse.dot(); // I
morse.dot(); morse.dash(); morse.dot(); morse.dot(); // L
delay(3000);

morse.dash(); morse.dot(); morse.dot(); // D
morse.dash(); morse.dot(); morse.dash(); morse.dash(); // Y
morse.dot(); morse.dot(); morse.dot(); // S
morse.dash(); // T
morse.dot(); // E
morse.dash(); morse.dot(); // N
delay(3000);

morse.dash(); morse.dash(); // M
morse.dash(); morse.dash(); morse.dash(); // O
morse.dash(); morse.dot(); // N
delay(3000);delay(7000);
}