BP Wiki - User contributions [en]

Dining Philosophers

2014-05-12T08:58:59Z

Assaf: /* Dining Philosophers */

= Dining Philosophers =
In this example one can see (a) how multiple behaviors coexist independently of each other, with very simple rules for each and (b) how model-checking can help find conflicts and other desired and undesired properties.

The example can be found in the BPJ project in the source package bp.state.unittest.ph .

= Problem Description =

In the famous dining philosophers problem several philosophers are sitting at a circular table, and are either eating or thinking. At the center is a large bowl of spaghetti, which requires two forks to serve and to eat. A fork is placed in between each pair of adjacent philosophers. Each philosopher may only use the fork to her left and the fork to her right. When a philosopher finishes eating, she puts down the two forks and begins thinking again. Our present goal is to check whether deadlocks, or other starvation conditions, may occur under various philosopher behaviors.

The problem is programmed/modeled behaviorally as follows:
== Events ==
The events are the picking up and the putting down of a given fork by a given philosopher (e.g., PickUp-F2-by-P2 or PutDown-F1-by-P2)

== B-Threads ==
There is a b-thread for the behavior of each philosopher and a b-thread for each fork. In the classical
version, each philosopher b-thread repeatedly requests the sequence of events representing her picking up the fork to her right, picking up the fork to her left, putting down the right-hand fork, and then putting down the left-hand one. Each fork's b-thread
repeatedly waits for an event of picking up the fork by either of its two adjacent philosophers and then blocks its picking up
(again)until the fork is put down.

The application assists the model-checking search by labeling the four philosopher behavior states
T(thinking -- forks down), 1 (one fork up), E (eating -- two forks up) and F (finished eating -- one fork down).

The fork b-thread states are D (down) and U (up).

We use model-checking to look for violations of liveness properties, and
detect the deadlock conditions that are possible under this classical behavior.

For example, a path to a deadlock state in the case of 3 philosophers is displayed as:

Verification failed:
init->[T, D, T, D, T, D]
PickUp-F2-by-P2->[T, D, T, D, 1, U]
PickUp-F1-by-P1->[T, D, 1, U, 1, U]
PickUp-F0-by-P0->[1, U, 1, U, 1, U]
[1, U, 1, U, 1, U] is a deadlock state

where each line of the form "<event> -> <State>" describes a composite states of the entire program along the path and the event whose triggering led the program to transition from the preceding state to the current.

In the symmetry breaking approach one of the philosophers is left-handed, and thus first picks up the fork to her left, rather than the one to her right. As expected, this setup is then proven by model-checking to be deadlock-free, following checking of all possible states.

For liveness testing, the philosophers behavior b-threads marks the non-eating states as hot, and the model-checker is then
able to detect the starvation conditions that are possible if fairness is weak.

Dining Philosophers

2014-05-12T08:58:36Z

Assaf: /* Dining Philosophers */

= Dining Philosophers =
In this example one can see (a) how multiple behaviors coexist independently of each other, with very simple rules for each and (b) how model-checking can help find conflicts and other desired and undesired properties.

The example can be found in the BPJ project under bp.state.unittest.ph .

= Problem Description =

In the famous dining philosophers problem several philosophers are sitting at a circular table, and are either eating or thinking. At the center is a large bowl of spaghetti, which requires two forks to serve and to eat. A fork is placed in between each pair of adjacent philosophers. Each philosopher may only use the fork to her left and the fork to her right. When a philosopher finishes eating, she puts down the two forks and begins thinking again. Our present goal is to check whether deadlocks, or other starvation conditions, may occur under various philosopher behaviors.

The problem is programmed/modeled behaviorally as follows:
== Events ==
The events are the picking up and the putting down of a given fork by a given philosopher (e.g., PickUp-F2-by-P2 or PutDown-F1-by-P2)

== B-Threads ==
There is a b-thread for the behavior of each philosopher and a b-thread for each fork. In the classical
version, each philosopher b-thread repeatedly requests the sequence of events representing her picking up the fork to her right, picking up the fork to her left, putting down the right-hand fork, and then putting down the left-hand one. Each fork's b-thread
repeatedly waits for an event of picking up the fork by either of its two adjacent philosophers and then blocks its picking up
(again)until the fork is put down.

The application assists the model-checking search by labeling the four philosopher behavior states
T(thinking -- forks down), 1 (one fork up), E (eating -- two forks up) and F (finished eating -- one fork down).

The fork b-thread states are D (down) and U (up).

We use model-checking to look for violations of liveness properties, and
detect the deadlock conditions that are possible under this classical behavior.

For example, a path to a deadlock state in the case of 3 philosophers is displayed as:

Verification failed:
init->[T, D, T, D, T, D]
PickUp-F2-by-P2->[T, D, T, D, 1, U]
PickUp-F1-by-P1->[T, D, 1, U, 1, U]
PickUp-F0-by-P0->[1, U, 1, U, 1, U]
[1, U, 1, U, 1, U] is a deadlock state

where each line of the form "<event> -> <State>" describes a composite states of the entire program along the path and the event whose triggering led the program to transition from the preceding state to the current.

In the symmetry breaking approach one of the philosophers is left-handed, and thus first picks up the fork to her left, rather than the one to her right. As expected, this setup is then proven by model-checking to be deadlock-free, following checking of all possible states.

For liveness testing, the philosophers behavior b-threads marks the non-eating states as hot, and the model-checker is then
able to detect the starvation conditions that are possible if fairness is weak.

Dining Philosophers

2014-05-12T08:56:55Z

Assaf: /* B-Threads */

= Dining Philosophers =
In this example one can see (a) how multiple behaviors coexist independently of each other, with very simple rules for each and (b) how model-checking can help find conflicts and other desired and undesired properties.

= Problem Description =

In the famous dining philosophers problem several philosophers are sitting at a circular table, and are either eating or thinking. At the center is a large bowl of spaghetti, which requires two forks to serve and to eat. A fork is placed in between each pair of adjacent philosophers. Each philosopher may only use the fork to her left and the fork to her right. When a philosopher finishes eating, she puts down the two forks and begins thinking again. Our present goal is to check whether deadlocks, or other starvation conditions, may occur under various philosopher behaviors.

The problem is programmed/modeled behaviorally as follows:
== Events ==
The events are the picking up and the putting down of a given fork by a given philosopher (e.g., PickUp-F2-by-P2 or PutDown-F1-by-P2)

== B-Threads ==
There is a b-thread for the behavior of each philosopher and a b-thread for each fork. In the classical
version, each philosopher b-thread repeatedly requests the sequence of events representing her picking up the fork to her right, picking up the fork to her left, putting down the right-hand fork, and then putting down the left-hand one. Each fork's b-thread
repeatedly waits for an event of picking up the fork by either of its two adjacent philosophers and then blocks its picking up
(again)until the fork is put down.

The application assists the model-checking search by labeling the four philosopher behavior states
T(thinking -- forks down), 1 (one fork up), E (eating -- two forks up) and F (finished eating -- one fork down).

The fork b-thread states are D (down) and U (up).

We use model-checking to look for violations of liveness properties, and
detect the deadlock conditions that are possible under this classical behavior.

For example, a path to a deadlock state in the case of 3 philosophers is displayed as:

Verification failed:
init->[T, D, T, D, T, D]
PickUp-F2-by-P2->[T, D, T, D, 1, U]
PickUp-F1-by-P1->[T, D, 1, U, 1, U]
PickUp-F0-by-P0->[1, U, 1, U, 1, U]
[1, U, 1, U, 1, U] is a deadlock state

where each line of the form "<event> -> <State>" describes a composite states of the entire program along the path and the event whose triggering led the program to transition from the preceding state to the current.

In the symmetry breaking approach one of the philosophers is left-handed, and thus first picks up the fork to her left, rather than the one to her right. As expected, this setup is then proven by model-checking to be deadlock-free, following checking of all possible states.

For liveness testing, the philosophers behavior b-threads marks the non-eating states as hot, and the model-checker is then
able to detect the starvation conditions that are possible if fairness is weak.

Dining Philosophers

2014-05-12T08:56:24Z

Assaf: Created page with "= Dining Philosophers = In this example one can see (a) how multiple behaviors coexist independently of each other, with very simple rules for each and (b) how model-checking ..."

= Dining Philosophers =
In this example one can see (a) how multiple behaviors coexist independently of each other, with very simple rules for each and (b) how model-checking can help find conflicts and other desired and undesired properties.

= Problem Description =

