2.1.28, initiation update to PXT v5.28.24 (#54)

This commit is contained in:
Amerlander
2019-12-02 05:58:26 +01:00
committed by Peli de Halleux
parent 38a964516e
commit 5c114a0c57
1261 changed files with 50692 additions and 21604 deletions

View File

@ -1,9 +0,0 @@
# Logic
```cards
if(true) {}
true;
true && false;
!true;
1 != 0;
```

View File

@ -1,102 +0,0 @@
# Boolean
true or false.
A Boolean has one of two possible values: `true`; `false`. Boolean (logical) operators (*and*, *or*, *not*) take Boolean inputs and yields a Boolean value. Comparison operators on other types ([numbers](/reference/types/number), [strings](/reference/types/string) yields a Boolean value.
The following blocks represent the true and false Boolean values, which can be plugged in anywhere a Boolean value is expected:
```blocks
true;
false;
```
The next three blocks represent the three Boolean (logic) operators:
```blocks
true && false;
true || false;
!true;
```
The next six blocks represent comparison operators that yield a Boolean value. Most comparisons you will do involve [numbers](/reference/types/number):
```blocks
42 == 0;
42 != 0;
42 < 0;
42 > 0;
42 <= 0;
42 >= 0;
```
Boolean values and operators are often used with an [if](/blocks/logic/if) or [while](/blocks/loops/while) statement to determine which code will execute next. For example:
### Functions that return a Boolean
Some functions return a Boolean value, which you can store in a Boolean variable. For example, the following code gets the on/off state of `point (1, 2)` and stores this in the Boolean variable named `on`. Then the code clears the screen if `on` is `true`:
### Boolean operators
Boolean operators take Boolean inputs and evaluate to a Boolean output:
### Conjunction: `A and B`
`A and B` evaluates to `true` if-and-only-if both A and B are true:
```blocks
false && false == false;
false && true == false;
true && false == false;
true && true == true;
```
### Disjunction: `A or B`
`A or B` evaluates to `true` if-and-only-if either A is true or B is true:
```blocks
false || false == false;
false || true == true;
true || false == true;
true || true == true;
```
### Negation: `not A`
`not A` evaluates to the opposite (negation) of A:
```blocks
!false == true;
!true == false;
```
### Example
This example turns on LED `3 , 3`, if LEDs `1 , 1` and `2 , 2` are both on:
```blocks
if (led.point(1,1) && led.point(2,2)) {
led.plot(3,3)
}
```
### Comparisons of numbers and strings
When you compare two Numbers, you get a Boolean value, such as the comparison `x < 5` in the code below:
```blocks
let x = Math.random(5)
if(x < 5) {
basic.showString("low");
} else {
basic.showString("high");
}
```
See the documentation on [Numbers](/reference/types/number) for more information on comparing two Numbers. You can also [compare strings](/reference/types/string-functions) using the `equals` function.
### See also
[if](/blocks/logic/if), [while](/blocks/loops/while), [number](/reference/types/number)

View File

@ -1,28 +0,0 @@
# If
### @parent blocks/language
Conditionally run code depending on whether a [Boolean](/blocks/logic/boolean) condition is true or false.
```blocks
if(true) {
}
```
Click on the dark blue gear icon (see above) to add an *else* or *if* to the current block.
### Example: adjusting screen brightness
```blocks
if(input.lightLevel()<100){
led.setBrightness(255);
}
```
If the [light level](/reference/input/light-level) is `< 100`, this code sets the brightness to `255`:
### See also
[while loop](/blocks/loops/while), [for](/blocks/loops/for), [boolean](/blocks/logic/boolean)

View File

@ -1,7 +0,0 @@
# Loops
```cards
for(let i = 0;i<5;i++) {}
while(true) {}
basic.forever(() => {});
```

View File

@ -1,20 +0,0 @@
# For
### @parent blocks/language
Run part of the program the number of times you say.
### Example: Count to 4
This program will show the numbers 0, 1, 2, 3, and 4 one after another on the LED screen.
```blocks
for(let i = 0; i < 5; ++i) {
basic.showNumber(i)
}
```
### See also
[repeat](/blocks/loops/repeat), [while](/blocks/loops/while), [if](/blocks/logic/if), [show number](/reference/basic/show-number)

View File

@ -1,12 +0,0 @@
# Repeat
Run part of the program the number of times you say.
### Block Editor
![](/static/mb/blocks/contents-0.png)
### See also
[for](/blocks/loops/for), [while](/blocks/loops/while), [if](/blocks/logic/if), [show number](/reference/basic/show-number)

View File

@ -1,29 +0,0 @@
# While
Repeat code while a [Boolean](/blocks/logic/boolean) `condition` is true.
```blocks
while(true) {
}
```
The while loop has a *condition* that evaluates to a [Boolean](/blocks/logic/boolean) value. After the `do` keyword, add the code that you want to run while the `condition` is `true`. The while loop concludes with `end while`.
The condition is tested before any code runs. Which means that if the condition is false, the code inside the loop doesn't execute.
### Example: diagonal line
The following example uses a while loop to make a diagonal line on the LED screen (points `0, 0`, `1, 1`, `2, 2`, `3, 3`, `4, 4`).
```blocks
let index = 4;
while(index >= 0) {
led.plot(index, index);
index--;
}
```
### See also
[on button pressed](/reference/input/on-button-pressed), [for](/blocks/loops/for), [if](/blocks/logic/if), [forever](/reference/basic/forever)

View File

@ -1,36 +0,0 @@
# Math
### [Numeric](/reference/types/number) values: 0, 1, 2, ...
```block
0;
1;
2;
```
### Arithmetic binary operation (+, -, *, /)
```block
0+1;
0-1;
1*2;
3/4;
```
### Absolute value
```block
Math.abs(-5);
```
### Minimum/maximum of two values
```block
Math.min(0, 1);
```
### Random value
```block
Math.random(5);
```

View File

@ -1,21 +0,0 @@
# Variables
[Assign](/blocks/variables/assign) (set) a variable's value
```blocks
let x = 0;
```
Get a variable's value
```blocks
let x = 0;
x;
```
[Change](/blocks/variables/change-var) a variable's value
```blocks
let x = 0;
x+=1;
```

View File

@ -1,36 +0,0 @@
# Assignment Operator
Use an equals sign to make a [variable](/blocks/variables/var) store the [number](/reference/types/number)
or [string](/reference/types/string) you say.
When you use the equals sign to store something in a variable, the equals sign is called
an *assignment operator*, and what you store is called a *value*.
### Storing numbers in variables
This program makes the variable `item` equal `5` and then shows it on the [LED screen](/device/screen).
````blocks
let item = 5
basic.showNumber(item)
````
### Storing strings in variables
This program makes the variable `name` equal `Joe` and then shows it on the [LED screen](/device/screen).
````blocks
let name = "Joe"
basic.showString(name);
````
### Notes
You can use the assignment operator with variables of
every [type](/reference/types). A *type* is which kind of thing
a variable can store, like a number or string.
### See also
[variable](/blocks/variables/var), [types](/reference/types)

View File

@ -1,40 +0,0 @@
# Change Value
Set the value for local and global variables.
### @parent blocks/change-value
Change the value of a variable
```blocks
let x = 0
x += 1
```
### Declare a variable
Use the assignment operator to set the value of a [variable](/blocks/variables/var). Change the value of a variable from 0 to 1 using the change item block. Like this:
```blocks
let x = 0
x += 1
```
### Example
Use the assignment operator to set the value of a [variable](/blocks/variables/var). Change the value of a variable from 0 to 1 using the change item block. Then display the new value of the variable on the LED screen. Like this:
```blocks
let x = 0;
x += 1;
basic.showNumber(x);
```
### Notes
* You can use the assignment operator with variables of each of the supported [types](/reference/types).
### See also
[variable](/blocks/variables/var), [types](/reference/types)

View File

@ -1,87 +0,0 @@
# Local Variables
How to define and use local variables.
### @parent language
A variable is a place where you can store and retrieve data. Variables have a name, a [type](/reference/types), and value:
* *name* is how you'll refer to the variable
* *type* refers to the kind of data a variable can store
* *value* refers to what's stored in the variable
### Var statement
Use the Block Editor variable statement to create a variable
and the [assignment operator](/blocks/variables/assign)
to store something in the variable.
For example, this code stores the number `2` in the `x` variable:
```blocks
let x = 2;
```
Here's how to define a variable in the Block Editor:
1. Click `variables`.
2. Change the default variable name if you like.
3. Drag a block type on the right-side of the [assignment operator](/blocks/variables/assign) and click the down arrow to change the variable name.
A variable is created for the number returned by the [brightness](/reference/led/brightness) function.
```blocks
let b = led.brightness();
```
### Using variables
Once you've defined a variable, just use the variable's name whenever you need what's stored in the variable. For example, the following code shows the value stored in `counter` on the LED screen:
```blocks
let counter = 1;
basic.showNumber(counter);
```
To change the contents of a variable use the assignment operator. The following code sets `counter` to 1 and then increments `counter` by 10:
```blocks
let counter = 1;
counter = counter + 10;
basic.showNumber(counter);
```
### Why use variables?
If you want to remember and modify data, you'll need a variable.
A counter is a great example:
```blocks
let counter = 0;
input.onButtonPressed(Button.A, () => {
counter = counter + 1;
basic.showNumber(counter);
});
```
### Local variables
Local variables exist only within the function or block of code where they're defined. For example:
```blocks
// x does NOT exist here.
if (led.brightness() > 128) {
// x exists here
let x = 0;
}
```
#### Notes
* You can use the default variable names if you'd like, however, it's best to use descriptive variable names. To change a variable name in the editor, select the down arrow next to the variable and then click "new variable".
### See also
[types](/reference/types), [assignment operator](/blocks/variables/assign)