Infrared head-tracker

#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>

#include <i2cmaster.h>

// i2c address
#define         I2C_ADR         0xB0            // ( 0x58 << 1 )

#define output(directions,pin) (directions |= pin) // set port direction for output
#define set(port,pin) (port |= pin) // set port pin
#define clear(port,pin) (port &= (~pin)) // clear port pin
#define pin_test(pins,pin) (pins & pin) // test for port pin
#define bit_test(byte,bit) (byte & (1 << bit)) // test for bit set
//#define bit_delay_time 8.5 // bit delay for 115200 with overhead
#define bit_delay_time 102 // 9600 baud

#define bit_delay() _delay_us(bit_delay_time) // RS232 bit delay
#define half_bit_delay() _delay_us(bit_delay_time/2) // RS232 half bit delay
#define char_delay() _delay_ms(10) // char delay


#define i2c_delay() _delay_ms(50)

#define serial_port PORTD
#define serial_direction DDRD
#define serial_pins PIND
// TX/RX from computer's perspective. in = computer sends TX. out = computer receives on RX.
#define serial_pin_in (1 << PD1)
#define serial_pin_out (1 << PD0)

#define max_buffer 25


#define led_port PORTC
#define led_direction DDRC
#define led_pin_1 (1 << PC1)
#define led_pin_2 (1 << PC0)
#define led_delay() _delay_ms(100) // LED delay


#define SCL_CLOCK  100000L // I2C clock in Hz
#define IR_CAMERA_ADDRESS 0xB0 // 8 bit address (0x58 << 1)



//
// SERIAL
//


void get_char(volatile unsigned char *pins, unsigned char pin, char *rxbyte) {
   //
   // read character into rxbyte on pins pin
   //    assumes line driver (inverts bits)
   //
   *rxbyte = 0;
   while (pin_test(*pins,pin))
      //
      // wait for start bit
      //
      ;
   //
   // delay to middle of first data bit
   //
   half_bit_delay();
   bit_delay();
   //
   // unrolled loop to read data bits
   //
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 0);
   else
      *rxbyte |= (0 << 0);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 1);
   else
      *rxbyte |= (0 << 1);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 2);
   else
      *rxbyte |= (0 << 2);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 3);
   else
      *rxbyte |= (0 << 3);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 4);
   else
      *rxbyte |= (0 << 4);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 5);
   else
      *rxbyte |= (0 << 5);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 6);
   else
      *rxbyte |= (0 << 6);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 7);
   else
      *rxbyte |= (0 << 7);
   //
   // wait for stop bit
   //
   bit_delay();
   half_bit_delay();
   }

void put_char(volatile unsigned char *port, unsigned char pin, char txchar) {
   //
   // send character in txchar on port pin
   //    assumes line driver (inverts bits)
   //
   // start bit
   //
   clear(*port,pin);
   bit_delay();
   //
   // unrolled loop to write data bits
   //
   if bit_test(txchar,0)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,1)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,2)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,3)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,4)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,5)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,6)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,7)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   //
   // stop bit
   //
   set(*port,pin);
   bit_delay();
   //
   // char delay
   //
   bit_delay();
   }

void put_string(volatile unsigned char *port, unsigned char pin, char *str) {
   //
   // print a null-terminated string
   //
   static int index;
   index = 0;
   do {
      put_char(port, pin, str[index]);
      ++index;
      } while (str[index] != 0);
   }






