Hi,

I am trying to model an 10 x 10 (or greater) array of automatic nightlights. These are the kind that turn on when it is dark and off when it is light. I want to be able to individually rotate the nightlights so that the light sensor can face any direction I chose but otherwise be fixed in position (at least for now).

I actually have made this using real nightlights and I get interesting behavior but there are problems with the tremendous manufacturing variability in sensor threshold, etc. I made a microcontroller version and that helped but there are some variables I want to play with such as delay and hysteresis that can profoundly affect behavior but individually programming 100 micros is tedious. So I want to model it and then implement the rules in micros.

I am new to processing and not a big programmer either. I figured out how to create a nightlight class and a way to make a light with an inverse square fall-off in illuminence but am a bit stuck on how to model the light sensor.

I don't think I really want to do this in a cellular automata fashion as the lights are separated by some distance and the light is not binary but a gradient. Also, a sensor should be able to see beyond its immediate neighbors if there is a concentration of lights switched on creating a larger illuminence radius...

Hints towards an approach would be most greatly appreciated.

Thanks,
Chabo

Since every nightlight can potentially contribute to the light level at any sensor then effectively have a n² problem. What it means is that for each sensor you have to measure the light contribution from every other nightlight so 100 nightlights then 100 x 100 calculations per step, double the nightlights and you quadruple the calculations.

Of course there are techniques to reduce the amount of 'runtime' computation for instance if the nightlight positions are fixed then then for each sensor we can predetermine which nightlights should be considered using the inverse square law.

This can be reduced further (possibly) since the sensor has a 'detection zone' so will not be pointing directly at some nightlights.

Quote:


For the actual sensor you might consider a finite state machine approach where each sensor has a number of states unlike the true/false approach of cellular automata you can use an integer value to represent a state e.g.

• waiting to switch off
• waiting to switch on
• turn on
• turn off

You can then use System.currentTimeMillis() to get the current time in milliseconds. If you do this for each sensor update  then you know how long has passed since the last update and adjust the state accordingly.

Hope this is useful.


Hope this helps

Hi,
interesting project.  I am wondering if you couldn't do something much simpler in Processing, though: just determine the amount of light hitting a sensor by a function of its distance ( dist() ) to  each relevant lightsource.  

Or, with your current gradient technique, I'm not sure why you can't just grab the pixel at point (x,y) and test its brightness?
--Ben

Thanks Ben,

Quote:


Duh, this seems so simple! I just need to sample a few lightsources within the sensor view, average them and compare to a threshold value. Not exactly sure what data structure to use to represent the lights. Is there some kind of array manipulation that would allow me to test only those lightsources that are a certain direction from the sensor?
hmmm... I'll keep searching. Thanks for everyone's help.

Chabo

Quote:


Not quite but if you have two nightlights (n0, n1) at positions (x0, y0) and (x1, y1) then the code
Code:

degrees(atan2(y1 - y0, x1 - x0)); 

returns a value between -180.0 and 180.0 representing the angle of n1 with respect to n0, you could then compare this with the angle of the sensor on n0 to see how close they are.