buzz_examples

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision		 Previous revision
buzz_examples [2016/09/02 13:11] – [Hexagonal Pattern Formation] ilpincybuzz_examples [2018/03/18 22:58] (current) – root
Line 1: Line 1:
 ====== Buzz Example Gallery ====== ====== Buzz Example Gallery ======
  
-===== Generic robots ====== +===== Calculation of a Distance Gradient =====
- +
-==== Calculation of a Distance Gradient ====+
  
 The aim of this code is to have a group of robots form a distance gradient from a source. The aim of this code is to have a group of robots form a distance gradient from a source.
Line 42: Line 40:
 </code> </code>
  
-==== Hexagonal Pattern Formation ====+===== Hexagonal Pattern Formation =====
  
 Hexagonal patterns can be formed in a simple way by mimicking particle interaction. A simple model of particle interaction is the [[https://en.wikipedia.org/wiki/Lennard-Jones_potential|Lennard-Jones potential]], which we use in the following code in a slightly modified way. Instead of the big exponents (12 and 6), we use the exponents 4 and 2, which give us smaller but more manageable numbers. Hexagonal patterns can be formed in a simple way by mimicking particle interaction. A simple model of particle interaction is the [[https://en.wikipedia.org/wiki/Lennard-Jones_potential|Lennard-Jones potential]], which we use in the following code in a slightly modified way. Instead of the big exponents (12 and 6), we use the exponents 4 and 2, which give us smaller but more manageable numbers.
Line 50: Line 48:
 <code buzz hexagon.bzz> <code buzz hexagon.bzz>
 # We need this for 2D vectors # We need this for 2D vectors
-include "vec2.bzz"+# Make sure you pass the correct include path to "bzzc -I <path1:path2> ..." 
 +include "include/vec2.bzz"
  
 # Lennard-Jones parameters # Lennard-Jones parameters
-TARGET  = 283.0 +TARGET     = 283.0 
-EPSILON = 150.0+EPSILON    = 150.0
  
 # Lennard-Jones interaction magnitude # Lennard-Jones interaction magnitude
Line 63: Line 62:
 # Neighbor data to LJ interaction vector # Neighbor data to LJ interaction vector
 function lj_vector(rid, data) { function lj_vector(rid, data) {
-  return math.vec2.newp(lj(data.distance, TARGET, EPSILON), data.azimuth)+  return math.vec2.newp(lj_magnitude(data.distance, TARGET, EPSILON), data.azimuth)
 } }
  
 # Accumulator of neighbor LJ interactions # Accumulator of neighbor LJ interactions
-function sum(rid, data, accum) {+function lj_sum(rid, data, accum) {
   return math.vec2.add(data, accum)   return math.vec2.add(data, accum)
 } }
Line 74: Line 73:
 function hexagon() { function hexagon() {
   # Calculate accumulator   # Calculate accumulator
-  var accum = neighbors.map(to_lj).reduce(lj_sum, math.vec2.new(0.0, 0.0))+  var accum = neighbors.map(lj_vector).reduce(lj_sum, math.vec2.new(0.0, 0.0))
   if(neighbors.count() > 0)   if(neighbors.count() > 0)
-    math.vec2.scale(accum, neighbors.count())+    math.vec2.scale(accum, 1.0 / neighbors.count())
   # Move according to vector   # Move according to vector
-  goto(accum.x, accum.y);+  goto(accum.x, accum.y)
 } }
  
Line 95: Line 94:
 </code> </code>
  
-==== Square Pattern Formation ====+===== Square Pattern Formation ===== 
 + 
 +To form square lattice, we can build upon the previous example. The insight is to notice that, in a square lattice, we can color the nodes forming the lattice with two shades, e.g., red and blue, and then mimic the [[http://www.metafysica.nl/turing/nacl_complex_motif_4.gif|crystal structure of kitchen salt]]. In this structure, if two nodes have different colors, they stay at a distance //D//; if they have the same color, they stay at a distance //D// * sqrt(2). 
 + 
 +With this idea in mind, the following script divides the robots in two swarms: those with an even id and those with an odd id. Then, using ''neighbors.kin()'' and ''neighbors.nonkin()'', the robots can distinguish which distance to pick and calculate the correct interaction vector. 
 + 
 +<code buzz square.bzz> 
 +# We need this for 2D vectors 
 +# Make sure you pass the correct include path to "bzzc -I <path1:path2> ..." 
 +include "include/vec2.bzz"
  
-<code buzz hexagon.bzz> 
 # Lennard-Jones parameters # Lennard-Jones parameters
-TARGET_KIN     = 283. +TARGET_KIN     = 283.0 
-EPSILON_KIN    = 150. +EPSILON_KIN    = 150.0 
-TARGET_NONKIN  = 200. +TARGET_NONKIN  = 200.0 
-EPSILON_NONKIN = 100.+EPSILON_NONKIN = 100.0
  
 # Lennard-Jones interaction magnitude # Lennard-Jones interaction magnitude
-function lj(dist, target, epsilon) {+function lj_magnitude(dist, target, epsilon) {
   return -(epsilon / dist) * ((target / dist)^4 - (target / dist)^2)   return -(epsilon / dist) * ((target / dist)^4 - (target / dist)^2)
 } }
  
-# Neighbor data to kin LJ interaction +# Neighbor data to LJ interaction vector 
-function to_lj_kin(rid, data) { +function lj_vector_kin(rid, data) { 
-  data.x = lj(data.distance, TARGET_KIN, EPSILON_KIN) * math.cos(data.azimuth) +  return math.vec2.newp(lj_magnitude(data.distance, TARGET_KIN, EPSILON_KIN), data.azimuth)
-  data.y = lj(data.distance, TARGET_KIN, EPSILON_KIN) * math.sin(data.azimuth) +
-  return data+
 } }
  
-# Neighbor data to non-kin LJ interaction +# Neighbor data to LJ interaction vector 
-function to_lj_nonkin(rid, data) { +function lj_vector_nonkin(rid, data) { 
-  data.x = lj(data.distance, TARGET_NONKIN, EPSILON_NONKIN) * math.cos(data.azimuth) +  return math.vec2.newp(lj_magnitude(data.distance, TARGET_NONKIN, EPSILON_NONKIN), data.azimuth)
-  data.y = lj(data.distance, TARGET_NONKIN, EPSILON_NONKIN) * math.sin(data.azimuth) +
-  return data+
 } }
  
 # Accumulator of neighbor LJ interactions # Accumulator of neighbor LJ interactions
-function sum(rid, data, accum) { +function lj_sum(rid, data, accum) { 
-  accum.x = accum.x + data.x +  return math.vec2.add(data, accum)
-  accum.y = accum.y + data.y +
-  return accum+
 } }
  
 # Calculates and actuates the flocking interaction # Calculates and actuates the flocking interaction
-function flock() { +function square() {
-  # Create accumulator +
-  var accum +
-  accum = {} +
-  accum.x = 0 +
-  accum.y = 0+
   # Calculate accumulator   # Calculate accumulator
-  accum = neighbors.kin().map(to_lj_kin).reduce(sum, accum) +  var accum = neighbors.kin().map(lj_vector_kin).reduce(lj_sum, math.vec2.new(0.0, 0.0)) 
-  accum = neighbors.nonkin().map(to_lj_nonkin).reduce(sum, accum) +  accum = neighbors.nonkin().map(lj_vector_nonkin).reduce(lj_sum, accum) 
-  if(neighbors.count() > 0) { +  if(neighbors.count() > 0) 
-    accum.x = accum.x / neighbors.count() +    math.vec2.scale(accum, 1.0 / neighbors.count())
-    accum.y = accum.y / neighbors.count() +
-  }+
   # Move according to vector   # Move according to vector
-  goto(accum.x, accum.y);+  goto(accum.x, accum.y)
 } }
  
 # Executed at init time # Executed at init time
 function init() { function init() {
 +  # Divide the swarm in two sub-swarms
   s1 = swarm.create(1)   s1 = swarm.create(1)
-  s1.join() 
   s1.select(id % 2 == 0)   s1.select(id % 2 == 0)
   s2 = s1.others(2)   s2 = s1.others(2)
Line 158: Line 152:
 # Executed every time step # Executed every time step
 function step() { function step() {
-  s1.exec(flock)     +  s1.exec(square) 
-  s2.exec(flock)+  s2.exec(square)
 } }
  
Line 166: Line 160:
 } }
 </code> </code>
- 
-===== Wheeled robots ===== 
- 
-===== Flying robots ===== 
  • buzz_examples.1472821867.txt.gz
  • Last modified: 2016/09/02 13:11
  • by ilpincy