int main()
{
        int i;
        int r = 0;
        unsigned char data_buf[16];
        int p0,p1,p2,p3;
        int Ix1,Iy1,Ix2,Iy2;
        int Ix3,Iy3,Ix4,Iy4;
        int s;
        char buf[255];

        CLKPR = (1 << CLKPCE);
        CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);

        //
        // initialize output pins
        //
        set(serial_port, serial_pin_out);
        output(serial_direction, serial_pin_out);

        output(led_port, led_pin_1);
        output(led_port, led_pin_2);
        clear(led_port, led_pin_1);
        clear(led_port, led_pin_2);


        i2c_init(); // i2c_master_init();

        // IR sensor initialize

        //p0=0x72; p1=0x20; p2=0x1F; p3=0x03; // sensitivity
        //p0=0xC8; p1=0x36; p2=0x35; p3=0x03;
          p0=0xAA; p1=0x64; p2=0x63; p3=0x03;
        //p0=0x96; p1=0xB4; p2=0xB3; p3=0x04;
        //p0=0x96; p1=0xFE; p2=0xFE; p3=0x05;

        i2c_start_wait(I2C_ADR+I2C_WRITE);
        i2c_write( 0x30 ); i2c_write( 0x01 );
        i2c_stop();
        if (r!=0) { rs_puts("Error: no ACK\n"); }
        i2c_delay();

        i2c_start_wait(I2C_ADR+I2C_WRITE);
        i2c_write( 0x00 );
        i2c_write( 0x02 ); i2c_write( 0x00 ); i2c_write( 0x00 ); i2c_write( 0x71 );
        i2c_write( 0x01 ); i2c_write( 0x00 ); i2c_write( p0 );
        i2c_stop();
        if (r!=0) { rs_puts("Error: no ACK\n"); }
        i2c_delay();

        i2c_start_wait(I2C_ADR+I2C_WRITE);
        i2c_write( 0x07 ); i2c_write( 0x00 ); i2c_write( p1 );
        i2c_stop();
        if (r!=0) { rs_puts("Error: no ACK\n"); }
        i2c_delay();

        i2c_start_wait(I2C_ADR+I2C_WRITE);
        i2c_write( 0x1A ); i2c_write( p2 ); i2c_write( p3 );
        i2c_stop();
        if (r!=0) { rs_puts("Error: no ACK\n"); }
        i2c_delay();

        i2c_start_wait(I2C_ADR+I2C_WRITE);
        i2c_write( 0x33 ); i2c_write( 0x03 );
        i2c_stop();
        if (r!=0) { rs_puts("Error: no ACK\n"); }
        i2c_delay();

        i2c_start_wait(I2C_ADR+I2C_WRITE);
        i2c_write( 0x30 ); i2c_write( 0x08 );
        i2c_stop();
        if (r!=0) { rs_puts("Error: no ACK\n"); }
        i2c_delay();


        while (1) {

                i2c_start_wait(I2C_ADR+I2C_WRITE);
                i2c_write( 0x36 );
                i2c_stop();
                if (r!=0) { rs_puts("Error: no ACK\n"); }

                i2c_start_wait(I2C_ADR+I2C_READ);
                for (i=0;i<16;i++) { data_buf[i]=0; }
                for (i=0;i<16;i++) {
                        if (i!=15) {
                                data_buf[i] = i2c_readAck();
                        } else {
                                data_buf[i] = i2c_readNak();
                        }
                }
                i2c_stop();
                if (r!=0) { rs_puts("Error: no ACK (2)\n"); }


                Ix1 = data_buf[1]; Iy1 = data_buf[2]; s = data_buf[3];
                Ix1 += (s & 0x30) <<4; Iy1 += (s & 0xC0) <<2;
                Ix2 = data_buf[4]; Iy2 = data_buf[5]; s = data_buf[6];
                Ix2 += (s & 0x30) <<4; Iy2 += (s & 0xC0) <<2;
                Ix3 = data_buf[7]; Iy3 = data_buf[8]; s = data_buf[9];
                Ix3 += (s & 0x30) <<4; Iy3 += (s & 0xC0) <<2;
                Ix4 = data_buf[10]; Iy4 = data_buf[11]; s = data_buf[12];
                Ix4 += (s & 0x30) <<4; Iy4 += (s & 0xC0) <<2;


                /* put_char(&serial_port, serial_pin_out, 1); */
                /* put_char(&serial_port, serial_pin_out, 2); */
                /* put_char(&serial_port, serial_pin_out, 3); */
                /* put_char(&serial_port, serial_pin_out, 4); */


                put_char(&serial_port, serial_pin_out, data_buf[0]);
                put_char(&serial_port, serial_pin_out, data_buf[1]);
                put_char(&serial_port, serial_pin_out, data_buf[2]);
                put_char(&serial_port, serial_pin_out, data_buf[3]);
                put_char(&serial_port, serial_pin_out, data_buf[4]);
                put_char(&serial_port, serial_pin_out, data_buf[5]);
                put_char(&serial_port, serial_pin_out, data_buf[6]);
                put_char(&serial_port, serial_pin_out, data_buf[7]);
                put_char(&serial_port, serial_pin_out, data_buf[8]);
                put_char(&serial_port, serial_pin_out, data_buf[9]);
                put_char(&serial_port, serial_pin_out, data_buf[10]);
                put_char(&serial_port, serial_pin_out, data_buf[11]);
                put_char(&serial_port, serial_pin_out, data_buf[12]);
                put_char(&serial_port, serial_pin_out, data_buf[13]);
                put_char(&serial_port, serial_pin_out, data_buf[14]);
                put_char(&serial_port, serial_pin_out, data_buf[15]);


                /* put_char(&serial_port, serial_pin_out, 5); */
                /* put_char(&serial_port, serial_pin_out, 6); */
                /* put_char(&serial_port, serial_pin_out, 7); */
                /* put_char(&serial_port, serial_pin_out, 8); */

                /* sprintf(buf,"%d," ,Ix1); rs_puts(buf); */
                /* sprintf(buf,"%d," ,Iy1); rs_puts(buf); */
                /* sprintf(buf,"%d," ,Ix2); rs_puts(buf); */
                /* sprintf(buf,"%d\n",Iy2); rs_puts(buf); */

                i2c_delay();
                i2c_delay();

        }

        return 0;
}

<!DOCTYPE html>
<!-- This file is dxh.render.infrared.2.html by Dylan Holmes !-->
<!-- Modified from dxh.plot.infrared.html  !-->

