Albert Chen | How to Make Almost Anything

Introduction
To bring everything I learned together into a final project, I wanted to challenge myself by making use of the radio module that I still cannot figure out how to use effectively. After brainstorming with some friends, I decided to make a companion cube. We thought that at a big schools like Harvard Law, it is easy to feel lonely even when there are many people around. People resort to texting to feel connected to their friends and loved ones, but we wanted something more tangible and tactile. Something that cannot be ignored.

The idea is pretty simple: to have two or more cubes that would talk to each other by radio. When one person squeezes one cube, the other cubes to buzz and glow. And vice versa. Finally, when two cubes are squeezed at the same time, the cubes glows and buzzes in psychedelic happy colors.

Materials
I started the project by ordering some components of my project online that is not be carried by the shop. Below is a summary of the materials that I used to make a pair of companion cubes.

Item	Price	Vendor	Quantity
LiPo 3.7V 500mAh Battery	$7.95	Adafruit	2
JST-PH 2-Pin SMT Right Angle Connector	$0.75	Adafruit	2
Mini-Motor, Vibrator (DCM-371)	$1.75	All Electronics	2
ATMEGA328P-AU-ND	$2.87	Inventory	2
nRF24L01+ 2.4GHz Wireless Transceiver	$6.85	Inventory	1
620-1021-1-ND Hall Effect	$1.39	Inventory	2
NDS355ANCT-ND N-CH 30V 1.7A Mosfet	$0.26	Inventory	2
Mold Star 20T Platinum-cure Silicone Rubber	$30.11	Amazon	0.5
TOTAL	$51.85

Although it was my first time ordering these parts, it was surprisingly easy to figure out. A few notes: make sure you have everything you can think of before ordering. Often the shipping costs are higher than the cost of the component when ordering in small units. Also, ask around to see if anyone has used the component before (or has the component to lend), and you might also learn about good alternatives.

Show Arduino code for I/O test


// Define RGB LED pins
#define red 5 // Red LED
#define green 6 // Green LED
#define blue 9 // Blue LED
#define anode 10 // Common Anode
#define sensor 0 // Sensor

// Define motor pin
#define motor 3 

void setup() {
  pinMode(red, OUTPUT);
  pinMode(green, OUTPUT);
  pinMode(blue, OUTPUT);
  pinMode(anode, OUTPUT);
  digitalWrite(anode, HIGH);

  analogWrite(red, 255);
  analogWrite(green, 255);
  analogWrite(blue, 0);
  analogWrite(motor, 0);

  
  pinMode(motor, OUTPUT);
  pinMode(sensor, INPUT);

  Serial.begin(9600);
}

void loop() {
  for(int i = 0; i<360; i++){
    //convert 0-360 angle to radian (needed for sin function)
    float rad = DEG_TO_RAD * i;

    //calculate sin of angle as number between 0 and 255
    int sinOut = constrain((sin(rad) * 128) + 128, 0, 255); 

    analogWrite(red, sinOut);
    analogWrite(green, sinOut);
    analogWrite(blue, sinOut);
    analogWrite(motor, sinOut);
    
    int value = analogRead(sensor);
    Serial.println(value);
    delay(15);
  }
}

Show Arduino code for modified Dan's send code


#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"
#include "SPI.h"

// Hardware configurati on: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 
RF24 radio(7,8);

int sensorPin = 0;    // select the input pin for the potentiometer
     
byte sensorValue;
byte seninbyte;
                                                                            // Topology
byte addresses[][6] = {"8Node","8Node"};                                    // Radio pipe addresses for the 2 nodes to communicate.

// Role management: Set up role.  This sketch uses the same software for all the nodes
// in this system.  Doing so greatly simplifies testing.  
typedef enum { role_ping_out = 1, role_pong_back } role_e;                 // The various roles supported by this sketch
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};  // The debug-friendly names of those roles
role_e role = role_pong_back;                                              // The role of the current running sketch

byte counter = 1;                                                          // A single byte to keep track of the data being sent back and forth


void setup(){

  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/GettingStarted/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  //printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

  // Setup and configure radio

  radio.begin();
  radio.setAutoAck(1);                    // Ensure autoACK is enabled
  radio.enableAckPayload();               // Allow optional ack payloads
  radio.setRetries(0,15);                 // Smallest time between retries, max no. of retries
  radio.setPayloadSize(1);                // Here we are sending 1-byte payloads to test the call-response speed
  radio.openWritingPipe(addresses[1]);    // Both radios listen on the same pipes by default, and switch when writing
  radio.openReadingPipe(1,addresses[0]);  // Open a reading pipe on address 0, pipe 1
  radio.startListening();                 // Start listening
  radio.powerUp();
  radio.printDetails();                   // Dump the configuration of the rf unit for debugging
  
  
  
  role=role_ping_out;

}

void loop(void) {


/****************** Ping Out Role ***************************/

int raw = analogRead(sensorPin);
Serial.print("Raw reading: ");
Serial.println(raw);
int mapped = raw / 3;
Serial.print("Mapped reading: ");
Serial.println(mapped);

  if (role == role_ping_out){                               // Radio is in ping mode

    byte gotByte;                                           // Initialize a variable for the incoming response
    
    radio.stopListening();                                  // First, stop listening so we can talk.      
    printf("Now sending %d as payload\n\r",mapped);         // Use a simple byte counter as payload
    unsigned long time = micros();                          // Record the current microsecond count   
                                                            
    if ( radio.write(&seninbyte,1  ) ){                     // Send the counter variable to the other radio 
        if(!radio.available()){                             // If nothing in the buffer, we got an ack but it is blank    
        }else{      
            while(radio.available() ){                      // If an ack with payload was received
                radio.read( &gotByte, 1 );                  // Read it, and display the response time
                printf("Got response %d, round-trip delay: %lu microseconds\n\r",gotByte,micros()-time);
            }
        }
    
    }else{        printf("Sending failed.\n\r"); }          // If no ack response, sending failed
    
    delay(500);  // Try again later
  }
}

Show Arduino code for modified Dan's receive code


#include "SPI.h"
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

// Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 
RF24 radio(7,8);
                                                                           // Topology
byte addresses[][6] = {"8Node","8Node"};                                   // Radio pipe addresses for the 2 nodes to communicate.

// Role management: Set up role.  This sketch uses the same software for all the nodes
// in this system.  Doing so greatly simplifies testing.  
typedef enum { role_ping_out = 1, role_pong_back } role_e;                 // The various roles supported by this sketch
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};  // The debug-friendly names of those roles
role_e role = role_pong_back;                                              // The role of the current running sketch

byte counter = 1;                                                          // A single byte to keep track of the data being sent back and forth


void setup(){

  Serial.begin(57600);

  printf_begin();
  printf("\n\rRF24/examples/GettingStarted/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  //printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

  // Setup and configure radio

  radio.begin();
  radio.setAutoAck(1);                    // Ensure autoACK is enabled
  radio.enableAckPayload();               // Allow optional ack payloads
  radio.setRetries(0,15);                 // Smallest time between retries, max no. of retries
  radio.setPayloadSize(1);                // Here we are sending 1-byte payloads to test the call-response speed
  radio.openWritingPipe(addresses[1]);    // Both radios listen on the same pipes by default, and switch when writing
  radio.openReadingPipe(1,addresses[0]);  // Open a reading pipe on address 0, pipe 1
  radio.startListening();                 // Start listening
  radio.powerUp();
  radio.printDetails();                   // Dump the configuration of the rf unit for debugging



  role=role_pong_back;
  printf("Setup Complete! \n\r"); 

}

void loop(void) {


/****************** Pong Back Role ***************************/
printf("Loop starting \n\r"); 

  if ( role == role_pong_back ) {
    byte pipeNo, gotByte;                          // Declare variables for the pipe and the byte received
    while( radio.available(&pipeNo)){              // Read all available payloads
      radio.read( &gotByte, 1 );                   
      printf("I am getting %d \n\r", gotByte); 
      
      if (gotByte>0){
      }
              delay(500);

   }
 }
}

Show Arduino code for modified Getting Started Code



/*
* Getting Started example sketch for nRF24L01+ radios
* This is a very basic example of how to send data from one node to another
* Updated: Dec 2014 by TMRh20
*/

#include <SPI.h>
#include "RF24.h"

/****************** User Config ***************************/
/***      Set this radio as radio number 0 or 1         ***/
bool radioNumber = 0;

/* Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 */
RF24 radio(7,8);
/**********************************************************/

byte addresses[][6] = {"1Node","2Node"};

// Used to control whether this node is sending or receiving
bool role = 0;

void setup() {
  Serial.begin(115200);
  Serial.println(F("RF24/examples/GettingStarted"));
  Serial.println(F("*** PRESS 'T' to begin transmitting to the other node"));
  
  radio.begin();

  // Set the PA Level low to prevent power supply related issues since this is a
 // getting_started sketch, and the likelihood of close proximity of the devices. RF24_PA_MAX is default.
  radio.setPALevel(RF24_PA_LOW);
  
  // Open a writing and reading pipe on each radio, with opposite addresses
  if(radioNumber){
    radio.openWritingPipe(addresses[1]);
    radio.openReadingPipe(1,addresses[0]);
  }else{
    radio.openWritingPipe(addresses[0]);
    radio.openReadingPipe(1,addresses[1]);
  }
  
  // Start the radio listening for data
  radio.startListening();

  // Initialize digital pins for led as an output
  pinMode(5, OUTPUT); // red
  pinMode(6, OUTPUT); // green
  pinMode(9, OUTPUT); // blue
  pinMode(10, OUTPUT); // anode
}

void loop() {
  
  
/****************** Ping Out Role ***************************/  
if (role == 1)  {
    
    radio.stopListening();                                    // First, stop listening so we can talk.

    digitalWrite(5, HIGH);                                    // Turn the LED on (HIGH is the voltage level)
    int magval = analogRead(0);                               // Read magnet sensor pin
    
    Serial.println(F("Now sending"));

    //unsigned long time = micros();                             // Take the time, and send it.  This will block until complete
     if (!radio.write( &magval, sizeof(int) )){
       Serial.println(F("failed"));
     }
        
    radio.startListening();                                    // Now, continue listening
    
    unsigned long started_waiting_at = micros();               // Set up a timeout period, get the current microseconds
    boolean timeout = false;                                   // Set up a variable to indicate if a response was received or not
    
    while ( ! radio.available() ){                             // While nothing is received
      if (micros() - started_waiting_at > 200000 ){            // If waited longer than 200ms, indicate timeout and exit while loop
          timeout = true;
          break;
      }      
    }
        
    if ( timeout ){                                             // Describe the results
        Serial.println(F("Failed, response timed out."));
    }else{
        unsigned int got_magval;                                 // Grab the response, compare, and send to debugging spew
        radio.read( &got_magval, sizeof(unsigned long) );
        //unsigned long time = micros();
        
        // Spew it
        Serial.print(F("Sent "));
        Serial.print(magval);
        Serial.print(F(", Got response "));
        Serial.print(got_magval);
//        Serial.print(F(", Round-trip delay "));
//        Serial.print(time-got_time);
//        Serial.println(F(" microseconds"));
    }

    digitalWrite(5, LOW);    // turn the LED off by making the voltage LOW
    
    // Try again 1s later
    delay(1000);
  }



/****************** Pong Back Role ***************************/

  if ( role == 0 )
  {
    int got_magval;
    
    
    if( radio.available()){
                                                                    // Variable for the received timestamp
      while (radio.available()) {                                   // While there is data ready
        radio.read( &got_magval, sizeof(int) );             // Get the payload
      }

      // turn on LED based on mag val
      if (got_magval < 100) {
        digitalWrite(5, HIGH);
        digitalWrite(6, HIGH);
        digitalWrite(9, LOW);   
      }
      else if (got_magval < 200) { 
        digitalWrite(5, LOW);
        digitalWrite(6, HIGH);
        digitalWrite(9, LOW);   
      }
      else if (got_magval < 300) { 
        digitalWrite(5, LOW);
        digitalWrite(6, HIGH);
        digitalWrite(9, HIGH);
      }   
      else if (got_magval < 400) { 
        digitalWrite(5, LOW);
        digitalWrite(6, LOW);
        digitalWrite(9, HIGH); 
      }
      else if (got_magval < 500) { 
        digitalWrite(5, HIGH);
        digitalWrite(6, LOW);
        digitalWrite(9, HIGH);
      }
      else if (got_magval < 600) { 
        digitalWrite(5, HIGH);
        digitalWrite(6, LOW);
        digitalWrite(9, LOW);
      }
      else if (got_magval < 1000) { 
        digitalWrite(5, HIGH);
        digitalWrite(6, HIGH);
        digitalWrite(9, HIGH);    
      }
      
      radio.stopListening();                                        // First, stop listening so we can talk   
      radio.write( &got_magval, sizeof(int) );              // Send the final one back.      
      radio.startListening();                                       // Now, resume listening so we catch the next packets.     
      Serial.print(F("Sent response "));
      Serial.println(got_magval);  
   }
 }




/****************** Change Roles via Serial Commands ***************************/

  if ( Serial.available() )
  {
    char c = toupper(Serial.read());
    if ( c == 'T' && role == 0 ){      
      Serial.println(F("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK"));
      role = 1;                  // Become the primary transmitter (ping out)
    
   }else
    if ( c == 'R' && role == 1 ){
      Serial.println(F("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK"));      
       role = 0;                // Become the primary receiver (pong back)
       radio.startListening();
       
    }
  }


} // Loop

Show Arduino code for sending values both ways



// set up libraries for radio
#include <SPI.h>
#include "RF24.h"

// define pins
#define red 5         // red LED
#define green 6       // green LED
#define blue 9        // blue LED
#define anode 10      // common anode
#define sensor 0      // magnetic sensor
#define motor 3       // vibration motor

// set trigger value
#define trigger 20    // triggers when delta > 20

/****************** User Config ***************************/
/***      Set this radio as radio number 0 or 1         ***/
bool radioNumber = 0;
byte addresses[][6] = {"1Node","2Node"};

/* Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 */
RF24 radio(7,8);
/**********************************************************/


// Used to control whether this node is sending or receiving
bool role = radioNumber;

// Create a data structure for transmitting and receiving data
struct dataStruct{
  unsigned long _micros;
  bool squeeze;
}myData;

// Set up global variable baselines
int myBaseline;
int myValue;
bool mySqueeze;
bool yourSqueeze;

void setup() {

  Serial.begin(115200);
  Serial.println(F("Starting program!"));
  
  radio.begin();

  // Set the PA Level low to prevent power supply related issues since this is a
  // getting_started sketch, and the likelihood of close proximity of the devices. RF24_PA_MAX is default.
  radio.setPALevel(RF24_PA_LOW);
  
  // Open a writing and reading pipe on each radio, with opposite addresses
  if(radioNumber){
    radio.openWritingPipe(addresses[1]);
    radio.openReadingPipe(1,addresses[0]);
  }else{
    radio.openWritingPipe(addresses[0]);
    radio.openReadingPipe(1,addresses[1]);
  }

  // Set up pins for I/O
  pinMode(red, OUTPUT);
  pinMode(green, OUTPUT);
  pinMode(blue, OUTPUT);
  pinMode(anode, OUTPUT);
  
  digitalWrite(anode, HIGH);
  
  pinMode(motor, OUTPUT);
  pinMode(sensor, INPUT);
  
  // Set baseline for magnetic sensor value
  myBaseline = analogRead(sensor);
  Serial.print(F("Baseline: "));
  Serial.println(myBaseline);
  mySqueeze = 0;
  yourSqueeze = 0;
    
  // Start the radio listening for data
  radio.startListening();
}




void loop() {

    
    myValue = analogRead(sensor);                             // Read value from sensor pin
    Serial.print(F("Magnetic sensor value: "));               // Spew to serial
    Serial.println(myValue);          
    mySqueeze = ( abs(myValue - myBaseline) > trigger );      // Squeezed if delta > trigger  
    Serial.print(F("My squeeze: "));                          // Spew to serial
    Serial.println(mySqueeze); 

    
    // Light it up
    if (!mySqueeze && !yourSqueeze){
      analogWrite(red, 255);
      analogWrite(green, 255);
      analogWrite(blue, 255);
      analogWrite(motor, 0);
    }else if (mySqueeze && !yourSqueeze){
      analogWrite(red, 255);
      analogWrite(green, 0);
      analogWrite(blue, 255);
      analogWrite(motor, 0);          
    }else if (!mySqueeze && yourSqueeze){
      analogWrite(red, 0);
      analogWrite(green, 255);
      analogWrite(blue, 255);
      analogWrite(motor, 255);              
    }else if (mySqueeze && yourSqueeze){
      
      for(int i = 0; i<720; i++){
        //convert 0-360 angle to radian and map sin(angle) to 0-255
        float rad = DEG_TO_RAD * i;
        int sinOut = constrain((sin(rad) * 128) + 128, 0, 255); 
    
        //write out color and motor
        analogWrite(red, sinOut);
        analogWrite(green, sinOut);
        analogWrite(blue, sinOut);
        analogWrite(motor, sinOut);
      }
    }
          
/****************** Ping Out Role ***************************/  
if (role == 1)  {
    
    radio.stopListening();                                    // First, stop listening so we can talk.
    
    Serial.println(F("Now sending"));                         // Update values in payload
    myData._micros = micros();
    myData.squeeze = mySqueeze;
    
     if (!radio.write( &myData, sizeof(myData) )){
       Serial.println(F("failed"));
     }
        
    radio.startListening();                                    // Now, continue listening
    
    unsigned long started_waiting_at = micros();               // Set up a timeout period, get the current microseconds
    boolean timeout = false;                                   // Set up a variable to indicate if a response was received or not
    
    while ( ! radio.available() ){                             // While nothing is received
      if (micros() - started_waiting_at > 200000 ){            // If waited longer than 200ms, indicate timeout and exit while loop
          timeout = true;
          break;
      }      
    }
        
    if ( timeout ){                                             // Describe the results
        Serial.println(F("Failed, response timed out."));
    }else{
                                                                // Grab the response, compare, and send to debugging spew
        radio.read( &myData, sizeof(myData) );
        unsigned long time = micros();

        yourSqueeze = myData.squeeze;                           // Update yourSqueeze
        
        // Spew it
        Serial.print(F("Sent "));
        Serial.print(time);
        Serial.print(F(", Got response "));
        Serial.print(myData._micros);
        Serial.print(F(", Round-trip delay "));
        Serial.print(time-myData._micros);
        Serial.print(F(" microseconds, Squeeze "));
        Serial.println(myData.squeeze);
     }

    // Try again 1s later
    delay(1000);
  }



/****************** Pong Back Role ***************************/

  if ( role == 0 )
  {

    if( radio.available()){
                                                           // Variable for the received timestamp
      while (radio.available()) {                          // While there is data ready
        radio.read( &myData, sizeof(myData) );             // Get the payload
      }
     
      radio.stopListening();                               // First, stop listening so we can talk  

      yourSqueeze = myData.squeeze;                        // Save your squeeze
      Serial.print(F("Your squeeze: "));                   // Spew to serial
      Serial.println(yourSqueeze);            
      myData.squeeze = mySqueeze;                          // Update myData to mySqueeze instead
      
      radio.write( &myData, sizeof(myData) );              // Send the final one back.      
      radio.startListening();                              // Now, resume listening so we catch the next packets.     
      Serial.print(F("Sent response "));
      Serial.print(myData._micros);  
      Serial.print(F(" : "));
      Serial.println(myData.squeeze);

    }
  }
  
} // Loop

Show final Arduino code


// set up libraries for radio
#include <SPI.h>
#include "RF24.h"

// define pins
#define red 5         // red LED
#define green 6       // green LED
#define blue 9        // blue LED
#define anode 10      // common anode
#define sensor 0      // magnetic sensor
#define motor 3       // vibration motor

// set trigger value
#define trigger 20    // triggers when delta > 20

/****************** User Config ***************************/
/***      Set this radio as radio number 0 or 1         ***/
bool radioNumber = 0;
byte addresses[][6] = {"1Node","2Node"};

/* Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 */
RF24 radio(7,8);
/**********************************************************/


// Used to control whether this node is sending or receiving
bool role = radioNumber;

// Create a data structure for transmitting and receiving data
struct dataStruct{
  unsigned long _micros;
  bool squeeze;
}myData;

// Set up global variable baselines
int myBaseline;
int myValue;
bool mySqueeze;
bool yourSqueeze;
int lastColor;

void setup() {

// Comment back in Serial.print for debugging
  
  radio.begin();
  Serial.begin(9600);

  // Set the PA Level low to prevent power supply related issues since this is a
  // getting_started sketch, and the likelihood of close proximity of the devices. RF24_PA_MAX is default.
  radio.setPALevel(RF24_PA_LOW);
  
  // Open a writing and reading pipe on each radio, with opposite addresses
  if(radioNumber){
    radio.openWritingPipe(addresses[1]);
    radio.openReadingPipe(1,addresses[0]);
  }else{
    radio.openWritingPipe(addresses[0]);
    radio.openReadingPipe(1,addresses[1]);
  }

  // Set up pins for I/O
  pinMode(red, OUTPUT);
  pinMode(green, OUTPUT);
  pinMode(blue, OUTPUT);
  pinMode(anode, OUTPUT);
  
  digitalWrite(anode, HIGH);
  
  pinMode(motor, OUTPUT);
  pinMode(sensor, INPUT);
  
  // Set baseline for magnetic sensor value
  myBaseline = analogRead(sensor);
  Serial.print(F("Baseline: "));
  Serial.println(myBaseline);
  mySqueeze = 0;
  yourSqueeze = 0;

  // Initialization color sequence
  setColourRgb(0,255,255);
  delay(500);
  setColourRgb(255,0,255);
  delay(500);
  setColourRgb(255,255,0);
  delay(500);
  
  // Set last color as off
  lastColor = 0;
  setColourRgb(255,255,255);
  analogWrite(motor,0);
  
  // Start the radio listening for data
  radio.startListening();
}




void loop() {
  
    myValue = analogRead(sensor);                             // Read value from sensor pin
//    Serial.print(F("Magnetic sensor value: "));               // Spew to serial
//    Serial.println(myValue);          
    mySqueeze = ( abs(myValue - myBaseline) > trigger );      // Squeezed if delta > trigger  
//    Serial.print(F("My squeeze: "));                          // Spew to serial
//    Serial.println(mySqueeze); 

    // Change color based on conditions, using lastColor to track last state
    if (!mySqueeze && !yourSqueeze){
        if (lastColor == 0){                                  // do nothing
          
        } else if (lastColor == 1){                           // fade from green
          lastColor = 0;
          analogWrite(motor,0);
          for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 1) {
              setColourRgb(255,fadeValue,255);
              delay(5);
              Serial.println(fadeValue); 
            }
        } else if (lastColor == 2){                           // fade from red
          lastColor = 0;
          analogWrite(motor,0);
            for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 1) {
              setColourRgb(fadeValue,255,255);
              delay(5);
            }          
        } else if (lastColor == 3){                           // fade from white
          lastColor = 0;
          analogWrite(motor,0);
          for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 1) {
              setColourRgb(fadeValue,fadeValue,fadeValue);
              delay(5);          
          }
        }
        
    }else if (mySqueeze && !yourSqueeze){
        if (lastColor != 1){
          lastColor = 1;
          analogWrite(motor,0);
          for (int fadeValue = 255 ; fadeValue > 0; fadeValue -= 1) {
            setColourRgb(255,fadeValue,255);
            delay(5);
          }
        }
    }else if (!mySqueeze && yourSqueeze){
        if (lastColor != 2){
          lastColor = 2;
          analogWrite(motor,255);
          for (int fadeValue = 255 ; fadeValue > 0; fadeValue -= 1) {
            setColourRgb(fadeValue,255,255);
            delay(5);
          }        
        }
    }else if (mySqueeze && yourSqueeze){
        lastColor = 3;        
        
        // off -> red
        for (int count = 0; count < 255; ++count) {
           setColourRgb(255 - count,255,255);
           // pulse motor
           if (count < 64){
            analogWrite(motor,255);
           } else if (count < 128){
            analogWrite(motor,0); 
           } else if (count < 192){
            analogWrite(motor,128); 
           } else{
            analogWrite(motor,0);  
           }
           delay(2);
           }
        // red -> green
        for (int count = 0; count < 255; ++count) {
           setColourRgb(0 + count,255 - count,255);
           // pulse motor
           if (count < 64){
            analogWrite(motor,255);
           } else if (count < 128){
            analogWrite(motor,0); 
           } else if (count < 192){
            analogWrite(motor,255); 
           } else{
            analogWrite(motor,0);  
           }
           delay(2);
           }
        // green -> blue
        for (int count = 0; count < 255; ++count) {
           setColourRgb(255,0 + count,255 - count);
           // pulse motor
           if (count < 64){
            analogWrite(motor,255);
           } else if (count < 128){
            analogWrite(motor,0); 
           } else if (count < 192){
            analogWrite(motor,255); 
           } else{
            analogWrite(motor,0);  
           }
           delay(2);
           }
        // blue -> red
        for (int count = 0; count < 255; ++count) {
           setColourRgb(255 - count,255,0 + count);
           // pulse motor
           if (count < 64){
            analogWrite(motor,255);
           } else if (count < 128){
            analogWrite(motor,0); 
           } else if (count < 192){
            analogWrite(motor,255); 
           } else{
            analogWrite(motor,0);  
           }
           delay(2);
           }
        // red -> off
        for (int count = 0; count < 255; ++count) {
           setColourRgb(0 + count,255,255);
           // pulse motor
           if (count < 64){
            analogWrite(motor,255);
           } else if (count < 128){
            analogWrite(motor,0); 
           } else if (count < 192){
            analogWrite(motor,255); 
           } else{
            analogWrite(motor,0);  
           }
           delay(2);
           }        
    }

          