In the famous dining philosophers problem several philosophers are sitting at a circular table, and are either eating or thinking. At the center is a large bowl of spaghetti, which requires two forks to serve and to eat. A fork is placed in between each pair of adjacent philosophers. Each philosopher may only use the fork to her left and the fork to her right. When a philosopher finishes eating, she puts down the two forks and begins thinking again. Our present goal is to check whether deadlocks, or other starvation conditions, may occur under various philosopher behaviors.

The problem is programmed/modeled behaviorally as follows:
== Events ==
The events are the picking up and the putting down of a given fork by a given philosopher (e.g., PickUp-F2-by-P2 or PutDown-F1-by-P2)

== B-Threads ==
There is a b-thread for the behavior of each philosopher and a b-thread for each fork. In the classical
version, each philosopher b-thread repeatedly requests the sequence of events representing her picking up the fork to her right, picking up the fork to her left, putting down the right-hand fork, and then putting down the left-hand one. Each fork's b-thread
repeatedly waits for an event of picking up the fork by either of its two adjacent philosophers and then blocks its picking up
(again)until the fork is put down.

==
The application assists the model-checking search by labeling the four philosopher behavior states
T(thinking -- forks down), 1 (one fork up), E (eating -- two forks up) and F (finished eating -- one fork down).

The fork b-thread states are D (down) and U (up).

We use model-checking to look for violations of liveness properties, and
detect the deadlock conditions that are possible under this classical behavior.

For example, a path to a deadlock state in the case of 3 philosophers is displayed as:

Verification failed:
init->[T, D, T, D, T, D]
PickUp-F2-by-P2->[T, D, T, D, 1, U]
PickUp-F1-by-P1->[T, D, 1, U, 1, U]
PickUp-F0-by-P0->[1, U, 1, U, 1, U]
[1, U, 1, U, 1, U] is a deadlock state

where each line of the form "<event> -> <State>" describes a composite states of the entire program along the path and the event whose triggering led the program to transition from the preceding state to the current.

In the symmetry breaking approach one of the philosophers is left-handed, and thus first picks up the fork to her left, rather than the one to her right. As expected, this setup is then proven by model-checking to be deadlock-free, following checking of all possible states.

For liveness testing, the philosophers behavior b-threads marks the non-eating states as hot, and the model-checker is then
able to detect the starvation conditions that are possible if fairness is weak.

BPJ Programming Examples

2014-05-12T08:41:56Z

Assaf: /* BPJ Programming Examples */

Download

2014-05-12T08:38:33Z

Assaf:

= Download and Installation =