<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Infrared render camera plotter</title>
  <script type="text/javascript" src="./js/jquery-3.3.1.slim.min.js"></script>
  <script src="./js/three.min.js"></script>
  <link rel="stylesheet" type="text/css" href="css/jquery.svg.css">

  <style type="text/css">
    svg {
        border:1px solid #555;
        position:relative; left:-5em;
        float:right;
    }
    #headsup {
        position:absolute;
        padding:0.5em;
        width:100%;
        background:rgba(255,255,255,0.5);
    }
  </style>
  <script type="text/javascript" src="js/jquery.svg.js"></script>

  <script type="text/javascript">
   // see: https://blog.teamtreehouse.com/an-introduction-to-websockets

    const twopi = 2 * Math.PI
    const camera_width_px = 1024
    const camera_height_px = 768
    const camera_width_radians = 33 * (twopi/360) 
    const camera_height_radians = 23 * (twopi/360)
    var viewer_attrs = {"X" : 0, "Y" : 0, "Z" : 0, "fov_degrees" : 40}

    // Focal length note: could have used vertical dimension as
    // well. this geometry comes from having a camera with an
    // aperture; focal length is distance from aperture to back of
    // camera. Field of view is angular extent of triangle with apex
    // at aperture, and height equal to focal length, and base along the
    // back of camera.
    const focal_length_px =
          (camera_width_px/2)/Math.tan(camera_width_radians/2)


    $("body").ready(function() {
        // $("#headsup").hide(1000)
        const dpi_screen =
              $("<div/>").css({"width":"1in","height":"1in"}).appendTo("body").width()
       const chart = function(width, height) {
           const scale = 0.1// 6
           const DETECT_NOTHING = 0

           var $svg = $("<div/>")

           $svg.inverted_x = false
           $svg.inverted_y = false

           var svg = $svg.svg().svg('get')
           svg.text(1,16,"NO CAMERA", {"fill" : "#c00", "font":"14px sans-serif"})

           $svg.find("svg").attr("width",scale*width).attr("height",scale*height)

           $svg.plot = function(x,y) {
               var px = x/width
               var py = y/height

               px = $svg.inverted_x ? 1-px : px
               py = $svg.inverted_y ? 1-py : py         
               svg.circle(px * width * scale,py * height * scale, 3,
                          {"fill" : "#c00", "class" : "dot"})
           }
           $svg.clear = function() {
               $svg.find(".dot").remove()
               $svg.find("text").remove()
           }



           return $svg;
       }

       //var $svg = chart(128, 96)
       var $svg = chart(camera_width_px, camera_height_px)
       $svg.prependTo("#headsup")


       // WEB SERVER STUFF
       const status = document.getElementById('status')
             //inputfield = document.getElementById('inputfield')


       // The port and address are defined in the nodejs server code.
       // Here, we're connected to :8081/ftdi
       const server_port = "8081"
       var socket = new WebSocket('ws://127.0.0.1:'+server_port+'/ftdi')

       socket.onopen = function(event) {
           status.innerHTML = "Connected to: " + event.currentTarget.url 
       }

       socket.onerror = function(error) {
           console.log("WebSockets error: "+error)
       }

       var parse_synthetic = function(event) {
           var message = event.data;
           var data = JSON.parse(event.data)
           console.log(data)
           $svg.clear()
           for(var i=0; i<data.length; i++) {
               $svg.plot(data[i][0], data[i][1])
           }

       }


       var xmax = 0, ymax = 0


       // lower dot: got a serial event
       // upper left: found framing


       var parse_real = function(event) {
           var message = event.data
           var data = JSON.parse(event.data)
           // console.log("A",data)

           if(!event.data) {
               return
           }
           data = data.data
           // console.log("B",data)

           var x,y,upper_bits
           if(data.length < 6) {
               return;
           }
           // search for framing
           var i = 0
           while(i < data.length && data[i] != 0) {i++;}
           if(i >= data.length) {return;}

           $svg.plot(10,10)

           // found framing
           //console.log(data)


           x = data[i+1]
           y = data[i+2]
           upper_bits = data[i+3]

           if (x == 0xff ||
               y == 0xff ||
               upper_bits == 0xff) {
               return;
           }


           x += (upper_bits & 0b00110000) << 4
           y += (upper_bits & 0b11000000) << 2

           if ( !Number.isInteger(x) || !Number.isInteger(y)) {
               return
           }

           xmax = Math.max(xmax, x)
           ymax = Math.max(ymax, y)


           //$svg.clear()

           //console.log(x,y, xmax, ymax,"q")
           $svg.clear()

           $svg.plot(x,y)




       }

       var buffer = []
       var parse_real_with_buffer = function(event) {
           var message = event.data
           var new_data = JSON.parse(event.data)
           var new_points = []

           //console.log(message)
           if(!event.data) {return}

           buffer = buffer.concat(new_data.data)


           var x,y,upper_bits

           // search for framing

           var i = 0

           while(i < buffer.length && buffer[i] != 0) {i++}
           if(i >= buffer.length) {return;}
           buffer.splice(0,i)
           // found framing
           if(buffer.length < 7) {return;}
           buffer.shift()

           var num_points = 0
           $svg.clear()

           while(buffer.length >= 3 && buffer[0] != 0xff && num_points < 2) {

               x = buffer.shift()
               y = buffer.shift()
               upper_bits = buffer.shift()

               if (x == 0xff ||
                   y == 0xff ||
                   upper_bits == 0xff) {
                   return;
               }

               x += (upper_bits & 0b00110000) << 4
               y += (upper_bits & 0b11000000) << 2

               if ( !Number.isInteger(x) || !Number.isInteger(y)) {
                   return
               }

               xmax = Math.max(xmax, x)
               ymax = Math.max(ymax, y)

               num_points += 1
               $svg.plot(x,y)
               new_points.push([x,y])

           }

           process_updated_points(new_points)

           //$svg.clear()

           //console.log(x,y, xmax, ymax,"q")
         }

       socket.onmessage = parse_real_with_buffer



        function process_updated_points(new_points) {
            process_without_interpolation(new_points);
        }

       function process_without_interpolation(new_points) {
           if (new_points.length < 2) {
               return
           }
           var left = new_points[0]
           var right = new_points[1]

           const true_length = 500 // arbitrary pixel width of true object

           var mid = [(left[0]+right[0])/2, (left[1]+right[1])/2]
           var scaled_length =
               Math.sqrt(
                   Math.pow(left[0]-right[0],2)
                       +Math.pow(left[1]-right[1],2))

           var dpi_camera = 5
           var Z_over_f = true_length/scaled_length

           //var Z = Z_over_f * (focal_length_px * dpi_camera) // in inches now
           var X = (mid[0] - camera_width_px/2) * Z_over_f
           var Y = (mid[1] - camera_height_px/2) * Z_over_f
           var Z = focal_length_px * Z_over_f

           X *= 0.5
           Y *= 0.5
           Z *= 0.1
           // var field_of_view = 2*Math.atan((mid[0] -
           //                               camera_width_px/2)/(2*focal_length_px))

           var field_of_view = 2 * Math.atan(camera_width_px/(2*Z))


           viewer_attrs["X"] = X / dpi_camera
           viewer_attrs["Y"] = Y / dpi_camera
           viewer_attrs["Z"] = Z / dpi_camera

           viewer_attrs["fov_degrees"] = field_of_view * (360/twopi)
           console.log("fov:", field_of_view * 360/twopi, "z:", Z, "z/f:", Z_over_f)

           $svg.plot(mid[0],mid[1])



           // X/Z = x/f
           // X = x * Z/f
           // Z/f = length/scaled_length
           // (length/Z = scaled_length/f)





       }

       // inputfield.onkeypress = function(event) {
       //          var message = inputfield.value
       //          socket.send(message)
       //          // textsent.innerHTML += '<li class="sent"><span>Sent:</span>' + message + '</li>';
       //          inputfield.value = ''

       //          return true
       // }
   });

  </script>
