How to use PICO V2 through i2c

Hello Ouman,

Welcome to the DLP & MEMS E2E forum.

I think that what you are requesting can be found in the "DLP Pico Chipset v2 Programmer's Guide" which can be downloaded from http://ti.com/mems, click on "0.17 HVGA Chipset" and then select the "DLPC100". Just under "Datasheet" there is a link "View all technical documents". This will lead you to a link to "Users Guide". Select DLP® Pico Chipset v2 Programmer’s Guide (Rev. A) (http://www.ti.com/litv/pdf/dlpu002a).

The commands for the DLPC100 are not given directly in the form "bus3-i2c 0x1b wb4 0x05 0x00000007", but you should be able to deduce the correct commands.

Best regards,

Pascal

hi ,

 I want to know how can I use any i2c-tools or code in linux on beagboard to set pico2,

I write 0x1b  0x08 0x00000001 to i2c-3, the pico2 is not controlled.

I write 0x36 0x08 0x00000001 to i2c-3, the i2c translate is refused.

Programmer's Guide is no use for me ,beacause I can not translate i2c hex data to pico.

ouman

Ouman,

The correct I2C address is 0x1b.

The format is:

bus3-i2c 0x1b wb4 0x04 0x00000001

where:

0x1b is the I2C address of the Pico Kit V2

wb4 mean write 4 bytes

0x04 is the register to write to

0x00000001 is the data (32 bits - 8 hex digits) written to the register

The command above should display a checkerboard pattern.

Now, if you are doing this, and you are not seeing any effect, please let me know. How are you supplying power to the BeagleBoard? USB? or 5V supply?

Best regards,

Pascal

hi,pascal

    thank you for your support.

 I can not find  commands  "bus3-i2c 0x1b wb4 0x05 0x00000007" in linux.

which linux release must I have? Where can I get this SD image?

ouman

Ouman,

Do a search for i2c-tools (package for Linux).

The bus3-i2c command is implemented by this package.

