[critor]

En décembre 2020, Casio France avait organisé à l'attention des enseignants un concours de Noël fort intéressant et joliment doté.
Il fallait programmer un dessin de Noël sur au choix sur fx-92+ Spéciale Collège ou en Python sur Graph 35+E II et Graph 90+E.
Un événement réussi qui a incité à la création de très beaux scripts !

Plusieurs enseignants avaient comme nous réagi à l'événement en mentionnant qu'une ouverture des participations aux élèves aurait été très pertinente sur ce genre de concours.

Message visiblement reçu cinq sur cinq en un temps record, Casio nous lance déjà un tout nouveau concours du même genre, Comme un air de Printemps, mais cette fois-ci justement ouvert aux seuls :

• collégiens et collégiennes
• lycéens et lycéennes, aussi bien en voie générale que technologique ou professionnelle (2^nde, 1^ère, T^le, CAP, BEP)

Il te suffit de réaliser un dessin sur le thème de la nature avec ta calculatrice Casio préférée.
Cela peut donc être une fleur, un arbre, un animal...

Aucune obligation d'achat puisque tu peux parfaitement utiliser également l'émulateur de la calculatrice que nous te remettons si besoin en ressource gratuite en fin d'annonce.

Tu peux participer au choix dans les 2 catégories suivantes :

• fx-92+ Spéciale Collège avec son application Algorithmique t'offrant un langage de tracé à la Scratch
• Graph 35+E II ou Graph 90+E avec leur application Python

Attention dans ce dernier cas, pour pouvoir bénéficier des tracés en Python (module casioplot), et éventuellement du module de tracés relatifs turtle, ta calculatrice doit faire tourner la dernière version :

• Graph 35+E II version 3.40
• Graph 90+E version 3.50

Si ce n'est pas le cas nous te remettons ici aussi de quoi mettre à jour gratuitement ta calculatrice en fin d'annonce.

Un jury composé de professeurs de Mathématiques désignera dans chaque catégorie 3 grands gagnants.

Dans chacune des 2 catégories donc, le meilleur dessin gagne le superbe lot suivant d'une valeur d'environ 180€ :
1 disque dur externe SSD de 1 To de capacité + 1 calculatrice graphique Casio Graph au choix

Le 2^ème meilleur dessin gagne pour sa part le non moins superbe lot suivant d'une valeur d'environ 180€ :
1 enceinte bluetooth + 1 calculatrice graphique Casio Graph au choix

Le 3^ème meilleur dessin gagne quant à lui le lot suivant d'une valeur d'environ 140€ :
1 montre Casio vintage or + 1 calculatrice graphique Casio Graph au choix

La calculatrice graphique au choix pourra être une Graph 35+E II ou Graph 90+E.

Mais ce n'est pas tout. Dans chaque catégorie, les 10 premières participations reçues et n'ayant pas remporté un des gros lots précédents recevront un lot de participation : un sac en toile Casio rempli de cadeaux (batterie USB externe, stylo, clé USB, ...), alors vite dépêche-toi !

Les participations sont ouvertes à compter du mercredi 27 janvier. Tu auras jusqu'au lundi 8 mars 2021 inclus pour envoyer par courriel à education-france@casio.fr :

1. une photo ou capture d'écran de ton dessin
2. le script qui le réalise
3. un justificatif de scolarité (photo/scan de ton carnet de correspondance, de ta carte de collégien/lycéen, ou de tout autre document que tu juges pertinent)

Tu manques d'inspiration ? Tu ne connais pas suffisamment ta calculatrice ?

Casio se propose même de t'aider à gagner en t'accompagnant ce mercredi 27 janvier au cours de 2 ateliers en ligne au choix tout spécialement dédiés aux dessins de printemps sur ses calculatrices :

• 14h-15h : appli Algorithmique sur fx-92+ Spéciale Collège
  
  
• 15h-16h : appli Python sur Graph 35+E II et Graph 90+E

Ils correspondant donc bien aux 2 catégories de participations, petits aperçus ci-contre.

Tu peux également aller consulter les scripts des dessins d'enseignants pour le concours de Noël sur fx-92+ Spéciale Collège ainsi que sur Graph 90+E et Graph 35+E II, avec des arbres (sapins) et animaux (cerfs et rennes) rentrant parfaitement dans le thème.

Si tu préfères les fleurs nous en avons également tout un champ sur fx-92+ Spéciale Collège suite à notre concours de rentrée 2018.

Bonne chance à toi !

Peut-être te demandes-tu en passant comment joindre le script de ta fx-92+ Spéciale Collège alors que la machine ne dispose pas de port de communication ?... mais en fait rien de plus simple !

Que tu utilises la calculatrice ou son émulateur il te suffira juste d'en exporter le contenu à l'aide d'un QR Code :

1. obtenir la sauvegarde du contenu sous forme de QR Code en tapant

   SECONDE

   OPTN