/****************** Ping Out Role ***************************/  
if (role == 1)  {
    
    radio.stopListening();                                    // First, stop listening so we can talk.
    
//    Serial.println(F("Now sending"));                         // Update values in payload
    myData._micros = micros();
    myData.squeeze = mySqueeze;
    
     if (!radio.write( &myData, sizeof(myData) )){
//       Serial.println(F("failed"));
     }
        
    radio.startListening();                                    // Now, continue listening
    
    unsigned long started_waiting_at = micros();               // Set up a timeout period, get the current microseconds
    boolean timeout = false;                                   // Set up a variable to indicate if a response was received or not
    
    while ( ! radio.available() ){                             // While nothing is received
      if (micros() - started_waiting_at > 200000 ){            // If waited longer than 200ms, indicate timeout and exit while loop
          timeout = true;
          break;
      }      
    }
        
    if ( timeout ){                                             // Describe the results
//        Serial.println(F("Failed, response timed out."));
    }else{
                                                                // Grab the response, compare, and send to debugging spew
        radio.read( &myData, sizeof(myData) );
        unsigned long time = micros();

        yourSqueeze = myData.squeeze;                           // Update yourSqueeze
        
//        // Spew it
//        Serial.print(F("Sent "));
//        Serial.print(time);
//        Serial.print(F(", Got response "));
//        Serial.print(myData._micros);
//        Serial.print(F(", Round-trip delay "));
//        Serial.print(time-myData._micros);
//        Serial.print(F(" microseconds, Squeeze "));
//        Serial.println(myData.squeeze);
     }
    
    // Try again 1s later
    //delay(100);
  }