</head>
<body>
  <div id="headsup">
    <div id="status">Not connected to anything.</div>
    <!-- <input id="inputfield"/> -->
  </div>
  <!-- <div id="outputfield"><h2>Received:</h2></div> -->

  <script type="text/javascript">

   /*
      Camera initially points down the z axis toward the origin.

    */

   const inch = 1
   const foot = 12 * inch
   const viewer_height = 60 * inch
   var mouse_x, mouse_y

   var camera, scene, renderer, ambientLight
   var mesh
   var skybox
   init()
   // animate()
   animate_with_input()


   function createSkybox() {
       var skysize = 200 * foot 
       cube = new THREE.CubeGeometry(skysize, skysize, skysize);


       var cubeMaterials = [
           // +x
           new THREE.MeshBasicMaterial({
               map: new THREE.TextureLoader().load('img/meadow/posx.jpg'),
               side: THREE.DoubleSide
           }),
           // -x
           new THREE.MeshBasicMaterial({
               map: new THREE.TextureLoader().load('img/meadow/negx.jpg'),
               side: THREE.DoubleSide
           }), 
           // Top side
           new THREE.MeshBasicMaterial({
               map: new THREE.TextureLoader().load('img/meadow/posy.jpg'),
               side: THREE.DoubleSide
           }), 
           // Bottom side
           new THREE.MeshBasicMaterial({
               map: new THREE.TextureLoader().load('img/meadow/negy.jpg'),
               side: THREE.DoubleSide
           }), 
           // right side
           new THREE.MeshBasicMaterial({
               map: new THREE.TextureLoader().load('img/meadow/posz.jpg'),
               side: THREE.DoubleSide
           }), 
           // left side
           new THREE.MeshBasicMaterial({
               map: new THREE.TextureLoader().load('img/meadow/negz.jpg'),
               side: THREE.DoubleSide
           }) 
       ];

       //add cube & materials
       var cubeMaterial = new THREE.MultiMaterial(cubeMaterials);
       skybox = new THREE.Mesh(cube, cubeMaterial);
       skybox.position.y = 15
       skybox.position.y = 25
       skybox.position.y = -45

       scene.add(skybox);

       //   //add light
       //   var ambientLight = new THREE.AmbientLight(0xFFFFFF, 0.5);
       //   scene.add(ambientLight);
       //   scene.add(controls.getObject());

       // //add mesh
       //   mesh = new THREE.Mesh(geometry, material);
       //   scene.add(mesh);


       // var sides  = ['img/meadow/px.jpg', 'img/meadow/nx.jpg', 'img/meadow/py.jpg', 'img/meadow/ny.jpg', 'img/meadow/pz.jpg', 'img/meadow/nz.jpg'];
       // var scCube = THREE.ImageUtils.loadTexture(sides);
       // scCube.format = THREE.RGBFormat;

       // var skyShader = THREE.ShaderLib["cube"];
       // skyShader.uniforms["tCube"].value = scCube;
       // var skyMaterial = new THREE.ShaderMaterial( {
       //     fragmentShader: skyShader.fragmentShader, vertexShader: skyShader.vertexShader,
       //     uniforms: skyShader.uniforms, depthWrite: false, side: THREE.BackSide
       // });

       // var skyBox = new THREE.Mesh(new THREE.CubeGeometry(500, 500, 500), skyMaterial);
       // skyMaterial.needsUpdate = true;

       // mirrorSphereCamera = new THREE.CubeCamera( 0.1, 150000, 512 );
       // mirrorSphereCamera.renderTarget.texture.minFilter = THREE.LinearMipMapLinearFilter;
       // scene.add( mirrorSphereCamera );

       // scene.add(skyBox);



   }

   function populateLights(scene) {
       ambientLight = new THREE.AmbientLight(0xffffff, 0.4+0.2)
       scene.add(ambientLight)


       var spotLight    = new THREE.SpotLight( 0xfffff0, 0.9 )
       spotLight.target.position.set( 0 * foot, 2 * foot, 50 * foot)
       spotLight.position.y = 5 * foot
       spotLight.position.z = -20 * foot
       spotLight.position.x = -10 * foot


       var pointlight = new THREE.PointLight( 0xff8000, 0.2 )

       pointlight.position.y = 10 * foot
       pointlight.position.z = -30 * foot
       pointlight.position.x = 0 * foot
       //scene.add(pointlight)

       // SUNSET
       // spotLight.position.y = 10 * foot
       // spotLight.position.z = -1 * foot
       // spotLight.position.x = 20 * foot
       // spotLight.color.set(0xfff0b0)


       // spotLight.position.y = 60 * foot
       // spotLight.position.z = -1 * foot
       // spotLight.position.x = 20 * foot

       // NOON
       spotLight.position.y = 120 * foot
       spotLight.position.z = -1 * foot
       spotLight.position.x = 20 * foot



       spotLight.shadowCameraNear       = 0.01
       spotLight.castShadow             = true 
       spotLight.shadowDarkness = 0.5
       spotLight.shadowCameraVisible    = true
       // console.dir(spotLight)
       // spotLight.shadowMapWidth      = 1024
       // spotLight.shadowMapHeight     = 1024

       scene.add( spotLight )

       // hemiLight = new THREE.HemisphereLight( 0xcccccc, 0xc0ffb0, 0.3)
       // hemiLight.position.set( 0, 500, 0 );
       // hemiLight.castShadow = true
       // hemiLight.shadowDarkness = 0.5
       // scene.add(hemiLight)

   }
   function populateObjects(scene) {



       var texture_wood = new THREE.TextureLoader().load(
           "./img/WoodRough0072_1_download600.jpg")
       texture_wood.wrapS = THREE.RepeatWrapping
       texture_wood.wrapT = THREE.RepeatWrapping
       texture_wood.repeat.set(24,1)

       var texture_wood_roof = new THREE.TextureLoader().load(
           "./img/WoodRough0072_1_download600.jpg")
       texture_wood_roof.wrapS = THREE.RepeatWrapping
       texture_wood_roof.wrapT = THREE.RepeatWrapping
       texture_wood_roof.repeat.set(4,4)      

       var texture = new THREE.TextureLoader().load(
           'img/repeating-stone-wall-pattern.jpg' );
       texture.wrapS = THREE.RepeatWrapping
       texture.wrapT = THREE.RepeatWrapping
       texture.repeat.set(1,2)

       // concrete_clean_0015_02_tiled_s.jpg
       // img/concrete_clean_0037_01_s.jpg
       var texture_concrete = new THREE.TextureLoader().load('img/concrete_clean_0029_01_s.jpg')
       texture_concrete.wrapS = THREE.RepeatWrapping
       texture_concrete.wrapT = THREE.RepeatWrapping
       texture_concrete.repeat.set(1,3)


       texture_stone_dense = new THREE.TextureLoader().load('img/repeating-stone-wall-pattern.jpg' );
       texture_stone_dense.wrapS = THREE.RepeatWrapping
       texture_stone_dense.wrapT = THREE.RepeatWrapping
       texture_stone_dense.repeat.set(5,6)

       texture_stone_long = new THREE.TextureLoader().load('img/repeating-stone-wall-pattern.jpg' );
       texture_stone_long.wrapS = THREE.RepeatWrapping
       texture_stone_long.wrapT = THREE.RepeatWrapping
       texture_stone_long.repeat.set(15,1)





       var material = new THREE.MeshBasicMaterial( { map: texture } );


       var material = new THREE.MeshPhongMaterial({color:0x80a0c0,
                                                   shininess: 200})
       var material = new THREE.MeshPhongMaterial({map: texture})
       var stone_dense = new THREE.MeshPhongMaterial({map: texture_stone_dense})
       var stone_long = new THREE.MeshPhongMaterial({map: texture_stone_long})
       var concrete = new THREE.MeshPhongMaterial({map:
                                                  texture_concrete,
                                                   shininess: 40//30

       })

       var wood = new THREE.MeshPhongMaterial( { map: texture_wood } );
       var wood_roof = new THREE.MeshPhongMaterial( { map: texture_wood_roof } );


       var pergola_width = 24 * foot,//12 * foot,
           pergola_length = 30 * foot // 30 * foot,
           pergola_height = 1 * foot,
           ledge_width = 1.6 * foot,
           ledge_height = 2.5 * foot,


           column_height = 11 * foot,
           column_size = 2 * foot,

           num_columns = 4

       pergola_width = 24 * foot
       var pergola_length = 20 * foot// 84 * foot,
           num_columns = 5


       const include_cube = false

       if(include_cube) {
           var cube_geometry = new THREE.BoxBufferGeometry(3*foot, 3*foot, 3*foot)
           var cube_material = concrete
           var cube_mesh = new THREE.Mesh( cube_geometry, cube_material )
           cube_mesh.position.y = -pergola_height
           cube_mesh.position.z = -pergola_length/2
           cube_mesh.castShadow = false
           cube_mesh.receiveShadow = true
           scene.add( cube_mesh )

       }

       if(1) {
           var floor_geometry = new THREE.BoxBufferGeometry(pergola_width, pergola_height, pergola_length)
           var floor_material = concrete
           var floor_mesh = new THREE.Mesh( floor_geometry, floor_material )
           floor_mesh.position.y = -pergola_height
           floor_mesh.position.z = -pergola_length/2
           floor_mesh.castShadow = false
           floor_mesh.receiveShadow = true
           scene.add( floor_mesh )


           // var ledge_geometry = new THREE.BoxBufferGeometry(ledge_width, ledge_height, pergola_length)
           // var ledge_material = material
           // var ledge_mesh = new THREE.Mesh( ledge_geometry, ledge_material )
           // ledge_mesh.position.x = -pergola_width/2
           // ledge_mesh.position.y = 9
           // ledge_mesh.position.z = -pergola_length/2
           // scene.add( ledge_mesh )




           for(var sign=-1; sign<=1; sign += 2) {


               if (false) {
                   // ONE LEDGE

                   // ledge
                   var ledge_geometry = new THREE.BoxBufferGeometry(ledge_width, ledge_height, pergola_length)
                   var ledge_material = stone_long
                   var ledge_mesh = new THREE.Mesh( ledge_geometry, ledge_material )
                   ledge_mesh.position.x = sign*(pergola_width/2) 
                   ledge_mesh.position.y = 9
                   ledge_mesh.position.z = -pergola_length/2
                   ledge_mesh.castShadow = true
                   ledge_mesh.receiveShadow = true

                   scene.add( ledge_mesh )
               }
               else {
                   // TWO LEDGE
                   var ledge_geometry = new THREE.BoxBufferGeometry(ledge_width, ledge_height, pergola_length*(0.5-(1/(1+num_columns))))
                   var ledge_material = stone_long
                   var ledge_mesh = new THREE.Mesh( ledge_geometry, ledge_material )
                   ledge_mesh.position.x = sign*(pergola_width/2) 
                   ledge_mesh.position.y = 9
                   ledge_mesh.position.z = -pergola_length/(num_columns+1)*(num_columns/4)
                   ledge_mesh.castShadow = true
                   ledge_mesh.receiveShadow = true
                   scene.add( ledge_mesh )

                   var ledge_geometry = new THREE.BoxBufferGeometry(ledge_width, ledge_height, pergola_length*(0.5-(1/(1+num_columns))))
                   var ledge_material = stone_long
                   var ledge_mesh = new THREE.Mesh( ledge_geometry, ledge_material )
                   ledge_mesh.position.x = sign*(pergola_width/2) 
                   ledge_mesh.position.y = 9
                   ledge_mesh.position.z = -pergola_length/(num_columns+1)*(3.2*num_columns/4)
                   ledge_mesh.castShadow = true
                   ledge_mesh.receiveShadow = true
                   scene.add( ledge_mesh )

               }

               // upper ledge
               var ledge_geometry = new THREE.BoxBufferGeometry(ledge_width*0.4, column_size*0.4, pergola_length)
               var ledge_mesh = new THREE.Mesh( ledge_geometry, wood )

               ledge_mesh.position.x = sign*(pergola_width/2+ledge_width*0.3) 
               ledge_mesh.position.y = column_height
               ledge_mesh.position.z = -pergola_length/2
               ledge_mesh.castShadow = true
               ledge_mesh.receiveShadow = true

               scene.add( ledge_mesh )

               // roof
               var roof_geometry = new THREE.BoxBufferGeometry(pergola_width, pergola_height, pergola_length)
               var roof_material = wood_roof
               var roof_mesh = new THREE.Mesh( roof_geometry, roof_material )
               roof_mesh.position.y = column_height*1.6
               roof_mesh.position.z = -pergola_length/2
               roof_mesh.rotation.z = 0.6 * sign
               roof_mesh.position.x = -50 * sign

               roof_mesh.castShadow = true
               roof_mesh.receiveShadow = true
               scene.add( roof_mesh )


               // columns
               for(var col=0; col < num_columns; col +=1) {
                   var column_geometry = new
                   THREE.BoxBufferGeometry(column_size, column_height, column_size )
                   var column_material = material
                   var column_mesh = new THREE.Mesh( column_geometry, column_material )
                   column_mesh.position.x = sign * (pergola_width/2 )
                   column_mesh.position.y = column_height * 0.5 -pergola_height
                   column_mesh.position.z = pergola_length / (num_columns +
                                                              0) * -col - column_size
                   column_mesh.castShadow = true
                   column_mesh.receiveShadow = true

                   scene.add( column_mesh )
               }
           }
       }

   }

   function init() {
       camera = new THREE.PerspectiveCamera( 90,//100,
                                             window.innerWidth /
           window.innerHeight, 1, 10000 );
       camera.position.x = 0
       camera.position.y = 60 * inch
       camera.position.z = 24 * inch
       camera.position.z = 50 * inch

       camera.rotation.y = 0.0
       camera.fov = 40

       scene = new THREE.Scene()
       createSkybox()

       populateObjects(scene)
       populateLights(scene)


       renderer = new THREE.WebGLRenderer( { antialias: true } );
       renderer.setClearColor(new THREE.Color(0xf8ffff))
       renderer.setPixelRatio( window.devicePixelRatio );
       renderer.setSize( window.innerWidth, window.innerHeight );
       renderer.shadowMapEnabled        = true
       renderer.shadowMapType = THREE.PCFSoftShadowMap

       document.body.appendChild( renderer.domElement );
       //
       window.addEventListener( 'resize', onWindowResize, false );


       //      window.addEventListener("mousemove", onMouseMove)

   }
   function onMouseMove(e) {
       var vertical_axis_control = "z"

       mouse_x = (e.clientX / window.innerWidth) - 0.5
       mouse_y = (e.clientY / window.innerHeight) - 0.5

       camera.position.x = mouse_x * 10 * inch
       // camera.position.y = 60 * inch  - mouse_y * 8 * inch


       if (vertical_axis_control == "z") {
           camera.fov = 50 + 3*6*mouse_y
       }

       camera.lookAt(new THREE.Vector3(0*foot,
                                       (vertical_axis_control == "y") ?
                                       60 * inch - mouse_y * 8 * inch :
                                       60 * inch,0));

       //console.log(mouse_x, mouse_y)
   }

   function onWindowResize() {
       camera.aspect = window.innerWidth / window.innerHeight;
       camera.updateProjectionMatrix();
       renderer.setSize( window.innerWidth, window.innerHeight );
   }




   var t = 0;
   var u = 0;
   var v = 0;
   var ambientTarget = 0.1

   function animate_with_input() {
       // CONTROL NATURAL LIGHTING EFFECT
       requestAnimationFrame( animate_with_input );

       t += 0.025 * 0
       u += 0.005
       v += 0.01 + 0.05*(1-Math.random())

       camera.position.x =  -viewer_attrs.X //* 0.00002
       camera.position.y =  viewer_height+viewer_attrs.Y //* 0.00002 + 
       camera.position.z =  -12*foot + viewer_attrs.Z //* 0.002
       camera.lookAt(new THREE.Vector3(0, viewer_height, -80*foot));

       camera.fov = viewer_attrs.fov_degrees

       ambientLight.intensity = 0.4 + 0.2*(Math.cos(u)**5)+0.01*(2*Math.sin(v)+3*Math.cos(v))
       // ambientLight.intensity = 0.0



       //skybox.position.z = camera.fov * 1.8
       //skybox.position.y = -50-1*Math.sin(t)

       //camera.position.z = Math.sin(t) * 300
       camera.updateProjectionMatrix()

       renderer.render( scene, camera );
   }
   function animate() {
       requestAnimationFrame( animate );


       // CONTROL NATURAL LIGHTING EFFECT
       t += 0.025 * 0
       u += 0.005
       v += 0.01 + 0.05*(1-Math.random())


       //camera.fov = 50 + 4*Math.sin(t)
       //    camera.position.z = 4*Math.sin(t)
       //camera.position.z = -12 * foot

       //console.log(ambientTarget)
       // ambientTarget = 0.5 * (ambientTarget + (0.01 * Math.random()) ) 
       ambientLight.intensity = 0.4 + 0.2*(Math.cos(u)**5)+0.01*(2*Math.sin(v)+3*Math.cos(v))
       // ambientLight.intensity = 0.0



       //skybox.position.z = camera.fov * 1.8
       //skybox.position.y = -50-1*Math.sin(t)

       //camera.position.z = Math.sin(t) * 300
       camera.updateProjectionMatrix()
       // mesh.rotation.x += 0.005;
       // mesh.rotation.y += 0.01;
       renderer.render( scene, camera );
   }
  </script>  