The package can be installed in Angstrom Distribution Linux (http://angstrom-distribution.com) for the BeagleBoard.

I recommend that you look at the forums for http://beagleboard.org.

Best regards,

Pascal

Pascal:

I set 0x1F 00 00 00 06 to get "1440 Hz, 1 bit green mode".

I made vedio used 60 frame/s ,these frame must not been compressed , if compressed

 1bit frames in 1byte will intrusions each other.

 then I wish to get images of 60*24 =1440 f/s .

But the vedio is slowly displayd, I thick that the SD card of beagleboard is slow.

How can I get 1440 Hz, 1 bit green images?

ouman

Ouman,

I think that you may misunderstand the 1440 fps mode. The BeagleBoard should be producing 60 fps 24-bit color - only. This is what is being sent across the HDMI cable to the Pico Kit. The data for each pixel in the frame is 24 bits wide - 8-bits each for R G B.

What the Pico Kit does in the 1440 fps monochrome mode is to create a separate frame for each of the 24 bits, and display them sequentially during a single 60 Hz frame (16.67 ms). As the controller steps through the 24 bits (per each pixel) the "picture" shown for each of the 24 "sub" frames will consist of a monochrome pattern based on the value of the corresponding bit ("1"=on or "0"=off) for each pixel.

To specify each pattern, the "picture" data for each 60 Hz frame must be loaded with bits in each pixel location corresponding to what you want displayed in that frame. This is illustrated in the Application Report "Using the DLP Pico 2.0 Kit for Structured Light Applications", section 3.3 (page 8).

I hope this makes it somewhat clearer.

Best regards,

Pascal

Hi Ouman,

Did you manage to get this working? I have the same requirement, and need to be able to project 1440 f/s monochrome.  How did you encode the 24 frames into a single one before sending it to the projector?  

many thanks

Gav

Pascal DLP said:

Ouman,

I think that you may misunderstand the 1440 fps mode. The BeagleBoard should be producing 60 fps 24-bit color - only. This is what is being sent across the HDMI cable to the Pico Kit. The data for each pixel in the frame is 24 bits wide - 8-bits each for R G B.

What the Pico Kit does in the 1440 fps monochrome mode is to create a separate frame for each of the 24 bits, and display them sequentially during a single 60 Hz frame (16.67 ms). As the controller steps through the 24 bits (per each pixel) the "picture" shown for each of the 24 "sub" frames will consist of a monochrome pattern based on the value of the corresponding bit ("1"=on or "0"=off) for each pixel.

To specify each pattern, the "picture" data for each 60 Hz frame must be loaded with bits in each pixel location corresponding to what you want displayed in that frame. This is illustrated in the Application Report "Using the DLP Pico 2.0 Kit for Structured Light Applications", section 3.3 (page 8).

I hope this makes it somewhat clearer.

Best regards,

Pascal

 

 

Hi Pascal,

Can you give me a sample code (e.g. a walking slit)  that I can try to achieve 1440 Hz with 1-bit?

Thanks,

Rong

Hi there , can you explain what a walking slit is ? I should e able to help . I am now very familiar with the  1440 mode .

I have a shell script which I'll post which will run  from the standard beagleboard angsrom image with no modifications . 

With regards to encoding the images , if you want more than 24 frames in your animation you will need to use a MOV animation using the Animation codec from apple as all others I tried lost the ColorSpace information due to image ccompression.

If you just need to loop through 24 frames at 1440 fps , you can create a tiff , or png image and  if the  frames do not overlap one another simply code each sub frame by drawing it using 24 colors from an BRG pallatte that each have a single bit set.

Eg

10000000 00000000 00000000

01000000 00000000 00000000

00100000 00000000 00000000

I can send you something more detailed on Monday when I'm back at work.

We will also be publishing a website in 2 weeks which will explain this in detail .

Gavin Smith said:

Hi there , can you explain what a walking slit is ? I should e able to help . I am now very familiar with the  1440 mode .

I have a shell script which I'll post which will run  from the standard beagleboard angsrom image with no modifications . 

With regards to encoding the images , if you want more than 24 frames in your animation you will need to use a MOV animation using the Animation codec from apple as all others I tried lost the ColorSpace information due to image ccompression.

If you just need to loop through 24 frames at 1440 fps , you can create a tiff , or png image and  if the  frames do not overlap one another simply code each sub frame by drawing it using 24 colors from an BRG pallatte that each have a single bit set.

Eg

10000000 00000000 00000000

01000000 00000000 00000000

00100000 00000000 00000000

I can send you something more detailed on Monday when I'm back at work.

We will also be publishing a website in 2 weeks which will explain this in detail .

Hi Gavin,

Thanks for your help! I am looking forward to your newcoming post and website!

A walking slit is like when you play piano just press one key at a time from left to right. The pressed key will be white, and the rest is black. So it is 1-bit. See below:

This is for structural light application.

Gavin,

Good to hear from you again. Many thanks for offering help with this.

Heres a quick example of what a single RGB frame looks like with 24 frames encoded in it.  If you display this on your pico in 1440 mode, you will get a line moving accross the screen through 24 positions , and it will cross the screen 60 times a second.  The rotating line on the right will rotate 60 times a second through 24 positons, it shows a good example oif what happens when the lines overlap, creating lovely rainbow colors!

Note, that some of the lines are hard to see, as each gets exponentially darker than the previous one. Use a color picker in a paint program to get an understanding of each color and a better feel for the process.  The PICO will seperate each bit patten in sequence playing dark blue through to light blue, followed by red, then green.

if you cut and paste the following code into a file and save it with a .sh extention, you can then run it as a shell scipt on the beagleboard, and it will set the Pico 2 to the correct mode.

To Create a walking line, you would just code an animation that moved a line accross the screen and cyce though the color palette as above.

  echo 'Selecting HDMI'
  bus3-i2c 0x1b wb4 0x04 0x00000000 # Select Pico Kit v2 HDMI input
  sleep 1
  echo 'Set VGA to landscape'
  bus3-i2c 0x1b wb4 0x05 0x00000007 # VGA landscape (640h*480v cropped to HVGA (not scaled)
  sleep 1
  echo 'set to externally generate vertical sync'
  bus3-i2c 0x1b wb4 0x24 0x00000001 # lock to externally generated vertical sync
  sleep 1
  echo 'Disabling Auto Gain control'
  bus3-i2c 0x1b wb4 0x82 0x00000006 # disable AGC (bit 0)
  sleep 1
  echo 'Disabling color co-ordinte adjustment'
  bus3-i2c 0x1b wb4 0x92 0x00000000 # disable CCA
  sleep 1
  echo 'disabling Termporal Enhance'
  bus3-i2c 0x1b wb4 0x26 0x00000000 # disable Temporal Enhance
  sleep 1
  echo 'Inhibiting non-linear processing blocks'
  bus3-i2c 0x1b wb4 0x62 0x00000000 # inhibit certain non-linear processing blocks to support linear input to output transfer function for structured light processing modes
  sleep 1
  echo 'Reducing Green LED power output'
  bus3-i2c 0x1b wb4 0x0f 0x00000287 # reduce current to avoid lamp degredation
  sleep 1
  echo 'Setting mode to 1440 frames per second monochrome'
  bus3-i2c 0x1b wb4 0x1f 0x00000006 # 1440 fps green

Gavin Smith said:

Heres a quick example of what a single RGB frame looks like with 24 frames encoded in it.  If you display this on your pico in 1440 mode, you will get a line moving accross the screen through 24 positions , and it will cross the screen 60 times a second.  The rotating line on the right will rotate 60 times a second through 24 positons, it shows a good example oif what happens when the lines overlap, creating lovely rainbow colors!

Note, that some of the lines are hard to see, as each gets exponentially darker than the previous one. Use a color picker in a paint program to get an understanding of each color and a better feel for the process.  The PICO will seperate each bit patten in sequence playing dark blue through to light blue, followed by red, then green.

if you cut and paste the following code into a file and save it with a .sh extention, you can then run it as a shell scipt on the beagleboard, and it will set the Pico 2 to the correct mode.

To Create a walking line, you would just code an animation that moved a line accross the screen and cyce though the color palette as above.

  echo 'Selecting HDMI'
  bus3-i2c 0x1b wb4 0x04 0x00000000 # Select Pico Kit v2 HDMI input
  sleep 1
  echo 'Set VGA to landscape'
  bus3-i2c 0x1b wb4 0x05 0x00000007 # VGA landscape (640h*480v cropped to HVGA (not scaled)
  sleep 1
  echo 'set to externally generate vertical sync'
  bus3-i2c 0x1b wb4 0x24 0x00000001 # lock to externally generated vertical sync
  sleep 1
  echo 'Disabling Auto Gain control'
  bus3-i2c 0x1b wb4 0x82 0x00000006 # disable AGC (bit 0)
  sleep 1
  echo 'Disabling color co-ordinte adjustment'
  bus3-i2c 0x1b wb4 0x92 0x00000000 # disable CCA
  sleep 1
  echo 'disabling Termporal Enhance'
  bus3-i2c 0x1b wb4 0x26 0x00000000 # disable Temporal Enhance
  sleep 1
  echo 'Inhibiting non-linear processing blocks'
  bus3-i2c 0x1b wb4 0x62 0x00000000 # inhibit certain non-linear processing blocks to support linear input to output transfer function for structured light processing modes
  sleep 1
  echo 'Reducing Green LED power output'
  bus3-i2c 0x1b wb4 0x0f 0x00000287 # reduce current to avoid lamp degredation
  sleep 1
  echo 'Setting mode to 1440 frames per second monochrome'
  bus3-i2c 0x1b wb4 0x1f 0x00000006 # 1440 fps green

Hi Gavin,

Thank you so much. Now I understand the concept much better. This is a great start to me. Thanks! Did you get the image done with processing 2.0?

Rong

Heres another image, which I made for our upcoming website. It shows the actual bit patterns for each slice of a 24 slice frame, and the order in which you need to code them.

I used processing 1.5.1, as I've had some issue running some of my old code in 2.5.   Both should work if you are writing from scratch though.  I can't share my exact code as part of another confidential project at the moment, but processing is very straighforwards, and I can tell you that for this image. I read in a 24 frame monochrome MOV file which had each frame to be encoded. Then looped through each pixel 24 times, and created a new output pixel by combining each bit value in turn using a look up table which looked like this.

numbers[24] = 32768 ;
numbers[23] = 16384 ;
numbers[22] = 8192 ;
numbers[21] = 4096 ; // green
numbers[20] = 2048 ;
numbers[19] = 1024 ;
numbers[18] = 512 ;
numbers[17] = 256 ;

numbers[16] = 8388608 ;
numbers[15] = 4194304 ;
numbers[14] = 2097152 ;
numbers[13] = 1048576 ; // red
numbers[12] = 524288 ;
numbers[11] = 262144 ;
numbers[10] = 131072 ;
numbers[9] = 65536 ;

numbers[8] = 128 ;
numbers[7] = 64 ;
numbers[6] = 32 ; // blue
numbers[5] = 16 ;
numbers[4] = 8 ;
numbers[3] = 4 ;
numbers[2] = 2 ;
numbers[1] = 1 ;

The bit where i write out the new pixel value looks somehing like this

output.pixels[i] = output.pixels[i] | (myMovie.pixels[i] & 0x00FFFFFF & numbers[framepos]);

Cheers

Gav

OK, its your lucky day. I'm feeling charitable, so I wrote you a program to generate lines in realtime.  Pascal, feel free to share it with the community.

Simply install processing, and cut and past the code in. Then you can run it, or compile it into an exe for PC or UNIX.  Should be easy to adapt generate any other structured light apps.

Have fun

// Color Space Multiplexer for Pico 2.0 Projector 1440 mode
//
// This program can be run from within the processing 2.0a6 environment
// downloadable from www.processing.org
//
// This basic program simply draws a 1 pixel wide line that
// moves accross the screen at 1440 frames per second.

// Written by Gavin Smith
// 12/9/2012
//
// If you need any bespoke software writting for the PICO then let me know
// (hourly rates apply ;-) )
//
// gavinfinlaysmith@gmail.com

int[] numbers = new int[25] ;
int x = 0;

void setup() {
size(640, 480,OPENGL);

//
numbers[24] = 0xFF008000;
numbers[23] = 0xFF004000;
numbers[22] = 0xFF002000;
numbers[21] = 0xFF001000;
numbers[20] = 0xFF000800;
numbers[19] = 0xFF000400;
numbers[18] = 0xFF000200;
numbers[17] = 0xFF000100;
numbers[16] = 0xFF800000;
numbers[15] = 0xFF400000;
numbers[14] = 0xFF200000;
numbers[13] = 0xFF100000;
numbers[12] = 0xFF080000;
numbers[11] = 0xFF040000;
numbers[10] = 0xFF020000;
numbers[9] = 0xFF010000;
numbers[8] = 0xFF000080;
numbers[7] = 0xFF000040;
numbers[6] = 0xFF000020;
numbers[5] = 0xFF000010;
numbers[4] = 0xFF000008;
numbers[3] = 0xFF000004;
numbers[2] = 0xFF000002;
numbers[1] = 0xFF000001;

;
} // end of setup

PImage output = createImage(640,480,RGB);

void draw()

{ // start of draw
background(0);


for (int f = 1;f < 24; f++)
{

stroke (numbers[f]);
strokeWeight(1);
line(x,0,x,240);
x++;
if (x > 479){x=0;}

println(frameRate);

}
// delay(100);
}

Yes indeed, Galvin, you made my day! Thank you very much for sharing. I appreciate it!!