/****************** Pong Back Role ***************************/

  if ( role == 0 )
  {

    if( radio.available()){
                                                           // Variable for the received timestamp
      while (radio.available()) {                          // While there is data ready
        radio.read( &myData, sizeof(myData) );             // Get the payload
      }
     
      radio.stopListening();                               // First, stop listening so we can talk  

      yourSqueeze = myData.squeeze;                        // Save your squeeze
//      Serial.print(F("Your squeeze: "));                   // Spew to serial
//      Serial.println(yourSqueeze);            
      myData.squeeze = mySqueeze;                          // Update myData to mySqueeze instead
      
      radio.write( &myData, sizeof(myData) );              // Send the final one back.      
      radio.startListening();                              // Now, resume listening so we catch the next packets.     
//      Serial.print(F("Sent response "));
//      Serial.print(myData._micros);  
//      Serial.print(F(" : "));
//      Serial.println(myData.squeeze);

    }
  }
  
} // Loop

// function to set RGB LED to the right color
void setColourRgb(unsigned int r, unsigned int g, unsigned int b) {
  analogWrite(red, r);
  analogWrite(green, g);
  analogWrite(blue, b);
}

Show C code for alternate blinking


// LED1    PA7 (pin 6).
// LED2    PB2 (pin 5).
#include <avr/io.h>