</body>
</html>

//
// ir-serial.js
// by Dylan Holmes
//

// based on hello-serial.js
// requires nodejs, npm, serial, express@4.15.2, ws, express-ws

// BASIC PARAMETERS
const server_port = 8081
const client_address = '127.0.0.1'
const serial_port = "/dev/ttyUSB0"
var baud = 9600 // 19200 // 9600// 115200


example_terminal = function(as_text = true) {
    // Create a terminal for speaking with a pcb board over serial.
    // Performs the same function as term.py (from class) or picocom.


    // Set up serial connection
    const SerialPort = require('serialport')
    const Readline = require('@serialport/parser-readline')
    const port = new SerialPort(serial_port,
                                {baudRate: baud,
                                 databits:8,
                                 dtr: true,
                                })

    // Serial-opening errors will be emitted as an error event
    port.on('error', function(err) {
        console.log('Error: ', err.message)
    })


    // Whenever serial data is received, interpret the data as
    // keycodes and print as a string.
    // See: https://thisdavej.com/making-interactive-node-js-console-apps-that-listen-for-keypress-events/
    port.on('data', function(data) {
        console.log(as_text ? data.toString('utf8') : data)
    })

    // Listen to keyboard in nodejs terminal
    const readline = require('readline')
    readline.emitKeypressEvents(process.stdin)
    process.stdin.setRawMode(true)

    console.log("Ready for input: ")

    process.stdin.on('keypress', (str, key) => {
        // Ctrl-c exits the terminal
        if(key.ctrl && key.name === 'c') process.exit()

        var debug = false
        if(debug) console.log("You pressed the '",str,"' key.", key)
        port.write(key.sequence)

    })
}