2. flasher le QR Code alors obtenu :
   
   • sur émulateur, il te suffit juste de cliquer le QR Code dans la fenêtre popup qui apparaît
   • sur calculatrice, si celle-ci génère 1 seul QR Code, il te suffit de le flasher avec l'outil de ton choix
   • sur calculatrice, si celle-ci génère une série de plusieurs QR Codes (au-delà d'une certaine taille de script), il te faudra les flasher avec l'appli Casio Edu+
   
3. dans la page web qui s'ouvre, de cliquer sur l'icône d'envoi par courriel

Si besoin des tutoriels plus détaillés traitant séparément des 3 situations ici évoquées sont disponibles dans les ressources en fin d'annonce.

Superbe événement, à la coloration thématique fort bienvenue en cette période difficile.

De quoi te distraire et t'amuser quand tu rentres dans ta cage chaque soir à 18 heures ou prochainement pendant tes vacances d'hiver, et t'aider à rêver au retour du printemps et on espère avec lui de la liberté, merci Casio !

Nous avons hâte de voir si tu vas être capable de faire mieux que les enseignants à Noël...

Lien : inscription ateliers mercredi 27 janvier

Téléchargments :

• scripts de fleurs fx-92+ Spéciale Collège
• scripts de Noël fx-92+ Spéciale Collège
• scripts de Noël Casio Graph 90+E et Graph 35+E II en Python
• modèle de participation fx-92+ Spéciale Collège
• modèle de participation Graph 90+E ou Graph 35+E II

Ressources :

Graph
90+E Graph
35+E II fx-92+ Spéciale
Collège

Mise à jour calculatrice :

• 3.50 pour Graph 90+E / fx-CG50 avec Windows / Mac

Émulateurs :

• Graph 90+E / fx-CG50 version 3.50 à installer sur Windows / Mac
  (période d'essai gratuite sans engagement de 90 jours, prolongeable gratuitement si besoin jusqu'au 31 août 2021 si déjà entamée ou épuisée)
• Graph 90+E version 3.50 pour clé USB d'émulation officielle

Transfert de données :

• tutoriel transfert de données

Mise à jour calculatrice :

• Mise à jour 3.40 pour Graph 35+E II / fx-9750/9860GIII avec Windows

Émulateurs :

• Graph 35+E II version 3.40 à installer sur Windows
  (période d'essai gratuite sans engagement de 90 jours, prolongeable gratuitement si besoin jusqu'au 31 août 2021 si déjà entamée ou épuisée)
• Graph 35+E II version 3.40 pour clé USB d'émulation officielle

Transfert de données :

• tutoriel transfert de données

Emulateur :

• fx-92+ Spéciale Collège à installer sur Windows
  (période d'essai gratuite sans engagement de 90 jours, prolongeable gratuitement si besoin jusqu'au 31 août 2021 si déjà entamée ou épuisée)
• fx-92+ Spéciale Collège pour clé USB d'émulation officielle

Transfert de données :

• appli Casio Edu+ pour Android / iOS (gratuite)
• tutoriel flashing QR Codes sur émulateur fx-92+ Spéciale Collège
• tutoriel flashing série de QR Codes sur calculatrice fx-92+ Spéciale Collège avec appli Casio Edu+
• tutoriel flashing QR Code unique sur calculatrice fx-92+ Spéciale Collège avec toute appli

Source : https://www.casio-education.fr/actualit ... mps-casio/

[critor]

Du 9 au 15 Décembre 2020, Casio France avait organisé à l'attention des enseignants un concours de Noël fort intéressant et joliment doté.
Il fallait programmer un dessin de Noël au choix :

• sur calculatrice fx-92+ Spéciale Collège ou son émulateur (langage à la Scratch/Logo)
• en Python sur Graph 35+E II, Graph 90+E ou leur émulateur

Nous t'avions partagé les scripts Python Graph 90+E gracieusement fournis par 3 participants dont les 2 grands gagnants.

Florian Allard alias Afyu, grand gagnant, utilisait le module de tracés relatifs turtle sur Graph 90+E.

Il nous dessinait une scène de Noël très complète. Tout y était, exploitant à fond le large écran de la Graph 90+E :

• le sapin décoré de guirlandes et coiffé d'une étoile
• le renne tirant un traineau recevant une pluie de cadeaux

Etaient tracés dans l'ordre par le code ci-après :

1. le renne avec :
   
   1. sa patte arrière droite
   2. son dos
   3. ses oreilles
   4. ses bois
   5. sa tête
   6. son torse
   7. sa patte avant droite
   8. sa patte avant gauche
   9. son abdomen
   10. sa patte arrière gauche
2. le traineau
3. le harnais
4. le sapin avec :
   
   1. son feuillage
   2. ses guirlandes
   3. ses boules
   4. son étoile
5. les 4 paquets cadeaux avec pour chacun :
   
   1. la boîte
   2. le ruban

Remarquable, on ne repérait quasiment pas d'élément géométrique remarquable, témoin du soin et de la précision apportés au tracé !

Code: Select all

from turtle import *
hideturtle()
penup()
goto(-110,-50)
pendown()
#4  me patte
rt(40)
penup()
for i in range(30):
  fd(1/4)
  lt(1/2)
pendown()
for i in range(30):
  fd(1)
  rt(3-i/15)
for j in range(4):
  for i in range(10):
    fd(1/2)
    lt(3)
  lt(60)
lt(120)
for i in range(10):
  fd(1/2)
  rt(3)
lt(110)
for i in range(20):
  fd(1)
  rt(1.5)
#fd(30)
lt(50)
for i in range(25):
  fd(0.6)
  rt(2)
for i in range(15):
  fd(1)
  lt(3)
for i in range(30):
  rt(12)
  fd(1/2)
for i in range(15):
  fd(1)
  lt(4)
for i in range(30):
  fd(1)
  rt(i//10)
lt(30)
for i in range(40):
  fd(1/2)
  rt(i//10)
setheading(0)
penup()
fd(-15/2)
pendown()#les oreilles
for i in range(40):
  fd(((400-10*i)//160)/2)
  lt(4)
lt(290)
#for i in range(42):
  #fd((10*i)//160)
  #lt(4.2)
#penup()
#for i in range(42):
  #fd(-(10*(28-i))//160)
  #lt(-4.2)
#pendown()
for i in range(40):
  fd(((10*i)//160)/2)
  lt(4)
penup()
rt(90)
#fd(5)
lt(90)
fd(-5/2)
pendown()
#les bois
#penup()
rt(110)
fd(1)
#pendown()
rt(90)
for i in range(20):
  fd(1)
  rt(1)
lt(20)
for j in range(3):
  rt(90)
  #for i in range(20):
    #fd(3)
    #lt(2+20-2*i)
  for i in range(10):
    fd(3/2)
    lt(2+10-i)
  for i in range(4):
    fd(1/2)
    lt(36)
  lt(10)
  for i in range(9):
    fd(1)
    rt(1+2*i)
lt(40)   
for i in range(80):
  fd(1/2)
  rt(2)
for i in range(10):
  fd(1/2)
  lt(18)
for i in range(30):
  fd(1/2)
  lt(1)
for i in range(20):
  fd(1/2)
  rt(3)
#fin des bois
penup()
setheading(-90)
fd(15/2)
lt(90)
fd(1)
pendown()
setheading(240)
pensize(2)
for j in range(2):
  for i in range(40):
    fd(1/12)
    rt(3)
  rt(60)
pensize(1)
setheading(90)
penup()
fd(15/2)
lt(90)
fd(1)
lt(75)

pendown()
rt(60)
for i in range(20):
  fd(1/2)
  lt(2)
lt(40)
for i in range(30):
  fd(1/2)
  rt((30-i)//7)
lt(70)
for j in range(4):
  for i in range(10):
    fd(1/2)
    lt(5)
  lt(40)
rt(0)
#for j in [1,-1]:
  #for i in range(30):
    #fd(j)
    #lt(4*j)
fd(5/2)
rt(50)
fd(1)
lt(70)
for i in range(25):
  fd(1)
  lt((50-5*i)/3.7)
lt(70)
for j in range(2):
  for i in range(10):
    fd(1)
    rt(2)
  lt(40)
rt(50)
fd(7/2)
fd(-7/2)
rt(40)
#1  re patte
for j in range(2):
  for i in range(30):
    fd(1/2)
    rt(1)
  lt(70)
lt(20)
fd(5)
rt(200)
for j in range(4):
  for i in range(10):
    fd(1/2)
    lt(3)
  lt(60)
lt(100)
for j in range(2):
  for i in range(30):
    fd(-1/2)
    rt(-1)
  rt(70)
  penup()
#2  me patte
#lt(90)
fd(15/2)
#pendown()
lt(100)
pendown()
for j in range(2):
  for i in range(30):
    fd(1/2)
    rt(1)
  lt(50)
lt(30)
fd(5)
rt(190)
for j in range(4):
  for i in range(10):
    fd(1/2)
    lt(3)
  lt(60)
lt(100)
for j in range(2):
  for i in range(30):
    fd(-1/2)
    rt(-1)
  rt(60)
#bas du corps
rt(90)
fd(5/2)
fd(-5/2)
rt(120)
for i in range(50):
  fd(1/2)
  lt(1/4)
lt(90)
penup()
fd(15/2)
pendown()
rt(190)
#3  me patte
for i in range(40):
  fd(1/2)
  lt(2-i/20)
rt(0)
for i in range(30):
  fd(1/2)
  rt((100-3*i)/30)
lt(0)
for j in range(4):
  for i in range(10):
    fd(1/2)
    lt(3)
  lt(60)
lt(120)
for i in range(10):
  fd(1/2)
  rt(3)
lt(90)
for i in range(30):
  fd(1/2)
  lt(1)
lt(10)
for i in range(30):
  fd(1/2)
  rt(1+i//15)
rt(20)
for i in range(30):
  fd(1/2)
  lt(1+i//15)



from turtle import *
hideturtle()
penup()
setheading(0)
pencolor([120/255,60/255,0])
pensize(3)
goto(-80,-40)
pendown()
rt(35)
for i in range(45):
  fd(1/2)
  rt(1)
rt(90)
#bois
pensize(3)
pencolor([120/255,60/255,0])
for i in range(30):
  fd(1)
  lt(6)
rt(10)
fd(5)
lt(90)

for i in range(4):
  fd(10)
  rt(90)
  fd(3.5)
  rt(90)
  fd(10)
  lt(90)
  fd(20)
  lt(90)

rt(90)
for i in range(10):
  fd(0.6)
  rt(18)

fd(47*2+5)

for i in range(28):
  fd(1.45)
  rt(6)

rt(84)
for i in range(20):
  fd(1/2)
  rt(1)
fd(7/2)

setheading(0)
fd(90)

#arri  re
lt(90)
for i in range(30):
  fd(3/2)
  rt(i//10)

setheading(0)
for i in range(17):
  fd(1/2)
  lt(10)
fd(3/2)
penup()
fd(-3/2)
for i in range(17):
  fd(-1/2)
  lt(-10)
pendown()
setheading(160)
for i in range(38):
  fd(3)
  lt((15-i)/2)
for i in range(40):
  fd(1/2)
  lt((15-i))
 
penup()
setheading(0)
fd(105)
lt(90)
fd(20)
pendown()

setheading(160)
for i in range(38):
  fd(3)
  lt((15-i)/2)
for i in range(42):
  fd(1/2)
  lt((15-i))

lt(70)
fd(15/2)

pensize(2)
setheading(203)
for i in range(34):
  fd(3)
  rt(2-i/40)



from turtle import *
setheading(-30)
penup()
goto(110,-80)
hideturtle()
#pendown()
pencolor([0,205/255,0])
pensize(2)
for k in [-1,1]:
  penup()
  goto(110,-80)
  setheading(90)
  fd(15)
  setheading(90-120*k)
  fd(16)
  pendown()
  for j in range(4):
    for i in range(30):
      fd(1-j/5)
      lt(k*(1+i//20))
    rt(50*k)
    for i in range(10):
      fd(-1+j/5)
      lt(k*(-1-i//20))

    lt(50*k)
    for i in range(50):
      fd(1-j/5)
      lt(k*(i/30))
    rt(40*k)
    for i in range(40):
      fd(-1+j/5)
      lt(k*(-i//20))

    lt(70*k)
    for i in range(10):
      fd(1-j/5)
      lt(k*(1+i//20))
    rt(30*k)
    for i in range(40):
      fd(-1+j/5)
      lt(k*(-1-i//30))
    setheading(90-90*k-30*k+30*j*k)
  setheading(90-50*k)
  for i in range(30):
    fd(1/2)
    lt(k*(1+i//20))
  rt(40*k)
  for i in range(20):
    fd(-1/3)
    lt(k*(-1-i//20))

  lt(50*k)
  for i in range(30):
    fd(1/2)
    lt(k*(i/10))
  rt(60*k)
  for i in range(30):
    fd(-1/3)
    lt(k*(i/20))

  lt(20*k)
  for i in range(30):
    fd(1/2)
    lt(k*(1+i//20))
#guirlandes
penup()
goto(120,50)
pendown()
pencolor([1,0,0])

setheading(-140)
for i in range(6):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  rt(5)

setheading(-50)
for i in range(10):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  lt(6)
 
setheading(-150)
for i in range(12):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  rt(4)
 
setheading(-60)
for i in range(13):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  lt(6)
 
setheading(-120)
for i in range(15):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  rt(6)
 
setheading(-50)
for i in range(13):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  lt(6)

#boules
from random import randint
for coord in [(17,32),(-17,24),(-60,-10),(15,0),(-30,-40),(40,-50)]:
  penup()
  goto(coord[0]+110,coord[1]-10)
  pensize(20)
  pencolor([randint(1,10)/10,randint(1,10)/10,randint(1,10)/10])
  pendown()
  fd(1)

#etoile
penup()
goto(100,80)
pendown()
pencolor([220/255,220/255,40/255])
pensize(5)
setheading(0)
for i in range(5):
  fd(20)
  rt(72*2)




#paquets
from random import randint
for coord in [(0,20),(-30,-10),(-70,10),(-30,50)]:
  penup()
  goto(coord[0],coord[1])
  pendown()
  pensize(7/2)
  pencolor([randint(1,10)/10,randint(1,10)/10,randint(1,10)/10])
  setheading(randint(1,60)-30)
  for i in range(4):
    fd(20)
    lt(90)
  fd(20)
  lt(45)
  fd(15/2)
  lt(45)
  fd(20)
  lt(135)
  fd(15/2)
  fd(-15/2)
  rt(45)
  fd(20)
  lt(45)
  fd(15/2)
 
 
  penup()
  lt(45)
  pencolor([randint(1,10)/10,randint(1,10)/10,randint(1,10)/10])
  pensize(7/2)
  fd(10)
  #pendown()
  lt(90)
  fd(20)
  lt(45)
  fd(15/2)
 
  fd(-7/2)
  pendown()
  pensize(5/2)
  lt(45)
  fd(-10)
  fd(20)
  lt(90)
  fd(20)
  fd(-20)
  rt(90)
  fd(-10)
  rt(45)
  pensize(7/2)
  penup()
  fd(-4)
  rt(45)
  fd(-10)
  pendown()
  lt(90)
  fd(-10)
  fd(20)
  #ruban
  rt(45)
  fd(7/2)
  rt(15)
  for j in range(2):
    for i in range(30):
      fd(1/2)
      lt(2)
    lt(120)
    for i in range(30):
      fd(1/2)
      lt(2)
    rt(180)

Thomas Fontaine, 2^ème grand gagnant qui s'était déjà illustré au 3^ème défi de notre concours de rentrée 2019, utilise également le module turtle sur Graph 90+E.

Il nous dessinait cette fois-ci un buste de renne.

Un tracé façon 3D fil de fer, décomposant très artistiquement le tout en triangles et quadrilatères telle une sculpture sur bois.

Le script profitait avantageusement en taille de la symétrie verticale, n'ayant donc à décrire que le demi-buste qui sera itéré 2 fois.

Le plus remarquable était qu'une fois le tracé de chaque demi-buste commencé après un goto() et un couple penup/pendown() initial, à aucun moment la tortue ne se téléportait ou ne levait le stylo, superbe arabesque !

Sur chaque demi-buste, étaient tracés dans l'ordre par le code reproduit ci-après:

1. tête
2. oreille
3. cou
4. poitrail
5. bois

Code: Select all

from turtle import *
pensize(2)
for k in [-1,1]:
  penup()
  goto(0,-50)
  pendown()
  hideturtle()

  setheading(90-90*k+30*k)
  fd(19)
  lt(90*k)
  fd(10)

  lt(60*k)
  fd(10)
  fd(-10)
  lt(40*k)
  fd(12)
  fd(-12)
  rt(100*k)

  rt(15*k)
  fd(10)
  rt(15*k)
  fd(10)
  rt(40*k)
  fd(15)
  lt(140*k)
  fd(17)
  fd(-17)
  rt(40*k)
  fd(20)
  fd(-20)
  rt(100*k)
  #oreille
  lt(15*k)
  fd(10)
  lt(60*k)
  fd(7)
  lt(100*k)
  fd(7)
  fd(-7)
  rt(210*k)
  fd(25)
  rt(163*k)
  fd(25)
  fd(-25)
  lt(48*k)
  fd(8)
  rt(65*k)
  fd(20)
  fd(-20)
  lt(50*k)
  fd(20)
  rt(115*k)
  fd(15)
  fd(-15)
  lt(30*k)
  fd(16)
  fd(-16)
  lt(30*k)
  fd(13)

  lt(90*k)
  fd(5)
  rt(110*k)
  fd(10)
  lt(30*k)
  fd(10)
  fd(-10)
  rt(30*k)
  fd(-10)
  lt(90*k)
  fd(20)
  rt(120*k)
  fd(7)
  lt(10*k)
  fd(12)
  fd(-12)
  rt(10*k)
  fd(-7)
  lt(130*k)
  fd(9)

  rt(60*k)
  fd(5)
  lt(45*k)
  fd(50)

  rt(165*k)
  fd(52)
  fd(-52)
  lt(165*k)
  #cou
  lt(140*k)
  fd(35)
  lt(70*k)
  fd(42)
  fd(-42)
  rt(30*k)
  fd(29)
  lt(45*k)
  fd(32)

  rt(40*k)
  fd(5)
  lt(22*k)
  fd(13)
  lt(20*k)
  fd(15)
  lt(40*k)
  fd(11)
  lt(108*k)
  fd(49)
  fd(-49)
# on est en haut de la tete
#bois
  rt(108*k)
  fd(-13)
  #debut des bois
  rt(110*k)
  fd(10)
  lt(90*k)
  fd(6)
  fd(-6)
  rt(130*k)
  fd(30)
  lt(90*k)
  fd(5)
  fd(-5)
  rt(60*k)
  fd(20)
  lt(90*k)
  fd(5)
  fd(-5)
  rt(40*k)
  fd(25)
  lt(165*k)
  fd(25)
  rt(43*k)
  fd(15)
  rt(24*k)
  fd(20)
  fd(-20)
  rt(120*k)
  fd(15)
  lt(90*k)
  fd(5)
  fd(-5)
  rt(45*k)
  fd(25)
  lt(165*k)
  fd(25)
  rt(45*k)
  fd(15)
  rt(45*k)
  fd(5)
  rt(90*k)
  fd(10)
  lt(90*k)
  fd(4)
  fd(-4)
  rt(120*k)
  fd(15)
  lt(165*k)
  fd(15)
  lt(30*k)
  fd(15)
  rt(75*k)
  fd(15)
  fd(-5)
  rt(70*k)
  fd(12)
  lt(160*k)
  fd(12)
  rt(30*k)
  fd(10)

Voici ci-contre ma propre participation, une forêt de Noël, envoyée juste pour le plaisir.
Je ne souhaitais piquer de lot à personne et je l'ai bien dit, et c'est parfait puisque je gagne bien le seul lot de participation.

Ce script disposait d'un mode monochrome, et était compatible à la fois Graph 35+E II et Graph 90+E, même si c'était sur cette dernière qu'il révélait son plein potentiel.

Voici l'astuce utilisée pour détecter le type d'écran :

Code: Select all

def init_casioplot():
  global color_screen, screen_w, screen_h
  set_pixel(0, 0, (0, 0, 255))
  col = get_pixel(0, 0)
  color_screen = col[0] != col[2]
  screen_w, screen_h = color_screen and (384, 192) or (128, 64)

Dans l'ordre, mon script utilisant la bibliothèque de tracé par pixels casioplot :

1. faisait tomber la nuit : Il utilise ici 2 dégradés dans les tons de bleu pour représenter le sol et le ciel.
2. allumait les étoiles (pixels blancs)
3. plantait une forêt de sapins - nous allons y revenir
4. décorait mon plus beau sapin : des disques de rayon 2 selon 3 couleurs de remplissage alternées, avec une couleur voisine pour la bordure rajoutant un peu de relief
5. saupoudrait le tout de neige : des disques de rayon 1

La bibliothèque casioplot offre un nombre assez restreint de fonctions de tracé :

• clear_screen() pour effacer l'écran en blanc
• set_pixel(x,y,couleur) pour allumer un pixel dans une couleur (R,G,B) au choix
• draw_string(x,y,string,couleur,taille) pour écrire du texte dans une couleur RGB et selon une taille de police au choix ("small", "medium" ou "large")

Ce n'est absolument pas un défaut, au contraire cela permet un travail absolument passionnant : la construction et optimisation de fonctions pour tracer chaque primitive. J'avais donc rajouté de quoi tracer des cercles, disques, mais également segments pour les sapins :

Code: Select all

def draw_line(x1, y1, x2, y2, c):
  m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2)
  if (x2 - x1) ** 2 < (y2 - y1) ** 2:
    m, a1, a2, b1, b2 = 1, b1, b2, a1, a2
  if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1
  for k in range(a2 - a1 + 1):
    a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1))
    set_pixel((a, b)[m], (b, a)[m], c)

def draw_ellipse(x, y, rx, ry, c):
  for h in range(-int(ry), int(ry)+1):
    w = sqrt(max(0, rx*rx*(1-h*h/ry/ry)))
    x1, x2 = int(x - w), int(x + w)
    yc = int(y + h)
    set_pixel(x1, yc, c)
    set_pixel(x2, yc, c)
  for w in range(-int(rx), int(rx)+1):
    h = sqrt(max(0, ry*ry*(1-w*w/rx/rx)))
    y1, y2 = int(y - h), int(y + h)
    xc = int(x + w)
    set_pixel(xc, y1, c)
    set_pixel(xc, y2, c)

def fill_ellipse(x, y, rx, ry, c):
  for h in range(-int(ry), int(ry)+1):
    w = sqrt(max(0, rx*rx*(1-h*h/ry/ry)))
    x1, x2 = int(x - w), int(x + w)
    yc = int(y + h)
    draw_line(x1, yc, x2, yc, c)

def draw_circle(x, y, r, c):
  draw_ellipse(x, y, r, r, c)

def fill_circle(x, y, r, c):
  fill_ellipse(x, y, r, r, c)

La construction des sapins utilisait des similitudes, transformations géométriques conservant les rapports de distances.
Une similitude peut se décomposer en une isométrie (transformation conservant les distances : translation, rotation, ...) la plupart du temps suivie d'une homothétie (agrandissement ou réduction).

Plus précisément, en partant d'un couple de seulement 2 points que l'on va appeler le tronc, 5 similitudes étaient appliquées pour créer 5 branches (en bas à gauche, à gauche, en haut, à droite, en bas à droite).

En itérant le même processus sur chacune de ces branches, on faisait ainsi pousser l'arbre, le développant dans ces 5 directions.

Par exemple, sur la capture couleur ci-contre, nous avons de gauche à droite des arbres avec :

• 1 itération
• 3 itérations
• 5 itérations (profitant pleinement des 1 Mio de mémoire de tas Python )
• 4 itérations
• 3 itérations

Pour l'exécution sur Graph 35+E II nous avions dû limiter le nombre d'itérations afin de ne pas exploser la mémoire de tas Python (heap) ici limitée à 100 Kio. Nous avons ici de gauche à droite :

• 0 itération (donc le tronc initial nu)
• 1 itération (donc le tronc avec ses 5 branches initiales)
• 3 itérations
• 2 itérations
• 0 itération

Code: Select all

from math import pi, sin, cos, exp, sqrt
import matplotlib.pyplot as plt
from random import *
from casioplot import *

def init_casioplot():
  global color_screen, screen_w, screen_h
  set_pixel(0, 0, (0, 0, 255))
  col = get_pixel(0, 0)
  color_screen = col[0] != col[2]
  screen_w, screen_h = color_screen and (384, 192) or (128, 64)

def transform(x, y):
  f = screen_h * 45 // 64
  return (x*f,screen_h-1-y*f)

def draw_line(x1, y1, x2, y2, c):
  m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2)
  if (x2 - x1) ** 2 < (y2 - y1) ** 2:
    m, a1, a2, b1, b2 = 1, b1, b2, a1, a2
  if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1
  for k in range(a2 - a1 + 1):
    a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1))
    set_pixel((a, b)[m], (b, a)[m], c)

def draw_ellipse(x, y, rx, ry, c):
  for h in range(-int(ry), int(ry)+1):
    w = sqrt(max(0, rx*rx*(1-h*h/ry/ry)))
    x1, x2 = int(x - w), int(x + w)
    yc = int(y + h)
    set_pixel(x1, yc, c)
    set_pixel(x2, yc, c)
  for w in range(-int(rx), int(rx)+1):
    h = sqrt(max(0, ry*ry*(1-w*w/rx/rx)))
    y1, y2 = int(y - h), int(y + h)
    xc = int(x + w)
    set_pixel(xc, y1, c)
    set_pixel(xc, y2, c)

def fill_ellipse(x, y, rx, ry, c):
  for h in range(-int(ry), int(ry)+1):
    w = sqrt(max(0, rx*rx*(1-h*h/ry/ry)))
    x1, x2 = int(x - w), int(x + w)
    yc = int(y + h)
    draw_line(x1, yc, x2, yc, c)

def draw_circle(x, y, r, c):
  draw_ellipse(x, y, r, r, c)

def fill_circle(x, y, r, c):
  fill_ellipse(x, y, r, r, c)

def horiz_gradient(x, y, w, h, col1, col2):
  for k in range(h):
    draw_line(x, y + k, x + w - 1, y + k, [col1[i] + (col2[i] - col1[i])*k//(h-1) for i in range(3)])

def cmath_exp(a):
  return exp(a.real) * (cos(a.imag) + 1j*sin(a.imag))

def similitude(u, v):
    v = 1j * (u - v)
    return lambda z: v*z + u

def generer_arbre(n):
  lf = (
    similitude(.2j, .2j + .5*cmath_exp(1j * pi / 7)),
    similitude(.22j, .22j + .45j*cmath_exp(1j * pi / 3)),
    similitude(.55j, .55j + .35*cmath_exp(1j * pi / 6)),
    similitude(.57j, .57j + .3j*cmath_exp(1j * pi / 3)),
    similitude(.7j, 1.2j - .01)
  )
  lz = [0j, 0.7j]
  lz1 = lz[:]
  for _ in range(n):
    lz2 = []
    for f in lf:
      lz2.extend([f(z) for z in lz1])
    lz.extend(lz2)
    lz1 = lz2
  return lz

def rotate_color(c):
  return (c[1], c[2], c[0])
   
def trace(d, nb_trees, nb_balls, nb_stars, nb_flakes):

  color_black = (0,) * 3
  color = color_screen and (255,) * 3 or color_black

  # fait tomber la nuit
  colors = (color_black, (0, 0, 127), (0, 127, 255))
  dy = screen_h / (len(colors))
  if color_screen:
    for k in range(len(colors) - 1):
      horiz_gradient(0, round(dy*k), screen_w, round(dy), colors[k], colors[k + 1])
    horiz_gradient(0, screen_h - 1 - round(dy), screen_w, round(dy), (0, 63, 127), color_black)
  dx = (screen_w - 1) / 2 / (nb_trees - 1)

  # allume les etoiles
  for k in range(nb_stars):
    set_pixel(randint(0, screen_w - 1), randint(0, screen_h - 1 - round(dy)), color)

  # plante une foret de sapins
  for p in range(d - nb_trees, d + 1):
    x0 = screen_w // 2 + (p < d and dx * ((d - p) % 2 and d + 1 - p or p - d))
    dy = screen_h / (len(colors)) * (d - p) / nb_trees
    lz = generer_arbre(p)
    for k in range(0, len(lz), 2):
      x1, y1 = transform(lz[k].real, lz[k].imag)
      x2, y2 = transform(lz[k+1].real, lz[k+1].imag)
      x1 += x0
      x2 += x0
      draw_line(x1, y1 - dy, x2, y2 - dy, (0, 160 * (1 - (d - p)//(nb_trees - 1)), 0))

  # decore mon plus beau sapin
  if color_screen:
    lz, r, color_in, color_out = lz[1::max(1, len(lz)//nb_balls)], 2, (0, 255, 255), (0, 0, 255)
    for z in lz:
      x, y = transform(z.real, z.imag)
      x += x0
      fill_circle(x, y, r, color_in)
      draw_circle(x, y, r, color_out)
      color_in, color_out = rotate_color(color_in), rotate_color(color_out)

  # saupoudre de neige
  if color_screen:
    for k in range(nb_flakes):
      fill_circle(randint(0, screen_w - 1), randint(0, screen_h - 1), 1, color)

init_casioplot()
trace(color_screen and 5 or 3, 5, 30, 100, 40)
show_screen()

Et puis c'était tout. Nous supposions qu'il y avait eu plus que 3 participants, mais les autres ne nous avaient à la différence et à notre connaissance rien partagé, ni en public ni en privé.

Et bien tu n'attendras pas plus longtemps, Casio nous publie enfin aujourd'hui les scripts Python du concours. Et voici donc de suite ceux qui nous manquaient.

Isabelle Vanacker retourne à l'utilisation du module turtle et nous dresse un sapin sous une nuit étoilée.

On note la répétition de motifs identiques ou similaires (étoiles et triangles du sapin).

Mais c'est codé proprement puisque les répétitions sont tracées par appels d'une même fonction.

Voici par exemple la fonction pour les triangles du feuillage du sapin, en fait des triangles rectangles isocèles :

Code: Select all

def triangle(t):
  forward(t/2)
  left(135)
  forward(sqrt((t*t)/2))
  left(90)
  forward(sqrt((t*t)/2))
  left(135)
  forward(t/2)

Ou encore la fonction pour les étoiles :

Code: Select all

def etoile(x,y):
  up()
  goto(x,y)
  down() 
  for i in range(6):
    forward(10)
    left(120)
    forward(10)
    left(-60)

Le script suivant trace donc dans l'ordre :

1. le sapin avec :
   
   1. les triangles de son feuillage, de haut en bas
   2. son tronc
2. les étoiles

Code: Select all

from turtle import *

pencolor("green")
pensize(5)

def triangle(t):
  forward(t/2)
  left(135)
  forward(sqrt((t*t)/2))
  left(90)
  forward(sqrt((t*t)/2))
  left(135)
  forward(t/2)

def arbre():
  pencolor("green")
  pensize(5)
  for i in range(4):
    triangle(50+20*i)
    up()
    goto(0,30-40*i)
    down()
  pencolor("brown")
  forward(10)
  left(90)
  forward(40)
  left(90)
  forward(20)
  left(90)
  forward(40)
  left(90)
  forward(10)

def etoiles():
  pencolor("yellow")
  pensize(2)
  etoile(-150,60)
  etoile(-100,10)
  etoile(-120,-40)
  etoile(-60,-80)
  etoile(100,50)
  etoile(140,30)
  etoile(160,-30)
  etoile(100,-70)
   
def etoile(x,y):
  up()
  goto(x,y)
  down() 
  for i in range(6):
    forward(10)
    left(120)
    forward(10)
    left(-60)

up()
goto(0,60)
down()
arbre()

up()
goto(-50,20)
down()
etoiles()

Et voici enfin le cadeau offert par Isabelle Duval, toujours tracé avec le module turtle sur Graph 90+E.

Son script suivant trace dans l'ordre :

1. la boîte
2. le ruban avec :
   
   1. son noeud
   2. le reste

Code: Select all

from turtle import *

for i in range(4):
  forward(50)
  right(90)
forward(25)
circle(10)
right(90)
forward(25)
for j in range(3):
  right(90)
  forward(25)
  right(180)
  forward(25)
right(90)

Merci à tous et merci Casio, un concours très réussi qui a encouragé la création de très beaux scripts.
A quand un concours similaire ouvert aux élèves, que l'on voit si ils sont capables de faire mieux ?

Téléchargements :

1. script de Florian Allard / Afyu
2. script de Thomas Fontaine
3. script de Xavier Andréani / Critor
4. script d'Isabelle Vanacker
5. script d'Isabelle Duval

Source : https://www.casio-education.fr/contenus ... -plus-loin

[critor]

Du 9 au 15 Décembre 2020, Casio France avait organisé à l'attention des enseignants un concours de Noël fort intéressant et joliment doté.
Il fallait programmer un dessin de Noël au choix :

• sur calculatrice fx-92+ Spéciale Collège ou son émulateur (langage à la Scratch/Logo)
• en Python sur Graph 35+E II, Graph 90+E ou leur émulateur

Nous t'avions partagé les scripts Python Graph 90+E gracieusement fournis par 3 participants dont les 2 grands gagnants.

Mais hélas rien sur fx-92+ Spéciale Collège, les participants concernés par ce modèle ne nous ayant à la différence et à notre connaissance rien partagé, ni en public ni en privé. Et c'était d'autant plus regrettable que les captures d'écran publiées par Casio lors de l'annonce des résultats paraissaient très riches, rendant ainsi le code hautement intéressant.

Et bien tu n'attendras pas plus longtemps, Casio nous publie enfin aujourd'hui les scripts fx-92+ Spéciale Collège du concours. Tu vas pouvoir les retrouver ci-dessous, et si tu le souhaites enfin décorer ta calculatrice !

Alain Ladiesse, grand gagnant, n'y va pas à moitié. Tout y est dans son script : forêt de sapins, traineau de cadeaux, étoile et neige. Félicitations !

C'est d'une maisonnette qu'Amélie Roy, 2^ème grande gagnante, accompagne pour sa part la forêt de sapins enneigée. Bravo !

Avec un script ô combien plus court mais tout aussi efficace, c'est après avoir construit un bonhomme de neige qu'Elodie Morin fait tomber la neige.

Bernard Di Domenico nous gâte lui aussi, décorant non pas un mais 4 sapins !

Et enfin ce n'est pas un sapin que Maxime Chartier décore, mais directement le logo du constructeur !



Merci à tous et merci Casio, un concours très réussi qui a encouragé la création de très beaux scripts.
A quand un concours similaire ouvert aux élèves, que l'on voit ce dont ils sont capables ?

Téléchargements :

1. script d'Alain Ladiesse
2. script d'Amélie Roy
3. script d'Elodie Morin
4. script de Bernard Di Domenico
5. script de Maxime Chartier

Source : https://www.casio-education.fr/contenus ... -plus-loin

[critor]

La 1Ko Basic Casio Jam est une compétition de programmation organisée sur Planète Casio à l'initiative de KikooDX et Massena. Comme son nom l'indique les programmes soumis doivent être écrits en langage Casio Basic et ne pas dépasser la taille de 1000 octets.

Lancée dès aujourd'hui et ouverte aux participations jusqu'au dimanche 24 janvier à 18 heures, voici la 1KBCJ#4, 4^ème édition de la compétition.

Pour cette édition tu dois donc créer un programme répondant aux critères suivants :

1. comme déjà dit en langage Casio Basic (langage interprété officiel des calculatrices Graph 25/35/75/90+E)
2. comme tu le sais déjà sans dépasser les 1000 octets de code (les variables éventuellement créées par le programme ne comptent pas)
3. il doit s'agir d'un jeu
4. le jeu doit être basé sur le pseudo d'un membre Planète Casio
5. le membre en question doit avoir un minimum de 30 points sur son profil Planète Casio
6. le membre doit s'être connecté à Planète Casio en 2020 ou 2021
7. le membre doit s'être inscrit sur Planète Casio avant le 16 janvier 2021

Le meilleur programme choisi par le jury fera remporter à son créateur ou sa créatrice une impression du logo 1KBJC4 réalisée bien évidemment par une calculatrice Casio et pas n'importe laquelle, la calculatrice imprimante Casio HR-8RCE !

Aucune obligation d'achat pour participer et gagner, nous te repartageons les émulateurs de calculatrices ci-dessous.

Bonne chance à toi !

Source : https://www.planet-casio.com/Fr/forums/ ... theme.html

Ressources :

Graph
90+E Graph
35+E II

Mise à jour calculatrice :

• 3.50 pour Graph 90+E / fx-CG50 avec Windows / Mac

Émulateurs :

• Graph 90+E / fx-CG50 version 3.50 à installer sur Windows / Mac
  (période d'essai gratuite sans engagement de 90 jours, prolongeable gratuitement si besoin jusqu'au 31 août 2021)
• Graph 90+E version 3.50 pour clé USB d'émulation officielle

Transfert de données :

• tutoriel transfert de données

Mise à jour calculatrice :

• Mise à jour 3.40 pour Graph 35+E II / fx-9750/9860GIII avec Windows

Émulateurs :

• Graph 35+E II / fx-9750/9860GIII version 3.40 à installer sur Windows
  (période d'essai gratuite sans engagement de 90 jours, prolongeable gratuitement si besoin jusqu'au 31 août 2021)
• Graph 35+E II version 3.40 pour clé USB d'émulation officielle

Transfert de données :

• tutoriel transfert de données

[critor]

Casio a à cœur de développer des produits respectueux de l'environnement. Depuis 1993, les nouveaux produits du constructeur font l'objet d'une évaluation interne de leur impact environnemental, et peuvent alors se voir décerner la certification Casio Green Products.

Pour minimiser encore et toujours l'impact environnemental de ses produits, Casio a conçu en 2010 des normes beaucoup plus rigoureuses dans le cadre d'une toute nouvelle certification, Casio Green Star Products, décernée aux produits avec une évaluation particulièrement bonne.

La performance environnementale est évaluée sur les éléments suivants :

1. favorise le recyclage
2. conçu pour le recyclage
3. composants des produits peuvent être séparés, démontés
4. recyclage amélioré
5. amélioration de l'efficacité énergétique
6. utilisation réglementée de substances chimiques
7. recyclabilité de l'alimentation
8. étiquette de recyclage sur l'alimentation
9. conformité réglementaire
10. composants de l'emballage peuvent être séparés, démontés
11. utilisation réglementée des matériaux d'emballage
12. préserve l'environnement naturel

Depuis 2017 le constructeur a même commencé à commercialiser des produits certifiés Casio Super Green Star Products, aux performances environnementales encore plus élevées.

La part des ventes de produits certifiés Green Star ou Super Green Star n'a cessé de croître depuis 2010 pour atteindre 72% en 2019, et Casio s'est fixé comme objectif ambitieux de dépasser les 90% d'ici 2026.

En 2019 Casio proposait déjà à la vente pas moins de 36 produits certifiés Super Green Star, dont un que tu connais très bien, la calculatrice graphique Graph 35+E II.

En terme de fonctionnalités, la Graph 35+E II remplace et améliore la Graph 75+E. Et effectivement, plusieurs critères pris en compte marquent une progression exceptionnelle selon Casio :

• réduction de 50% de la consommation de la calculatrice
• réduction de 23% du volume de la calculatrice, la Graph 35+E II étant à la fois plus petite et moins épaisse

Comme nous te l'avions révélé, Casio va cette année encore et toujours plus loin dans l'écologie.

Commencent à apparaître dans nos rayons des Graph 25+E II munies d'un tout nouvel emballage d'exposition intégralement en carton et de dimensions nettement réduites, remplaçant donc l'ancien emballage blister !
Cela permet à la fois l'avantage de faire disparaître totalement la coque de plastique transparent, mais aussi un conditionnement bien plus efficace lors de l'acheminement des calculatrices, double avantage pour l'écologie !

Bien évidemment, on pouvait supposer que ce renouvellement d'emballage ne se cantonnait pas juste à la Graph 25+E II, pas le modèle le plus populaire en France.

Sans doute de nouveaux emballages Graph 35+E II et Graph 90+E feront leur apparition d'ici la rentrée 2021, et peut-être même fx-92+ Spéciale Collège et fx-CP400+E.

Nous n'avons pas encore pu les trouver ni photographier en boutique physique, mais voici déjà sans plus attendre le 1^er visuel officiel du nouvel emballage carton réduit de la Graph 90+E !

Merci pour la planète Casio !

Référence : https://world.casio.com/csr/environment ... greenstar/
Source : https://www.fnac.com/Calculatrices-Casi ... p48530/w-4