# PyLogo # Exemple de primitives logo imlémentées \- https://turing.cs.hbg.psu.edu/LOCAL/ucblogo/ucbl\_7.htm \- https://fmslogo.sourceforge.io/manual/workspace-control.html \- https://www.calormen.com/jslogo/language.html The section numbers are per the [Berkeley Logo Reference Manual](https://www.cs.berkeley.edu/~bh/v2ch14/manual.html) in Brian Harvey's Computer Science Logo Style volume 2: Advanced Techniques for ease of comparison.

1. [Data Types and Syntax](https://www.calormen.com/jslogo/language.html#types) 2. [Data Structure Primitives](https://www.calormen.com/jslogo/language.html#sec2) 3. [Communication](https://www.calormen.com/jslogo/language.html#sec3) 4. [Arithmetic](https://www.calormen.com/jslogo/language.html#sec4) 5. [Logical Operations](https://www.calormen.com/jslogo/language.html#sec5) 6. [Graphics](https://www.calormen.com/jslogo/language.html#sec6) 7. [Workspace Management](https://www.calormen.com/jslogo/language.html#sec7) 8. [Control Structures](https://www.calormen.com/jslogo/language.html#sec8)

### Data Types and Syntax

`"word`
`'word`
`number`: Word. (Quoted words are terminated by \[\](){} or whitespace, \\ to escape.); show "hello; show "hello\\ logo; show 12.34
`:variable`: Input definition/variable reference; show :name
`[ word ... ]`: List of words or lists, whitespace separated; show \[1 2 3\]
`{ word ... }`
`{ word ... }@origin`: Array of words, whitespace separated; show {1 2 3}
` ( expression )`: Parenthesis can be used to group expressions; show ( 1 + 2 ) \* 3
`procedure input ...`: Call procedure with default number of inputs; show "hello
` ( procedure input ... )`: Call procedure with an arbitrary number of inputs; (show "hello :name)

### 2. Data Structure Primitives #### 2.1 Constructors

`word expr expr`
`(word expr ...)`: Concatenate two (or more) words into one word; show (word "a "b "c)
`list thing1 thing2`
`(list thing1 thing2 ...)`: Create a new list from the inputs; show (list 1+2 2+3 3+4)
`sentence thing1 thing2`
`(sentence thing1 thing2 ...)`
`se thing1 thing2`
`(se thing1 thing2 ...)`: Create a new list from the inputs (if non-lists) or members of the inputs (if lists); show sentence \[1 2 3\] \[and so on\]
`fput thing list`
`lput thing list`: Outputs list, but with thing added as a new first/last item; if list is a word, concatenates; show fput 0 \[ 1 2 3 \]; show fput "a "bcd; show lput 4 \[ 1 2 3 \]; show lput "e "bcd
`array size`
`(array size origin)`: Create a new array. The default origin is 1.; show array 10
`mdarray [dimensions ...]`
`(mdarray [dimensions ...] origin)`: Create a new multi-dimensional array. The default origin is 1.; show mdarray \[2 2\]
`listtoarray list`
`(listtoarray list origin)`: Create a new array populated by members of a list; show listtoarray \[ 1 3 5 7 \]
`arraytolist array`: Create a new list populated by members of a array; show arraytolist { 2 4 6 8 }
`combine thing1 thing2`: If thing2 is a word, like `word`; otherwise, like `fput`; show combine "a \[b c\]
`reverse list`: Outputs a list with the items in reverse order; if input is a word, reverses characters; show reverse \[ 1 2 3 \]; show reverse "abc
`gensym`: Outputs a unique string, e.g. G1, G2, etc.; show gensym

#### 2.2 Data Selectors

`first list`
`last list`: Outputs the first or last item (or character) from the list (or word), respectively; show first \[ 1 2 3 \]; show first "abc; show last \[ 1 2 3 \]; show last "abc
`firsts listoflists`: Outputs a list of the first item (or character) of each sublist (or word); show firsts \[ \[1 2 3\] \[a b c\] \]; show firsts \[ abc def \]
`butfirst list`
`bf list`
`butlast list`
`bl list`: Outputs the list (or word), except for the first/last item (or character); show butfirst \[ 1 2 3 \]; show butfirst "abc; show butlast \[ 1 2 3 \]; show butlast "abc
`butfirsts listoflists`
`bfs listoflists`: Outputs a list of sublists (or words) without the first item (or characters); show butfirsts \[ \[ 1 2 3 \] \[ a b c \] \]; show butfirsts \[ abc def \]
`item index thing`: Outputs the indexth item of the list or array or word; show item 2 \[ 1 2 3 \]; show item 2 "abc
`mditem [index ...] thing`: Outputs an item from a multi-dimensional array; show mditem \[2 1\] {{a b} {c d}}
`pick list`: Outputs one item from a list (or word), at random; show pick \[ 1 2 3 \]; show pick "abc
`remove thing list`: Outputs the list (or word) with any occurences of thing removed; show remove "b \[ a b c \]; show remove "a "banana
`remdup list`: Outputs the list (or word) with duplicates removed; show remdup \[ 1 2 3 2 3 4 3 4 5 \]; show remdup "banana
`quoted thing`: Outputs thing with " prepended if a word, or just thing otherwise.; show quoted "abc
`split thing list`: Outputs the list split into a list of lists (or list of words) wherever thing appears.; show split "a "banana; show split 3 \[1 2 3 4 1 2 3 4\]

#### 2.3 Data Mutators

`setitem index array value`: Sets the indexth item of the array to value (circular arrays prevented); make "a { 1 2 3 } setitem 2 :a "x show :a
`mdsetitem [index...] array value`: Sets an item in a multi-dimensional array to value (circular arrays prevented); make "a {{1 2} {3 4}} mdsetitem \[2 1\] :a "x show :a
`.setfirst list value`: Sets the first item of the list to value; make "a \[ 1 2 3 \] .setfirst :a "7 show :a
`.setbf list value`: Sets the 'butfirst' of the list to the items in value (a list); make "a \[ 1 2 3 \] .setbf :a \[ 4 9 \] show :a
`.setitem index array value`: Sets the indexth item of the array to value (circular arrays allowed); make "a { 1 2 3 } setitem 2 :a "x show :a
`push stackname thing`
`pop stackname`: Push to/pop from a stack i.e. list variable. Stacks grow from the front. Works on words.; make "s \[ 2 1 \] push "s 3 show :s show pop "s; make "s "ba push "s "c show :s show pop "s
`queue stackname thing`
`dequeue stackname`: Add/remove from a queue i.e. list variable, Queues grow from the end. Works on words.; make "q \[ 1 2 \] queue "q 3 show :q show dequeue "q; make "q "ab queue "q "c show :q show dequeue "q

#### 2.4 Predicates Predicates return 1 (true) or 0 (false)

`wordp thing`
`word? thing`
`listp thing`
`list? thing`
`arrayp thing`
`array? thing`
`numberp thing`
`number? thing`: Test if thing is a word, list, array, or number respectively.
`emptyp expr`
`empty? expr`: Test if thing is an empty list or empty string.
`equalp expr expr`
`equal? expr expr`
`expr = expr`
`notequalp expr expr`
`notequal? expr expr`
`expr <> expr`: Equality/inequality tests. Compares strings, numbers, or lists (equal if length and all members are equal).
`beforep thing1 thing2`
`before? thing1 thing2`: Test string collation order.
`.eq thing1 thing2`: Test if things have the same identity.
`memberp thing list`
`member? thing list`: Test if thing is equal to any member of list.
`substringp thing1 thing2`
`substring? thing1 thing2`: Test if thing1 is a substring of thing2.

#### 2.5 Queries

`count thing`: Outputs length of a list or number of characters in a string; show count \[ 1 2 3 \]; show count "hello
`ascii expr`: Outputs ASCII (actually, Unicode) code point for first character of string; show ascii "abc
`char expr`: Outputs Unicode character at specified code point; show char 97
`member thing list`: Outputs the list (or word) from the first occurence of thing to the end, or empty list (or word); show member "a "banana; show member 2 \[1 2 3 4\]
`uppercase expr`
`lowercase expr`: Outputs string converted to upper/lowercase; show uppercase "abc; show lowercase "ABC
`standout expr`: Outputs string with alphanumeric characters in bold; show standout "ABCabc123
`parse word`: Outputs word parsed as a list.; show parse "1+2
`runparse word`: Outputs word parsed as instructions.; show runparse "1+2

### 3. Communication #### 3.1 Transmitters

`print thing`
`pr thing`
(`print thing1 thing2 ...)`
(`pr thing1 thing2 ...)`: Print inputs to the text screen, separated by spaces, and followed by a newline. Square brackets are only put around sublists.; print "hello
`type thing`
(`type thing1 thing2 ...)`: Like `print` but with no trailing newline.; type "hel type "lo
`show thing`
(`show thing1 thing2 ...)`: Like `print` but with square brackets around list inputs.; show "hello

#### 3.2 Receivers

`readlist`
`(readlist promptstr)`: Prompt the user for a line of input. The result is a list of words.; show readlist; make "colors (readlist \[Type some colors:\]) show :colors
`readword`
`(readword promptstr)`: Prompt the user for a line of input. The result (including spaces) is the single word output.; show readword; make "name (readword \[What is your name?\]) show :name

#### 3.4 Terminal Access

`cleartext`
`ct`: Clear the text screen.
`settextcolor color`: Change the text color.
`textcolor`: Output the current text color.
`increasefont`
`decreasefont`: Increase/decrease the text size.
`settextsize height`: Change the text size (in pixels).
`textsize`: Output the current text size (in pixels).
`setfont name`: Change the text font.
`font`: Output the current text font.

### 4. Arithmetic #### 4.1 Numeric Operations Inputs are numbers or numeric expressions, output is a number.

`sum expr expr`
`(sum expr ...)`
`expr + expr`
`difference expr expr`
`expr - expr`
`product expr expr`
`(product expr ...)`
`expr * expr`
`quotient expr expr`
`(quotient expr)`
`expr / expr`
`power expr expr`
`expr ^ expr`: Add, subtract, multiply, divide, and raise-to-the-power-of respectively. A single input to quotient returns the reciprocal.
`remainder expr expr`
`expr % expr`
`modulo expr expr`: Outputs the remainder (modulus). For `remainder` and `%` the result has the same sign as the first input; for `modulo` the result has the same sign as a the second input.
`minus expr`
`- expr`: Unary minus sign must begin a top-level expression, follow an infix operator, or have a leading space and no trailing space.
`abs num`: Absolute value
`int num`
`round num`: Truncate or round a number, respectively.
`sqrt expr`
`exp expr`
`log10 expr`
`ln expr`: Square root, *e* to the power of, common logarithm, and natural logarithm, respectively.
`arctan expr`
`(arctan x y)`
`sin expr`
`cos expr`
`tan expr`: The usual trig functions. Angles are in degrees.
`radarctan expr`
`(radarctan x y)`
`radsin expr`
`radcos expr`
`radtan expr`: The usual trig functions. Angles are in radians.
`iseq first last`: Outputs a list with integers from first to last, inclusive; show iseq 1 10
`rseq first last count`: Outputs a list of count numbers from first to last, inclusive; show rseq 1 9 5

#### 4.2 Numeric Predicates

`lessp expr expr`
`less? expr expr`
`expr < expr`
`greaterp expr expr`
`greater? expr expr`
`expr > expr`
`lessequalp expr expr`
`lessequal? expr expr`
`expr <= expr`
`greaterequalp expr expr`
`greaterequal? expr expr`
`expr >= expr`: Less than, greater than, less than or equal to, greater than or equal to, respectively. Inputs are numbers or numeric expressions, output is 1 (true) or 0 (false).

#### 4.3 Random Numbers

`random expr`
`(random start end)`: Outputs a random number from 0 through one less than expr, or from start to end inclusive.; show random 10; show (random 1 6)
`rerandom`
(`rerandom expr)`: Reseeds the random number generator, either to a fixed value or the specified seed.

#### 4.4 Print Formatting

`form expr width precision`: Outputs a formatted string with the result of a numeric expression with precision decimal places and padded on the left with spaces (if necessary) to be at least width characters long.; show form 1/3 10 3

#### 4.5 Bitwise Operations

`bitand expr expr`
`(bitand expr ...)`
`bitor expr expr`
`(bitor expr ...)`
`bitxor expr expr`
`(bitxor expr ...)`
`bitnot expr`: Bitwise and, or, exclusive-or, and not, respectively.
`ashift expr bitcount`: Arithmetic bit shift. If bitcount is negative, shifts to the right, preserving sign.
`lshift expr bitcount`: Logical bit shift. If bitcount is negative, shifts to the right, zero-filling.

### 5. Logical Operations

`true`: Outputs 1
`false`: Outputs 0
`and expr expr`
`(and expr ...)`
`or expr expr`
`(or expr ...)`
`xor expr expr`
`(xor expr ...)`
`not expr`: Logical "and", "or", "exclusive-or", and "not", respectively. Inputs are numbers or numeric expressions, output is 1 (true) or 0 (false).

### 6. Graphics An introduction to [Turtle Geometry](https://www.cs.berkeley.edu/~bh/v1ch10/turtle.html). #### 6.1 Turtle Motion

`forward expr`
`fd expr`: Move turtle forward expr pixels; fd 100
`back expr`
`bk expr`: Move turtle backward expr pixels; bk 100
`left expr`
`lt expr`: Rotate expr degrees counterclockwise; lt 90
`right expr`
`rt expr`: Rotate expr degrees clockwise; rt 90
`setpos [ expr expr ]`
`setxy expr expr`
`setx expr`
`sety expr`: Move turtle to the specified location; setpos \[ 100 -100 \]; setxy -100 100
`setheading expr`
`seth expr`: Rotate the turtle to the specified heading; setheading 45
`home`: Moves the turtle to center, pointing upwards
`arc angle radius`: Without moving the turtle, draws an arc centered on the turtle, starting at the turtle's heading.; arc 180 100

#### 6.2 Turtle Motion Queries

`pos`
`xcor`
`ycor`: Outputs the current turtle position as \[ x y \], x or y respectively; show pos
`heading`: Outputs the current turtle heading; show heading
`towards [ expr expr ]`: Outputs the heading towards the specified \[ x y \] coordinates; show towards \[ 0 0 \]
`scrunch`: Outputs the current graphics scaling factors; show scrunch
`bounds`: Outputs the current graphics screen bounds \[ xmin xmax ymin ymax \]; show bounds

#### 6.3 Turtle and Window Control

`showturtle`
`st`: Show the turtle
`hideturtle`
`ht`: Hide the turtle
`clean`: Clear the drawing area
`clearscreen`
`cs`: Same as clean and home together
`wrap`: If the turtle moves off the edge of the screen it will continue on the other side. (default)
`window`: The turtle can move past the edges of the screen, unbounded.
`fence`: If the turtle attempts to move past the edge of the screen it will stop.
`fill`: Does a paint bucket flood fill at the turtle's position.; arc 360 100 fill
`filled fillcolor [ statements ... ]`: Execute statements without drawing but keeping track of turtle movements. When complete, fill the region traced by the turtle with fillcolor and outline the region with the current pen style.; filled "red \[ repeat 5 \[ fd 100 rt 144 \] \]
`label expr`: Draw a word (same logic as `print`) on the graphics display at the turtle location; repeat 8 \[ label "Logo rt 45 \]
`setlabelheight expr`: Set the height for text drawn by `label`, in pixels; setlabelheight 100 label "Logo
`setlabelfont expr`: Set the font for text drawn by `label`; setlabelfont "Times\\ New\\ Roman label "Logo
`setscrunch sx sy`: Set the graphics scaling factors; setscrunch 1 2 arc 360 100
`setturtle index`: Switch to the turtle numbered index (starting from 1 for the default turtle present at start). If the turtle has not been used yet, it will be created at the center, facing upwards, visible, with the pen down.; setturtle 2 rt 90 fd 100
`ask turtleindex [ statements ... ]`: Execute statements as turtle number turtleindex.; ask 2 \[ rt 90 fd 100 \]
`clearturtles`: Remove all turtles, keeping the current one as index 1.; fd 50 setturtle 2 rt 90 fd 100 clearturtles

#### 6.4 Turtle and Window Queries

`shownp`
`shown?`: Outputs 1 if the turtle is shown, 0 if the turtle is hidden
`turtlemode`: Outputs `WRAP`, `WINDOW` or `FENCE`
`labelsize`: Outputs the height of text drawn by `label`, in pixels
`labelfont`: Outputs the name of the font drawn by `label`
`turtle`: Outputs the index of the currently-active turtle
`turtles`: Outputs the largest index that has been passed to `setturtle`

#### 6.5 Pen and Background Control

`pendown`

`pd`

Turtle resumes leaving a trail

`penup`

`pu`

Turtle stops leaving a trail

`penpaint`

`ppt`

`penerase`

`pe`

`penreverse`

`px`

Change the turtle drawing mode - *paint* (the default) leaves a colored trail, *erase* restores the background, *reverse* inverts the background.

setpw 10 px repeat 5 \[ fd 100 rt 144 \]

`setpencolor logocolor`

`setpencolor csscolor`

`setpencolor [r g b]`

Set pen/text color. Color can be a standard Logo color number (0-15), CSS color string ([CSS color names or #rrggbb](https://www.w3.org/TR/css3-color/)), or in the list version, r/g/b values in 0...99.

The standard Logo colors are:

0 black	1 blue	2 green	3 cyan
4 red	5 magenta	6 yellow	7 white
8 brown	9 tan	10 green	11 aqua
12 salmon	13 purple	14 orange	15 gray

setpencolor 4

setpencolor "red

setpencolor "#ff0000

setpencolor \[ 99 0 0 \]

`setpalette colornumber csscolor`

`setpalette colornumber [r g b]`

Change one of the standard color entries (8 or above) to the given color.

setpalette 8 "pink setbg 8

setpalette 8 "#ff4f00 setbg 8

setpalette 8 \[ 99 31 0 \] setbg 8

`setpensize expr`

Set pen width in pixels. If expr is a list, the first member is used.

`setbackground color`

`setscreencolor color`

`setsc color`

Set the background color; same options as `setpencolor`

setbackground "red

#### 6.6 Pen Queries

`pendownp`
`pendown?`: Outputs 1 if the pen is down, 0 otherwise; show pendown?
`penmode`: Outputs `PAINT`, `ERASE` or `REVERSE`; show penmode
`pencolor`
`pc`: Outputs the current pen color. This will be a CSS color string, not necessarily the value passed in.; show pencolor
`palette colornumber`: Outputs the a palette entry. This will be a CSS color string, not necessarily the value passed in.; show palette 8
`pensize`: Outputs a two element list with the pen width and height (usually the same).; show pensize
`background`
`bg`
`getscreencolor`
`getsc`: Outputs the background color. This will be a CSS color string, not necessarily the value passed in.; show background

#### 6.7 Bitmap Operations

`bitcut width height`: Copy a bitmap, from the turtle's position width by height pixels.
`bitpaste`: Paste the previously copied bitmap at the current turtle position.; repeat 4 \[ rt 90 fd 40 \] bitcut 50 50 pu fd 100 bitpaste

#### 6.8 Mouse/Touch Queries

`mousepos`: Outputs a list of the x, y coordinates of the last mouse position; forever \[setpos mousepos\]
`clickpos`: Outputs a list of the x, y coordinates of the last mouse press; forever \[setpos clickpos\]
`buttonp`
`button?`: Outputs 1 if any mouse button is down, 0 otherwise.; forever \[ifelse button? \[pd\] \[pu\] setpos mousepos\]
`button`: Outputs a number indicating the pressed mouse buttons (`1` = left, 2 = right, etc) or 0 for none.
`touches`: Outputs a list of current touch coordinates; forever \[ifelse count touches \[setpos first touches pendown\] \[penup\]\]

### 7. Workspace Management #### 7.1 Procedure Definition

`to procname inputs ... statements ... end`: Define a new named procedure. Inputs can be: - Required: `:a :b` - Optional (with default values): `[:c 5] [:d 7]` - Rest (remaining inputs as a list): `[:r]` - Default number of inputs: `3`; to star :n repeat 5 \[ fd :n rt 144 \] end
`define procname [[inputs ...][statements ...]]`: Define a new named procedure with optional inputs; define "star \[\[n\]\[repeat 5 \[fd :n rt 144\]\]\]
`def procname`: Outputs the definition of a named procedure as a string; show def "star
`text procname`: Outputs the definition of a named procedure as a list, suitable for use with `DEFINE`; show text "star
`copydef newname oldname`: Copy a procedure. If a procedure newname already existed it will be overridden. Primitive procedures can't be overridden unless `REDEFP` is `TRUE`.; copydef "new "old

#### 7.2 Variable Definition

`make varname expr`: Update a variable or define a new global variable. The variable name must be quoted; make "myvar 5
`name expr varname`: Like `make` but with the inputs reversed; name 5 "myvar
`local varname`
`(local varname ...)`: A subsequent `make` will create the variable(s) in the local scope instead of the global scope; local "myvar
`localmake varname expr`: Define a variable in the local scope (shortcut for `local` then `make`; localmake "myvar 5
`thing varname`: Outputs the value of variable. `:foo` is a shortcut for `thing "foo`; show thing "myvar
`global varname`: Reserve the variable at the global scope. This doesn't do anything useful.; global "myvar

#### 7.3 Property Lists

`pprop plistname propname value`: Set the property propname in the property list plistname to value value.
`gprop plistname propname`: Get the value of the property propname in the property list plistname, or the empty list if no such property.
`remprop plistname propname`: Remove the property propname in the property list plistname.
`plist plistname`: Return a list of properties in the property list plistname, alternating property name, property value.

#### 7.4 Workspace Predicates Predicates return 1 (true) or 0 (false)

`procedurep name`
`procedure? name`: Test if there is a procedure with the given name.
`primitivep name`
`primitive? name`: Test if there is a built-in procedure with the given name.
`definedp name`
`defined? name`: Test if there is a user-defined procedure with the given name.
`namep name`
`name? name`: Test if there is a variable with the given name.
`plistp name`
`plist? name`: Test if there is a property list with the given name.

#### 7.5 Workspace Queries

`contents`: Outputs a list with three members. The first is a list of user-defined procedure names. The second is a list of defined variables. The third is a list of non-empty property list names. Only non-buried procedures, variables, and property lists are included.
`buried`: Outputs a list with three members. The first is a list of user-defined procedure names The second is a list of defined variables. The third is a list of non-empty property list names. Only buried procedures, variables, and property lists are included.
`procedures`: Outputs a list of user-defined non-buried procedure names.
`primitives`: Outputs a list of primitive non-buried procedure names.
`globals`: Outputs a list of defined non-buried global variables.
`names`: Outputs a list with two members. The first is an empty list. The second is a list of defined non-buried variables.
`plists`: Outputs a list with three members. The first is an empty list. The second is an empty list. The third is a list of non-empty non-buried property list names.
`namelist name`
`namelist namelist`: Return a `contents`-style list with the given variable names.
`pllist plname`
`pllist plnamelist`: Return a `contents`-style list with the given property lists.
`arity procname`: Return a list with the procedure's minimum, default, and maximum number of inputs; maximum is -1 if unlimited.

#### 7.7 Workspace Control

`erase contentslist`: Takes a three member list, where the first is a list of user-defined procedure names to erase, the second is a list of defined variables to erase, the third is a list of property lists to erase. Primitive procedures can't be erased unless `REDEFP` is `TRUE`.; erase \[ \[myproc\] \[myvar\] \[\] \]
`erall`: Erase all non-buried user-defined procedures, variables and property lists.
`erps`: Erase all non-buried user-defined procedures.
`erns`: Erase all non-buried variables.
`erpls`: Erase all non-buried property lists.
`ern varname`
`ern varnamelist`: Erase the named variable(s).
`epl plname`
`epl plnamelist`: Erase the named property list(s).
`bury contentslist`: Takes a three member list, where the first is a list of user-defined procedure names to bury, the second is a list of defined variables to bury, the third is a list of property lists to bury.
`buryall`: Bury all user-defined procedures, variables, and property lists.
`buryname varname`
`buryname varnamelist`: Bury the given variable (or list of variables).
`unbury contentslist`: Takes a three member list, where the first is a list of user-defined procedure names to unbury, the second is a list of defined variables to unbury, the third is a list of property lists to unbury.
`unburyall`: Unbury all user-defined procedures, variables, and property lists.
`unburyname varname`
`unburyname varnamelist`: Unbury the given variable (or list of variables).
`buriedp contentslist`
`buried? contentslist`: Return 1 if the first named user-defined procedure, variable, or property list exists and is buried, 0 otherwise.

### 8. Control Structures #### 8.1 Control

`run [ statements ... ]`: Run the specified statements once; run \[ fd 100 rt 90 \]
`runresult [ statements ... ]`: Run the specified statements once. If the statements return a value, the result is a list with the value as a single member. Otherwise, the result is an empty list.
`repeat expr [ statements ... ]`: Repeat statements expr times; repeat 4 \[ fd 100 rt 90 \]
`forever [ statements ... ]`: Repeat statements forever. Used inside a user-defined procedure that terminates with `output`, `stop` or `bye`; forever \[ make "n random 100 show :n if :n == 0 \[ bye \] \]
`repcount`
`#`: Outputs the current iteration number of the current `repeat` or `forever`; repeat 10 \[ show repcount \]; repeat 10 \[ show # \]
`if expr [ statements ... ]`
`if [expr] [ statements ... ]`: Execute statements if the expression is non-zero; if 2 > 1 \[ show "yep \]
`ifelse expr [ statements ... ] [ statements ... ]`
`ifelse [expr] [ statements ... ] [ statements ... ]`: Execute first set of statements if the expression is non-zero, otherwise execute the second set; ifelse 1 > 2 \[ show "yep \] \[ show "nope \]
`test expr`
`test [expr]`: Test the specified expression, save the result in the local scope for subsequent use by `iftrue` or `iffalse`
`iftrue [ statements ...]`
`ift [ statements ...]`
`iffalse [ statements ...]`
`iff [ statements ...]`: Run the statements if the result of the last local `test` was non-zero (true) or zero (false) respectively.; test 1 > 2 iftrue \[ show "yep \] iffalse \[ show "nope \]
`stop`: End the running procedure with no output value.
`output expr`
`op expr`: End the running procedure and output the specified value.
`catch tag instructionlist`: Run instructions, but if an error with matching tag is thrown, return the thrown value (if any). Use `"ERROR` to catch errors from regular procedures.; catch "t \[ show "before throw "t show "after \]; catch "error \[ show 1 / 0 \] show error
`throw tag`
`(throw tag value)`: Throw an error with the given tag which may be caught. An optional return value can be passed.; show catch "t \[ show "hello (throw "t "world) \]
`error`: Outputs a list describing the last error caught: an error number, an error message message, and the procedure name where the error occurred.; catch "error \[ show 1 / 0 \] show error
`wait time`: Pauses execution. time is in 60ths of a second.
`bye`: Terminate the program
`.maybeoutput expr`: Like `output` if expr returns a value, like `stop` otherwise
`ignore expr`: Evaluate and ignore results of the expression; make "q \[ 1 2 3 \] ignore dequeue "q
`` list`: Outputs the list with substitutions: - `, instructionlist` replaced by output - `,@ instructionlist` replaced by output list members - `",instruction` replaced by output prefixed with " - `,@instruction` replaced by output prefixed with :; show `\[a b ,\[bf \[c d e\]\] f ,@\[bf \[g h i\]\]\]; make "v "x show `\[",:v :,:v\]
`for controllist [ statements ...]`: Typical `for` loop. The controllist specifies three or four members: the local varname, start value, limit value, and optional step size.; for \[ a 1 10 \] \[ show :a \]; for \[ a 0 20 2 \] \[ show :a \]
`dotimes [varname times] [ statements ...`: Run the statements the specified number of times. The variable varname is set to the current iteration number.; dotimes \[ i 5 \] \[ show :i \* :i \]
`do.while [ statements ...] expr`
`do.while [ statements ...] [expr]`: Runs the specified statements at least once, and repeats while the expression is non-zero (true).; do.while \[ make "a random 10 show :a \] :a < 8
`while expr [ statements ...]`
`while [expr] [ statements ...]`: Runs the specified statements only while the expression remains non-zero (true).; while (random 2) = 0 \[ show "zero \] show "one
`do.until [ statements ...] expr`
`do.until [ statements ...] [expr]`: Runs the specified statements at least once, and repeats while the expression is zero (false).; do.until \[ make "a random 10 show :a \] :a < 8
`until expr [ statements ...]`
`until [expr] [ statements ...]`: Runs the specified statements only while the expression remains zero (false).; until (random 2) = 0 \[ show "one \] show "zero
`case value [ clauses ... ] `: For each clause in order: If the clause is of the form `[ ELSE expr ]` then expr is evaluated and returned. Otherwise, if the clause is of the form `[ [ matches ] expr ]` and value is a member of matches then expr is evaluated and returned.; show case :var \[ \[ \["a\] "AAA \] \[ \["b\] "BBB \] \[ else "other \] \]
`cond [ clauses ... ] `: For each clause in order: If the clause is of the form `[ ELSE expr ]` then expr is evaluated and returned. Otherwise, if the clause is of the form `[ [ expr1 ] expr2 ]` and expr1 evaluates to non-zero (true) then expr2 is evaluated and returned.; show cond \[ \[ \[:var = 1\] "one\] \[ \[:var = 2\] "two\] \[ else "other \] \]

#### 8.2 Template-based Iteration These higher-level procedures support only the *named procedure* form of template. The first input is the name of a procedure to call.

`apply procname list`: Call procname with the members of list as inputs
`invoke procname input1`
`(invoke procname input1 ...)`: Call procname with the specified inputs as inputs; invoke "show "hello
`foreach list procname`: call procname for each item in the list; foreach \[1 2 3\] "show
`map procname list`: Outputs a list composed of the results of calling procname for each item in the list; to double :n output :n \* 2 end show map "double \[1 2 3\]
`filter procname list`: Outputs a list composed of the input list where procname called on the item returns non-zero (true); to oddp :n output bitand :n 1 end show filter "oddp \[ 1 2 3 4 5 \]
`find procname list`: Outputs the first item in list for which calling procname on it returns non-zero (true). If not found, the empty list is returned.; to oddp :n output bitand :n 1 end show find "oddp \[ 2 8 4 7 10 9 \]
`reduce procname list`
`(reduce procname list initial)`: Call procname repeatedly with two inputs - the current value and the next list item. If initial is not specified, the first list element is used instead.; show reduce "sum \[ 1 2 3 4 5 \]
`crossmap procname listlist`
`(crossmap procname list list ...)`: Call procname repeatedly with inputs from the lists, in all possible combinations.; show crossmap "word \[\[a b\] \[x y\]\]; show (crossmap "word \[a b c\] \[1 2 3 4\])

# sortie discussions et commentaire avec Claude #### version 0.03 \- https://turing.cs.hbg.psu.edu/LOCAL/ucblogo/ucbl\_7.htm \- https://fmslogo.sourceforge.io/manual/workspace-control.html \- https://www.calormen.com/jslogo/language.html ● Le fichier PyLogo\_0.03.py est créé et prêt. Voici le résumé : Modifications apportées 1. En-tête de version (lignes 11-28) Historique des versions ajouté en début de fichier. 2. Classe Workspace (lignes 447-639) Nouvelle classe pour gérer les procédures : \- define() / get() / exists() / erase() \- bury() / unbury() / is\_buried() \- list\_visible() / list\_buried() / list\_all() \- get\_source() - reconstruit le code source d'une procédure \- save() - sauvegarde dans un fichier .logo 3. Nouvelles commandes Logo ┌──────────────────┬──────────────────┬─────────────────────────────────┐ │ Commande │ Alias │ Description │ ├──────────────────┼──────────────────┼─────────────────────────────────┤ │ LISTEPROCEDURES │ PROCEDURES, POCS │ Liste les procédures │ ├──────────────────┼──────────────────┼─────────────────────────────────┤ │ MONTREPROCEDURE │ PO, PRINTOUT │ Affiche le code d'une procédure │ ├──────────────────┼──────────────────┼─────────────────────────────────┤ │ ENTERREPROCEDURE │ BURY │ Protège une procédure │ ├──────────────────┼──────────────────┼─────────────────────────────────┤ │ DETERREPROCEDURE │ UNBURY │ Déprotège une procédure │ ├──────────────────┼──────────────────┼─────────────────────────────────┤ │ SAUVEPROCEDURES │ SAVE │ Sauvegarde dans un fichier │ ├──────────────────┼──────────────────┼─────────────────────────────────┤ │ CHARGEPROCEDURES │ LOAD │ Charge depuis un fichier │ └──────────────────┴──────────────────┴─────────────────────────────────┘ 4. Intégration \- LogoInterpreter utilise maintenant self.workspace au lieu de self.procedures \- Méthode load\_procedures() ajoutée pour charger les fichiers La syntaxe est validée. Tu peux tester avec des commandes comme : POUR CARRE :taille REPETE 4 \[AVANCE :taille DROITE 90\] FIN SAUVEPROCEDURES "mes\_dessins LISTEPROCEDURES Brewed for 7m 7s ❯ C'est un profond remaniement du code qui va permettre d'être plus solide et cohérent pour la suite. Je testerais, mais la lecture du code généré est satisfaisante ! ● Merci. Effectivement, cette refactorisation apporte plusieurs avantages : Architecture plus propre : \- Séparation des responsabilités : Workspace gère les procédures, LogoInterpreter exécute \- Encapsulation : toute la logique de gestion des procédures est centralisée \- Code plus testable unitairement Préparation pour la suite : \- Ajout facile de nouvelles fonctionnalités (bibliothèques, modules) \- Base solide pour l'IDE enfants \- Le système BURY/UNBURY permet de protéger des procédures "système" que tu pourrais fournir Points à tester en priorité : 1. POUR ... FIN → définition de procédure 2. LISTEPROCEDURES → vérifier qu'elle apparaît 3. SAUVEPROCEDURES "test → vérifier le fichier généré 4. CHARGEPROCEDURES "test → après un redémarrage 5. ENTERREPROCEDURE / DETERREPROCEDURE → protection N'hésite pas à revenir si tu rencontres des soucis lors des tests ou pour continuer sur d'autres aspects du projet. # Interface à l'interpréteur # Discussions préalables Discussion Mistral : Je comprends parfaitement ! À ce stade, il est crucial de **clarifier les cas d’usage** pour affiner l’architecture et éviter les choix techniques prématurés. Voici une synthèse des **scénarios clés** à valider, organisés par priorité et impact sur la conception. Ces cas d’usage serviront de base pour les décisions architecturales finales. --- ### **1. Cas d’Usage Principaux (Priorité Haute)** #### **A. Utilisation en Classe (Collaboratif)** **Scénario** : - **5 à 10 enfants** travaillent simultanément sur leurs postes (tablettes/PC). - Ils **partagent des morceaux de code** (ex. : une procédure `POUR MAISON`) et voient les modifications en temps réel. - L’enseignant peut **projeté la tortue virtuelle** sur un mur/écran pour que tous voient le résultat collectif. **Questions clés** : 1. **Partage de code** : - Les enfants peuvent-ils **modifier le même code simultanément** (comme un Google Doc) ? → *Si oui* : Nécessite un système de synchronisation fine (CRDT ou WebSockets + verrouillage). → *Si non* : Un système de "copier-coller partagé" suffit (plus simple). - Faut-il un **historique des modifications** (pour revenir en arrière) ? 2. **Projection centrale** : - La tortue projetée doit-elle **afficher qui a envoyé la dernière commande** (ex. : "Alice a fait AVANCE 50") ? - Faut-il un **mode "présentation"** où l’enseignant peut geler l’affichage pour expliquer un concept ? 3. **Rôle de l’enseignant** : - Peut-il **bloquer l’envoi de commandes** pendant une explication ? - Peut-il **sauvegarder les projets** de tous les enfants en une fois ? --- #### **B. Intégration avec la Tortue-Robot** **Scénario** : - La classe dispose d’**1 ou 2 tortues-robot** (MicroPython) qui se déplacent sur une feuille au sol. - Les enfants envoient des commandes depuis leurs postes, et la tortue-robot **exécute les mêmes mouvements** que la tortue virtuelle projetée. **Questions clés** : 1. **Synchronisation virtuel/physique** : - La tortue-robot doit-elle **suivre exactement** la tortue virtuelle (même position, même vitesse) ? → *Si oui* : Nécessite un système de calibration précis (ex. : 1 pas virtuel = 1 cm physique). → *Si non* : La tortue-robot exécute les commandes **indépendamment**, avec ses propres contraintes (ex. : elle bute sur un obstacle). 2. **Feedback physique** : - Si la tortue-robot est bloquée, faut-il **afficher un message d’erreur** sur tous les écrans (ex. : "La tortue ne peut pas avancer !") ? - Peut-on **envoyer des commandes "spéciales"** à la tortue-robot (ex. : allumer une LED, émettre un son) ? 3. **Logistique** : - Combien de tortues-robot seront utilisées **simultanément** ? - Faut-il prévoir un **système de réservation** (ex. : "C’est au tour de Bob d’utiliser la tortue") ? --- #### **C. Utilisation Individuelle (À la Maison)** **Scénario** : - Un enfant utilise l’interpréteur **seul sur son poste**, sans tortue-robot ni projection. - Il peut **sauvegarder ses projets** et les retrouver en classe. **Questions clés** : 1. **Sauvegarde** : - Les projets sont-ils sauvegardés **localement** (fichier sur l’ordinateur) ou **sur un serveur** (compte utilisateur) ? - Faut-il un système de **synchronisation** entre la maison et l’école ? 2. **Compatibilité** : - L’interface doit-elle fonctionner sur **mobile/tablette** (ex. : iPad) ? - Faut-il une **version hors ligne** (pour les zones sans internet) ? --- ### **2. Cas d’Usage Secondaires (Priorité Moyenne)** #### **A. Collaboration À Distance** **Scénario** : - Deux classes (ou un enfant à la maison et un autre en classe) collaborent sur le même projet. **Questions** : - Faut-il un système d’**invitation par lien** (comme Google Docs) ? - Comment gérer les **décalages horaires** ou les connexions instables ? --- #### **B. Extensions Pédagogiques** **Scénario** : - L’enseignant veut **créer des défis** (ex. : "Dessine un hexagone") ou **limiter les commandes disponibles** pour les débutants. **Questions** : - Faut-il un **mode "défi"** où certaines commandes sont désactivées ? - Peut-on **enregistrer des séquences** pour les rejouer plus tard (ex. : pour montrer une solution) ? --- #### **C. Accessibilité** **Scénario** : - Un enfant malvoyant ou avec des troubles dys utilise l’outil. **Questions** : - Faut-il prévoir un **mode haute contraste** ou une **saisie vocale** ? - Peut-on **agrandir la taille du texte** ou des boutons ? --- ### **3. Cas d’Usage Exclus (Priorité Basse)** - **Intégration avec d’autres outils** (ex. : exporter un dessin vers un logiciel de dessin). - **Compétitions entre classes** (ex. : "Qui dessine le plus beau motif ?"). - **Utilisation par des adultes** (ex. : pour des ateliers de programmation créative). --- ### **4. Synthèse des Impacts Architecturaux**

Cas d’Usage	Impact Technique Principal	Complexité
Collaboratif en temps réel	WebSockets + gestion des conflits de code	Élevée
Tortue-robot synchronisée	Communication serveur/MicroPython + calibration	Moyenne
Projection centrale	Séparation frontend/backend + mode lecture seule	Faible
Sauvegarde des projets	Base de données (SQLite) ou fichiers locaux	Faible
Utilisation hors ligne	Service Workers (pour le web) ou app desktop	Moyenne

--- ### **5. Prochaines Étapes pour Toi** 1. **Valider les cas d’usage prioritaires** avec les enseignants/élèves : - Quels scénarios sont **indispensables** pour la rentrée 2026–2027 ? - Quels sont **optionnels** (peuvent attendre une V2) ? 2. **Affiner les contraintes techniques** : - Exemple : Si la tortue-robot doit être synchronisée avec la virtuelle, il faudra un **protocole de communication temps réel** (WebSockets + MicroPython). - Si le partage de code est collaboratif, il faudra choisir entre **CRDT** (complexe) ou **verrouillage** (plus simple). 3. **Prototypage léger** : - Une fois les cas d’usage validés, un **prototype minimal** (ex. : Flask + HTML basique) permettra de tester les flux principaux. --- ### **6. Exemple de Décisions Architecturales Découlant des Cas d’Usage**

Décision	Si Cas d’Usage X est validé...	Sinon...
Technologie backend	Flask + WebSockets (pour le temps réel)	Flask seul (plus simple)
Stockage des projets	SQLite + système de versions (pour l’historique)	Fichiers locaux (JSON)
Frontend	Vue.js léger (pour la réactivité)	Vanilla JS (plus simple)
Communication tortue-robot	WebSockets + protocole custom	USB sériel (pour un prototype)

--- **Question pour toi** : Quels sont les **3 cas d’usage prioritaires** que tu veux absolument voir implémentés pour la rentrée 2026–2027 ? Cela permettra de focaliser l’architecture sur l’essentiel. 😊 *(Exemple de réponse : "1. Collaboratif en classe avec projection, 2. Tortue-robot synchronisée, 3. Sauvegarde locale des projets.")* ### **1. Principes fondateurs de l’UI (version "puriste mais moderne")** #### **a. Minimalisme radical** - **Pas de blocs prédéfinis** (type Scratch) : L’enfant écrit **toujours** du code texte, mais avec des aides **optionnelles et non intrusives**. - **Pas de surcharge visuelle** : L’écran est épuré, avec **uniquement** : - Une **zone de dessin** (tortue + traces). - Une **console de commande** (saisie texte). - Une **zone de procédures** (pour sauvegarder/réutiliser du code écrit par l’enfant). #### **b. Modernité discrète** - **Design sobre mais actuel** : - **Couleurs** : Fond clair (blanc cassé ou bleu très pâle) pour éviter la fatigue oculaire, tortue et textes en noir ou couleurs vives **uniquement pour le feedback** (ex. : syntaxe correcte en vert, erreur en orange). - **Typographie** : Police monospace (ex. **Courier New** ou **Fira Code**) pour le code (lisibilité et alignement des commandes), et une police simple (ex. **Open Sans**) pour les menus. - **Formes** : Lignes épurées, pas de boutons superflus. Les éléments interactifs sont **discrets** mais identifiables (ex. : survol = léger soulignement). - **Feedback visuel intelligent** : - La tortue **clignote brièvement** quand une commande est exécutée (sans son, pour éviter la distraction). - Les erreurs de syntaxe sont signalées par un **soulignement rouge** + message court en bas de l’écran (ex. : *"Il manque un nombre après AVANCE"*). - **Pas d’animations inutiles** : La tortue se déplace **immédiatement** (pas de "dance" ou d’effets de style). #### **c. Personnalisation par l’enfant (sans assistance forcée)** - **Boutons programmables** : - L’enfant peut **créer ses propres boutons** en glissant-déposant **du code qu’il a écrit** dans une zone dédiée (ex. : un bouton "CARRÉ" exécutant sa procédure `POUR CARRE ... FIN`). - Ces boutons sont **des raccourcis**, pas des commandes prédéfinies. Ils apparaissent comme des **étiquettes textuelles simples** (pas d’icônes imposées). - **Éditeur de procédures** : - Une zone latérale (ou un onglet) permet de **lister les procédures définies par l’enfant**, avec un bouton "Éditer" pour les modifier. - **Pas de "bibliothèque" prédéfinie** : Tout doit être écrit par l’enfant ou importé depuis ses propres fichiers. #### **d. Respect de la philosophie Logo** - **Pas de gamification** (badges, étoiles) : L’enfant est motivé par **la création elle-même**, pas par des récompenses externes. - **Pas de "mode découverte" guidé** : L’interface ne propose **jamais** de défis ou de tutoriels intrusifs. En revanche, un bouton "?" peut ouvrir un **manuel minimaliste** avec des exemples de code (ex. : *"Pour dessiner un carré : Répète 4 fois \[AVANCE 100 TOURNE 90\]"*). - **Accès direct au métalangage** : - L’enfant peut **voir et modifier** les primitives de base (ex. : redéfinir `AVANCE` s’il le souhaite, comme dans les versions historiques de Logo). > On est encore en réflexion sur le sujet. J'ai aussi les idées suivante > - permettre à plusieurs enfants de partager en temps réel des codes ou morceaux de code > - pouvoir séparer de l'interface la zone d'exécution ou il y a la tortue : elle peut-être projetée par exemple sur un mur, et les enfants travaillent sur un/leur poste. > - donc ou peut aussi envisager une architecture client/serveur ou un code python/flask sert l'interface ou plusieurs interfaces, dont la zone de projection tortue. > - enfin, j'inscris ce projet dans un suite de projet ou les enfants peuvent utiliser une tortue-robot réelle, qui se déplace sur un feuille sur le sol de la classe. > - ce projet sera porté par les enfants ados et la programmation de la tortue pourrait-être faite au travers de la bibliothèque micro-python PROPOSITION : ## **1. Architecture Globale Proposée** Ton projet combine **4 dimensions** : 1. **Interpréteur Logo collaboratif** (partage de code en temps réel). 2. **Séparation interface/exécution** (projection de la tortue sur un mur). 3. **Architecture client/serveur** (pour gérer plusieurs interfaces et la projection). 4. **Intégration avec des tortues-robot physiques** (via MicroPython). Voici une architecture technique cohérente pour répondre à ces besoins : +-------------------+ +-------------------+ +---------------------+ | Client 1 | | Client 2 | | Projecteur/Écran | | (Enfant A) |------>| (Enfant B) |------>| (Tortue virtuelle) | | - Éditeur de code | | - Éditeur de code | | - Affichage seul | | - Console | | - Console | | - Pas de saisie | +-------------------+ +-------------------+ +---------------------+ \\ / \\ / +-------------------+ +-------------------------------+ | Serveur | | Tortue-Robot (MicroPython) | | (Python/Flask) |<----->| - Reçoit les commandes | | - Gère les sessions| | - Se déplace sur le sol | | - Synchronise | | - Envoie des feedbacks | | le code | | (position, erreurs) | +-------------------+ +-------------------------------+ Merci pour ces précisions passionnantes ! Ton projet prend une dimension **collaborative, physique et pédagogique** très riche, qui dépasse largement un simple interpréteur Logo classique. Voici une analyse structurée des enjeux et des solutions possibles, en gardant à l’esprit tes contraintes (fidélité à l’esprit Logo, modernité discrète, et intégration avec du matériel comme les tortues-robot). --- ## **2. Solutions Techniques par Dimension** ### **A. Collaboratif en temps réel** **Objectif** : Permettre à plusieurs enfants de partager du code ou des morceaux de code. **Solutions** : - **CRDT (Conflict-free Replicated Data Type)** : - Utiliser une bibliothèque comme [Yjs](https://github.com/yjs/yjs) (pour le web) ou [Automerge](https://automerge.org/) (pour une app desktop). - Avantages : Synchronisation fluide, pas de conflits, historique des modifications. - Exemple : Si un enfant écrit `POUR CARRE`, un autre peut voir la définition en temps réel et l’utiliser. - **WebSockets (pour une solution client/serveur)** : - Le serveur Flask diffuse les mises à jour de code à tous les clients connectés. - Exemple avec Flask-SocketIO :

`from flask_socketio import SocketIO, emit@socketio.on('code_update')def handle_code_update(data): emit('code_update', data, broadcast=True) # Envoie à tous les clients`

- **Alternative simple** : - Un système de "copier-coller partagé" via le serveur (moins fluide, mais plus simple à implémenter). --- ### **B. Séparation interface/exécution (projection)** **Objectif** : La tortue s’affiche sur un écran/mur, tandis que les enfants codent sur leurs postes. **Solutions** : - **Mode "Projection"** : - Le serveur Flask génère une **URL dédiée** pour la projection (ex. : `/projection`). - Cette page n’a **que la zone de dessin** (tortue + traces), sans éditeur ni console. - Les enfants envoient leurs commandes au serveur, qui les exécute et met à jour l’affichage pour tous. - **Technos** : - **Frontend** : HTML/Canvas pour la projection (même code que les clients, mais en mode "lecture seule"). - **Backend** : Flask gère les états partagés (position de la tortue, couleurs, etc.). - **Exemple de flux** : 1. Un enfant tape `AVANCE 50` sur son poste. 2. Le code est envoyé au serveur via WebSocket. 3. Le serveur met à jour l’état de la tortue et envoie la nouvelle position à **tous les clients + la projection**. --- ### **C. Architecture Client/Serveur (Flask)** **Objectif** : Centraliser la logique pour gérer plusieurs interfaces et la projection. **Solutions** : - **Flask + SocketIO** : - **Avantages** : - Léger et facile à déployer (même sur un Raspberry Pi en classe). - Permet de gérer les sessions, l’historique des commandes, et la synchronisation. - **Exemple de routes** :

`@app.route('/')def index(): return render_template('editeur.html') # Interface complète pour les enfants@app.route('/projection')def projection(): return render_template('projection.html') # Zone de dessin seule`

- **Stockage des projets** : - Utiliser une base **SQLite** (légère, sans serveur) pour sauvegarder les procédures des enfants. - Exemple de table :

`CREATE TABLE projets ( id INTEGER PRIMARY KEY, nom TEXT, code TEXT, date_modification DATETIME);`

--- ### **D. Intégration avec les tortues-robot (MicroPython)** **Objectif** : Permettre aux enfants de contrôler une tortue physique via le même code Logo. **Solutions** : - **Protocole de communication** : - Le serveur Flask agit comme un **pont** entre les clients et la tortue-robot. - Les commandes Logo sont traduites en instructions MicroPython (ex. : `AVANCE 50` → `robot.forward(50)`). - **Matériel** : - La tortue-robot est équipée d’un **ESP32 ou Raspberry Pi Pico** (compatible MicroPython). - Elle se connecte au serveur via **Wi-Fi** (pour les ESP32) ou **USB** (pour un prototype simple). - **Exemple de code MicroPython** (côté robot) :

`from machine import Pin, PWMimport networkimport socket# Configuration Wi-Fista_if = network.WLAN(network.STA_IF)sta_if.active(True)sta_if.connect('SSID', 'password')# Moteurs (exemple simplifié)def forward(steps): # Logique pour avancer print(f"Avance de {steps} pas")# Serveur TCP pour recevoir les commandess = socket.socket()s.bind(('0.0.0.0', 8080))s.listen(1)while True: conn, addr = s.accept() data = conn.recv(1024).decode() if data.startswith("AVANCE"): steps = int(data.split()[1]) forward(steps) conn.close()`

- **Côté serveur Flask** : - Quand un enfant envoie `AVANCE 50`, le serveur transmet la commande à la tortue-robot via Wi-Fi/USB. --- ## **3. Points d’Attention** - **Latence** : - Avec plusieurs enfants + une tortue physique, la latence peut devenir visible. - **Solution** : Utiliser des WebSockets pour minimiser les délais, et prévoir un système de "file d’attente" pour les commandes. - **Sécurité** : - Si le serveur est accessible sur le réseau de l’école, sécuriser les connexions (mot de passe simple pour la classe). - **Pédagogie** : - **Ne pas cacher la complexité** : Les enfants doivent comprendre que la tortue physique et la tortue virtuelle suivent les mêmes règles. - **Feedback clair** : Si la tortue-robot bute sur un obstacle, envoyer un message comme *"Attention, la tortue est bloquée !"* sur tous les écrans. --- ## **4. Exemple de Workflow Complet** 1. **En classe** : - Les enfants ouvrent leur navigateur sur `http://`. - Ils voient l’éditeur Logo et la console. - Le projecteur affiche `http:///projection`. 2. **Collaboration** : - Alice écrit `POUR CARRE ... FIN`. - Bob peut voir la procédure et l’utiliser dans son propre code. 3. **Exécution** : - Quand un enfant exécute `CARRE`, la tortue virtuelle (projection) et la tortue-robot (si connectée) dessinent un carré. 4. **Feedback** : - Si la tortue-robot rencontre un problème, un message s’affiche sur tous les écrans. --- ## **5. Technologies Recommandées**

Composant	Technologie	Pourquoi
Frontend	HTML/CSS/JS (Vanilla ou Vue.js léger)	Simple, portable, pas de compilation.
Backend	Python/Flask + Flask-SocketIO	Léger, facile à déployer, compatible avec MicroPython.
Base de données	SQLite	Sans serveur, idéale pour un usage en classe.
Tortue-robot	ESP32 + MicroPython	Peu coûteux, programmable en Python, Wi-Fi intégré.
Collaboration	WebSockets (SocketIO)	Temps réel, simple à implémenter avec Flask.

--- ## **6. Prochaines Étapes Possibles** 1. **Prototype minimal** : - Un serveur Flask basique + une page HTML avec un éditeur et un canvas. - Test avec 2 clients et une projection. 2. **Intégration MicroPython** : - Connecter une tortue-robot (ESP32) au serveur et traduire les commandes Logo. 3. **Tests en classe** : - Observer comment les enfants interagissent avec l’outil (collaboration, compréhension des feedbacks). --- **Question pour toi** : - Veux-tu que je te propose un **exemple de code Flask + HTML/JS** pour démarrer le prototype (avec la synchronisation basique et la projection) ? - Ou préfères-tu approfondir un autre aspect (ex. : la communication avec la tortue-robot, ou la gestion des conflits de code) ?