infrared_camera_terminal = function() {
    // Speak with a PCB board that is speaking with an infrared
    // positioning camera.  (part id: 1738-1250-ND) 

    // Set up serial connection
    const SerialPort = require('serialport')
    const Readline = require('@serialport/parser-readline')
    const port = new SerialPort(serial_port,
                                {baudRate: baud,
                                 databits:8,
                                 dtr: true,
                                })
    var stream = []
    var pos_x = new Array(4)
    var pos_y = new Array(4)
    var upper_bits
    var index = null

    // Serial-opening errors will be emitted as an error event
    port.on('error', function(err) {
        console.log('Error: ', err.message)
    })


    // Whenever serial data is received, interpret the data as
    // the special format of the infrared positional camera.


    var process_ir_data = function() {

        while( stream.length >= 16 ) {
            stream.shift()
            // Look for framing data
            if( stream[0] == 1 &&
                stream[1] == 2 &&
                stream[2] == 3 &&
                stream[3] == 4 ) {


                pos_x[0] = stream[4]
                pos_y[0] = stream[5]
                upper_bits = stream[6]          
                pos_x[0] += (upper_bits & 0b00110000) << 4;
                pos_y[0] += (upper_bits & 0b11000000) << 2;

                pos_x[1] = stream[7]
                pos_y[1] = stream[8]
                upper_bits = stream[9]          
                pos_x[1] += (upper_bits & 0b00110000) << 4;
                pos_y[1] += (upper_bits & 0b11000000) << 2;

                pos_x[2] = stream[10]
                pos_y[2] = stream[11]
                upper_bits = stream[12]         
                pos_x[2] += (upper_bits & 0b00110000) << 4;
                pos_y[2] += (upper_bits & 0b11000000) << 2;

                pos_x[3] = stream[13]
                pos_y[3] = stream[14]
                upper_bits = stream[15]         
                pos_x[3] += (upper_bits & 0b00110000) << 4;
                pos_y[3] += (upper_bits & 0b11000000) << 2;

                console.log(stream[4], stream[5], stream[6])
                console.log("x: ",pos_x[0],",\ty: ",pos_y[0])
                // console.log("x: ",pos_x[1],",\ty: ",pos_y[1])

                stream = stream.slice(16)
                return;
            }


        }
    }

    port.on('data', function(data) {
        stream.push(...data) // apparently js has an ... operator.
        process_ir_data()
        console.log(data)
    })

    // Listen to keyboard in nodejs terminal
    const readline = require('readline')
    readline.emitKeypressEvents(process.stdin)
    process.stdin.setRawMode(true)

    console.log("Ready for input: ")

    process.stdin.on('keypress', (str, key) => {
        // Ctrl-c exits the terminal
        if(key.ctrl && key.name === 'c') process.exit()

        var debug = false
        if(debug) console.log("You pressed the '",str,"' key.", key)
        port.write(key.sequence)

    })
}