#define output(directions,pin) (directions |= pin) // set port direction for output
#define input(directions,pin) (directions &= (~pin)) // set port direction for input
#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 output_port_1 PORTA		//  port A will be used for LED1
#define output_direction_1 DDRA	//  DDRA defines input/output for port B
#define output_pin_1 (1 << PA7)    //  The LED1 is on pin 7 of port A
#define output_port_2 PORTB		//  port B will be used for LED2
#define output_direction_2 DDRB	//  DDRB defines input/output for port B
#define output_pin_2 (1 << PB2)    //  The LED2 is on pin 2 of port B
#define DELAY 100 // blink delay

int main(void) {
	//
	// initialize pins
	//
	output(output_direction_1, output_pin_1);
	output(output_direction_2, output_pin_2);
	//
	// main loop
	//
	while (1) {
		set(output_port_1, output_pin_1);
		clear(output_port_2, output_pin_2);
		_delay_ms(DELAY);
		clear(output_port_1, output_pin_1);
		set(output_port_2, output_pin_2);
		_delay_ms(DELAY);
	}
}

Show .make code for alternate blinking


PROJECT=button_44_test
SOURCES=$(PROJECT).c
MMCU=attiny44
F_CPU = 20000000

CFLAGS=-mmcu=$(MMCU) -Wall -Os -DF_CPU=$(F_CPU)

