BitWizard Wiki - User contributions [en]

Blog 26

2016-02-09T10:55:34Z

Cartridge1987:

Hardware used:
*[http://www.bitwizard.nl/shop/expansion-boards/relay SPI Relay] | [[SPI Relay]]
*[http://www.bitwizard.nl/shop/raspberry-pi-ui-20x4 User interface 20x4] | [[User Interface]]
*Two [http://bitwizard.nl/shop/cables-connectors/6-pin-idc-cable-30cm IDC Cables, 6 Pin (SPI)]

Hello,

In this project I worked on the arduino. I made an pulse controller. With that you can control the amount of pulses and the pulse time of the relay.
Link to the code: [http://bitwizard.nl/source/Pulsecontroller.ino click here]

I made this script building on the [http://www.bitwizard.nl/software/ardemo_lcd.pde arduino spi demo script]. The parts I am going to explain are only for my script part.

In the script itself I also added some explanation.

Setup part:

//int offms = 500;
int OnTime = 500;
unsigned int s = 0;
int pulses = 1;
int PulseTime = 500;

set_var (0x8e, 0x10, 0x00);
PulsPrint(pulses);
TimePrint(PulseTime);

char bufline2[32];
char bufline4[32];

sprintf(bufline2, "1=down |2=up |5=res", bufline2);
write_at_lcd (0, 1, bufline2);

delay(10);
sprintf(bufline4, "3=down |4=up |6=run", bufline4);
write_at_lcd (0, 3, bufline4);

Serial.write (bufline2);
Serial.write ("\r\n");
Serial.write (bufline4);
Serial.write ("\r\n");

loop part:
// read the buttons:
int Button = get_var (0x94, 0x31);
// print out the state of the buttons:
Serial.println(Button);

//Button 6
//runs the pulses with the given pulse time to the relay
if (Button == 1){
Pulsing(pulses);
get_var (0x94, 0x31);
}

// Button 5
// reset the pulses and time back to the start settings
if (Button == 2){
PulseTime = 500;
pulses = 1;
TimePrint(PulseTime);
PulsPrint(pulses);
delay(OnTime);
get_var (0x94, 0x31);
}

// button 4
// +0.1 second to the previous amount of time
// the maximum amount of seconds is 10
if (Button == 4){
PulseTime = PulseTime + 100;
if ( PulseTime > 10000) PulseTime = 10000;
TimePrint(PulseTime);
delay(OnTime);
get_var (0x94, 0x31);
}

// button 3
// -0.1second to the previous amount of time
// The minimum amount of seconds is 0.1.
if (Button == 8){
PulseTime = PulseTime - 100;
if ( PulseTime < 100) PulseTime = 100;
TimePrint(PulseTime);
delay(OnTime);
get_var (0x94, 0x31);
}

// button 2
// +1 to the previous value pulses
// the maximum amount of pulses is 99
if (Button == 16){
pulses = pulses +1;
if ( pulses > 99) pulses = 99;
PulsPrint(pulses);
delay(OnTime);
get_var (0x94, 0x31);
}

// button 1
// -1 to the previous value pulses
// the minimum value is 1
if (Button == 32){
pulses = pulses - 1;
if ( pulses < 1) pulses = 1;
PulsPrint(pulses);
delay(OnTime);
get_var (0x94, 0x31);
}

delay(20);
}

functions:

//function that shows the amount of pulses on the display
void PulsPrint(int Puls){
char buf[32];
sprintf (buf, "Pulses: %02d", Puls);
write_at_lcd (0, 0, buf);
Serial.write (buf);
Serial.write ("\r\n");
}
// function that shows the pulsetime on the display
void TimePrint(int Time){
float FloatTime = Time;
FloatTime = FloatTime/1000;

delay(10);
char TextBuf[32];
char buf[32];

sprintf(TextBuf, "Time: seconds", buf);
write_at_lcd (0, 2, TextBuf);

dtostrf (FloatTime,3, 1, buf);
write_at_lcd (7, 2, buf);

Serial.write (TextBuf);
Serial.write (buf);
Serial.write ("\r\n");
}

// function that will run the given pulses and pulsetime
void Pulsing(int Puls){
int PulsHalf = PulseTime / 2;
for (int count = 0; pulses > count; count++){
set_var (0x8e, 0x20, 0x01);
delay(PulsHalf);
set_var (0x8e, 0x20, 0x00);
delay(PulsHalf);
}
}

== Useful links ==

*[[DIO protocol]] - The SPI relay has the same protocol
*[[User Interface]]
*[http://www.bitwizard.nl/software/ardemo_lcd.pde arduino spi demo script] - My script uses the basics of that script.

Blog 26

2016-02-04T07:58:12Z

Cartridge1987: /* Useful links */

Blog 26

2016-02-04T07:57:52Z

Cartridge1987:

Blog 26

2016-01-22T17:24:41Z

Cartridge1987:

Blog 26

2016-01-22T16:51:07Z

Cartridge1987:

Blog 26

2016-01-22T15:13:55Z

Cartridge1987:

File:Arduinorelay.jpg

2016-01-22T09:33:01Z

Cartridge1987:

Blog 26

2016-01-21T14:24:21Z

Cartridge1987:

Blog 26

2016-01-21T14:23:31Z

Cartridge1987:

SPI Relay

2016-01-21T10:04:30Z

Cartridge1987: Redirected page to Relay

#REDIRECT[[Relay]]

Blog 26

2016-01-21T10:03:50Z

Cartridge1987:

Rpi ssr

2016-01-20T15:32:03Z

Cartridge1987: Redirected page to Raspberry Relay

#REDIRECT[[Raspberry Relay]]

USB-step

2016-01-18T15:57:50Z

Cartridge1987:

[[File:usbstep.jpg|thumb|300px|alt=The USB_stepper board|The USB_stepper board]]

= USB-step =

The USB stepper allows you to step a small stepper a certain number of steps at regular intervals.

The intended use is for example home-built clocks.

== Overview ==

The usb-step has basically two connectors. The USB connector (micro USB), and a 5-pin JST for the stepper motor.

The board has a few other connectors for debugging (for us), for power (GND/3V3/5V between the motor and USB connector), for SPI (in the future we might make it possible to add an SPI display for example), and for selecting the voltage of the powerpin of the SPI connector. These connectors are unpopulated.

The board is 50x25.

== pinout ==

The JST power connector is something like
1 - 5V
2 - A+
3 - B+
4 - A-
5 - B-

== default ==

By default the board will step every second, and make a full revolution in 15 minutes.

== programming/protocol ==

When you insert the board into your PC, you will get a virtual com port (VCP).
Under Windows you should get a device for which "no driver could be found". install [http://www.bitwizard.nl/software/cdc.zip this driver], and you will get a virtual com port.

Use your favorite serial-communciation program to connect to the VCP. (I suggest Minicom/Kermit for Linux users, putty for windows-users).

you'll be presented with a commandline interface. The "help" command lists the available commands.

'''clock''' lists or sets the "steps-per-second" setting.

'''cal''' lists or sets the crystal calbration.

'''write''' writes the current settings to flash.

'''pat''' allows setting the activation pattern. For forward use: 4 1 2 4 8, for reverse use "4 8 4 2 1" as the arguments.

'''step''' allows setting the time that the motor is activated/stepping speed. Times are in ms.

For adjusting the clock setting you must know that the board uses microsteps. It won't drive the motor with better than "full step" resolution, but it uses very small steps internally. The motor will make a full revolution every 34190060316 of these internal steps. The motor is actually stepped when the accumulated number of steps internally exceeds 2^24 = 16777216. So at the slowest setting, 1 internal microstep per second, the motor wil be issued a step every 2^24 seconds (about twice a year), resulting in a full revolution every milennium.

The time required for each step limits the fastest possible stepping rate. You can experiment with reducing the "step" times with the '''step''' command to see what is the fastest possible step rate with your load.

== current usage ==

the board uses about 120mA per motor-phase that is activated. Normally only one is activated at a time. The motor is powered off between the movements. We measured about 12mA "in rest", Add to that (by default) about 1% times 120mA, the total average power is around 13-14 mA.

== future ==

In the future the interval between each group-of-steps will be configurable, currently fixed at "1s".

USB-step

2016-01-18T15:16:06Z

Cartridge1987: /* programming/protocol */

[[File:usbstep.jpg|thumb|300px|alt=The USB_stepper board|The USB_stepper board]]

= USB-step =

The USB stepper allows you to step a small stepper a certain number of steps at regular intervals.

The intended use is for example home-built clocks.

== Overview ==

The usb-step has basically two connectors. The USB connector (micro USB), and a 5-pin JST for the stepper motor.

The board has a few other connectors for debugging (for us), for power (GND/3V3/5V between the motor and USB connector), for SPI (in the future we might make it possible to add an SPI display for example), and for selecting the voltage of the powerpin of the SPI connector. These connectors are unpopulated.

The board is 50x25.

== pinout ==

The JST power connector is something like
1 - 5V
2 - A+
3 - B+
4 - A-
5 - B-

== default ==

By default the board will step every second, and make a full revolution in 15 minutes.

== programming/protocol ==

When you insert the board into your PC, you will get a virtual com port (VCP).
Under Windows you should get a device for which "no driver could be found". install [http://forum.chibios.org/phpbb/download/file.php?id=968&sid=1ea558897dff1ee77df5aa87ad6a008a this driver], and you will get a virtual com port.

Use your favorite serial-communciation program to connect to the VCP. (I suggest Minicom/Kermit for Linux users, putty for windows-users).

you'll be presented with a commandline interface. The "help" command lists the available commands.

'''clock''' lists or sets the "steps-per-second" setting.

'''cal''' lists or sets the crystal calbration.

'''write''' writes the current settings to flash.

'''pat''' allows setting the activation pattern. For forward use: 4 1 2 4 8, for reverse use "4 8 4 2 1" as the arguments.

'''step''' allows setting the time that the motor is activated/stepping speed. Times are in ms.

For adjusting the clock setting you must know that the board uses microsteps. It won't drive the motor with better than "full step" resolution, but it uses very small steps internally. The motor will make a full revolution every 34190060316 of these internal steps. The motor is actually stepped when the accumulated number of steps internally exceeds 2^24 = 16777216. So at the slowest setting, 1 internal microstep per second, the motor wil be issued a step every 2^24 seconds (about twice a year), resulting in a full revolution every milennium.

The time required for each step limits the fastest possible stepping rate. You can experiment with reducing the "step" times with the '''step''' command to see what is the fastest possible step rate with your load.

== current usage ==

the board uses about 120mA per motor-phase that is activated. Normally only one is activated at a time. The motor is powered off between the movements. We measured about 12mA "in rest", Add to that (by default) about 1% times 120mA, the total average power is around 13-14 mA.

== future ==

In the future the interval between each group-of-steps will be configurable, currently fixed at "1s".

User Interface

2016-01-14T15:02:40Z

Cartridge1987: /* Read ports */

[[File:RPi-UI.jpg|thumb|300px|alt=The RPi_UI PCB|The RPi_UI PCB]]

This is the documentation page for the RPi_UI board. That can be found in the [http://www.bitwizard.nl/shop/index.php?route=product/search&search=user%20interface BitWizard shop].

== Installation ==
See [[bw_tool#Setting up I2C/SPI under Linux | Setting up I2C/SPI under Linux]]

== External resources ==

=== Datasheets ===

* [http://ww1.microchip.com/downloads/en/DeviceDoc/22266D.pdf MCP79412 (I2C RTC)]
* [http://ww1.microchip.com/downloads/en/DeviceDoc/22300A.pdf MCP79522 (SPI RTC)]
* [http://ww1.microchip.com/downloads/en/DeviceDoc/21942e.pdf MCP9700 thermistor]

== Additional software ==

The [[Bw_tool]] is meant to provide a basic commandline access to the bitwizard expansion boards

== Pinout ==

The 26 pin gpio connector is described at [http://elinux.org/RPi_Low-level_peripherals elinux] 
The SPI connector has the same pinout as the atmel 6-pin ICSP connector and is documented here: [[SPI_connector_pinout]]. 
The I2C connector is documented here: [[I2C_connector_pinout]]. 
The UART connector is documented here: [[uart connector pinout]]. 
The analog connector has the following pinout:
{| border=1
! pin !! function
|-
| 1 || 5V
|-
| 2 || Analog in
|-
| 3 || GND
|}

Some people report they find it difficult to read the names of the connectors on the PCB. We'll fix that in a future version. In the meanwhile:
[[File:Rpi_ui_docu.png|none|thumb|500px|alt=The RPi_UI PCB|The RPi_UI PCB]]

Note that for the 20x4 version of the board, the connectors are in the same order with the same pinout.

=== LEDs ===

The only LED is a power indicator.

== Jumper settings ==

There is one 2x2 pin jumper (JP1), which controls which SPI bus (actually which SPI chip-select line) is routed to the AVRs slave-select pin, and which is routed to the reset pin (to enable reprogramming of the AVR): 
Left pads/pins connected: SPI0 connected to Slave-Select
Right pads/pins connected: SPI1 connected to RESET
Bottom pads/pins connected: SPI0 connected to RESET
Top (near the LCD) pads/pins connected: SPI1 connected to Slave-Select

The recommended configuration is to have 1-3 connected. The pins 1 and 2 are marked on the PCB. So 1-3 means the jumper is closest to the board edge, running from the "1" to the "J" of "JP1".

People with the buttons/LCD on I2C can/should not install any jumpers here.

There is also one solder jumper, SJ1, which controls the supply voltage on the SPI, I2C, and UART connectors: 
1-2: 5V (left) 
2-3: 3V3 (right, near the PCB edge)

We deliver this jumper in the "5V" position with a small PCB trace. If you want to switch to 3.3V you'll have to cut the small trace with a knife.

== Protocol ==

To make the RPI_UI PCB do things, you need to send things over the SPI or I2C bus to the PCB. A comparison of the two protocols can be found [[SPI_versus_I2C_protocols|here]].

The general overview of the SPI protocol is [[General_SPI_protocol|here]].

the list of the default addresses is [[Default_addresses|here]].

== The software ==

Controlling the display works the same way as our SPI_LCD or I2C_LCD modules. Reading the pushbuttons is very much like the DIO module. The read and write ports are described below.

=== Write ports ===

Some ports just set a single value. So writing more than one byte to such a port is redundant. Other ports are logically a stream of bytes. So writing more than one byte is encouraged.

The rpi_ui board defines several ports.
{| border=1
! port !! function
|-
| 0x00 || display data.
|-
| 0x01 || write data as command to LCD.
|-
| 0x08 || Set startup message line 1. After setting the startup message please wait 100ms before sending the next line. works from version 1.6+
|-
| 0x09 || Set startup message line 2.
|-
| 0x0a || Set startup message line 3.
|-
| 0x0b || Set startup message line 4.
|-
| 0x10 || any data clears the screen.
|-
| 0x11 || move the cursor to line l, position p. l is the top 3 bits p is the bottom 5 bits of the data.
|-
| 0x12 || set contrast.
|-
| 0x13 || set backlight.
|-
| 0x14 || reinit LCD. The initialzation procedure of the LCD takes a long time. A timed delay of about 500ms is in order after issuing this command
|-
| 0x15 || send 0 to set overrun-status back to zero.
|-
| 0x17 || Set the boot-time backlight intensity. (0xff means: use programmed default (0xc0))
|-
| 0x20 || set display number-of-lines. These are passed on to the display software, but seem to have little effect.
|-
| 0x21 || set display number-of-characters.
|-

| 0x70 .. 0x71 || Select which i/o is coupled to which ADC channel
|-
| 0x80 || Set number of ADC channels to read
|-
| 0x81 || Set number of samples to add (we suggest using a power of 2) (two bytes) See: [[annoying bug]]
|-
| 0x82 || Set ammounts of bits to shift accumulated sample value
|-
| 0xf0 || change address. But need to unlock first. See below. Might require a reboot to take effect.
|-
| 0xf1 || change address: unlock phase 1: write 0x55 here to start unlocking.
|-
| 0xf2 || change address: unlock phase 2: write 0xaa here to allow changing of the address (after writing 0x55 to f1).
|}

=== Read ports ===
The rpi_ui board supports several read ports:

{| border=1
! port !! function
|-
| 0x01 || identification string. (terminated with 0).
|-
| 0x02 || read eeprom (serial number).
|-
| 0x12 || contrast
|-
| 0x13 || backlight intensity
|-
| 0x15 || read FIFO(first in, first out) overrun status. If different from previous value, you've had an overrun. Best to
clear the screen and resend any data you want displayed.
|-
| 0x16 || read FIFO bytes-in-buffer. The fifo is 32 bytes, So you can send 20 chars to display if the value is less than 12.
|-
| 0x17 || read stored backlight intensity.
|-
| 0x20 || read button 1 (1 means NOT pushed, 0 means pushed)
|-
| 0x21 || read button 2 (1 means NOT pushed, 0 means pushed)
|-
| 0x22 || read button 3 (1 means NOT pushed, 0 means pushed)
|-
| 0x23 || read button 4 (1 means NOT pushed, 0 means pushed)
|-
| 0x24 || read button 5 (1 means NOT pushed, 0 means pushed)
|-
| 0x25 || read button 6 (1 means NOT pushed, 0 means pushed)
|-
| 0x30 || reports which buttons have been pushed since last read of this register 
If you keep a button pushed, it will read out as 1 multiple times
|-
| 0x31 || reports which buttons have been pushed since last read of this register (V1.2 and up) 
If you keep a button pushed, it will read out as 1 only once
|-
| 0x40 || read button 1 (1 means pushed, 0 means NOT pushed) (V1.1 and up)
|-
| 0x41 || read button 2 (1 means pushed, 0 means NOT pushed) (V1.1 and up)
|-
| 0x42 || read button 3 (1 means pushed, 0 means NOT pushed) (V1.1 and up)
|-
| 0x43 || read button 4 (1 means pushed, 0 means NOT pushed) (V1.1 and up)
|-
| 0x44 || read button 5 (1 means pushed, 0 means NOT pushed) (V1.1 and up)
|-
| 0x45 || read button 6 (1 means pushed, 0 means NOT pushed) (V1.1 and up)
|-
| 0x60.. 0x61 || Return analog value (2 bytes)
|-
| 0x68 .. 0x69 || Return added and bitshifted analog value (2 bytes)
|-
| 0x70 .. 0x71 || Return which i/o is coupled to which ADC channel
|-
| 0x80 || Return number of ADC channels to read
|-
| 0x81 || Return number of samples to add (two bytes)
|-
| 0x82 || Return ammounts of bits to shift accumulated sample value
|}

== Using the analog inputs ==

Please see [[DIO_protocol#Using_the_analog_inputs|this]] chapter on the page explaining the DIO protocol. There are two major differences:
* The internal reference voltage needs to be configured in a different way
* The mapping of the analog inputs; please use the following table instead:

{| border=1
! IO pin !! value
|-
| temp || 0xC7 (Vref=1V1) OR 0x47 (Vref=Vcc=~5V)
|-
| ext || 0xC6 (Vref=1V1) OR 0x46 (Vref=Vcc=~5V)
|}

=== Example ===

Setup the ADC (only needed once after reboot):
bw_tool -a 94 -w 70:c7 //Set ADC channel 0 to temperature sensor, and internal 1V1 reference
bw_tool -a 94 -w 80:01 //Set number of channels to sample to 1

Read the value:
bw_tool -a 94 -R 60:s // Read the result, output in hex

== Using the temperature sensor ==

The temperature sensor is a MCP9700. It's output voltage depends on the temperature. For more information, please see the [http://ww1.microchip.com/downloads/en/DeviceDoc/21942e.pdf MCP9700 datasheet].

An initialization and readout script are available on the [[Temperature sensor example]] page.

== Using the RTC ==

We first designed the User Interface to be equipped with either an SPI RTC or an I2C RTC. In practice the driver for the i2c version was a lot easier, so we're not selling the ones with the SPI RTC unless you really, really want (and we haven't run out of boards by then).

=== I2C ===

The I2C RTC has a Linux driver, which is available in the standard kernels delivered with raspian. (and probably others too).

Just use:
modprobe i2c:mcp7941x
echo mcp7941x 0x6f > /sys/class/i2c-dev/i2c-1/device/new_device
and the module is loaded and detects the RTC.

You can then set the RTC with: "hwclock -w". This will write the unix clock to the RTC. Put a "hwclock -s" somewhere in your startup scripts to initialize the unix clock from the RTC.
The version 1 raspberry pi's had the i2c-0 bus on the gpio connector, you for the older raspberry pi you'll need to change i2c-1 into i2c-0..

=== SPI ===

We are not aware of a device driver for the SPI version of the RTC. We can read/write the RTC with bw_tool from the command line using the raw SPI bytes command line option "--hex". The CPU on the board has to enable the CS line for the SPI RTC. This limits the speed of the SPI transactions a bit (50 kHz has been verified working).

bw_tool -s 50000 --hex 96 12 20 1 2 34 5 6 7 89

will write (0x12) the test-bytes 1 2 34 5 6 7 89 to the RAM at location 0x20 in the RAM.

bw_tool -s 50000 --hex 96 13 20 0 0 0 0 0 0 0 0

will read them back.

Refer to the datasheet of the MCP79522 for information on the registers of the chip http://ww1.microchip.com/downloads/en/DeviceDoc/22300A.pdf

= Examples =

== Read identification ==

read the identification string of the board.
{| border=1
! data sent !! data recieved || explanation
|-
| 0x95 || xx || select destination with address 0x94 for READ.
|-
| 0x01 || xx || identify
|-
| xx || 0x73 || 's'
|-
| xx || 0x70 || 'p'
|-
| xx || 0x69 || 'i'
|-
| xx || ... || etc.
|}

== Send text to display ==
Display the string "Hello World!" (only the first 5 bytes of the string shown).
{| border=1
! data sent !! data recieved || explanation
|-
| 0x94 || xx || select destination with address 0x94 for WRITE
|-
| 0x00 || xx || datastream
|-
| 0x48 || xx || 'H'
|-
| 0x65 || xx || 'e'
|-
| 0x6c || xx || 'l'
|-
| 0x6c || xx || 'l'
|-
| 0x6f || xx || 'o'
|-
| xx || ... || etc.
|}

== Set cursor position ==
move to line 1, character 5:
{| border=1
! data sent !! data recieved || explanation
|-
| 0x94 || xx || select destination with address 0x94 for WRITE
|-
| 0x11 || xx || port 0x11 = set cursor position.
|-
| 0x25 || xx || 0x25 = 001 00101 = line 1 position 5.
|}

== Bash script to show system informations ==

This bash script shows the current time and load averages of the cpu. The refresh is set to 5 seconds.

#!/bin/bash

# What display to use:
DISPL="bw_tool -I -D /dev/i2c-1 -a 94"
# e.g. for SPI use:
#DISPL="bw_tool -D /dev/spidev1.0 -a 94"

#clean the display
$DISPL -W 10:0:b

while true; do
#get cpu loads
load=`cut -d' ' -f-3 /proc/loadavg`

#print the current time
$DISPL -W 11:00:b
$DISPL -t `date +%H:%M:%S`

#print the load averages
$DISPL -W 11:20:b
$DISPL -t $load

#idle for 5 seconds
sleep 5
done

== Changelog ==

=== 1.0 ===
* Initial public release

Blog 26

2016-01-13T17:28:26Z

Cartridge1987: Created page with " Hardware used: *[http://www.bitwizard.nl/shop/expansion-boards/relay SPI Relay] | spi relay *[http://www.bitwizard.nl/shop/raspberry-pi-ui-20x4 User interface 20x4] | [[..."

Hardware used:
*[http://www.bitwizard.nl/shop/expansion-boards/relay SPI Relay] | [[spi relay]]
*[http://www.bitwizard.nl/shop/raspberry-pi-ui-20x4 User interface 20x4] | [[User Interface]]

Default address

2016-01-13T11:31:11Z

Cartridge1987: Redirected page to Default addresses

#REDIRECT[[Default addresses]]

Blog 24

2016-01-11T16:41:02Z

Cartridge1987: /* The code */

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashes and has to be reseted. When the RGB leds are still attached they will give a rainbow effect. To reset the WS2812 you have to put a cable in pin 5 of the 6 pin connector with a ground. The ground of the ws2812 is every odd number on the 16 pin connector.
After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

This is the list of colors, with their given RGB values. This gets invoked later in the script to give the right color value.
#define WHITE 0x808080
#define YELLOW 0x808000
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x000080
#define BLACK 0x000000

( The first two numbers behind 0x are for Red. The second two numbers are for green and the last two are for blue. )

Here the amount of time in milliseconds and steps given for to make the fading go fluent. ( later used in the script )
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b ).
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color. The value would be send back which then could be printed out in the terminal in that display.

The bit shifting to the right is needed to

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the RGB led. So in this example it would be that red will change from 80 to 00.
The reason for making it 80, instead of FF is to makes the light not hurting your eyes.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values. It also print that information in the C-Kermit terminal.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

Here are the given amount of RGB leds is given. When you want to run the script you can give a value after it. ( ./randomname 20 ) When the script runs it will look if a value about one is given if it is true it will give nleds an new value.

After that the peak RGB led will become white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statement will count from zero till nine. Every time it counts one up it will get a random number and use a remainder that divides it to two. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that the for statement can count to the next number until it reached the end.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. It will then look if the chosen RGB led is red. If that is true it will say that the newcolor it has to become is green. Else the opposite will happen. ( The RGB led will become red. ) The given values will then be send to fadeto. ( Example: (5, RED, GREEN). After that it will replace the previous color with the newcolor. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B C Operator list]
*[http://www.cplusplus.com/ C programming site]

Blog 24

2016-01-11T15:51:18Z

Cartridge1987: /* Useful links */

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashes and has to be reseted. When the RGB leds are still attached they will give a rainbow effect. To reset the WS2812 you have to put a cable in pin 5 of the 6 pin connector with a ground. The ground of the ws2812 is every odd number on the 16 pin connector.
After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

This is the list of colors, with their given RGB values. This gets invoked later in the script to give the right color value.
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000

( The first two numbers behind 0x are for Red. The second two numbers are for green and the last two are for blue. )

Here the amount of time in milliseconds and steps given for to make the fading go fluent. ( later used in the script )
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b ).
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color. The value would be send back which then could be printed out in the terminal in that display.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the RGB led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

Here are the given amount of RGB leds is given. When you want to run the script you can give a value after it. ( ./randomname 20 ) When the script runs it will look if a value about one is given if it is true it will give nleds an new value.

After that the peak RGB led will become white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statement will count from zero till nine. Every time it counts one up it will get a random number and use a remainder that divides it to two. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that the for statement can count to the next number until it reached the end.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. It will then look if the chosen RGB led is red. If that is true it will say that the newcolor it has to become is green. Else the opposite will happen. ( The RGB led will become red. ) The given values will then be send to fadeto. ( Example: (5, RED, GREEN). After that it will replace the previous color with the newcolor. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B C Operator list]
*[http://www.cplusplus.com/ C programming site]

Blog 24

2016-01-08T15:46:40Z

Cartridge1987: /* The code */

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashes and has to be reseted. When the RGB leds are still attached they will give a rainbow effect. To reset the WS2812 you have to put a cable in pin 5 of the 6 pin connector with a ground. The ground of the ws2812 is every odd number on the 16 pin connector.
After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

This is the list of colors, with their given RGB values. This gets invoked later in the script to give the right color value.
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000

( The first two numbers behind 0x are for Red. The second two numbers are for green and the last two are for blue. )

Here the amount of time in milliseconds and steps given for to make the fading go fluent. ( later used in the script )
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b ).
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color. The value would be send back which then could be printed out in the terminal in that display.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the RGB led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

Here are the given amount of RGB leds is given. When you want to run the script you can give a value after it. ( ./randomname 20 ) When the script runs it will look if a value about one is given if it is true it will give nleds an new value.

After that the peak RGB led will become white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statement will count from zero till nine. Every time it counts one up it will get a random number and use a remainder that divides it to two. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that the for statement can count to the next number until it reached the end.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. It will then look if the chosen RGB led is red. If that is true it will say that the newcolor it has to become is green. Else the opposite will happen. ( The RGB led will become red. ) The given values will then be send to fadeto. ( Example: (5, RED, GREEN). After that it will replace the previous color with the newcolor. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]
*[http://www.cplusplus.com/ C programming site]

Blog 24

2016-01-08T15:11:02Z

Cartridge1987: /* The code */

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashes and has to be reseted. When the RGB leds are still attached they will give a rainbow effect. To reset the WS2812 you have to put a cable in pin 5 of the 6 pin connector with a ground. The ground of the ws2812 is every odd number on the 16 pin connector.
After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

This is the list of colors, with their given RGB values. This gets invoked later in the script to give the right color value.
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000

( The first two numbers behind 0x are for Red. The second two numbers are for green and the last two are for blue. )

Here the amount of time and steps in milliseconds is given for to make the fading go fluent. ( later used in the script )
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b )
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

Here are the given amount of RGB leds is given. When you want to run the script you can give a value after it. ( ./randomname 20 ) When the script runs it will look if a value about one is given if it is true it will give nleds an new value.

After that the peak RGB led will become white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statement will count from zero till nine. Every time it counts one up it will get a random number and use a remainder that divides it to two. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that the for statement can count to the next number until it reached the end.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. It will then look if the chosen RGB led is red. If that is true it will say that the newcolor it has to become is green. Else the opposite will happen. ( The RGB led will become red. ) The given values will then be send to fadeto. ( Example: (5, RED, GREEN). After that it will replace the previous color with the newcolor. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]
*[http://www.cplusplus.com/ C programming site]

Blog 24

2016-01-08T14:41:44Z

Cartridge1987: /* The code */

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashes and has to be reseted. When the RGB leds are still attached they will give a rainbow effect. To reset the WS2812 you have to put a cable in pin 5 of the 6 pin connector with a ground. The ground of the ws2812 is every odd number on the 16 pin connector.
After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

This is the list of colors, with their given RGB values. This can be invoked by typing the capital name.
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first two numbers after 0x can be used for changing the red color value. The middle two numbers are for the amount of green and the last two are for blue. With RGB you can mix the colors into different colors.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b )
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

Here are the given amount of RGB leds is given. When you want to run the script you can give a value after it. ( ./randomname 20 ) When the script runs it will look if a value about one is given if it is true it will give nleds an new value.

After that the peak RGB led will become white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statement will count from zero till nine. Every time it counts one up it will get a random number and use a remainder that divides it to two. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that the for statement can count to the next number until it reached the end.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. It will then look if the chosen RGB led is red. If that is true it will say that the newcolor it has to become is green. Else the opposite will happen. ( The RGB led will become red. ) The given values will then be send to fadeto. ( Example: (5, RED, GREEN). After that it will replace the previous color with the newcolor. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]
*[http://www.cplusplus.com/ C programming site]

Blog 25

2016-01-08T13:39:06Z

Cartridge1987: Created page with " == Working with the usb stepper =="

== Working with the usb stepper ==

USB-step

2016-01-08T12:46:12Z

Cartridge1987: /* programming/protocol */

[[File:usbstep.jpg|thumb|300px|alt=The USB_stepper board|The USB_stepper board]]

= USB-step =

The USB stepper allows you to step a small stepper a certain number of steps at regular intervals.

The intended use is for example home-built clocks.

== Overview ==

The usb-step has basically two connectors. The USB connector (micro USB), and a 5-pin JST for the stepper motor.

The board has a few other connectors for debugging (for us), for power (GND/3V3/5V between the motor and USB connector), for SPI (in the future we might make it possible to add an SPI display for example), and for selecting the voltage of the powerpin of the SPI connector. These connectors are unpopulated.

The board is 50x25.

== pinout ==

The JST power connector is something like
1 - 5V
2 - A+
3 - B+
4 - A-
5 - B-

== default ==

By default the board will step every second, and make a full revolution in 15 minutes.

== programming/protocol ==

When you insert the board into your PC, you will get a virtual com port (VCP).
Under Windows you should get a device for which "no driver could be found". install XXX this driver, and you will get a virtual com port.

Use your favorite serial-communciation program to connect to the VCP. (I suggest Minicom/Kermit for Linux users, putty for windows-users).

you'll be presented with a commandline interface. The "help" command lists the available commands.

'''clock''' lists or sets the "steps-per-second" setting.

'''cal''' lists or sets the crystal calbration.

'''write''' writes the current settings to flash.

'''pat''' allows setting the activation pattern. For forward use: 4 1 2 4 8, for reverse use "4 8 4 2 1" as the arguments.

'''step''' allows setting the time that the motor is activated/stepping speed. Times are in ms.

For adjusting the clock setting you must know that the board uses microsteps. It won't drive the motor with better than "full step" resolution, but it uses very small steps internally. The motor will make a full revolution every 34190060316 of these internal steps. The motor is actually stepped when the accumulated number of steps internally exceeds 2^24 = 16777216. So at the slowest setting, 1 internal microstep per second, the motor wil be issued a step every 2^24 seconds (about twice a year), resulting in a full revolution every milennium.

The time required for each step limits the fastest possible stepping rate. You can experiment with reducing the "step" times with the '''step''' command to see what is the fastest possible step rate with your load.

== current usage ==

the board uses about 120mA per motor-phase that is activated. Normally only one is activated at a time. The motor is powered off between the movements. We measured about 12mA "in rest", Add to that (by default) about 1% times 120mA, the total average power is around 13-14 mA.

== future ==

In the future the interval between each group-of-steps will be configurable, currently fixed at "1s".

Usb ws2812

2016-01-08T12:46:07Z

Cartridge1987: /* Protocol */

[[File:ws2812.jpg|thumb|300px|alt=The USB_WS2812 board|The USB_WS2812 board]]

This is the documentation page for the USB_WS2812 board. That you can buy in the [http://www.bitwizard.nl/shop/index.php?route=product/product&product_id=161&search=ws2812 BitWizard shop].

== Overview ==

This board enables you to drive up to 600 WS2812 fullcolor RGB leds. These leds are sometimes called "neopixels". The board can drive up to 75 leds in in 8 strings. Due to the way things are implemented it is not possible to drive a single string of say 600 leds. Furthermore you would not want that: for each led on a string there is a fixed amount of time necessary for sending its data. Too many leds and the refresh rate has to drop!

== Assembly instructions ==

None: the board comes fully assembled.

== External resources ==

=== Datasheets ===

[http://www.bitwizard.nl/pdf/WS2812B.pdf The datasheet of the WS2812B chip/led.]

== Additional software ==

=== Related projects ===

== Pinout ==

The USB connector is a standard micro USB connector.

Pinout of the 16-pin header:

{| border=1
! function !! pin !! pin !! function
|-
| GND || 1 || 2 || D7 || Data for led-chain 7.
|-
| GND || 3 || 4 || D6 || Data for led-chain 6.
|-
| GND || 5 || 6 || D5 || Data for led-chain 5.
|-
| GND || 7 || 8 || D4 || Data for led-chain 4.
|-
| GND || 9 || 10 || D3 || Data for led-chain 3.
|-
| GND || 11 || 12 || D2 || Data for led-chain 2.
|-
| GND || 13 || 14 || D1 || Data for led-chain 1.
|-
| GND || 15 || 16 || D0 || Data for led-chain 0.
|-
|}

Please ignore the other connectors on the board.

Each pin controls 75 leds:

{| border=1
! pin !! leds
|-
| D0 || 0-74
|-
| D1 || 75-149
|-
| D2 || 150-224
|-
| D3 || 225-299
|-
| D4 || 300-374
|-
| D5 || 375-449
|-
| D6 || 450-524
|-
| D7 || 525-599
|-
|}

=== LEDs ===

There are two leds. One is the power led. It should be lit whenever the USB is connected. The other should blink every two seconds (one second on, one second off).

== Jumper settings ==

This board has no jumpers.

== Protocol ==

When you connect the board to your PC or raspberry PI, you will get a virtual com port. You can use your favorite communications program to talk to the device. (I personally use "kermit" because I've been using that for 30 years. "Minicom" is also a good option)

The board supports the following commands:

=== help ===

Print a list of supported commands, and also the compilation time of the firmware.
You might see a few commands that are there for debugging purposes. Consider those not described here as "do not use".

=== pix ===

pix <num> <color>

Set pixel "num" to color "color". Color is specified in 6 hexadecimal digits specifying the color in RGB order. Specifying 102030 will set the red component to 0x10, or about 1/16th of full intensity, the green component to 0x20/0xff or aobut 1/8th of full intensity and blue to about 3/16th.

=== shift ===

Shift each chain one pixel towards the controller board.

=== rainbow ===

Create a rainbow color effect.

rainbow [start] [nleds]

will create a rainbow starting at the led "start" and extend over "nleds" leds. The rainbow starts with red, fades via yellow, green, cyan, blue, violet back to red, so it is cyclic.

=== white ===

will set all leds to white.

=== black ===

will set all leds off (black).

=== color ===

sets a fixed color.

color <color> [start] [nleds]

Sets "nleds" starting at "start" to the color specified by "color".

=== fade ===

creates a fade from one color to another color.

fade <start> <nleds> <color1> <color2>

=== uid ===

print the uuniq identifier for this board.

Some chips have an

== The software ==

== Default operation ==

== Future hardware enhancements ==

== Future software enhancements ==

== Changelog ==

=== 1.0 ===
* Initial public release

USB-step

2016-01-08T12:17:04Z

Cartridge1987: /* pinout */

[[File:usbstep.jpg|thumb|300px|alt=The USB_stepper board|The USB_stepper board]]

= USB-step =

The USB stepper allows you to step a small stepper a certain number of steps at regular intervals.

The intended use is for example home-built clocks.

== Overview ==

The usb-step has basically two connectors. The USB connector (micro USB), and a 5-pin JST for the stepper motor.

The board has a few other connectors for debugging (for us), for power (GND/3V3/5V between the motor and USB connector), for SPI (in the future we might make it possible to add an SPI display for example), and for selecting the voltage of the powerpin of the SPI connector. These connectors are unpopulated.

The board is 50x25.

== pinout ==

The JST power connector is something like
1 - 5V
2 - A+
3 - B+
4 - A-
5 - B-

== default ==

By default the board will step every second, and make a full revolution in 15 minutes.

== programming/protocol ==

When you insert the board into your PC, you will get a virtual com port (VCP).
Under Windows you should get a device for which "no driver could be found". install XXX this driver, and you will get a virtual com port.

Use your favorite serial-communciation program to connect to the VCP. (I suggest Minicom for Linux users, putty for windows-users).

you'll be presented with a commandline interface. The "help" command lists the available commands.

'''clock''' lists or sets the "steps-per-second" setting.

'''cal''' lists or sets the crystal calbration.

'''write''' writes the current settings to flash.

'''pat''' allows setting the activation pattern. For forward use: 4 1 2 4 8, for reverse use "4 8 4 2 1" as the arguments.

'''step''' allows setting the time that the motor is activated/stepping speed. Times are in ms.

For adjusting the clock setting you must know that the board uses microsteps. It won't drive the motor with better than "full step" resolution, but it uses very small steps internally. The motor will make a full revolution every 34190060316 of these internal steps. The motor is actually stepped when the accumulated number of steps internally exceeds 2^24 = 16777216. So at the slowest setting, 1 internal microstep per second, the motor wil be issued a step every 2^24 seconds (about twice a year), resulting in a full revolution every milennium.

The time required for each step limits the fastest possible stepping rate. You can experiment with reducing the "step" times with the '''step''' command to see what is the fastest possible step rate with your load.

== current usage ==

the board uses about 120mA per motor-phase that is activated. Normally only one is activated at a time. The motor is powered off between the movements. We measured about 12mA "in rest", Add to that (by default) about 1% times 120mA, the total average power is around 13-14 mA.

== future ==

In the future the interval between each group-of-steps will be configurable, currently fixed at "1s".

Usb ws 2812

2016-01-08T11:54:22Z

Cartridge1987: Redirected page to Usb ws2812

#REDIRECT[[Usb ws2812]]

Blog 24

2016-01-08T11:37:04Z

Cartridge1987: /* Resetting the WS2812 */

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashes and has to be reseted. When the RGB leds are still attached they will give a rainbow effect. To reset the WS2812 you have to put a cable in pin 5 of the 6 pin connector with a ground. The ground of the ws2812 is every odd number on the 16 pin connector.
After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first two numbers after 0x can be used for changing the red color value. The middle two numbers are for the amount of green and the last two are for blue. With RGB you can mix the colors into different colors.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b )
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

Here are the given amount of RGB leds is given. When you want to run the script you can give a value after it. ( ./randomname 20 ) When the script runs it will look if a value about one is given if it is true it will give nleds an new value.

After that the peak RGB led will become white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statement will count from zero till nine. Every time it counts one up it will get a random number and use a remainder that divides it to two. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that the for statement can count to the next number until it reached the end.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. It will then look if the chosen RGB led is red. If that is true it will say that the newcolor it has to become is green. Else the opposite will happen. ( The RGB led will become red. ) The given values will then be send to fadeto. ( Example: (5, RED, GREEN). After that it will replace the previous color with the newcolor. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]
*[http://www.cplusplus.com/ C programming site]

Blog 24

2016-01-08T11:32:47Z

Cartridge1987: /* Resetting the WS2812 */

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashes and has to be reseted. When the RGB leds are still attached they will give a rainbow effect. To reset the WS2812 you have put a male-female cable on pin 5 on the horizontal connector. The male part of the connector should then hit the ground once. The grounds on the ws2812 are the odd numbers for the 16 pins.
After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first two numbers after 0x can be used for changing the red color value. The middle two numbers are for the amount of green and the last two are for blue. With RGB you can mix the colors into different colors.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b )
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

Here are the given amount of RGB leds is given. When you want to run the script you can give a value after it. ( ./randomname 20 ) When the script runs it will look if a value about one is given if it is true it will give nleds an new value.

After that the peak RGB led will become white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statement will count from zero till nine. Every time it counts one up it will get a random number and use a remainder that divides it to two. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that the for statement can count to the next number until it reached the end.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. It will then look if the chosen RGB led is red. If that is true it will say that the newcolor it has to become is green. Else the opposite will happen. ( The RGB led will become red. ) The given values will then be send to fadeto. ( Example: (5, RED, GREEN). After that it will replace the previous color with the newcolor. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]
*[http://www.cplusplus.com/ C programming site]

Main Page

2016-01-08T11:27:45Z

Cartridge1987: /* Other boards */

<big>'''BitWizard documentation wiki.'''</big>

This WIKI is for documentation of the BitWizard SPI/I2C expansion system and other boards, available from the [http://www.bitwizard.nl/catalog/ BitWizard Shop]. If you are considering adding information that is not related to one of our products, please contact us beforehand. 
It is expressly forbidden to add information intended to promote other sites. It is expressly forbidden to have a program add accounts and add articles with links to other sites.

= How-to's =
* [[Beginners guide to SPI on Raspberry Pi]]
* [[Installing and booting FriendlyArm mini6410]]

= Kits =
* [[RGB clock]]
* [[Raspberry Pi camera extension kit]]

= Developement boards =
* [[Raspduino]]
* [[FTDI_ATmega]]
* [[USB-multio]]
* [[Usbbigmultio]]
* [[Cyclone dev board]]

= Expansion boards =

== General ==
* [[Default addresses]] (both SPI and I2C)
* [[SPI versus I2C protocols]]
* [[Daisy-chaining BitWizard I2C boards]]
* [[USB Relay]]
* [[Model B+ compatibility]]

== Board specific pages ==
These expansion boards come in I2C and SPI versions, and thus can be connected to a single bus. This allows you to easily expand your microcontroller system with new functions, without the cost of additional I/O pins.

* [[LCD|LCD]]
* [[DIO|DIO]]
* [[Servo|Servo]]
* [[7FETs|7FETs]]
* [[3FETs|3FETs]]
* [[temp|Temperature Interface]]
* [[relay|Relay/BigRelay]]
* [[motor|Motor]]

* [[Raspberry Juice]]
* [[Raspberry Relay]]
* [[User Interface|User Interface]]
* [[7_Segment]]

* [[Pushbutton]]
* [[Rtc]]
* [[Dimmer]]
* [[16 LEDs]]

== Other boards ==
* [[USB-SATA powerswitch]]
* [[USB-opto]]
* [[Servotester]]
* [[USB-step]]
* [[Usb ws2812]]


= Breakout boards =

* [[Raspberry Pi Serial]]
* [[Dio breakout]]

== FTDI chips ==

* [[FT201X]] USB I2C slave
* [[FT220X]] USB 4-bit SPI/FT1248
* [[FT221X]] USB 8-bit SPI/FT1248
* [[FT230X]] USB to basic UART
* [[FT231X]] USB to full handshake UART
* [[FT240X]] USB 8-bit FIFO
* [[FT245RL V1.5]] USB FIFO
* [[FT311D]] USB Android host, compatible with AOA (Android Open Accessory)
* [[FT312D]] USB Android host, compatible with AOA (Android Open Accessory)
* [[FT245RL breakout board]]
* [[FT2232H breakout board]]
* [[FTDI serial]]
* [[FTDI serial 2]]

== I2C chips ==
* [[I2C DAC|Dual MCP4726 DAC]]
* [[I2C ADC|MCP3424 ADC]]
* [[I2C splitter|PCA9548A I2C switch/mux]]
* [[IO Expander|MCP23008 IO Expander]]
* [[I2C accellerometer]]
* [[I2C magnetometer]]
* [[I2C pressure sensor]]

== SPI chips ==
* [[IO Expander|MCP23S08 IO Expander]]
* [[SPI DAC|MCP4822 DAC]]

= Sample programs =
* [[Usbio kitt]]
* [[Usbio ACM sample program]]
* [[Raspberry Pi LCD program]]

= Sample projects =
* [[Temperature control]] (ftdi_atmega, spi_temp, spi_relay).

= Raspberry Pi projects =
* [[Reducing power consumption of a raspberry Pi]]
* [[LCD + 3FETs demonstration|Connecting two 1602 LCDs and an RGB LED Strip to a Raspberry Pi]]
* [[Connecting a motor and 1602 LCD to a Raspberry Pi]]
* [[MPU-6050 sensor connected to Raspberry Pi]]
* [[Raspberry pi expansion system page]]
* [[GPS reciever connected to Raspberry Pi]]

= Help! =

If you have trouble finding things on this wiki you can:
* Use the search function on the left
* [http://www.bitwizard.nl/contact.php Contact us]
* Or use the [http://forum.bitwizard.nl/ forum]

= Miscellaneous =
* [[Solder jumpers]]
* [[SPI_connector_pinout]]
* [[Template]]
* [[Nikon D80 wired remote]]
* [[Iphone 3GS camera]]

Main Page

2016-01-08T11:24:30Z

Cartridge1987: /* Breakout boards */

<big>'''BitWizard documentation wiki.'''</big>

This WIKI is for documentation of the BitWizard SPI/I2C expansion system and other boards, available from the [http://www.bitwizard.nl/catalog/ BitWizard Shop]. If you are considering adding information that is not related to one of our products, please contact us beforehand. 
It is expressly forbidden to add information intended to promote other sites. It is expressly forbidden to have a program add accounts and add articles with links to other sites.

= How-to's =
* [[Beginners guide to SPI on Raspberry Pi]]
* [[Installing and booting FriendlyArm mini6410]]

= Kits =
* [[RGB clock]]
* [[Raspberry Pi camera extension kit]]

= Developement boards =
* [[Raspduino]]
* [[FTDI_ATmega]]
* [[USB-multio]]
* [[Usbbigmultio]]
* [[Cyclone dev board]]

= Expansion boards =

== General ==
* [[Default addresses]] (both SPI and I2C)
* [[SPI versus I2C protocols]]
* [[Daisy-chaining BitWizard I2C boards]]
* [[USB Relay]]
* [[Model B+ compatibility]]

== Board specific pages ==
These expansion boards come in I2C and SPI versions, and thus can be connected to a single bus. This allows you to easily expand your microcontroller system with new functions, without the cost of additional I/O pins.

* [[LCD|LCD]]
* [[DIO|DIO]]
* [[Servo|Servo]]
* [[7FETs|7FETs]]
* [[3FETs|3FETs]]
* [[temp|Temperature Interface]]
* [[relay|Relay/BigRelay]]
* [[motor|Motor]]

* [[Raspberry Juice]]
* [[Raspberry Relay]]
* [[User Interface|User Interface]]
* [[7_Segment]]

* [[Pushbutton]]
* [[Rtc]]
* [[Dimmer]]
* [[16 LEDs]]

== Other boards ==
* [[USB-SATA powerswitch]]
* [[USB-opto]]
* [[Servotester]]
* [[USB-step]]


= Breakout boards =

* [[Raspberry Pi Serial]]
* [[Dio breakout]]

== FTDI chips ==

* [[FT201X]] USB I2C slave
* [[FT220X]] USB 4-bit SPI/FT1248
* [[FT221X]] USB 8-bit SPI/FT1248
* [[FT230X]] USB to basic UART
* [[FT231X]] USB to full handshake UART
* [[FT240X]] USB 8-bit FIFO
* [[FT245RL V1.5]] USB FIFO
* [[FT311D]] USB Android host, compatible with AOA (Android Open Accessory)
* [[FT312D]] USB Android host, compatible with AOA (Android Open Accessory)
* [[FT245RL breakout board]]
* [[FT2232H breakout board]]
* [[FTDI serial]]
* [[FTDI serial 2]]

== I2C chips ==
* [[I2C DAC|Dual MCP4726 DAC]]
* [[I2C ADC|MCP3424 ADC]]
* [[I2C splitter|PCA9548A I2C switch/mux]]
* [[IO Expander|MCP23008 IO Expander]]
* [[I2C accellerometer]]
* [[I2C magnetometer]]
* [[I2C pressure sensor]]

== SPI chips ==
* [[IO Expander|MCP23S08 IO Expander]]
* [[SPI DAC|MCP4822 DAC]]

= Sample programs =
* [[Usbio kitt]]
* [[Usbio ACM sample program]]
* [[Raspberry Pi LCD program]]

= Sample projects =
* [[Temperature control]] (ftdi_atmega, spi_temp, spi_relay).

= Raspberry Pi projects =
* [[Reducing power consumption of a raspberry Pi]]
* [[LCD + 3FETs demonstration|Connecting two 1602 LCDs and an RGB LED Strip to a Raspberry Pi]]
* [[Connecting a motor and 1602 LCD to a Raspberry Pi]]
* [[MPU-6050 sensor connected to Raspberry Pi]]
* [[Raspberry pi expansion system page]]
* [[GPS reciever connected to Raspberry Pi]]

= Help! =

If you have trouble finding things on this wiki you can:
* Use the search function on the left
* [http://www.bitwizard.nl/contact.php Contact us]
* Or use the [http://forum.bitwizard.nl/ forum]

= Miscellaneous =
* [[Solder jumpers]]
* [[SPI_connector_pinout]]
* [[Template]]
* [[Nikon D80 wired remote]]
* [[Iphone 3GS camera]]

Blog 24

2016-01-08T10:35:14Z

Cartridge1987: /* Useful links */

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashed and has to be resetted. When the RGB leds are still attached they will get a rainbow effect. To reset the WS2812 you have put a male-female cable on pin 5 on the horizontal connector. The male part of the connector should then hit the ground once. After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first two numbers after 0x can be used for changing the red color value. The middle two numbers are for the amount of green and the last two are for blue. With RGB you can mix the colors into different colors.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b )
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

Here are the given amount of RGB leds is given. When you want to run the script you can give a value after it. ( ./randomname 20 ) When the script runs it will look if a value about one is given if it is true it will give nleds an new value.

After that the peak RGB led will become white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statement will count from zero till nine. Every time it counts one up it will get a random number and use a remainder that divides it to two. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that the for statement can count to the next number until it reached the end.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. It will then look if the chosen RGB led is red. If that is true it will say that the newcolor it has to become is green. Else the opposite will happen. ( The RGB led will become red. ) The given values will then be send to fadeto. ( Example: (5, RED, GREEN). After that it will replace the previous color with the newcolor. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]
*[http://www.cplusplus.com/ C programming site]

Blog 24

2016-01-08T10:33:44Z

Cartridge1987: /* The code */

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashed and has to be resetted. When the RGB leds are still attached they will get a rainbow effect. To reset the WS2812 you have put a male-female cable on pin 5 on the horizontal connector. The male part of the connector should then hit the ground once. After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first two numbers after 0x can be used for changing the red color value. The middle two numbers are for the amount of green and the last two are for blue. With RGB you can mix the colors into different colors.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b )
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

Here are the given amount of RGB leds is given. When you want to run the script you can give a value after it. ( ./randomname 20 ) When the script runs it will look if a value about one is given if it is true it will give nleds an new value.

After that the peak RGB led will become white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statement will count from zero till nine. Every time it counts one up it will get a random number and use a remainder that divides it to two. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that the for statement can count to the next number until it reached the end.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. It will then look if the chosen RGB led is red. If that is true it will say that the newcolor it has to become is green. Else the opposite will happen. ( The RGB led will become red. ) The given values will then be send to fadeto. ( Example: (5, RED, GREEN). After that it will replace the previous color with the newcolor. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]

Blog 24

2016-01-08T09:38:21Z

Cartridge1987: /* The code */

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashed and has to be resetted. When the RGB leds are still attached they will get a rainbow effect. To reset the WS2812 you have put a male-female cable on pin 5 on the horizontal connector. The male part of the connector should then hit the ground once. After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first two numbers after 0x can be used for changing the red color value. The middle two numbers are for the amount of green and the last two are for blue. With RGB you can mix the colors into different colors.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b )
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

After that the peak led will get white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statement will count from zero till nine. Every time it counts one up it will get a random number and use a remainder that divides it to two. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that the for statement can count to the next number until it reached the end.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. It will then look if the chosen RGB led is red. If that is true it will say that the newcolor it has to become is green. Else the opposite will happen. ( The RGB led will become red. ) The given values will then be send to fadeto. ( Example: (5, RED, GREEN). After that it will replace the previous color with the newcolor. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]

Blog 24

2016-01-08T08:48:27Z

Cartridge1987:

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashed and has to be resetted. When the RGB leds are still attached they will get a rainbow effect. To reset the WS2812 you have put a male-female cable on pin 5 on the horizontal connector. The male part of the connector should then hit the ground once. After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first two zeros can be used for changing the the amount of red color. The middle two zeros are for the amount of green and the last two are for blue. With this you can mix the colors and make different colors.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b )
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

After that the peak led will get white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statements is the first loop that is getting used. It will count from zero till nine. Every time it counts it will get a random number and use a remainder to divide it with. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that i can be changed to the next number.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. If it then has chosen the certain led it will look if the led is red. If that is true it will say that the newcolor has to become green. Else the opposite will happen, so that the led will become red. The given values will then be sended to fadeto. ( Example: (5, RED, GREEN). After that it will save the newcolour in the previous led color. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]

Blog 24

2016-01-08T08:47:56Z

Cartridge1987:

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashed and has to be resetted. When the RGB leds are still attached they will get a rainbow effect. To reset the WS2812 you have put a male-female cable on pin 5 on the horizontal connector. The male part of the connector should then hit the ground once. After that you can do the previous commands and everything should work fine again.

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first two zeros can be used for changing the the amount of red color. The middle two zeros are for the amount of green and the last two are for blue. With this you can mix the colors and make different colors.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b )
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

After that the peak led will get white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statements is the first loop that is getting used. It will count from zero till nine. Every time it counts it will get a random number and use a remainder to divide it with. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that i can be changed to the next number.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. If it then has chosen the certain led it will look if the led is red. If that is true it will say that the newcolor has to become green. Else the opposite will happen, so that the led will become red. The given values will then be sended to fadeto. ( Example: (5, RED, GREEN). After that it will save the newcolour in the previous led color. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]

Blog 24

2016-01-07T17:33:01Z

Cartridge1987:

== Connecting the WS2812 ==

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY:

For Linux/Raspberry:
apt-get install ckermit

If you use an other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

On a UNIX device, when you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up with c. You can make a new terminal and write:
nano .kermrc

That file(.kermrc) should only have the code:
SET CARRIER-WATCH OFF

When the carrier-watch is off you have to type c again.

Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
The image pretty much explains itself. What you have to do is connect RGB with the 3-pin header.( GND - pin 1 | DO - pin 2 | +5V - pin 3 )
The pointers of this example RGB strip should be pointing away from the WS2812 usb controller.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I drew a Christmas tree. At the points where every single RGB led were laying I put a dot by using a pencil.
After that I cut the tree out and made holes at the pencil dots. After that I used some scotch tape to bring the front and back paper together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the peak RGB led white. It will then read the for statement where it goes through all the RGB leds(Except the peak). Every RGB led will randomly get the color green or red. The script will then keep fading the colors of the RGB leds to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first two zeros can be used for changing the the amount of red color. The middle two zeros are for the amount of green and the last two are for blue. With this you can mix the colors and make different colors.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

In interpolate it will get the values from fadeto three times ( for every color r, g & b )
It will give new values to c1 and c2 it will bit shift it to the right, and give it the value together with 0xff.
After that it calculates difference between previous color.

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Void fadeto receives the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.
it will keep doing calculations of the steps until it reached 30(nfadesteps).
After that it prints out on the certain RGB led that given color values.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

After that the peak led will get white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statements is the first loop that is getting used. It will count from zero till nine. Every time it counts it will get a random number and use a remainder to divide it with. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that i can be changed to the next number.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. If it then has chosen the certain led it will look if the led is red. If that is true it will say that the newcolor has to become green. Else the opposite will happen, so that the led will become red. The given values will then be sended to fadeto. ( Example: (5, RED, GREEN). After that it will save the newcolour in the previous led color. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashed and has to be resetted. When the RGB leds are still attached they will get a rainbow effect. To reset the WS2812 you have put a male-female cable on pin 5 on the horizontal connector. The male part of the connector should then hit the ground once. After that you can do the previous commands and everything should work fine again.

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]

Blog 24

2016-01-07T14:28:23Z

Cartridge1987: /* The code */

== Working with RGB leds on the WS2812 ==

For Linux/Raspberry:
apt-get install ckermit

If you use and other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

=== Connecting with the WS2812 ===

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY or an other program, which could run the c-program.

On a UNIX device, whebn you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up c. You can make a new terminal and write:
nano .kermrc

That file should only have the code:
SET CARRIER-WATCH OFF

If the carrier-watch is off you have to type c again.

Now you can finally send form an other terminal the information to the ws2812.
Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

The random name should be the same.
After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
On ////J7 a connector is added, also an cable from the J1 was connected on pin 15 with the second pin from J7.
The image further on explains itself.
You still have to look out, that you let the pointers point away from the usb ws2812.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I draw a Christmas tree. At the point every single RGB led were laying I put a dot with a pencil.
After that I cut the tree and put holes only on paper with the pencil dots. After that I used some scotch tape to bring it all together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the top led (the peak) white. It will then read the for statement where it goes through all the leds under the peak. Every led will randomly get the color green or red. Then the script will keep fading the colors of the leds from to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first ff is making the red led go to it's maximum. The middle ff is for green and the last for blue. It works in hexadecimals so you can lower or make the density higher or lower. And mix them so that you can get different colors as for example yellow.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Here the colors are given. void fadeto recieves the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

After that the peak led will get white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statements is the first loop that is getting used. It will count from zero till nine. Every time it counts it will get a random number and use a remainder to divide it with. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that i can be changed to the next number.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. If it then has chosen the certain led it will look if the led is red. If that is true it will say that the newcolor has to become green. Else the opposite will happen, so that the led will become red. The given values will then be sended to fadeto. ( Example: (5, RED, GREEN). After that it will save the newcolour in the previous led color. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Resetting the WS2812 ==

Maybe you will get the experience that the ws2812 crashed and has to be resetted. When the RGB leds are still attached they will get a rainbow effect. To reset the WS2812 you have put a male-female cable on pin 5 on the horizontal connector. The male part of the connector should then hit the ground once. After that you can do the previous commands and everything should work fine again.

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]

Blog 24

2016-01-07T14:10:04Z

Cartridge1987: /* Useful links */

== Working with RGB leds on the WS2812 ==

For Linux/Raspberry:
apt-get install ckermit

If you use and other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

=== Connecting with the WS2812 ===

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY or an other program, which could run the c-program.

On a UNIX device, whebn you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up c. You can make a new terminal and write:
nano .kermrc

That file should only have the code:
SET CARRIER-WATCH OFF

If the carrier-watch is off you have to type c again.

Now you can finally send form an other terminal the information to the ws2812.
Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

The random name should be the same.
After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
On ////J7 a connector is added, also an cable from the J1 was connected on pin 15 with the second pin from J7.
The image further on explains itself.
You still have to look out, that you let the pointers point away from the usb ws2812.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I draw a Christmas tree. At the point every single RGB led were laying I put a dot with a pencil.
After that I cut the tree and put holes only on paper with the pencil dots. After that I used some scotch tape to bring it all together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the top led (the peak) white. It will then read the for statement where it goes through all the leds under the peak. Every led will randomly get the color green or red. Then the script will keep fading the colors of the leds from to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first ff is making the red led go to it's maximum. The middle ff is for green and the last for blue. It works in hexadecimals so you can lower or make the density higher or lower. And mix them so that you can get different colors as for example yellow.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Here the colors are given. void fadeto recieves the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

After that the peak led will get white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statements is the first loop that is getting used. It will count from zero till nine. Every time it counts it will get a random number and use a remainder to divide it with. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that i can be changed to the next number.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. If it then has chosen the certain led it will look if the led is red. If that is true it will say that the newcolor has to become green. Else the opposite will happen, so that the led will become red. The given values will then be sended to fadeto. ( Example: (5, RED, GREEN). After that it will save the newcolour in the previous led color. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]
*[https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B Operator list of C]

Blog 24

2016-01-07T12:41:06Z

Cartridge1987: /* Working with RGB leds on the WS2812 */

== Working with RGB leds on the WS2812 ==

For Linux/Raspberry:
apt-get install ckermit

If you use and other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

=== Connecting with the WS2812 ===

First you just have to connect the WS2812 with a micro-USB cable to your device.

You have to use C-kermit or PuTTY or an other program, which could run the c-program.

On a UNIX device, whebn you want to run the code from the device to the WS2812. You have to type in the terminal:
/usr/bin/kermit -l /dev/ttyACM0
It could be that you have to send to/from an other destination.

It will then say C-kermit is opened. You then just have to type the letter:
c

It will tell you to turn off carrier watch with:
SET CARRIER-WATCH OFF

If you don't want to ask this every time you start up c. You can make a new terminal and write:
nano .kermrc

That file should only have the code:
SET CARRIER-WATCH OFF

If the carrier-watch is off you have to type c again.

Now you can finally send form an other terminal the information to the ws2812.
Before you send a code to the ws2812 check it with:
gcc -Wall -o randomname randomname.c

The random name should be the same.
After that you can send it to the ws2812 with:
./randomname > /dev/ttyACM1

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
On ////J7 a connector is added, also an cable from the J1 was connected on pin 15 with the second pin from J7.
The image further on explains itself.
You still have to look out, that you let the pointers point away from the usb ws2812.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I draw a Christmas tree. At the point every single RGB led were laying I put a dot with a pencil.
After that I cut the tree and put holes only on paper with the pencil dots. After that I used some scotch tape to bring it all together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the top led (the peak) white. It will then read the for statement where it goes through all the leds under the peak. Every led will randomly get the color green or red. Then the script will keep fading the colors of the leds from to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first ff is making the red led go to it's maximum. The middle ff is for green and the last for blue. It works in hexadecimals so you can lower or make the density higher or lower. And mix them so that you can get different colors as for example yellow.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Here the colors are given. void fadeto recieves the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

After that the peak led will get white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statements is the first loop that is getting used. It will count from zero till nine. Every time it counts it will get a random number and use a remainder to divide it with. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that i can be changed to the next number.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. If it then has chosen the certain led it will look if the led is red. If that is true it will say that the newcolor has to become green. Else the opposite will happen, so that the led will become red. The given values will then be sended to fadeto. ( Example: (5, RED, GREEN). After that it will save the newcolour in the previous led color. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]

Blog 24

2016-01-07T11:59:05Z

Cartridge1987: /* The code */

== Working with RGB leds on the WS2812 ==

For Linux/Raspberry:
apt-get install ckermit

If you use and other device, or want to know more:
[http://www.kermitproject.org/ck90.html C-Kermit]

For Windows users it's optional to use:
[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]

== RGB lighted paper Tree ==

Hardware used:
*WS2812 usb controller: [http://bitwizard.nl/shop/index.php?route=product/product&product_id=161 Shop link] | [[Usb ws2812|Wiki link]]
*RGB led strip
*Equipment wire

Software used on my linux pc:
*C-kermit

=== Making the construction ===

The RGB leds:
[[File:RGBTree1.jpg|none|400px]]
On ////J7 a connector is added, also an cable from the J1 was connected on pin 15 with the second pin from J7.
The image further on explains itself.
You still have to look out, that you let the pointers point away from the usb ws2812.

Paper tree:
The paper tree is made by folding a green paper. On the folded green paper I put my RGB led connection. Around the RGB led I draw a Christmas tree. At the point every single RGB led were laying I put a dot with a pencil.
After that I cut the tree and put holes only on paper with the pencil dots. After that I used some scotch tape to bring it all together. The final result:
[[File:RGBTree2.jpg|none|400px]]
You can of course go all crazy with the tree by adding glitters and stuff like that.

=== The code ===

The full c-program RGBTree.c can be downloaded: [http://bitwizard.nl/source/ here].

What the code does in short is this: When starting up it will make the the top led (the peak) white. It will then read the for statement where it goes through all the leds under the peak. Every led will randomly get the color green or red. Then the script will keep fading the colors of the leds from to the opposite color. ( red to green or green to red )

The parts of the script that I will give some explanation:

Here I made a list of colors(if you also want other colors search for: color table):
#define WHITE 0xffffff
#define YELLOW 0xffff00
#define RED 0x800000
#define GREEN 0x008000
#define BLUE 0x0000ff
#define BLACK 0x000000
Because it's RGB ( red green blue ) the first ff is making the red led go to it's maximum. The middle ff is for green and the last for blue. It works in hexadecimals so you can lower or make the density higher or lower. And mix them so that you can get different colors as for example yellow.

Here the amount of time and steps in milliseconds is given for to make the fading go fluent.
int nfadesteps = 30;
int delayms = 30;

int interpolate (int c1, int c2, int shift, int pos, int end)
{
c1 >>= shift;
c2 >>= shift;
c1 &= 0xff;
c2 &= 0xff;

return c1 * (end-pos) / end + c2 * pos / end;
}

Here the colors are given. void fadeto recieves the information from int main for example: (5, RED, GREEN).
It will give the information to every single part of the rgb led. So in this example it would be that red will change from 80 to 00.

void fadeto (int pixnum, int col1, int col2)
{
int i;
int r, g, b;

for (i=0;i <= nfadesteps;i++) {
r = interpolate (col1, col2, 16, i, nfadesteps);
g = interpolate (col1, col2, 8, i, nfadesteps);
b = interpolate (col1, col2, 0, i, nfadesteps);
printf ("pix %d %06x\n", pixnum,
(r << 16) | (g << 8) | (b << 0));

usleep (delayms*1000);
}
}

After that the peak led will get white.

int main (int argc, char **argv)
{
int nleds = 10;
int *pixels;
int pixnum, newcolor;
int i;

if (argc > 1)
nleds = atoi (argv[1]);

pixels = calloc (nleds, sizeof(int));

printf ("pix %d %06x\n", nleds, WHITE);

The for statements is the first loop that is getting used. It will count from zero till nine. Every time it counts it will get a random number and use a remainder to divide it with. The result could be a zero or an one. If it is zero the color red will be given else it would be green. After that it will directly be printed, so that i can be changed to the next number.

for (i=0;i < nleds;i++){
if (random () % 2 == 0)
pixels[i] = RED;
else
pixels[i] = GREEN;
printf ("pix %d %06x\n", i, pixels[i]);
}

In the while statement it has to choose a random led. It does this by giving a random number and remainder it with nleds. If it then has chosen the certain led it will look if the led is red. If that is true it will say that the newcolor has to become green. Else the opposite will happen, so that the led will become red. The given values will then be sended to fadeto. ( Example: (5, RED, GREEN). After that it will save the newcolour in the previous led color. so pixels[05] would become green.

while (1) {
pixnum = random () % nleds;
if (pixels[pixnum] == RED)
newcolor = GREEN;
else
newcolor = RED;
fadeto (pixnum, pixels[pixnum], newcolor);
pixels[pixnum] = newcolor;
}
exit (0);

}

[[File:RGBThree.jpg|none|400px]]

== Useful links ==

*[[usb ws2812|usb ws2812 wiki]]
*[http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY]
*[http://www.kermitproject.org/ck90.html C-Kermit]
*[http://www.columbia.edu/kermit/ckscripts.html#top C-Kermit tutorial]
*[http://www.columbia.edu/kermit/ckututor.html C-Kermit manual page and tutorial]

Blog 24

2016-01-07T10:34:47Z

Cartridge1987: /* The code */

Blog 24

2016-01-07T09:50:33Z

Cartridge1987: /* The code */

Blog 24

2016-01-07T09:44:57Z

Cartridge1987: /* RGB lighted paper Tree */

Blog 24

2016-01-07T09:21:27Z

Cartridge1987: /* Useful links */

Blog 24

2016-01-07T09:12:35Z

Cartridge1987: /* RGB lighted paper Tree */

Blog 24

2016-01-07T09:09:00Z

Cartridge1987: /* RGB lighted paper Tree */

Blog 24

2016-01-06T17:43:13Z

Cartridge1987:

Blog 24

2016-01-06T17:27:13Z

Cartridge1987: /* RGB lighted paper Tree */

Blog 24

2016-01-06T16:52:54Z

Cartridge1987: /* RGB lighted paper Tree */