// example_terminal(false)
// // infrared_camera_terminal()


// cf example_serial_websocket_server from hello-serial.js

fake_websocket_server = function() {
    // Send synthetic (artifically-generated) serial data to the
    // websockets to confirm that it works.

    // Used in connection with dxh.plot.infrared.html.

// Set up the web socket server
    const express = require('express')
    const app = express()
    require('express-ws')(app);

    // Connections maintain a list of who has connected to the
    // websocket server, so we know who needs to hear serial messages.
    var connections = []

    app.get('/', (req, res) => res.send('(The infrared-sockets-serial server is running.)'))
    app.listen(server_port, () => console.log(`Infrared Sockets-serial. Listening on port :${server_port}`))

    var simulate_data
    app.ws('/ftdi', function(ws, req) {
        // sockets <-- serial

        simulate_data = function(data) {
            console.log("artificial data:", data)

            // translate into camera format
            data = data[0]
            var upper_bits = 0
            upper_bits |= (data[0] & 0b1100000000) >> 4
            upper_bits |= (data[1] & 0b1100000000) >> 2
            upper_bits |= 0b1111

            data[0] &= 0xff
            data[1] &= 0xff
            data.push(upper_bits)
            data.unshift(0)
            for(var i=0;i<6;i++) {
                data.push(0xff)
            }
            var message = {}
            message.data = data
            console.log(message)
            // end translate into camera format

            ws.send(JSON.stringify(data))
        }

        var t = 0
        setInterval(function(){
            t+=0.1;
            var pt = [400+100*Math.cos(t), 100+50*Math.sin(t)]

            pt[0] = Math.floor(pt[0])
            pt[1] = Math.floor(pt[1])

            simulate_data([pt])
        }, 40)


        // sockets --> serial
        ws.on('message', function(msg) {
            console.log("html page sent:", msg)
        });
    });




}