$(PROJECT).hex: $(PROJECT).out
	avr-objcopy -O ihex $(PROJECT).out $(PROJECT).c.hex;\
	avr-size --mcu=$(MMCU) --format=avr $(PROJECT).out
 
$(PROJECT).out: $(SOURCES)
	avr-gcc $(CFLAGS) -I./ -o $(PROJECT).out $(SOURCES)
 
program-usbtiny: $(PROJECT).hex
	avrdude -p t44 -P usb -c usbtiny -U flash:w:$(PROJECT).c.hex

program-usbtiny-fuses: $(PROJECT).hex
	avrdude -p t44 -P usb -c usbtiny -U lfuse:w:0x5E:m

Show C code for button


// Button  PA3 (pin 10). 
// LED1    PA7 (pin 6).
// LED2    PB2 (pin 5).
// CE      PA1 (pin 12).
// CSN     PA2 (pin 11).  
#include <avr/io.h>

#define output(directions,pin) (directions |= pin) // set port direction for output
#define input(directions,pin) (directions &= (~pin)) // set port direction for input
#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 button_port PORTA		// The button is on port A
#define button_direction DDRA	//  DDRA defines input/output for port A
#define button_pin (1 << PA3)	//  The button is on pin 3 of port A
#define input_pins PINA			//  PINA is the register that is read to detect input high or low.
#define output_port PORTB		//  port B will be used for LED2
#define output_direction DDRB	//  DDRB defines input/output for port B
#define output_pin (1 << PB2)    //  The LED2 is on pin 2 of port B

int main(void) {
	//
	// initialize pins
	//
	output(output_direction, output_pin);
	set(button_port, button_pin); // turn on pull-up
	input(button_direction, button_pin);
	//
	// main loop
	//
	while (1) {
		//
		//
		//
		if (pin_test(input_pins,button_pin))
			clear(output_port,output_pin);
		else
			set(output_port,output_pin);
		//
		// wait for button up
		// 
	}
}

Show .make code for button


PROJECT=button_44_test2
SOURCES=$(PROJECT).c
MMCU=attiny44
F_CPU = 20000000

CFLAGS=-mmcu=$(MMCU) -Wall -Os -DF_CPU=$(F_CPU)

$(PROJECT).hex: $(PROJECT).out
	avr-objcopy -O ihex $(PROJECT).out $(PROJECT).c.hex;\
	avr-size --mcu=$(MMCU) --format=avr $(PROJECT).out
 
$(PROJECT).out: $(SOURCES)
	avr-gcc $(CFLAGS) -I./ -o $(PROJECT).out $(SOURCES)
 
program-usbtiny: $(PROJECT).hex
	avrdude -p t44 -P usb -c usbtiny -U flash:w:$(PROJECT).c.hex

program-usbtiny-fuses: $(PROJECT).hex
	avrdude -p t44 -P usb -c usbtiny -U lfuse:w:0x5E:m

After much testing, I couldn’t find anything else wrong with the board, so I replaced the Mega 328p, and it worked again! This time, I talked to Rob and we tried to fuse it to a different setting. After looking at the data sheet, it looks like the setting we were trying should have worked (56) since it called for an external crystal. After taking a look at Rob’s board with the same external crystal setup, I tried using his setting (FF):

program-usbtiny-fuses: $(PROJECT).hex
avrdude -p atmega328p -P usb -c usbtiny -U lfuse:w:0xFF:m
avrdude -p atmega328p -P usb -c usbtiny -U hfuse:w:0xD9:m
avrdude -p atmega328p -P usb -c usbtiny -U efuse:w:0x07:m

And… it stopped working again. So I gave up. I replaced the Mega 328p one last time and just skipped the fuse step, going string to flashing the program. Although I got the lights to flash, I could not get the motor to work. I wonder if it has something to do with the fuse settings? I guess we’ll find out next week when I revisit this board!

Show C code for 328p transmit-receive step response


#include 
#include 

#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 102 // bit delay for 9600 with overhead
#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 settle_delay() _delay_us(100) // settle delay
#define char_delay() _delay_ms(10) // char delay
#define nloop 100 // loops to accumulate

#define serial_port PORTD
#define serial_direction DDRD
#define serial_pin_out (1 << PD1) // Rx pin for FTDI
#define transmit_port PORTC
#define transmit_direction DDRC
#define transmit_pin (1 << PC0) // Tx pin for sensor

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();
   }

int main(void) {
   //
   // main
   //
   static unsigned char count;
   static uint16_t up,down;
   //
   // set clock divider to /1
   //
   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);
   clear(transmit_port, transmit_pin);
   output(transmit_direction, transmit_pin);
   //
   // init A/D
   //
   ADMUX = (1 << REFS0) // Vcc ref = AVcc
         | (0 << ADLAR) // right adjust
         | (0 << MUX3) | (0 << MUX2) | (0 << MUX1) | (1 << MUX0); // Rx on sensor ADC1 (See Input Channel Selections on datasheet)
   ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); // prescaler /128
   //
   // main loop
   //
   while (1) {
      //
      // accumulate
      //
      up = 0;
      down = 0;
      for (count = 0; count < nloop; ++count) { 
         //
         // settle, charge
         //
         settle_delay();
         set(transmit_port, transmit_pin);
         //
         // initiate conversion
         //
         ADCSRA |= (1 << ADSC);
         //
         // wait for completion
         //
         while (ADCSRA & (1 << ADSC))
            ;
         //
         // save result
         //
         up += ADC;
         //
         // settle, discharge
         //
         settle_delay();
         clear(transmit_port, transmit_pin);
         //
         // initiate conversion
         //
         ADCSRA |= (1 << ADSC);
         //
         // wait for completion
         //
         while (ADCSRA & (1 << ADSC))
            ;
         //
         // save result
         //
         down += ADC;
         }
      //
      // send framing
      //
      put_char(&serial_port, serial_pin_out, 1);
      char_delay();
      put_char(&serial_port, serial_pin_out, 2);
      char_delay();
      put_char(&serial_port, serial_pin_out, 3);
      char_delay();
      put_char(&serial_port, serial_pin_out, 4);
      //
      // send result
      //
      put_char(&serial_port, serial_pin_out, (up & 255));
      char_delay();
      put_char(&serial_port, serial_pin_out, ((up >> 8) & 255));
      char_delay();
      put_char(&serial_port, serial_pin_out, (down & 255));
      char_delay();
      put_char(&serial_port, serial_pin_out, ((down >> 8) & 255));
      char_delay();
      }
   }