*Operating System:
** Windows or Linux.
*IDE Requirements:
** BPJ does not depend on any specific environment. The library and examples can be used with the latest version of Eclipse, or in any other Java programming environment.
* Downloading Eclipse:
** Download Eclipse classic for Java from http://www.eclipse.org/.
** Extract the downloaded files – no installation is needed.
*Downloading and Configuring BPJ:
** Download [http://www.wisdom.weizmann.ac.il/~bprogram/code/BPJ.zip BPJ.zip]
** In Eclipse, import the project BPJCore110 as follows:
*** File -> Import -> General -> Existing Project into Work Space -> BPJCore110
** Rebuild the project.
** Import run configurations (optional -- Required mainly for running model-checking examples):
*** File -> Import -> Run/Debug. Then select all available configurations

BP Blockly User Guide

2014-05-12T08:30:14Z

Assaf:

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =

* When in BP for Blockly (under FireFox), click the drop-down menu and select "Hot and Cold".

This example contains three enabled b-threads and one disabled b-thread.

* 1. Requesting the event addHot 10 times.
* 2. Requesting the event addCold 10 times.
* 3. Forcing the alternation of the two events by waiting for two occurrences of addHot event and blocking the addCold, and vice versa, in a loop.

Experimenting:
* Try disabling the third b-thread. Both remaining b-threads will run and events will alternate, per the round robin scheduling in this version of BP for Blockly.
* Then try disabling the first b-thread. Only addCold events will be triggered.
* Then enable the third b-thread, and run the program again. No events will be triggered due the blocking of addCold.
* Click on the HTML tab and examine the HTML actuator code that displays the event text upon triggering of the events. In another implementation this code could call a JavaScript method that actually opens a water tap for a few seconds.
* The 4th b-thread was loaded disabled. This is an "actuator" b-thread that reacts to the addHot and addCold events. In this case, by displaying a window with the event text. Again, this b-thread could call a JavaScript method that performs a desired action.

= Example: The Rocket Landing Game Example =

* Download the zipped version of BP Blockly.
* To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* BtnNorth: User clicked North
* BtnSouth: User clicked South
* TimeTick: A unit of time passed
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* (Same for west, north and south) . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketNorth: Request to redraw rocket 10 pixels further to the north
* RocketSouth: Request to redraw rocket 10 pixels further to the south
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* PadEast: The application wishes the pad to move 10 pixels further to the east
* PadNorth: The application wishes the pad to move 10 pixels further to the north
* PadSouth: The application wishes the pad to move 10 pixels further to the south
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides two additional examples
* A nullification game: See explanation in [http://www.wisdom.weizmann.ac.il/~bprogram/pres/agere2012AuthorVersion.pdf AGERE 2012 paper]
* A basic game of Tic-Tac-Toe: This example, with very basic strategies, demonstrates the instantiation of a b-thread according to a parameter list. For example, the application block "all Squares" represents a list of all possible squares, and a b-thread is instantiated for each one of these, waiting for a user click in this square, and requesting an X event in the same square.

Sudoku

2014-04-29T09:48:39Z

Assaf: /* Playing b-threads */

= Sudoku =
In this example one can see two properties of behavioral programming
* How different heuristics and pieces of knowledge about the problem domain can be used separately to program an application
* How model-checking can be used to help find a desired scenario.

= Requirements =
In the cells of a 9X9 grid which is also divided into 9 3X3 boxes, place the digits 1-9 such that in each row, column and box, each digit appears exactly once.

= Events =

* Move: A single event class with 9X9X9 = 721 instances, indicating the writing of a given digit in a given cell. The class has the following data fields:

** number: the digit written in the cell (1-9)
** row: The row of the cell (1-9)
** col: the column of the cell (1-9)
** boxrow: The row of the 3X3 box in which this cell resides (1-3)
** boxcol: the column of the 3X3 box in which this cell resides (1-3)

When enough data is provided, the strategies below are sufficient for solving the game.
When not enough data is provided, model checking explores the different possibilities until a solution is found.

== Playing b-threads ==
* MakeGivenMoves: This b-thread provides the opening input to the riddle - filling in the known cells.
* DefaultMove: Each of the 81 instances of this b-thread class, is associated with a cell, and requests all possible 9 digits. Once an event occurs, all other events for the cell are blocked.
* DetectWin: This b-thread simply counts until 81 events have been triggered. The correctness of the solution is guaranteed
* EliminateTwoInABox: This b-thread tries to write a number in a cell after the same number was written in two other columns of this box. It does not check if the cell is occopied or if the digit was already written in the present column - this is provided by event-blocking in other b-threads.
* PlaceANumberInARow: With an instance for each digit and each row, this b-thread tries to place a particular digit in the row. It waits till there is only one place to put it, and then requests the corresponding event.
* PlaceANumberInAColumn: With an instance for each digit and each row, this b-thread tries to place a particular digit in the Column. It waits till there is only one place to put it, and then requests the corresponding event.
* PlaceANumberInABox: With an instance for each digit and each place in the box, this b-thread tries to place a particular digit in the box. It waits till there is only one place to put it, and then requests the corresponding event.
* EliminateEight: For each cell, an instance of this b-thread checks the possibilities for the cell, and eliminates possibilities as conflicting events occur elsewhere. When the number of remaining possibilities is one, the b-thread requests the remaining digit.

== b-threads that support model-checking ==
PruneWhenNoSolution: This b-thread requests an event at a low priority. If it is triggered, it means that all move events are blocked, hence the game has failed. It then calls the model-checking API to prune the search.

== Design Notes ==
* The b-thread DefaultMove could have been split into two. One that requests the default moves and terminates, and one that waits for any event in a cell and blocks all alternative digits in the cell. The present design works because a pending request of DefaultMove is unified with any granted request due to the stratgies/heuristics b-threads, as well as the GivenMoves b-thread.

== Download ==
# Click [[Media:Sudoku1.zip | here]] to download the sudoku example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The sudoku example project is now part of your workspace.
##Refer to the readme.txt file for execution instructions.

BPJ Programming Examples

2014-04-29T09:45:18Z

Assaf: /* BPJ Programming Examples */

BP Blockly User Guide

2014-04-29T09:43:39Z

Assaf: /* Example: Alternating Taps */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =

* When in BP for Blockly (under FireFox), click the drop-down menu and select "Hot and Cold".

This example contains three enabled b-threads and one disabled b-thread.

* 1. Requesting the event addHot 10 times.
* 2. Requesting the event addCold 10 times.
* 3. Forcing the alternation of the two events by waiting for two occurrences of addHot event and blocking the addCold, and vice versa, in a loop.

Experimenting:
* Try disabling the third b-thread. Both remaining b-threads will run and events will alternate, per the round robin scheduling in this version of BP for Blockly.
* Then try disabling the first b-thread. Only addCold events will be triggered.
* Then enable the third b-thread, and run the program again. No events will be triggered due the blocking of addCold.
* Click on the HTML tab and examine the HTML actuator code that displays the event text upon triggering of the events. In another implementation this code could call a JavaScript method that actually opens a water tap for a few seconds.
* The 4th b-thread was loaded disabled. This is an "actuator" b-thread that reacts to the addHot and addCold events. In this case, by displaying a window with the event text. Again, this b-thread could call a JavaScript method that performs a desired action.

= Example: The Rocket Landing Game Example =

* Download the zipped version of BP Blockly.
* To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides two additional examples
* A nullification game: See explanation in [http://www.wisdom.weizmann.ac.il/~bprogram/pres/agere2012AuthorVersion.pdf AGERE 2012 paper]
* A basic game of Tic-Tac-Toe: This example, with very basic strategies, demonstrates the instantiation of a b-thread according to a parameter list. For example, the application block "all Squares" represents a list of all possible squares, and a b-thread is instantiated for each one of these, waiting for a user click in this square, and requesting an X event in the same square.

BP Blockly User Guide

2014-04-29T09:43:17Z

Assaf: /* Example: Alternating Taps */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =

* When in BP for Blockly (under FireFox), click the drop-down meny and select Hot and Cold.

This example contains three enabled b-threads and one disabled b-thread.

* 1. Requesting the event addHot 10 times.
* 2. Requesting the event addCold 10 times.
* 3. Forcing the alternation of the two events by waiting for two occurrences of addHot event and blocking the addCold, and vice versa, in a loop.

Experimenting:
* Try disabling the third b-thread. Both remaining b-threads will run and events will alternate, per the round robin scheduling in this version of BP for Blockly.
* Then try disabling the first b-thread. Only addCold events will be triggered.
* Then enable the third b-thread, and run the program again. No events will be triggered due the blocking of addCold.
* Click on the HTML tab and examine the HTML actuator code that displays the event text upon triggering of the events. In another implementation this code could call a JavaScript method that actually opens a water tap for a few seconds.
* The 4th b-thread was loaded disabled. This is an "actuator" b-thread that reacts to the addHot and addCold events. In this case, by displaying a window with the event text. Again, this b-thread could call a JavaScript method that performs a desired action.

= Example: The Rocket Landing Game Example =

* Download the zipped version of BP Blockly.
* To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides two additional examples
* A nullification game: See explanation in [http://www.wisdom.weizmann.ac.il/~bprogram/pres/agere2012AuthorVersion.pdf AGERE 2012 paper]
* A basic game of Tic-Tac-Toe: This example, with very basic strategies, demonstrates the instantiation of a b-thread according to a parameter list. For example, the application block "all Squares" represents a list of all possible squares, and a b-thread is instantiated for each one of these, waiting for a user click in this square, and requesting an X event in the same square.

Main Page

2014-04-29T09:41:33Z

Assaf: /* BP in Blockly and JavaScript */

= Behavioral Programming in Imperative Languages =

----
== BP in Java ==
[[User Guide | BPJ Documentation and Examples]]

== BP in Blockly and JavaScript ==

[[BP Blockly User Guide | BP in Blockly and JavaScript Documentation and Examples]]
----

[http://www.b-prog.org BP Web Site]

Main Page

2014-04-29T09:40:48Z

Assaf: /* BP in Java */

= Behavioral Programming in Imperative Languages =

----
== BP in Java ==
[[User Guide | BPJ Documentation and Examples]]

== BP in Blockly and JavaScript ==

[[BP Blockly User Guide | BP Blockly User Guide]]
----

[http://www.b-prog.org BP Web Site]

User Guide

2014-04-29T09:40:05Z

Assaf:

= BPJ Documentation and Examples =

*[[Download|Downloading, installing and configuring the BPJ library, related tools and examples]]
*[http://www.wisdom.weizmann.ac.il/~bprogram/pres/BPintroduction.pdf A slide presentation: a general introduction to behavioral programming]
*[[The BPJ Library|The BPJ library: about b-threads, events, b-programs, etc.]]
*[[Dynamic b-threads|Symbolic and dynamic and b-threads]]
*[[TraceVis|Tracing and visualizing behavioral Java programs with TraceVis]]
*[[BPJ Model Checking|Verifying your application with the BPJ model checking]]
*[[BPJ Programming Examples | BPJ Programming Examples]]

= Advanced Topics =
*[http://www.wisdom.weizmann.ac.il/~amarron/FuzzIeee12.pdf Using BPJ for hybrid fuzzy control with BFUZ].
*[[Z3BP|Working with Z3 Theorem Prover / SMT Solver]]
*[[Learning | Adaptive Behavioral Programming]]

BP Blockly User Guide

2014-04-28T19:12:57Z

Assaf: /* Example: The Rocket Landing Game Example */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =

* Download the zipped version of BP Blockly.
* When in BP for Blockly (under FireFox), click Load Project, browse and select bp_code/apps/bp/examples/addHotCold.xml.

This example contains three b-threads:

* 1. Requesting the event addHot 10 times.
* 2. Requesting the event addCold 10 times.
* 3. Forcing the alternation of the two events by waiting for two occurrences of addHot event and blocking the addCold, and vice versa, in a loop.

Experimenting:
* Try disabling the third b-thread. Both remaining b-threads will run and events will alternate, per the round robin scheduling in this version of BP for Blockly.
* Then try disabling the first b-thread. Only addCold events will be triggered.
* Then enable the third b-thread, and run the program again. No events will be triggered due the blocking of addCold.
* Click on the HTML tab and examine the HTML actuator code that displays the event text upon triggering of the events. In another implementation this code could call a JavaScript method that actually opens a water tap for a few seconds.
* A 4th b-thread was loaded disabled. This is an "actuator" b-thread that reacts to the addHot and addCold events. In this case, by displaying a window with the event text. Again, this b-thread could call a JavaScript method that performs a desired action.

= Example: The Rocket Landing Game Example =

* Download the zipped version of BP Blockly.
* To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides two additional examples
* A nullification game: See explanation in [http://www.wisdom.weizmann.ac.il/~bprogram/pres/agere2012AuthorVersion.pdf AGERE 2012 paper]
* A basic game of Tic-Tac-Toe: This example, with very basic strategies, demonstrates the instantiation of a b-thread according to a parameter list. For example, the application block "all Squares" represents a list of all possible squares, and a b-thread is instantiated for each one of these, waiting for a user click in this square, and requesting an X event in the same square.

BP Blockly User Guide

2014-04-28T19:12:40Z

Assaf: /* Example: Alternating Taps */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =

* Download the zipped version of BP Blockly.
* When in BP for Blockly (under FireFox), click Load Project, browse and select bp_code/apps/bp/examples/addHotCold.xml.

This example contains three b-threads:

* 1. Requesting the event addHot 10 times.
* 2. Requesting the event addCold 10 times.
* 3. Forcing the alternation of the two events by waiting for two occurrences of addHot event and blocking the addCold, and vice versa, in a loop.

Experimenting:
* Try disabling the third b-thread. Both remaining b-threads will run and events will alternate, per the round robin scheduling in this version of BP for Blockly.
* Then try disabling the first b-thread. Only addCold events will be triggered.
* Then enable the third b-thread, and run the program again. No events will be triggered due the blocking of addCold.
* Click on the HTML tab and examine the HTML actuator code that displays the event text upon triggering of the events. In another implementation this code could call a JavaScript method that actually opens a water tap for a few seconds.
* A 4th b-thread was loaded disabled. This is an "actuator" b-thread that reacts to the addHot and addCold events. In this case, by displaying a window with the event text. Again, this b-thread could call a JavaScript method that performs a desired action.

= Example: The Rocket Landing Game Example =

To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides two additional examples
* A nullification game: See explanation in [http://www.wisdom.weizmann.ac.il/~bprogram/pres/agere2012AuthorVersion.pdf AGERE 2012 paper]
* A basic game of Tic-Tac-Toe: This example, with very basic strategies, demonstrates the instantiation of a b-thread according to a parameter list. For example, the application block "all Squares" represents a list of all possible squares, and a b-thread is instantiated for each one of these, waiting for a user click in this square, and requesting an X event in the same square.

BP Blockly User Guide

2014-04-28T19:11:46Z

Assaf: /* Example: Alternating Taps */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =

* Download the zipped version of BP Blockly.
* When in BP for Blockly (under FireFox), click Load Project, load the Hot and Cold example from the drop-down menu.

This example contains three b-threads:

* 1. Requesting the event addHot 10 times.
* 2. Requesting the event addCold 10 times.
* 3. Forcing the alternation of the two events by waiting for two occurrences of addHot event and blocking the addCold, and vice versa, in a loop.

Experimenting:
* Try disabling the third b-thread. Both remaining b-threads will run and events will alternate, per the round robin scheduling in this version of BP for Blockly.
* Then try disabling the first b-thread. Only addCold events will be triggered.
* Then enable the third b-thread, and run the program again. No events will be triggered due the blocking of addCold.
* Click on the HTML tab and examine the HTML actuator code that displays the event text upon triggering of the events. In another implementation this code could call a JavaScript method that actually opens a water tap for a few seconds.
* A 4th b-thread was loaded disabled. This is an "actuator" b-thread that reacts to the addHot and addCold events. In this case, by displaying a window with the event text. Again, this b-thread could call a JavaScript method that performs a desired action.

= Example: The Rocket Landing Game Example =

To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides two additional examples
* A nullification game: See explanation in [http://www.wisdom.weizmann.ac.il/~bprogram/pres/agere2012AuthorVersion.pdf AGERE 2012 paper]
* A basic game of Tic-Tac-Toe: This example, with very basic strategies, demonstrates the instantiation of a b-thread according to a parameter list. For example, the application block "all Squares" represents a list of all possible squares, and a b-thread is instantiated for each one of these, waiting for a user click in this square, and requesting an X event in the same square.

BP Blockly User Guide

2014-04-28T18:41:43Z

Assaf: /* Additional Examples */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =
When in BP for Blockly, load the Hot and Cold example from the drop-down menu.

This example contains three b-threads:

* 1. Requesting the event addHot 10 times.
* 2. Requesting the event addCold 10 times.
* 3. Forcing the alternation of the two events by waiting for two occurrences of addHot event and blocking the addCold, and vice versa, in a loop.

Experimenting:
* Try disabling the third b-thread. Both remaining b-threads will run and events will alternate, per the round robin scheduling in this version of BP for Blockly.
* Then try disabling the first b-thread. Only addCold events will be triggered.
* Then enable the third b-thread, and run the program again. No events will be triggered due the blocking of addCold.
* Click on the HTML tab and examine the HTML actuator code that displays the event text upon triggering of the events. In another implementation this code could call a JavaScript method that actually opens a water tap for a few seconds.
* A 4th b-thread was loaded disabled. This is an "actuator" b-thread that reacts to the addHot and addCold events. In this case, by displaying a window with the event text. Again, this b-thread could call a JavaScript method that performs a desired action.

= Example: The Rocket Landing Game Example =

To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides two additional examples
* A nullification game: See explanation in [http://www.wisdom.weizmann.ac.il/~bprogram/pres/agere2012AuthorVersion.pdf AGERE 2012 paper]
* A basic game of Tic-Tac-Toe: This example, with very basic strategies, demonstrates the instantiation of a b-thread according to a parameter list. For example, the application block "all Squares" represents a list of all possible squares, and a b-thread is instantiated for each one of these, waiting for a user click in this square, and requesting an X event in the same square.

BP Blockly User Guide

2014-04-28T18:36:23Z

Assaf: /* Additional Examples */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =
When in BP for Blockly, load the Hot and Cold example from the drop-down menu.

This example contains three b-threads:

* 1. Requesting the event addHot 10 times.
* 2. Requesting the event addCold 10 times.
* 3. Forcing the alternation of the two events by waiting for two occurrences of addHot event and blocking the addCold, and vice versa, in a loop.

Experimenting:
* Try disabling the third b-thread. Both remaining b-threads will run and events will alternate, per the round robin scheduling in this version of BP for Blockly.
* Then try disabling the first b-thread. Only addCold events will be triggered.
* Then enable the third b-thread, and run the program again. No events will be triggered due the blocking of addCold.
* Click on the HTML tab and examine the HTML actuator code that displays the event text upon triggering of the events. In another implementation this code could call a JavaScript method that actually opens a water tap for a few seconds.
* A 4th b-thread was loaded disabled. This is an "actuator" b-thread that reacts to the addHot and addCold events. In this case, by displaying a window with the event text. Again, this b-thread could call a JavaScript method that performs a desired action.

= Example: The Rocket Landing Game Example =

To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides two additional examples
* A nullification game: See explanation in [http://www.wisdom.weizmann.ac.il/~bprogram/pres/agere2012AuthorVersion.pdf AGERE 2012 paper]
* A basic game of Tic-Tac-Toe

BP Blockly User Guide

2014-04-28T18:34:14Z

Assaf: /* Example: Alternating Taps */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =
When in BP for Blockly, load the Hot and Cold example from the drop-down menu.

This example contains three b-threads:

* 1. Requesting the event addHot 10 times.
* 2. Requesting the event addCold 10 times.
* 3. Forcing the alternation of the two events by waiting for two occurrences of addHot event and blocking the addCold, and vice versa, in a loop.

Experimenting:
* Try disabling the third b-thread. Both remaining b-threads will run and events will alternate, per the round robin scheduling in this version of BP for Blockly.
* Then try disabling the first b-thread. Only addCold events will be triggered.
* Then enable the third b-thread, and run the program again. No events will be triggered due the blocking of addCold.
* Click on the HTML tab and examine the HTML actuator code that displays the event text upon triggering of the events. In another implementation this code could call a JavaScript method that actually opens a water tap for a few seconds.
* A 4th b-thread was loaded disabled. This is an "actuator" b-thread that reacts to the addHot and addCold events. In this case, by displaying a window with the event text. Again, this b-thread could call a JavaScript method that performs a desired action.

= Example: The Rocket Landing Game Example =

To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides three additional examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

BP Blockly User Guide

2014-04-28T18:33:24Z

Assaf: /* Example: Alternating Taps */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =
When in BP for Blockly, load the Hot and Cold example from the drop-down menu.

This example contains three b-threads:

* 1. Requesting the event addHot 10 times.
* 2. Requesting the event addCold 10 times.
* 3. Forcing the alternation of the two events by waiting for two occurrences of addHot event and blocking the addCold, and vice versa, in a loop.

Experimenting:
* Try disabling the third b-thread. Both remaining b-threads will run and events will alternate, per the round robin scheduling in this version of BP for Blockly.
* Then try disabling the first b-thread. Only addCold events will be triggered.
* Then enable the third b-thread, and run the program again. No events will be triggered due the blocking of addCold.

Click on the HTML tab and examine the HTML actuator code that displays the event text upon triggering of the events. In another implementation this code could call a JavaScript method that actually opens a water tap for a few seconds.

A 4th b-thread was loaded disabled. This is an "actuator" b-thread that reacts to the addHot and addCold events. In this case, by displaying a window with the event text. Again, this b-thread could call a JavaScript method that performs a desired action.

= Example: The Rocket Landing Game Example =

To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides three additional examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

BP Blockly User Guide

2014-04-28T18:31:37Z

Assaf: /* Example: Alternating Taps */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =
When in BP for blockly, load the Hot and Cold example from the drop-down menu.

This example contains three b-threads:

* 1. Requesting the event addHot 10 times
* 2. Requesting the event addCold 10 times
* 3. Forcing the alternation of the two events by waiting for two occurrences of addHot event and blocking the addCold, and vice versa, in a loop.

Experimenting:
* Try disabling the third b-thread. Both remaining b-threads will run and events will alternate, per the round robin scheduling in this version of BP for Blockly.
* Then try disabling the first b-thread. Only addCold events will be triggered.
* Then enable the third b-thread, and run the program again. No events will be triggered due the blocking of addCold.

Click on the HTML tab and examine the HTML actuator code that displays the event text upon triggering of the events. In another implementation this code could call a JavaScript method that actually opens a water tap for a few seconds.

A 4th b-thread was loaded disabled. This is an "actuator" b-thread that reacts to the addHot and addCold events. In this case, by displaying a window with the event text. Again, this b-thread could call a JavaScript method that performs a desired action.

= Example: The Rocket Landing Game Example =

To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides three additional examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

BP Blockly User Guide

2014-04-28T18:07:31Z

Assaf:

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Example: Alternating Taps =
When in BP for blockly, load the hotcold example from the drop-down menu.
= Example: The Rocket Landing Game Example =

To load this example click "Load Project" and browse and select bp_code/apps/bp/examples/RocketLanding.xml.

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

= Additional Examples =

The dropdown menu provides three additional examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

BP Blockly User Guide

2014-04-28T17:55:58Z

Assaf: /* BP Programming Blocks */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: In the version of BP for Blockly there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory. An earlier version of BP there is a container block for a b-threads.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* b-Sync: This block is available in an earlier version of BP for Blockly, and it can specify requested, waited-for and blocked events.
* Application specific blocks: These blocks are defined by the user in the application blocks tab, and can then be used from the pallet. They can be used for events, lists and more. For example, to code an application event block, the easiest way is to copy and paste the following code changing the text "MYEVENT" to your event name (in four places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

BP Blockly User Guide

2014-04-28T17:49:48Z

Assaf: /* Introduction */

= BP Blockly User Guide =

= Introduction =

BP in Google Blockly is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

It is implemented in Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

BP Blockly User Guide

2014-04-28T17:48:51Z

Assaf: /* Introduction */

= BP Blockly User Guide =

= Introduction =

BP is implemented in Google Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

This is an experimental platform set to illustrate visually the basic capabilities of behavioral programming.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

Helicopter flight and mission

2014-04-28T16:47:42Z

Assaf: /* Basic Composite Behavior */

= Helicopter Flight Examples =
The examples below demonstrates the control of a toy helicopter - AR DRONE by Parrot Inc.

= Basic Composite Behavior =
The following movies show flight of the helicopter, as well as simulation. The flight was generated by independent concurrent LSCs - where one directs the helicopter through a rectangular flight path without changing altitude, and another directs the helicopter to go up and down without changing its horizontal location. The result is a composite motion, traveling the prescribed path while going up and down.

{{#ev:youtube|nMTbQc_iq5Y|640}}

{{#ev:youtube|sMp8QTetobc|640}}

= Detailed Example: Wall Painting =
In this example, the mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

The example is implemented with a simulator.

Below we describe the requirements and the associated b-threads, along with screen images and a movie of the helicopter behavior as it evolves with the addition of new b-threads.

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

{{#ev:youtube|6cSqPGvRWw0|640}}

With only basic movements and no color change b-threads:

[[Image: Black - thin.jpg]]

Basic movements with color changes:

[[Image: Color-thin.jpg]]

Adding horizontal brush movements:

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location:

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.

BP Blockly User Guide

2014-04-28T14:42:14Z

Assaf: /* BP Programming Blocks */

= BP Blockly User Guide =

= Introduction =

BP is implemented in Google Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* B-thread: there is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory.
** However, the block called "instantiate with" enables the creation of multiple b-threads with different parameters. See example in the Tic-Tac-Toe game.
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

BP Blockly User Guide

2014-04-28T14:38:36Z

Assaf: /* Programming */

= BP Blockly User Guide =

= Introduction =

BP is implemented in Google Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

BP Blockly User Guide

2014-04-28T14:37:03Z

Assaf: /* The B-threads */

= BP Blockly User Guide =

= Introduction =

BP is implemented in Google Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* There is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory.
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to:
* User pressing a button - request rocket move
* Time ticks - Rocket descending
* Time ticks - Landing pad moves
* Rocket reaching a wall - block movements
* Rocket departing from a wall - allow movements
* Rocket touching the ground - loss
* Rocket landing on the landing pad - win
* Etc.

A key point to observe is that the behavior when rocket reaches the walls is independent and is by blocking of a move past the wall.

BP Blockly User Guide

2014-04-28T11:46:25Z

Assaf: /* The B-threads */

= BP Blockly User Guide =

= Introduction =

BP is implemented in Google Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* There is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory.
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to user pressing a button, time ticks, rocket reaching a wall, rocket departing from a wall, etc.
A key point to observe is that the behavior of the walls is independent and is by blocking of a move past the wall.

BP Blockly User Guide

2014-04-28T11:46:02Z

Assaf: /* The B-threads */

= BP Blockly User Guide =

= Introduction =

BP is implemented in Google Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* There is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory.
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

The b-threads in the application can be seen on the canvas.
They react to user pressing a button, time ticks, rocket reaching a wall, rocket departing from a wall etc.
A key point to observe is that the behavior of the walls is independent and is by blocking of a move past the wall.

BP Blockly User Guide

2014-04-28T11:44:11Z

Assaf:

= BP Blockly User Guide =

= Introduction =

BP is implemented in Google Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =
* To create an application drag blocks onto the canvas
* There is no separate block for behavior threads. Each contiguous set of execution blocks forms a b-thread. You can add a comment to the b-thread, indicating its name or function, but this is not mandatory.
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost
* GameOver: The application determined that the game should be stopped

== The B-threads ==

As can be seen in the example - behavior threads in blockly are not named. You can add t

BP Blockly User Guide

2014-04-28T11:38:25Z

Assaf: /* The B-threads */

= BP Blockly User Guide =

= Introduction =

BP is implemented in Google Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =

* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost

== The B-threads ==
Actuator & GameOver & The application determined that the game should be stopped \\

BP Blockly User Guide

2014-04-28T11:38:12Z

Assaf: /* Actuator Events */

= BP Blockly User Guide =

= Introduction =

BP is implemented in Google Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =

* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

=== Actuator Events ===
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost

== The B-threads ==
Actuator & GameOver & The application determined that the game should be stopped \\

BP Blockly User Guide

2014-04-28T11:38:00Z

Assaf: /* Sensor Events */

= BP Blockly User Guide =

= Introduction =

BP is implemented in Google Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =

* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

== Actuator Events ==
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost

== The B-threads ==
Actuator & GameOver & The application determined that the game should be stopped \\

BP Blockly User Guide

2014-04-28T11:37:31Z

Assaf:

= BP Blockly User Guide =

= Introduction =

BP is implemented in Google Blockly by introducing new programming blocks, and by using the co-routines (generators) facility of JavaScript.
Behavioral programs written in Blockly are translated into and executed as JavaScript programs.

= Installation / Getting started =
* Install Firefox browser version 15.0.1 or later.
* For online use: open with FireFox the designated [http://www.b-prog.org/BP_Code/apps/BP Blockly link]
* For offline/local use on your computer:
** Download the zip file containing the Blockly and JavaScript package from the download screen;
** Extract the zip file, preserving directory structure;
** Open with Firefox the file BP_Code\apps\BP\index.html;
* Look at example projects in the examples drop down, additional examples linked from this site, and the [http://bp-new-blockly.appspot.com/ tutorial]

= User Interface =

== Tabs ==
The BP Blockly interface introduces four tabs:
* Blocks: In this tab, on the left is the 'pallet' or menu of Blockly blocks to choose from, and on the right is the canvas where the application is developed.
* HTML: In this tab you program the HTML interfaces of your application, especially sensors and actuators.
* Project Blocks: In this tab you can define new application-specific blocks. For example, application specific events.
* JavaScript: This tab, shown in "debug" mode, shows the executable JavaScript generated from the Blockly code
* XML: This tab, shown in "debug" mode, shows the text file where the entire application is stored.

== Navigation ==
* To scroll click and drag the canvas up or down, or use the scroll bar.
* Note that at initial loading parts of an application may be hidden and you may need to scroll up.
* Actions: Right click offers a popup menu

= Programming =

* To create an application drag blocks onto the canvas
* To start the application click on the red "Play" button
* To provide HTML information, look at templates of existing projects and at [http://www.b-prog.org/pres/agere2012AuthorVersion.pdf AGERE!2012 paper].
* Sensor example: for translating a button click into a behavioral event
input value="StartGame"
type="button"
onclick="startGame();"
style="position:relative;background-color:LightPink;"
* To create an actuator, code
when_<eventName> = ... < mycode >
* Example actuator which changes a screen display:
input value='Status: Playing '
type="button"
when_DisplayWin ="value='Status: *** Successful*** ';alert(' !!! You Won !!! ');"
when_DisplayLose="value='Status: !!! Game Lost !!! ';alert(' !!! Game Lost !!! ');"
style="position:relative;background-color:LightPink;"

* Your application is not required to have its own GUI and HTML – you can experiment with creating interwoven behavioral flow just with events
* B-thread priority:
** Round robin: All b-threads have same priority. Events that are requested and not blocked are chosen from the different b-threads in turn.
** Strict priority: All b-threads are ordered, as determined by their top down and left-to-right placement on the canvas (presently disabled).
* Loading an existing project: Click "Load project", and browse and select an XML file where a project has been saved.
* Saving a project: Click "Save Project" and use standard browser functions to save the XML file. Close the extra tabs.
* Debugging and Event Logging:
** Use Firefox console native, or
** Use [ http://getfirebug.com/ Firebug tool]:
*** Start the application
*** In the application GUI screen – click on the firebug icon;
*** You may have to reload the application GUI screen;
*** In the firebug display click console tab;
*** In the console drop-down - make sure console is enabled;
*** Start the application
*** Watch the events in the console log.
* Do not edit the compiled JavaScript or XML file;
* Avoid spaces or periods in strings and variable names
* Sometimes the XML file may be corrupted. To avoid losing your data, save frequently in different file names and verify the file can be loaded.

= BP Programming Blocks =
With BP you have in Blockly the following new programming blocks:
* Event: Defines a e behavioral event. The event name should be entered a string inside this event block.
* Request <event>: Request an event. The event is requested and the program continues when the event is triggered.
* Wait for <event >: wait for and event. The program continues when the event is triggered.
* Blocking <event>: This container block, forbids the specified event until the code contained in it completes
* Break upon <event>: This container block executes the code contained in it, but the execution is interrupted if and when the specified event is triggered.
* Application specific events: These events are defined by the user in the application blocks tab, and can then be used from the pallet. To code an application block. The easiest way is to copy and paste the following code changing the text "MYEEVENT" to your event name (4 places).

custom.bp_event_MYEVENT = {
helpUrl: 'http://www.example.com/',
init: function() {
this.setColour(290);
this.appendDummyInput()
.appendTitle("MYEVENT");
this.setOutput(true, 'event');
this.setTooltip('');
}
};
Blockly.JavaScript.bp_event_MYEVENT = function () {
return ['"MYEVENT"', Blockly.JavaScript.ORDER_NONE];
};

= Examples =

The dropdown menu provides three examples
* A water tap example with two b-threads adding hot water and cold water separately, and a third one alternating between them.
* A nullification game
* A basic game of Tic-Tac-Toe

Two additional examples are provided in the examples folder.
To load them, press Load Project, and then go to the folder where you have downloaded BP Blockly, and browse the subfolder ..BP_Code/apps/BP/examples.

* WaterTap2.xml - A similar example to the hot cold example above, with an actuator b-threads that prints a message
* RocketLanding.xml - A 3-dimensional rocket-landing game, explained in more detail below

== The Rocket Landing Game Example ==

In this game the player attempts to land a rocket on a landing pad on the surface of a planet. The rocket moves downward at a fixed speed in the vertical direction. Using GUI buttons, the player can move the rocket north, south, east and west, with the goal of positioning it directly above the landing pad. The player can also press an Up button to create an exhaust burst that
suspends the rocket and prevents it from going down in the next time unit. The landing pad keeps moving on the ground either randomly or subject to an unknown plan. Four walls mark the sides of the playing area, and the rocket cannot move past them (but
does not crash when it touches them). The game is won when the rocket lands exactly on the landing pad, and is lost when it touches the ground without being fully on the pad. The rocket movement is in three dimensions and the view of the entire game scene can be manipulated (tilt, pan, etc.) in 3D.

=== Sensor Events ===

* BtnEast: User clicked East
* BtnWest: User clicked West
* . . .
* TimeTick: A unit of time passed (s
* RocketTouchedEastWall: Rocket arrived at east wall
* RocketAwayFromEastWall: Rocket departed from east wall
* . . .
* TouchDown: Rocket touched launch pad and is aligned with it
* Missed: Rocket reached or passed launch pad without being aligned with it

== Actuator Events
* RocketWest: Request to redraw rocket 10 pixels further to the west
* RocketEast: Request to redraw rocket 10 pixels further to the east
* RocketDown: Request to redraw rocket 10 pixels down
* PadWest: The application wishes the pad to move 10 pixels further to the west
* . . .
* DisplayWin: The application determined that the player won
* DisplayLose: The application determined that the player lost

== The B-threads ==
Actuator & GameOver & The application determined that the game should be stopped \\

Helicopter flight and mission

2014-04-28T11:03:49Z

Assaf: /* Incremental Development Notes */

= Helicopter Flight Examples =
The examples below demonstrates the control of a toy helicopter - AR DRONE by Parrot Inc.

= Basic Composite Behavior =
The following movies show flight of the helicopter, as well as simulation. The flight was generated by two independent concurrent LSCs - one directs the helicopter through a rectangular flight path without changing altitude, while the other directs the helicopter to go up and down without changing its horizontal location. The result is a composite motion, traveling the prescribed path while going up and down.

{{#ev:youtube|nMTbQc_iq5Y|640}}

{{#ev:youtube|sMp8QTetobc|640}}

= Detailed Example: Wall Painting =
In this example, the mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

The example is implemented with a simulator.

Below we describe the requirements and the associated b-threads, along with screen images and a movie of the helicopter behavior as it evolves with the addition of new b-threads.

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

{{#ev:youtube|6cSqPGvRWw0|640}}

With only basic movements and no color change b-threads:

[[Image: Black - thin.jpg]]

Basic movements with color changes:

[[Image: Color-thin.jpg]]

Adding horizontal brush movements:

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location:

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.

Helicopter flight and mission

2014-04-28T11:02:49Z

Assaf: /* Incremental Development Notes */

= Helicopter Flight Examples =
The examples below demonstrates the control of a toy helicopter - AR DRONE by Parrot Inc.

= Basic Composite Behavior =
The following movies show flight of the helicopter, as well as simulation. The flight was generated by two independent concurrent LSCs - one directs the helicopter through a rectangular flight path without changing altitude, while the other directs the helicopter to go up and down without changing its horizontal location. The result is a composite motion, traveling the prescribed path while going up and down.

{{#ev:youtube|nMTbQc_iq5Y|640}}

{{#ev:youtube|sMp8QTetobc|640}}

= Detailed Example: Wall Painting =
In this example, the mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

The example is implemented with a simulator.

Below we describe the requirements and the associated b-threads, along with screen images and a movie of the helicopter behavior as it evolves with the addition of new b-threads.

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

{{#ev:youtube|6cSqPGvRWw0|640}}

[http://www.wisdom.weizmann.ac.il/~bprogram/videos/WallPainting.mp4 Movie: Incremental development of the wall painting application]

With only basic movements and no color change b-threads

[[Image: Black - thin.jpg]]

Basic movements with color changes

[[Image: Color-thin.jpg]]

Adding horizontal brush movements

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.

Helicopter flight and mission

2014-04-28T11:02:09Z

Assaf: /* Incremental Development Notes */

= Helicopter Flight Examples =
The examples below demonstrates the control of a toy helicopter - AR DRONE by Parrot Inc.

= Basic Composite Behavior =
The following movies show flight of the helicopter, as well as simulation. The flight was generated by two independent concurrent LSCs - one directs the helicopter through a rectangular flight path without changing altitude, while the other directs the helicopter to go up and down without changing its horizontal location. The result is a composite motion, traveling the prescribed path while going up and down.

{{#ev:youtube|nMTbQc_iq5Y|640}}

{{#ev:youtube|sMp8QTetobc|640}}

= Detailed Example: Wall Painting =
In this example, the mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

The example is implemented with a simulator.

Below we describe the requirements and the associated b-threads, along with screen images and a movie of the helicopter behavior as it evolves with the addition of new b-threads.

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

6cSqPGvRWw0

[http://www.wisdom.weizmann.ac.il/~bprogram/videos/WallPainting.mp4 Movie: Incremental development of the wall painting application]

With only basic movements and no color change b-threads

[[Image: Black - thin.jpg]]

Basic movements with color changes

[[Image: Color-thin.jpg]]

Adding horizontal brush movements

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.

Helicopter flight and mission

2014-04-28T10:52:27Z

Assaf: /* Detailed Example: Wall Painting */

= Helicopter Flight Examples =
The examples below demonstrates the control of a toy helicopter - AR DRONE by Parrot Inc.

= Basic Composite Behavior =
The following movies show flight of the helicopter, as well as simulation. The flight was generated by two independent concurrent LSCs - one directs the helicopter through a rectangular flight path without changing altitude, while the other directs the helicopter to go up and down without changing its horizontal location. The result is a composite motion, traveling the prescribed path while going up and down.

{{#ev:youtube|nMTbQc_iq5Y|640}}

{{#ev:youtube|sMp8QTetobc|640}}

= Detailed Example: Wall Painting =
In this example, the mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

The example is implemented with a simulator.

Below we describe the requirements and the associated b-threads, along with screen images and a movie of the helicopter behavior as it evolves with the addition of new b-threads.

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

[http://www.wisdom.weizmann.ac.il/~bprogram/videos/WallPainting.mp4 Movie: Incremental development of the wall painting application]

With only basic movements and no color change b-threads

[[Image: Black - thin.jpg]]

Basic movements with color changes

[[Image: Color-thin.jpg]]

Adding horizontal brush movements

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.

Helicopter flight and mission

2014-04-28T10:50:15Z

Assaf: /* Detailed Example: Wall Painting */

= Helicopter Flight Examples =
The examples below demonstrates the control of a toy helicopter - AR DRONE by Parrot Inc.

= Basic Composite Behavior =
The following movies show flight of the helicopter, as well as simulation. The flight was generated by two independent concurrent LSCs - one directs the helicopter through a rectangular flight path without changing altitude, while the other directs the helicopter to go up and down without changing its horizontal location. The result is a composite motion, traveling the prescribed path while going up and down.

{{#ev:youtube|nMTbQc_iq5Y|640}}

{{#ev:youtube|sMp8QTetobc|640}}

= Detailed Example: Wall Painting =
In this example, the mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

The example is implemented with a simulator (see link to a movie below).

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

[http://www.wisdom.weizmann.ac.il/~bprogram/videos/WallPainting.mp4 Movie: Incremental development of the wall painting application]

With only basic movements and no color change b-threads

[[Image: Black - thin.jpg]]

Basic movements with color changes

[[Image: Color-thin.jpg]]

Adding horizontal brush movements

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.

Helicopter flight and mission

2014-04-28T10:49:31Z

Assaf: /* Detailed Example: Wall Painting */

= Helicopter Flight Examples =
The examples below demonstrates the control of a toy helicopter - AR DRONE by Parrot Inc.

= Basic Composite Behavior =
The following movies show flight of the helicopter, as well as simulation. The flight was generated by two independent concurrent LSCs - one directs the helicopter through a rectangular flight path without changing altitude, while the other directs the helicopter to go up and down without changing its horizontal location. The result is a composite motion, traveling the prescribed path while going up and down.

{{#ev:youtube|nMTbQc_iq5Y|640}}

{{#ev:youtube|sMp8QTetobc|640}}

= Detailed Example: Wall Painting =
In this example, the mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

The example is implemented with a simulator.

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

[http://www.wisdom.weizmann.ac.il/~bprogram/videos/WallPainting.mp4 Movie: Incremental development of the wall painting application]

With only basic movements and no color change b-threads

[[Image: Black - thin.jpg]]

Basic movements with color changes

[[Image: Color-thin.jpg]]

Adding horizontal brush movements

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.

Helicopter flight and mission

2014-04-28T10:47:30Z

Assaf: /* Basic Composite Behavior */

= Helicopter Flight Examples =
The examples below demonstrates the control of a toy helicopter - AR DRONE by Parrot Inc.

= Basic Composite Behavior =
The following movies show flight of the helicopter, as well as simulation. The flight was generated by two independent concurrent LSCs - one directs the helicopter through a rectangular flight path without changing altitude, while the other directs the helicopter to go up and down without changing its horizontal location. The result is a composite motion, traveling the prescribed path while going up and down.

{{#ev:youtube|nMTbQc_iq5Y|640}}

{{#ev:youtube|sMp8QTetobc|640}}

= Detailed Example: Wall Painting =
The mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

[http://www.wisdom.weizmann.ac.il/~bprogram/videos/WallPainting.mp4 Movie: Incremental development of the wall painting application]

With only basic movements and no color change b-threads

[[Image: Black - thin.jpg]]

Basic movements with color changes

[[Image: Color-thin.jpg]]

Adding horizontal brush movements

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.

Helicopter flight and mission

2014-04-28T10:47:18Z

Assaf: /* Basic Composite Behavior */

= Helicopter Flight Examples =
The examples below demonstrates the control of a toy helicopter - AR DRONE by Parrot Inc.

= Basic Composite Behavior =
The following movies show flight of the helicopter, as well as simulation. The flight was generated by two independent concurrent LSCs - one directs the helicopter through a rectangular flight path without changing altitude, while the other directs the helicopter to go up and down without changing its horizontal location. The result is a composite motion, traveling the prescribed path while going up and down.

{{#ev:youtube|nMTbQc_iq5Y|640}}

{{#ev:youtube|sMp8QTetobc|640}

= Detailed Example: Wall Painting =
The mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

[http://www.wisdom.weizmann.ac.il/~bprogram/videos/WallPainting.mp4 Movie: Incremental development of the wall painting application]

With only basic movements and no color change b-threads

[[Image: Black - thin.jpg]]

Basic movements with color changes

[[Image: Color-thin.jpg]]

Adding horizontal brush movements

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.

Helicopter flight and mission

2014-04-28T10:43:33Z

Assaf: /* Helicopter Flight Example */

= Helicopter Flight Examples =
The examples below demonstrates the control of a toy helicopter - AR DRONE by Parrot Inc.

= Basic Composite Behavior =
The following movies show flight of the helicopter, as well as simulation. The flight was generated by two independent concurrent LSCs - one directs the helicopter through a rectangular flight path without changing altitude, while the other directs the helicopter to go up and down without changing its horizontal location. The result is a composite motion, traveling the prescribed path while going up and down.

{{#ev:youtube|nMTbQc_iq5Y|640}}

= Detailed Example: Wall Painting =
The mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

[http://www.wisdom.weizmann.ac.il/~bprogram/videos/WallPainting.mp4 Movie: Incremental development of the wall painting application]

With only basic movements and no color change b-threads

[[Image: Black - thin.jpg]]

Basic movements with color changes

[[Image: Color-thin.jpg]]

Adding horizontal brush movements

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.

Helicopter flight and mission

2014-04-28T10:14:51Z

Assaf: /* Helicopter Flight Example */

= Helicopter Flight Example =
This example demonstrates the control of a toy helicopter. The mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

The detailed example below is based on a simulator.

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

[http://www.wisdom.weizmann.ac.il/~bprogram/videos/WallPainting.mp4 Movie: Incremental development of the wall painting application]

With only basic movements and no color change b-threads

[[Image: Black - thin.jpg]]

Basic movements with color changes

[[Image: Color-thin.jpg]]

Adding horizontal brush movements

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.

Flight of a flock of birds

2014-04-28T10:05:01Z

Assaf: /* Requirements - from each bird */

= Simulating Flight of a Flock of Birds =
In this example we simulate the flight of a flock of birds, with each bird having a simple set of rules implemented as b-threads.
The example highlights
* Multi-agent activity
* Emergent group behaviors - emanating from individual agent behavior
* Implementation of animation with BPJ - and handling of associated design issues.
* [http://www.wisdom.weizmann.ac.il/~bprogram/videos/flock25Gather.avi Movie: 25 birds gathering and flying]
* [http://www.wisdom.weizmann.ac.il/~bprogram/videos/flockScare.mp4 Movie: Birds disperse in reaction to a "scare" action]

= Requirements - from each bird =
* Always try to move towards the center of the flock
* Always avoid colliding with other birds
* When getting close to a wall - change direction - in the same "reflection" angle
* When the "Scare" button is hit - fly away from the center of the flock.

= Download =
# Click [[Media:Flock.zip | here]] to download the flock of birds example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The flock of birds example project is now part of your workspace.
##Refer to the readme.txt file for execution instructions.

User Guide

2014-04-28T10:01:31Z

Assaf: /* Advanced Topics */

= BPJ User Guide=

*[[Download|Downloading, installing and configuring the BPJ library, related tools and examples]]
*[http://www.wisdom.weizmann.ac.il/~bprogram/pres/BPintroduction.pdf A slide presentation: a general introduction to behavioral programming]
*[[The BPJ Library|The BPJ library: about b-threads, events, b-programs, etc.]]
*[[Dynamic b-threads|Symbolic and dynamic and b-threads]]
*[[TraceVis|Tracing and visualizing behavioral Java programs with TraceVis]]
*[[BPJ Model Checking|Verifying your application with the BPJ model checking]]
*[[BPJ Programming Examples | BPJ Programming Examples]]

= Advanced Topics =
*[http://www.wisdom.weizmann.ac.il/~amarron/FuzzIeee12.pdf Using BPJ for hybrid fuzzy control with BFUZ].
*[[Z3BP|Working with Z3 Theorem Prover / SMT Solver]]
*[[Learning | Adaptive Behavioral Programming]]

Z3BP

2014-04-28T10:01:04Z

Assaf: /* Verifying your application */

= Verifying behavioral programs with the Z3 Theorem Prover / SMT Solver =

== Installation ==
* See [http://www.wisdom.weizmann.ac.il/~bprogram/emsoft13 reference materials ]
* Required Environment: Windows 7, Eclipse.
* Install latest version of Z3 from Z3 Web Site (at the time of writing this page the version is 4.1). Note that the software is under a Microsoft Research folder.
* Install Python version 2.7.3 from Python web site. Presently the latest version of Z3 does not support the latest version of Python version. The following instructions assume that you have installed Python into C:\Python27\ on your computer.
* Install PyDev from Pydev web site as follows: find and copy the link for PyDev Eclipse plugin. Open Eclipse. Click "help" and "install new software". Add the plugin location and install. During installation check and approve the certificate trust.
* Create a Z3 project. Eclipse -> "file" -> "import project" -> "general" -> "existing project into workspace" (do not copy into workspace). The project will be marked red.
* Define Interpreter: In Eclipse, open PyDev perspective, right click on the project, select "properties" and then "python interpreter". Define as C:\Python27\python.exe.
* Define PYTHONPATH: In Eclipse: Select "Window" -> "Preferences" -> "PyDev" -> "Interpreter PYTHON" -> "PYTHONPATH" -> "New Folder". Add to the Python path the Python folder within Z3, e.g., C:\Program Files (x86)\Microsoft Research\Z3-4.1\python.
* Define Windows Path: Add to windows system path variable the bin folder of z3 C:\Program Files (x86)\Microsoft Research\Z3-4.1\bin.
* Change appearance: In Eclipse, select "Window" -> "Preferences" -> "PyDev" -> "Editor" (click on it) -> "Aptana themes" -> "Eclipse".

== Verifying your application ==
* See Z3 information for Z3 syntax and its Python interface.
* See examples in the provided project how to define b-thread properties.
* Modify the example, introducing new b-thread properties, but preserving BP composition properties.
* Run the model.

Helicopter flight and mission

2014-04-27T19:33:46Z

Assaf: /* Incremental Development Notes */

= Helicopter Flight Example =
This example demonstrates the control of a toy helicopter. The mission here is to paint a wall with different colors. This can be considered as an analogy to a photography mission where a particular area as to be covered.

== Requirements==
The requirements below were added incrementally, and b-threads were added to deal with each requirement. In the simulator - the painting of the wall is by drawing a line on the screen.

*The helicopter should go up and down along the wall.
*When the helicopter reaches the ceiling or the floor it should move to the right
*Every fixed number of pixels the paint color should be changed
*Since the line drawn by the helicopter is thin, after every small vertical move, the helicopter should move right and left with horizontal brush strokes, before moving vertically again.
*The helicopter may move from its present location due to wind.
*If the helicopter is moved by wind, it should return to its last known location.

In the integration with LSC, two more requirements were added
*The amount of paint is limited. After a certain number of points is painted - the paint runs out.
*When paint of a certain color runs out, this color can no longer be used.
*When all paint colors run out, the helicopter must stop.
*Paint cans may be re-filled. This is simulated by a user clicking on a button on the screen.

== Events ==

== General control events ==
* BeginPainting: Start the painting process
* StopPainting: End the painting process
* MoveDown: Move down a fixed number of pixels.
* EndOfColUp: End painting wall going up
* DoColDownL Start painting wall going down
* EndOfColDown: End painting wall going up
* DoRowRight: Start painting wall going right
* EndOfRowRight: Stop moving right.
* ChangeColor: This is an event class of which there are four events, indicating a request to change the painting color to the corresponding one in the event name:
** eChangeColorBLACK
** eChangeColorRED
** eChangeColorBLUE
** eChangeColorGreen
* UpdateArrived: simulate information from a GPS with actual helicopter location

=== Move Events ===

The following events indicate the desire to move a fixed number of pixels in the desired direction. These events have a data field - indicating whether the movement is for a mission or for maintenance, which serves in correcting wind shifts.

* MoveUp: Move down a fixed number of pixels
* MoveDown: Move down a fixed number of pixels
* MoveLeft: Move left a fixed number of pixels
* MoveRight: Move right a fixed number of pixels

== BPJ b-threads ==

=== General control b-threads ===
* DoColD2U: Controls coloring in the up direction;
* YAxis: Reports when helicopter reaches top or bottom end of wall (ceiling of floor)
* EndColUp: Handle reaching of ceiling. Stop moving vertically, start moving right.
* DoRowL2R: Left to right painting - waits for DoRowRight and then repeatedly requests movement to the right until end of right movement is reached.
* XAxis: Monitor horizontal coordinates. Report reaching of right and left borders of wall, and report end of movement right to start a new column
* DoColU2D: Controls coloring in the up direction
* EndColDown: Handles reaching the floor - requests a movement to the right
* BrushMove: Move the brush right and left (horizontal moves) to create a thicker line and paint continuous area. This b-thread performs its actions between any two vertical moves.

=== Actuator b-threads ===

The following b-threads wait for the corresponding move event and call the helicopter API (or the simulator) to cause the actual movement.
* MovingRight
* MovingLeft
* MovingDown
* MovingUp

=== Color control b-threads ===
* ChangePaintingColor: Waits for the need to change color and changes the color randomly.

=== Location correction b-threads ===
* FixWind: When a report comes in that the helicopter is not where it is supposed to be - stop painting movement and return to last known location.

=== Environment Simulation ===

* ColorControl: Counts movements and announces the need to change color.
* Wind: Every certain random number of steps, report a random location of the helicopter

= Incremental Development Notes =

[http://www.wisdom.weizmann.ac.il/~bprogram/videos/WallPainting.mp4 Movie: Incremental development of the wall painting application]

With only basic movements and no color change b-threads

[[Image: Black - thin.jpg]]

Basic movements with color changes

[[Image: Color-thin.jpg]]

Adding horizontal brush movements

[[Image: Color-thick.jpg]]

Random movements due to wind, and return by horizontal movement and then vertical to last known location

[[Image: FixWind.jpg]]

= LSC Integration =

The BPJ-based system was then integrated with the LSC language via PlayGo.
For details how to integrate a BPJ application with LSC see a separate section in this documentation.

The following LSC (scenario) was added

* PaintCanEmpty: Waits for a certain number of movements with a given color and block subsequent changes to that color, simulating and empty can, until an event of PaintFilled arrives. This event is generated by the user clicking on a corresponding GUI Button.

= Design Notes =

The following design patterns and choices can be seen throughout the example.

* Events can be distinguishes from each other by
** Class - different classes of events
** Name - multiple instances of an events of the same class distinguished by their name (e.g. the color change events).
** Data field - Two instances of events of the same class, with arbitrary names can be distinguished by a value in one of the event data fields (e.g. the maintenance vs. mission indicator in the move events).

* One activity can interfere with another by using
** priority - (relative priority among b-thread)
** blocking the events of the other activity (which can be distinguished as described above)

* Distinguishing internal and external events - those generated by the system/application and those generated by the environment (and which may be reported by sensors).

** External events should not be blocked (enforced by convention only).
** When external events are produced by simulator, the concepts of Logical Execution Time should be enforced by convention, where all internal events reacting to the last external event should be processed before generating the next external event.

= Download =
# Click [[Media:Helicopter.zip | here]] to download the helicopter example.
# Installation Instructions:
##Import the downloaded project to your workspace:
###From the 'File' menu choose 'Import'-->'General'-->'Existing Projects into Workspace'.
###Click the 'Next' button.
###Click the 'Select archive file' option and then click the 'Browse...' button to select the downloaded zip file.
###Click 'Finish'.
##The helicopter example projects are now part of your workspace.
### The example includes three projects:
#### BDrone - The main project that includes the b-threads that implement the drawing/scanning tasks.
#### HeliSim - A simple java-based simulator.
#### il.ac.wis.cs.rovtool.blender - A blender-based simulator.
##Refer to the BDrone/HowToRun.txt file for execution instructions.