infrared_serial_websocket_server = function() {


    // Set up the web socket server
    const express = require('express')
    const app = express()
    require('express-ws')(app);

    // Connections maintain a list of who has connected to the
    // websocket server, so we know who needs to hear serial messages.
    var connections = []

    app.get('/', (req, res) => res.send('(The infrared-sockets-serial server is running.)'))
    app.listen(server_port, () => console.log(`Infrared Sockets-serial. Listening on port :${server_port}`))



    // Set up serial connection
    const SerialPort = require('serialport')
    const Readline = require('@serialport/parser-readline')
    const port = new SerialPort(serial_port,
                                {baudRate: baud,
                                 databits:8,
                                 dtr: true,
                                })
    port.on('error', function(err) {
        console.log('Error: ', err.message)
    })

    // Enable communication between sockets and serial.  This is a
    // little messy (nested), because we have to do the sockets <--
    // serial connection in a variable scope where ws is defined.

    app.ws('/ftdi', function(ws, req) {
        // sockets <-- serial
        port.on('data', function(data) {
            // console.log("serial connection sent:", data.toString('utf8'))
            //ws.send(data.toString('utf8'))
            ws.send(JSON.stringify(data))
        })
        // sockets --> serial
        ws.on('message', function(msg) {
            console.log("html page sent:", msg)
            port.flush()
            port.write(Buffer.from(msg))
            port.flush()
        });
    });


}

//example_terminal(false);
infrared_serial_websocket_server()
// fake_websocket_server()