Show C code for step response with white LED output


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

#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 102 // bit delay for 9600 with overhead
#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 settle_delay() _delay_us(100) // settle delay
#define char_delay() _delay_ms(10) // char delay
#define nloop 100 // loops to accumulate
#define led_delay() _delay_ms(100) // LED delay

#define serial_port PORTD
#define serial_direction DDRD
#define serial_pin_out (1 << PD1) // Rx pin for FTDI
#define transmit_port PORTC
#define transmit_direction DDRC
#define transmit_pin (1 << PC0) // Tx pin for sensor

#define white_port PORTB
#define white_direction DDRB
#define white_pin (1 << PB0) // Pin for white LED
#define whiteg_port PORTD
#define whiteg_direction DDRD
#define whiteg_pin (1 << PD6) // Pin for white LED ground

int main(void) {
   //
   // main
   //
   static unsigned char count;
   static uint16_t up,down, value;

   Serial.begin(9600);  // start serial
   //
   // set clock divider to /1
   //
   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);
   clear(transmit_port, transmit_pin);
   output(transmit_direction, transmit_pin);
    //
   // initialize white LED pin
   //
   clear(white_port, white_pin);
   output(white_direction, white_pin);
   clear(whiteg_port, whiteg_pin);
   output(whiteg_direction, whiteg_pin);
   //
   //
   // init A/D
   //
   ADMUX = (1 << REFS0) // Vcc ref = AVcc
         | (0 << ADLAR) // right adjust
         | (0 << MUX3) | (0 << MUX2) | (0 << MUX1) | (1 << MUX0); // Rx on sensor ADC1 (See Input Channel Selections on datasheet)
   ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); // prescaler /128
   //
   // main loop
   //
   while (1) {
      //
      // accumulate
      //
      up = 0;
      down = 0;
      for (count = 0; count < nloop; ++count) { 
         //
         // settle, charge
         //
         settle_delay();
         set(transmit_port, transmit_pin);
         //
         // initiate conversion
         //
         ADCSRA |= (1 << ADSC);
         //
         // wait for completion
         //
         while (ADCSRA & (1 << ADSC))
            ;
         //
         // save result
         //
         up += ADC;
         //
         // settle, discharge
         //
         settle_delay();
         clear(transmit_port, transmit_pin);
         //
         // initiate conversion
         //
         ADCSRA |= (1 << ADSC);
         //
         // wait for completion
         //
         while (ADCSRA & (1 << ADSC))
            ;
         //
         // save result
         //
         down += ADC;
         }
	  //
	  // save difference in up/down
	  //
      value = up - down;
      // 
	  // set boundaries for when the LED should turn on/off
	  //
      if (value < 3000){ 
        set(white_port,white_pin);
      }
      else if (value < 4000){
        clear(white_port,white_pin);
      }
      else {
        set(white_port,white_pin);
      }
   }
}

Show C code for step response with RGB LED output


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

#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 102 // bit delay for 9600 with overhead
#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 settle_delay() _delay_us(100) // settle delay
#define char_delay() _delay_ms(10) // char delay
#define nloop 100 // loops to accumulate
#define led_delay() _delay_ms(100) // LED delay

#define serial_port PORTD
#define serial_direction DDRD
#define serial_pin_out (1 << PD1) // Rx pin for FTDI
#define transmit_port PORTC
#define transmit_direction DDRC
#define transmit_pin (1 << PC0) // Tx pin for sensor

#define ledr_port PORTB
#define ledr_direction DDRB
#define ledg_port PORTD
#define ledg_direction DDRD
#define ledb_port PORTD
#define ledb_direction DDRD
#define red (1 << PB1)
#define green (1 << PD5)
#define blue (1 << PD6)

#define leda_port PORTB
#define leda_direction DDRB
#define anode (1 << PB2)

int main(void) {
   //
   // main
   //
   static unsigned char count;
   static uint16_t up,down, value;

   Serial.begin(9600);  // start serial
   //
   // set clock divider to /1
   //
   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);
   clear(transmit_port, transmit_pin);
   output(transmit_direction, transmit_pin);
   //
   // initialize LED pins
   //
   set(ledr_port, red);
   output(ledr_direction, red);
   set(ledg_port, green);
   output(ledg_direction, green);
   set(ledb_port, blue);
   output(ledb_direction, blue);
   set(leda_port, anode);
   output(leda_direction, anode);
   //
   // init A/D
   //
   ADMUX = (1 << REFS0) // Vcc ref = AVcc
         | (0 << ADLAR) // right adjust
         | (0 << MUX3) | (0 << MUX2) | (0 << MUX1) | (1 << MUX0); // Rx on sensor ADC1 (See Input Channel Selections on datasheet)
   ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); // prescaler /128
   //
   // main loop
   //
   while (1) {
      //
      // accumulate
      //
      up = 0;
      down = 0;
      for (count = 0; count < nloop; ++count) { 
         //
         // settle, charge
         //
         settle_delay();
         set(transmit_port, transmit_pin);
         //
         // initiate conversion
         //
         ADCSRA |= (1 << ADSC);
         //
         // wait for completion
         //
         while (ADCSRA & (1 << ADSC))
            ;
         //
         // save result
         //
         up += ADC;
         //
         // settle, discharge
         //
         settle_delay();
         clear(transmit_port, transmit_pin);
         //
         // initiate conversion
         //
         ADCSRA |= (1 << ADSC);
         //
         // wait for completion
         //
         while (ADCSRA & (1 << ADSC))
            ;
         //
         // save result
         //
         down += ADC;
         }
	  //
	  // save difference in up/down
	  //
      value = up - down;
      // 
	  // set boundaries for when the different LEDs should turn on/off
	  //
      if (value < 3000)
      {
        set(ledr_port,red);
        clear(ledg_port,green);
        clear(ledb_port,blue);
      }
      else if (value < 4000)
      {
        set(ledr_port,red);
        set(ledg_port,green);
        clear(ledb_port,blue);
      }
      else if (value < 5000)
      {
        clear(ledr_port,red);
        set(ledg_port,green);
        clear(ledb_port,blue);
      }
      else if (value < 6000)
      {
        clear(ledr_port,red);
        set(ledg_port,green);
        set(ledb_port,blue);
      }
      else if (value < 7000)
      {
        clear(ledr_port,red);
        clear(ledg_port,green);
        set(ledb_port,blue);
      }
      else
      {
        set(ledr_port,red);
        clear(ledg_port,green);
        set(ledb_port,blue);
      }
   }
}


