The question of what is consciousness is or when does it appear and weather it exists or can be perceived in other living things is something that has been a curiosity and a fascinating subject for me.
When thinking about AI, or religion or spirituality, watching tv shows about quantum physics, I have found a kind of joy to see that different theories or explanations for this kind of questions have a tendency to point into something that I find marvelous. Scientific theories and experiments are gathering proof or go a little bit further into what we are, how we are made, by studying the universe to learn that when you get to quantum level we are all pretty much connected with everything else.
The facts stated on the readings and videos are fascinating, I like the idea (and had not realized it in the way that the reading explains that consciousness is not) that most of what we think we are conscious of is an illusion that our biology, the way we are constructed, has managed to create in order for us to really function and survive in this world or universe.
The examples on the video from TED, makes me smile, I feel a freshness to realize that decisions and choices are very relative to how they are displayed according to other choices.
How we are wired, and how the connections of those wires can be permuted in order to give a different result, seems to me like a very … natural explanation… sort of speak… to the relative and uncertain nature of our basic building blocks (it is how good magicians make a living jeje).
I also feel as true that when you let go, and not be son “conscious”of your body, helps imagination and helps get better results in some areas, like the arts and sports or even math. But that depends on the personal dexterity towards a certain activity. One that does require more conscious approach is, in most cases I think, the one that it is not hardwired or exploited by your genes, but this doesn’t mean one can’t do those things, it will just be more difficult (sometimes it could seem impossible) to be able to be fluent on it.
I also like the finishing idea from the video by Dan Ariely, that taking into account or being more conscious about the unconscious part of us (which seems dominant) we can build a better world, more human, social, enjoyable (if done and used by the right hands not evil conscious minds).
But I still do not understand how could there be human beings without a consciousness…. I have to keep reading on that….
PS
For the analog sensor practice, please see the “Pull”. An installation by the end of the Japanese room, just before the hall to the shop. I “finished” working on it yesterday. Web page with documentation still to come.
Here is the loooong code:
/*
Program and Interaction designed by Nelson Ramon and Ariel Kalinowski
May-June 2011, NYC
Aug-Sep 2011, NYC
It reads a range finder value, averages its output and fades a LED according to the distance
the LED gets brighter as you get close to the sensor
When you are further than the desired distance, the LED is off
*/
//int sensorPin = A4; // select the input pin for the potentiometer
int ledPin = 11; //#5 spot from left right
int ledPin1 = 9; //#4 spot from left right
int ledPin2 = 6; //#3 spot from left right
int ledPin3 = 5; //#2 spot from left right
int ledPin4 = 3; //#1 spot from left right
float sensorValue = 0; // variable to store the value coming from the sensor
/////////////////////////////////
float newValue=0.0; // the average value to be used as distance
int arraysize = 5;
int rangevalue[] = {
0, 0, 0, 0, 0};
/////////////////////////////////
float distance = 80.0; // to decide which is the max distance of interaction
float distance2= 20.0;//distance closest to the object, to start flickering lights
float tolerance=90.0;
float previousValue=0.0; //to make the max distance more tolerant, so it doesn’t flickr
//for pw input
int pwpin=13;//digital pin, not only pwm, any digital pin
//
///for effects moving away and towards
//towards if more analog
//away is more discrete, stronger diference
float from=distance;// because we start with the LED off
float to=distance;
float stablestate=0.0;
//
float firstAway=0.0;
float stepAway=-8.0;
/////////////// stand by animation variables
float startTime=0.0;
double previousMillis=0.0;
boolean BstartTime=false;
int numberIterations=0;
boolean iterations=false;
int steps=0;
int initialPosition=0;
int mothDelay=22;//milliseconds for a moth to light
int dimmSpeed=50;//how fast the brightess is reduced
int dimmSpeed2=20;
boolean right=true;
int standByBrightness=250;//max value for standby animation grightness
boolean boolFlicker=false;
int fickerTime=100;
int countFlick=0;
//////////////
void setup() {
// declare the ledPin as an OUTPUT:
pinMode(ledPin, OUTPUT);
pinMode(pwpin,INPUT);
Serial.begin(9600);
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
pinMode(ledPin4, OUTPUT);
randomSeed(analogRead(0));
}
void loop() {
// read the value from the sensor:
for(int i = 0; i < arraysize; i++){
sensorValue = pulseIn(pwpin,HIGH);
sensorValue = sensorValue/147.0; //from sensor specifics on PW reading
rangevalue[i] = sensorValue;
}
//organize values
isort(rangevalue, arraysize);
//select middle value
int midpoint = arraysize/2;
newValue = rangevalue[midpoint];
newValue = discardOutlierValues(newValue, previousValue,tolerance);
previousValue = newValue;
Serial.println(newValue);
if(newValue > distance2 && newValue <= distance && newValue!=0){
Serial.println(“someone”);
countFlick=0;
//see if it is going away or getting closer
to = newValue;//where the person is currently standing
if(from!=to){
stablestate = checkAction(from,to);//check if we increment ligth or not
}
else{
//if there is no change in position
//we light the LED with the last number
//Serial.println(“stable”);
//analogWrite(ledPin, 255.0-stablestate);
}
from = to;// this is to start from the new position
BstartTime=false;
}else if ((newValue <= distance2) && (newValue >0.0)){
int sel = int(random(0,5));
if(countFlick<30){
Serial.print(“flicker”);
flicker(sel);
}
countFlick++;
if(countFlick>90){
countFlick=0;
Serial.print(“flickerEND”);
}
}
else{
//standby behaviors
standBy();
}
}
/////my funcitons
float checkAction(int f, int t){
//first check de direction the person moved, away or towards the object
float valueMapped=0.0;
if(f-t<0){
//going away from object
//reduce light
//float aux = 255.0-valueMapped;
//Serial.println(aux);
////////////The desired efect is that at dimms down at bigger steps
//float aux = firstAway-t;
if(firstAway-t < stepAway){
//Serial.println(aux);
//Serial.println(“away”);
valueMapped = (newValue – 4.0) * (255.0 – 0.0) / (distance – 4.0) + 0.0;//map(newValue,4.0,distance,0.0,255.0);
analogWrite(ledPin, 255.0-valueMapped);
analogWrite(ledPin1, 255.0-valueMapped);
analogWrite(ledPin2, 255.0-valueMapped);
analogWrite(ledPin3, 255.0-valueMapped);
analogWrite(ledPin4, 255.0-valueMapped);
firstAway=t;
}
}
else if (f-t > 0){
//its getting closer to object
//increment light
//Serial.println(“towards”);
valueMapped = (newValue – 4.0) * (255.0 – 0.0) / (distance – 4.0) + 0.0;//map(newValue,4.0,distance,0.0,255.0);
analogWrite(ledPin, 255.0-valueMapped);
analogWrite(ledPin1, 255.0-valueMapped);
analogWrite(ledPin2, 255.0-valueMapped);
analogWrite(ledPin3, 255.0-valueMapped);
analogWrite(ledPin4, 255.0-valueMapped);
firstAway=t;
}
return valueMapped;
}
//*********************************************************************************
// sort function
void isort(int *a, int n)
// *a is an array pointer function
{
for (int i = 1; i < n; ++i)
{
int j = a[i];
int k;
for (k = i – 1; (k >= 0) && (j < a[k]); k–)
{
a[k + 1] = a[k];
}
a[k + 1] = j;
}
}
///////////////////////////////////
float discardOutlierValues(float newValue,float previousValue,float tolerance){
float r=0.0;
if(newValue-previousValue >= tolerance){
r = previousValue;
}
else{
r = newValue;
}
return r;
}
///////////////////////////////////
void standBy(){
//logic te be carried out when there is noone in range
//it selects a random time to start working first
if(BstartTime == false){
analogWrite(ledPin,0);
analogWrite(ledPin1,0);
analogWrite(ledPin2,0);
analogWrite(ledPin3,0);
analogWrite(ledPin4,0);
startTime = 0.1;//random(0.5, 2);
BstartTime=true;
iterations=false;
Serial.println(“standby”);
previousMillis = millis();
}
//count to that start time, if it is not in iteration mode
if(BstartTime == true && iterations==false){
if(millis() – previousMillis>((startTime*60)*1000)){
// we got to the desired start time
Serial.println(“start”);
numberIterations = int(random(1,4));
//now it can start to iterate an animation
//for a numberIterations
iterations=true;
previousMillis = millis();
}
}
//it has passed to iterations mode
if(iterations==true){
if(numberIterations>0){
//only come inside when there is an animation to be triggered
//Serial.println(“iterating”);
//select a random time for the iteration(animatio, to start)
float iterateStart = random(0.2,1.0);
if(millis() – previousMillis> (iterateStart * 1000)){
Serial.print(“iterate “);
Serial.println(numberIterations);
//select steps for the iteration
randomSeed(analogRead(0));
steps=5;//floor(random(6,17));//16 max steps
initialPosition = int(random(1,3));
//do animation
doAnimation(steps,initialPosition);
// analogWrite(ledPin,0);
// analogWrite(ledPin1,0);
// analogWrite(ledPin2,0);
// analogWrite(ledPin3,0);
// analogWrite(ledPin4,0);
Serial.println(“finishedAnimation”);
previousMillis = millis();
//reduce numberIterations
numberIterations –;
}
if(newValue > distance2 && newValue <= distance){
//to interrupt animation if someone enters the interactive area
numberIterations = 0;
}
}
else{
iterations = false;
}
}
}
///////////////////////////////////////////////////
void flicker(int sel){
//it makes a given pin flicker
int rand = int(random(3,5));
int valueMapped = (distance2 – 4.0) * (255.0 – 0.0) / (distance – 4.0) + 0.0;//map(newValue,4.0,distance,0.0,255.0);
analogWrite(ledPin, 255.0- valueMapped);
analogWrite(ledPin1, 255.0- valueMapped);
analogWrite(ledPin2, 255.0- valueMapped);
analogWrite(ledPin3, 255.0- valueMapped);
analogWrite(ledPin4, 255.0- valueMapped);
if (sel==0){
for(int i =0;i<rand;i++){
analogWrite(ledPin, 255.0);
delay(fickerTime);
analogWrite(ledPin, 255.0- valueMapped);
delay(fickerTime);
}
}else if(sel==1){
for(int i =0;i<rand;i++){
analogWrite(ledPin1, 255.0);
delay(fickerTime);
analogWrite(ledPin1, 255.0- valueMapped);
delay(fickerTime);
}
}else if(sel==2){
for(int i =0;i<rand;i++){
analogWrite(ledPin2, 255.0);
delay(fickerTime);
analogWrite(ledPin2, 255.0- valueMapped);
delay(fickerTime);
}
}else if(sel==3){
for(int i =0;i<rand;i++){
analogWrite(ledPin3, 255.0);
delay(fickerTime);
analogWrite(ledPin3, 255.0- valueMapped);
delay(fickerTime);
}
}else if(sel==4){
for(int i =0;i<rand;i++){
analogWrite(ledPin4, 255.0);
delay(fickerTime);
analogWrite(ledPin4, 255.0- valueMapped);
delay(fickerTime);
}
}
}
///////////////////////////////////////////////////
void doAnimation(int s, int ip){
//s->steps, number of times the light moves
//ip->initial position to start animation, it will be used for the new positon also
//the light move in a “moth” like manner,
//from the initial position, to a random neighbor positon
//a number s of steps
int lightOrder [s];
int intensityOrder[s];
int dir=1;
//initialize the arrays with zero values
for(int i=0;i<s;i++){
lightOrder[i]=0;
intensityOrder[i]=0;
}
int stepCounter=0;
//initialize the first value of the arrays
if(ip==2){
ip=5;
dir=2;
}
lightOrder[stepCounter]=ip;
intensityOrder [stepCounter]=standByBrightness;
while(stepCounter<s){//while there are steps left
//go through the array
for(int i=0;i<s;i++){
if(lightOrder[i] != 0){
//ask for position
if(lightOrder[i]==1){
//it is ledpin4
analogWrite(ledPin4,intensityOrder [i]);
}
else if(lightOrder[i]==2){
//it is ledpin3
analogWrite(ledPin3,intensityOrder [i]);
}
else if(lightOrder[i]==3){
//it is ledpin2
analogWrite(ledPin2,intensityOrder [i]);
}
else if(lightOrder[i]==4){
//it is ledpin1
analogWrite(ledPin1,intensityOrder [i]);
}
else if(lightOrder[i]==5){
//it is ledpin
analogWrite(ledPin,intensityOrder [i]);
}
//reduce own lighting
intensityOrder [i] = intensityOrder [i]-dimmSpeed;
delay(mothDelay);
}
else{
//generate a new step!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
if(dir==1){
//right
ip++;
}else{
ip–;
}
//store new position in array
lightOrder[i]=ip;
intensityOrder [i]=standByBrightness;
// Serial.print(“intensity 0: “);
// Serial.print(intensityOrder[0]);
// Serial.print(“order 0: “);
// Serial.println(lightOrder[0]);
// Serial.println(“–”);
break;
}
}
stepCounter++;
}
boolean ending = true;
int countZeros=0;
while(ending){
// //Serial.println(“ending”);
for(int i=0;i<s;i++){
//reduce own lighting
intensityOrder [i] = intensityOrder [i]-dimmSpeed2;
if(intensityOrder [i] <= 0){
intensityOrder [i]=0;
}
//ask for position
// Serial.print(i);
// Serial.print(” “);
// Serial.print(lightOrder[i]);
// Serial.print(” “);
// Serial.print(“intensity: “);
// Serial.println(intensityOrder [i]);
if(lightOrder[i]==1){
//it is ledpin4
analogWrite(ledPin4,intensityOrder [i]);
}
else if(lightOrder[i]==2){
//it is ledpin3
analogWrite(ledPin3,intensityOrder [i]);
}
else if(lightOrder[i]==3){
//it is ledpin2
analogWrite(ledPin2,intensityOrder [i]);
}
else if(lightOrder[i]==4){
//it is ledpin1
analogWrite(ledPin1,intensityOrder [i]);
}
else if(lightOrder[i]==5){
//it is ledpin
analogWrite(ledPin,intensityOrder [i]);
}
delay(mothDelay);
//}
} //for end
//check if all are off
countZeros=0;
for(int i=0;i<s;i++){
if(intensityOrder[i]==0){
countZeros++;
}
}
if(countZeros==s){
//all are off
ending=false;
}
if(right==true){
right=false;
}
else{
right=true;
}
}
}