<Buffer 36 0d 0a 36 30 32>
<Buffer 39 0d 0a 36 30 33>
<Buffer 34 0d 0a 36 30 34>
<Buffer 32 0d 0a 36 30 33>
<Buffer 37 0d 0a 36 30 32>
<Buffer 39 0d 0a 36 30 34>
<Buffer 32 0d 0a 36 30 35>

After much confusion, I finally realized that I had included a Serial.println in my Arduino code uploaded and so the data coming through were not bytes that Neil's code can read. I figured this out after searching for 0d 0a and realizing that this was CRLF in hex. After switching the code over to a simple parseInt() to convert the string coming through, it worked!

Show Javascript for transmit-receive


var server_port = '1234'
var client_address = '127.0.0.1'
var baud = 9600

// serial port initialization:
var serialport = require('serialport'), // include the serialport library
    SerialPort = serialport.SerialPort, // make a local instance of serial
    portName = process.argv[2];        // get the port name from the command line
    portConfig = {
    	baudRate: baud,
        // call myPort.on('data') when a CRLF is received Serial.println:
        parser: serialport.parsers.readline('\r\n')
        };

// open the serial port:
var myPort = new SerialPort(portName, portConfig);

// initialize value to send over to browser
var value = 0

myPort.open(function(error) {
   if (error) {
      console.log('can not open '+portName)
      }
   else {
      console.log('opened '+portName)
      myPort.on('data',function(data) {
		 // convert data (string of numbers) into int
		 value = parseInt(data)  
         })
      }
   })
//
// wait for socket request and then send field value
//
console.log("listening for connections from "+client_address+" on "+server_port)
var Server = require('ws').Server
wss = new Server({port:server_port})
wss.on('connection', function(ws) {
   if (ws._socket.remoteAddress != client_address) {
      console.log("error: client address doesn't match")
      return
      }
   console.log("connected to "+client_address+" on port "+server_port)
   ws.on('message', function(data) {
      ws.send(JSON.stringify(value.toFixed(1)))
      })
   })

Show Javascript for transmit-receive


//
// new.hello.mag.45.js based on Neil's example
//
var server_port = '1234'
var client_address = '127.0.0.1'
var serial_port = "/dev/tty.usbserial-FTHKH0N6"
var baud = 9600
var samples = 100
//
// open serial port
//
var SerialPort = require("serialport").SerialPort
var sp = new SerialPort(serial_port,{baudrate:baud})
//
// look for framing and then update field value
//
var byte2 = 0
var byte3 = 0
var byte4 = 0
var byte5 = 0
var byte6 = 0
var byte7 = 0
var value = 0
sp.open(function(error) {
   if (error) {
      console.log('can not open '+serial_port)
      }
   else {
      console.log('opened '+serial_port)
      sp.on('data',function(data) {
		 if (data.length == 1) {
			 byte1 = byte2
	         byte2 = byte3
	         byte3 = byte4
	         byte4 = byte5
	         byte5 = byte6
	         byte6 = byte7
	         byte7 = data[0]
	         if ((byte1 == 1) & (byte2 == 2) & (byte3 == 3) & (byte4 == 4)) {
	            value = (byte5 + 256*byte6 + 256*256*byte7)/samples
	            }
		 	}	
		 else {
          	 byte1 = byte3
          	 byte2 = byte4
          	 byte3 = byte5
          	 byte4 = byte6
          	 byte5 = byte7
          	 byte6 = data[0]
          	 byte7 = data[1]
         	 if ((byte1 == 1) & (byte2 == 2) &(byte3 == 3) & (byte4 == 4)) {
            	value = (byte5 + 256*byte6 + 256*256*byte7)/samples
             }
		 }
		 //console.log(byte1+','+byte2+','+byte3+','+byte4+','+byte5+','+byte6+','+byte7)
		 })
      }
   })
//
// wait for socket request and then send field value
//
console.log("listening for connections from "+client_address+" on "+server_port)
var Server = require('ws').Server
wss = new Server({port:server_port})
wss.on('connection', function(ws) {
   if (ws._socket.remoteAddress != client_address) {
      console.log("error: client address doesn't match")
      return
      }
   console.log("connected to "+client_address+" on port "+server_port)
   ws.on('message', function(data) {
      ws.send(JSON.stringify(value.toFixed(1)))
      })
   })

Final Project

Companion Cubes

Weekly Assignments

My trials and tribulations.

Computer-Aided Design

Computer Cutting

Electronics Production

3D Scanning and Printing

Computer Machining

Electronics Design

Molding & Casting

Embedded Programming

Output Devices

Input Devices

Interface & Application Programming

Group Project

About

Albert Chen
JD candidate at Harvard Law School.

Hong Kong

Ithaca, NY

Paris

Washington DC

Cambridge, MA

San Francisco

London

Los Angeles

The Road
Not
Taken