# 2.2 Cocodrilo hambriento

## Objetivo

Es sin duda la construcción que identifica este set de Lego. Se trata de un cocodrilo que tiene que abrir o cerrar la boca interactuando con el objeto que se encuentre en la boca. Aquí se trabaja:

- La entrada de un sensor
- La interacción que produce de forma real cerrando la boca
- Otras interacciones podrían ser de forma virtual: Personaje cocodrilo abriendo y cerrando la boca con sonido incorporado

## Construcción

En[ este enlace ](http://ro-botica.com/pdf/WeDo/Hungry%20Alligator.pdf)tenemos el pdf o en este otro [en Dropbox ](https://www.dropbox.com/s/t0dnpnfr580mxj3/COCODRILO.pdf?dl=0)

## Propuesta

De momento el enunciado que proponemos será que cierre la boca si se introduce un objeto y al cabo de 1 segundo que la abra para poder liberar el objeto:

<iframe allowfullscreen="allowfullscreen" height="314" id="bkmrk-" src="//www.youtube.com/embed/VX8i0Pg9DxE" width="560"></iframe>

##### Solución

  
![](https://libros.catedu.es/uploads/images/gallery/2022-02/embedded-image-raag0lpe.png)

## Otra propuesta

Que no pare de masticar mientres esté el objeto

<iframe allowfullscreen="allowfullscreen" height="314" id="bkmrk--1" src="//www.youtube.com/embed/vbzcMDYyoRk" width="560"></iframe>

##### Solución

  
![](data:;base64,<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" id="typepad-standard" xmlns:fb="http://www.facebook.com/2008/fbml">
<head>
	<!-- head-common -->
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
	<meta name="generator" content="http://www.typepad.com/" />
	
	<meta name="description" content="Simon Haughton shares his inspiring and creative ICT ideas." />
    <link rel="canonical" href="https://simonhaughton.typepad.com/main/" />



        <link rel="stylesheet" href="https://simonhaughton.typepad.com/main/styles.css?v=6" type="text/css" media="screen" />
        <link rel="stylesheet" href="https://static.typepad.com/.shared/themes/common/print.css" type="text/css" media="print" />

<link rel="stylesheet" href="https://static.typepad.com/.shared/css/featherlight-gallery.css">

<!-- Font Awesome -->
    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.6.3/css/all.css" integrity="sha384-UHRtZLI+pbxtHCWp1t77Bi1L4ZtiqrqD80Kn4Z8NTSRyMA2Fd33n5dQ8lWUE00s/" crossorigin="anonymous">

	<link rel="alternate" type="application/atom+xml" title="Posts on 'Simon Haughton's website' (Atom)" href="https://simonhaughton.typepad.com/main/atom.xml" />
	<link rel="alternate" type="application/rss+xml" title="Posts on 'Simon Haughton's website' (RSS 1.0)" href="https://simonhaughton.typepad.com/main/index.rdf" />
	<link rel="alternate" type="application/rss+xml" title="Posts on 'Simon Haughton's website' (RSS 2.0)" href="https://simonhaughton.typepad.com/main/rss.xml" />
	<script type="text/javascript">
		var TPApp = {};
		TPApp.app_uri = "https://www.typepad.com/";
	</script>
	<script type="text/javascript" src="https://static.typepad.com/.shared/js/yui/yahoo-dom-event.js,/js/app/thumbnail-gallery-min.js,/js/app/flyouts-min.js"></script>



<!--- head google analytics -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-225723-36', 'auto', {'name': 'Typepad'}, {'allowLinker': true} );  // Separate tracker for Typepad.
ga('Typepad.require', 'linker');
ga('Typepad.linker:autoLink', ['none']);
ga('Typepad.set', 'dimension1', '6a0120a530561e970b012876745169970c');
ga('Typepad.set', 'dimension2', 'index');
ga('Typepad.send', 'pageview');
</script>



<!-- fb-opengraph.tt -->
<meta property="og:title" content="Simon Haughton's website" />
<meta property="og:site_name" content="Simon Haughton's website" />
<meta property="og:type" content="blog" />
<meta property="og:url" content="https://simonhaughton.typepad.com/main/" />
<meta property="og:description" content="" />
<meta property="fb:admins" content="" />
<meta property="fb:app_id" content="55753818692" />
<meta property="og:image" content="https://up6.typepad.com/6a0120a530561e970b01630170d665970d-220si" />



	<title>Simon Haughton's website</title>
	<link rel="openid.server" href="https://www.typepad.com/services/openid/server" />
	<link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.typepad.com/services/rsd/6a0120a530561e970b012876745169970c" />
	
        
</head>


<body class="layout-two-column-left-mb">
<div id="fb-root"></div>
<script>
window.fbAsyncInit = function() {
    FB.init( { apiKey: 'a279adbe87e2b3c505e777af99a5260d', xfbml: true, version: 'v2.8' } );
};
( function() {
    var e = document.createElement( 'script' ); e.async = true;
    e.src = document.location.protocol + '//connect.facebook.net/en_US/sdk.js';
    document.getElementById( 'fb-root' ).appendChild( e );
} )();
</script>

	
	<div id="container">
	    <div id="wrapper">
		<div id="container-inner">
			
			<!-- banner -->
<div id="banner">
	<div id="banner-inner" class="pkg">
		
		<h1 id="banner-header"><a href="https://simonhaughton.typepad.com/main/" accesskey="1">Simon Haughton's website</a></h1>
		<div id="banner-screen"></div>
	</div>
	<div id="banner-bg"><a href="https://simonhaughton.typepad.com/main/" accesskey="1">Home</a></div>
</div>



			<div id="pagebody">
				<div id="pagebody-inner">
					<div id="alpha">
						<div id="alpha-inner">
							<!-- entry list sticky -->


		<h2 class="date-header">26 December 2019</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b0240a4ad6b5e200c">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2019/12/please-visit-my-new-website.html">Please visit my new website </a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>All of my content is now available on my new website:</p>
<p style="text-align: center;"><span style="font-size: 14pt;"><a href="https://sites.google.com/view/simonhaughton">https://sites.google.com/view/simonhaughton</a></span></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2019/12/please-visit-my-new-website.html">26 Dec 2019 16:10:06</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2019/12/please-visit-my-new-website.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b0240a4ad6b5e200c'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">12 October 2019</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b0240a4900316200c">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2019/10/internet-safety-day-2020-assembly-slides.html">Internet Safety Day 2020 Assembly Slides</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p style="text-align: center;"><span class="asset  asset-generic at-xid-6a0120a530561e970b0240a4ddd0ee200b img-responsive" style="font-size: 15pt;"> <a href="https://simonhaughton.typepad.com/files/internet-safety-day-2020.pptx">Download Internet Safety Day Assembly 2020 by Simon Haughton</a></span></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2019/10/internet-safety-day-2020-assembly-slides.html">12 Oct 2019 10:19:13</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2019/10/internet-safety-day-2020-assembly-slides.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2019/10/internet-safety-day-2020-assembly-slides.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b0240a4900316200c'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">27 January 2019</h2>
	
	<div class="entry-category-bett entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b022ad3d88656200b">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2019/01/bett-2019.html">BETT 2019</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad392e25d200c-pi"><img alt="IMG_3006" class="asset  asset-image at-xid-6a0120a530561e970b022ad392e25d200c img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad392e25d200c-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3006" /></a></p>
<p>Yesterday was my ninth visit to the annual BETT Show and I do think that I&#39;m becoming quite efficient now in navigating the stands and picking out the new products that are: manageable and cost-effective to implement in the classroom as well as having a positive impact on the curriculum and children&#39;s education. So, in no particular order, here are some of the highlights I found:</p>
<ul>
<li>the <em>Blue-Bot</em> and <em>Bee-Bot</em> now have an audio playback feature that speaks the movements that are happening (saving adults like me getting a dry throat and making it better to use independently by children) - <a href="https://www.tts-group.co.uk/Hero-BeeBot.html">https://www.tts-group.co.uk/Hero-BeeBot.html;</a></li>
</ul>
<p class="asset-video" style="text-align: center;"><iframe allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="" frameborder="0" height="281" src="https://www.youtube.com/embed/ctRio8s5hvk?feature=oembed" width="500"></iframe></p>
<ul>
<li><em>TTS</em> have also started selling <a href="https://www.tts-group.co.uk/wildlife-garden-activity-tin/1015661.html?cgid=Primary%3AComputing_%26_ICT%3ABee-Bot_Blue-Bot_%26_Pro-Bot" rel="noopener" target="_blank">activity tins for the Bee-Bot</a>, containing: accessories, jackets and activity cards to help enhance your use of the <em>Bee-Bot</em> on the many new mats that are now available like a wildlife garden, dinosaur jungle and an amusement park;</li>
</ul>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89642200b-pi"><img alt="IMG_3052" class="asset  asset-image at-xid-6a0120a530561e970b022ad3d89642200b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89642200b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3052" /></a></p>
<ul>
<li><em>Twinkl</em> have launched a free <a href="https://itunes.apple.com/gb/app/little-red-coding-club/id1434696246#?platform=ipad" rel="noopener" target="_blank">AR-based coding app</a> on the theme of Little Red Riding Hood;</li>
</ul>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89667200b-pi"><img alt="IMG_3039" class="asset  asset-image at-xid-6a0120a530561e970b022ad3d89667200b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89667200b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3039" /></a></p>
<ul>
<li><em>Twinkl </em>have also started creating AR-linked books too, like <a href="https://www.twinkl.co.uk/resources/twinkl-originals">https://www.twinkl.co.uk/resources/twinkl-originals</a>;</li>
<li><em><a href="https://www.lbq.org/" rel="noopener" target="_blank">Learning By Questions</a></em> appears to be an online, multiple-choice quiz from which you can get feedback on how children perform although personally, I&#39;d rather pick the questions myself (e.g. from the&#0160;<em>Classroom Secrets</em> resources) and just create a free&#0160;<em>Google Form</em>;</li>
</ul>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89657200b-pi"><img alt="IMG_3074" class="asset  asset-image at-xid-6a0120a530561e970b022ad3d89657200b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89657200b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3074" /></a></p>
<ul>
<li><em>Mission Python </em>is a book teaching you how to code via the theme of a space adventure, although look on their site, whilst it&#39;s very detailed, would need some simplification before actually presenting to children;</li>
<li><a href="https://www.bbc.com/bitesize" rel="noopener" target="_blank"><em>BBC Bitesize</em></a> has recently undergone a slight design update and archiving of old content, whilst&#0160;<a href="https://www.bbc.com/teach" rel="noopener" target="_blank"><em>BBC Teach</em></a> continues to upload curriculum video clips and live lessons.</li>
<li><a href="https://www.mightywriter.co.uk/what-is-mighty-writer.html" rel="noopener" target="_blank"><em>Mighty Writer</em></a> is a felt-based story mapping mat which looks quite fun.</li>
</ul>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89684200b-pi"><img alt="IMG_3043" class="asset  asset-image at-xid-6a0120a530561e970b022ad3d89684200b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3d89684200b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3043" /></a></p>
<ul>
<li><em><a href="https://scottiego.com/en/edu-scottiego/how-does-it-work/" rel="noopener" target="_blank">Scottie Go</a>&#0160;</em>is an interesting collaboration between real magnetic command blocks and a programming app.</li>
<li><a href="https://gocoderz.com/educators/" rel="noopener" target="_blank"><em>CoderZ</em></a> is an online robot programming site.</li>
<li><a href="https://isandbox.co.uk/" rel="noopener" target="_blank"><em>iSandBOX</em> </a>is basically projection-mapping technology for a sand tray which would be phenomenal if your school has the money and space to put it.</li>
</ul>
<p class="asset-video" style="text-align: center;"><iframe allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="" frameborder="0" height="281" src="https://www.youtube.com/embed/TAuQ7aun2rI?feature=oembed" width="500"></iframe></p>
<p>I had a fantastic day out and even came back with quite a nice haul of merchandise that&#39;ll I&#39;ll be distributing to my Technology Team at the end of the year!</p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2019/01/bett-2019.html">27 Jan 2019 11:13:02</a>
		|
		<a href="https://simonhaughton.typepad.com/main/bett/">BETT</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2019/01/bett-2019.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2019/01/bett-2019.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b022ad3d88656200b'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">07 December 2018</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b022ad3c56c5b200b">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/12/balancing-calculations-question-generator.html">Balancing Calculations - Question Generator</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>I always like making an Excel random-question generator and today I was challenged to make one for Year 6 balancing calculations.</p>
<p>If anybody wants to use it with their children, you can download it <a href="https://simonhaughton.typepad.com/files/balancing-equations-generator.xlsx">by clicking here</a>.</p>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/files/balancing-equations-generator.xlsx" style="display: inline;"><img alt="Balancing calculations" class="asset  asset-image at-xid-6a0120a530561e970b022ad37fb9a3200c img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad37fb9a3200c-500wi" title="Balancing calculations" /></a></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/12/balancing-calculations-question-generator.html">7 Dec 2018 19:02:49</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/12/balancing-calculations-question-generator.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/12/balancing-calculations-question-generator.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b022ad3c56c5b200b'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">07 October 2018</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b022ad3b6c0f6200b">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/10/google-sites-staff-bulletins.html">Google Sites - Staff Bulletins</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>Last week I was challenged to design an easier-to-produce method for my deputy head to produce the weekly staff bulletin, to replace the paper version (created in Word) which we&#39;ve used for many years now.</p>
<p>After asking on Twitter and doing a bit of investigating myself, I eventually opted to suggest Google Sites as a suitable alternative since it&#39;s: free, easy to design and allows for seamless embedding of Google Calendars (which we use to share: public events, staff development dates, assembly themes and much more) and linking of Google Forms (which we use for collecting feedback from lots of things within school). With these already inserted, all that now needs to be updated each week are the bullet points for news and reminders - everything else can mostly just be kept the same or updates automatically. It&#39;s emailed out to all staff so no printing is required and the fact that it contains lots of web links means that staff can now know exactly where to find them when needed.</p>
<p>Since our staff bulletin obviously contains private information, I&#39;ve tried my best to share a screenshot of it below that shows the general layout of and design as much as possible. Please let me know if you find it useful - email me (simonhaughton@ymail.com) or my deputy head (mkemp@parkfield.rochdale.sch.uk) for more details if you&#39;re interested in replicating a similar system in your school.</p>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad397267a200d-pi"><img alt="Gsite" class="asset  asset-image at-xid-6a0120a530561e970b022ad397267a200d img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad397267a200d-400wi" style="width: 400px; display: block; margin-left: auto; margin-right: auto;" title="Gsite" /></a></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/10/google-sites-staff-bulletins.html">7 Oct 2018 14:53:22</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/10/google-sites-staff-bulletins.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/10/google-sites-staff-bulletins.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b022ad3b6c0f6200b'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">12 July 2018</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b022ad3809a81200d">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/07/how-to-teach-primary-computing-staff-meeting-slides.html">How to Teach Primary Computing - Staff Meeting Slides</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>I was recently asked to deliver a staff meeting a nearby school sharing my methods and plans for teaching primary Computing.</p>
<p>Here&#39;s a copy of the presentation I created for it in case you find it useful in any way:</p>
<p style="text-align: center;"><span class="asset  asset-generic at-xid-6a0120a530561e970b022ad3809a75200d img-responsive" style="font-size: 15pt;"> <a href="https://simonhaughton.typepad.com/files/computing-staff-meeting-by-simon-haughton.pdf">Download Computing Staff Meeting</a></span></p>
<p style="text-align: center;"><span class="asset  asset-generic at-xid-6a0120a530561e970b022ad3809a75200d img-responsive" style="font-size: 15pt;"> <a class="asset-img-link" href="https://simonhaughton.typepad.com/files/computing-staff-meeting-by-simon-haughton.pdf"><img alt="How" class="asset  asset-image at-xid-6a0120a530561e970b022ad3a06bb3200b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad3a06bb3200b-400wi" style="width: 400px; display: block; margin-left: auto; margin-right: auto;" title="How" /></a><br /></span></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/07/how-to-teach-primary-computing-staff-meeting-slides.html">12 Jul 2018 17:28:24</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/07/how-to-teach-primary-computing-staff-meeting-slides.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/07/how-to-teach-primary-computing-staff-meeting-slides.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b022ad3809a81200d'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">09 July 2018</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b022ad37fccb5200d">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/07/ways-to-integrate-twitter-into-school-life.html">Ways to Integrate Twitter into School Life</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>I visited a local school to help them set up a school Twitter account&nbsp;this morning and thought that people might find these tips I shared with them useful, based on the system I've set up and promoted at my school, Parkfield Primary:</p>
<ul>
<li>Only have one Twitter account for the whole school. Some people like their own class teacher or department accounts but this just becomes a jumble from examples I've seen, and the 'main' account just ends up with somebody having to retweet lots of things from different accounts before/so it can appear in the main feed that's embedded onto the website homepage. To restrict usage, only me and the SLT know the account password which we enter in for staff when they want to do an initial login to Twitter.</li>
<li>Offer a range of different methods for staff to tweet to increase the likelihood of them actually tweeting - let them use both school-owned tablets/lapotops as well as their own mobile phones (which they're comfortable with). Our mobile phone policy allows for this use, as long as any photos/videos are deleted at the earliest opportunity (i.e. after they've been transferred to the school server).</li>
<li>Don't be too strict about your expectations for tweets as staff will worry about getting it wrong and therefore not tweet otherwise. Praise any snapshots of learning that are shared onto Twitter as they all help to raise awareness of what's happening in the school community and improve engagement from stakeholders like parents.</li>
<li>Encourage the use of hashtags to make it easy to find groups of tweets at a later date. This can be as simple as #Y1/#Y2/#Y3 etc. along with the name of the subject the tweet is about, e.g. #Art/#Computing/#History. At my school, I created this list of hashtags which also contain a few additional ones that are useful on certain occasions, although only a few people really have the need to use them.</li>
</ul>
<p><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad37fcceb200d-pi"><img alt="Hashtags" class="asset  asset-image at-xid-6a0120a530561e970b022ad37fcceb200d img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad37fcceb200d-400wi" style="width: 400px; display: block; margin-left: auto; margin-right: auto;" title="Hashtags" /></a></p>
<ul>
<li>Prompt the more confident members of staff to include @mentions in their tweets to help promote the school and improve community cohesion - e.g. mentioning places visited on trips or organisations that are involved with the school.</li>
<li>Use <a href="http://www.wordle.net/" rel="noopener noreferrer" target="_blank">http://www.wordle.net/</a> or a similar online service to create a word collage of words associated with your school (e.g. from the motto, mission statement, parent questionnaire responses or inspection report). This can then be printed out and made into a display to use as a backdrop when tweeting celebrations and awards so they look really professional.</li>
</ul>
<div align=center>
<div style="text-align: center;">
<blockquote class="twitter-tweet" data-lang="en">
<p dir="ltr" lang="en">Well done to this super speller from <a href="https://twitter.com/hashtag/Y1?src=hash&amp;ref_src=twsrc%5Etfw">#Y1</a>! 📝 <a href="https://twitter.com/hashtag/headteacheraward?src=hash&amp;ref_src=twsrc%5Etfw">#headteacheraward</a> <a href="https://t.co/sZ2kWd6x5z">pic.twitter.com/sZ2kWd6x5z</a></p>
— Parkfield Primary (@Parkfield) <a href="https://twitter.com/Parkfield/status/1012646336636817408?ref_src=twsrc%5Etfw">June 29, 2018</a></blockquote>
<p>
<script src="https://platform.twitter.com/widgets.js"></script>
</p>
</div>
</div>
<ul>
<li>On your school website, add links to Twitter searches that show tweets containing specific hashtags from your school Twitter account to make it easy for visitors to easily search for examples of specific tweets. To do this, simply go to the Twitter website, type <span style="font-family: 'courier new', courier; color: #0000bf;">ACCOUNT: #HASHTAG OR #HASHTAG</span> into the search box (putting your Twitter handle instead of 'account' and any hashtags you want - remembering to put 'OR' in capitals if needed), click 'Search', click 'Latest Tweets' and then copy/paste the generated URL. For example, <a href="https://twitter.com/search?f=tweets&amp;vertical=default&amp;q=%23Computing%20from%3AParkfield&amp;src=typd&amp;lang=en" rel="noopener noreferrer" target="_blank">this link</a> will show all the tweets from my school that include #Computing in them. Doing this provides instant evidence of work that has been produced, ordered by the most recent at the top, which is a far more efficient method of celebrating/showcasing work than creating 'Big Books' that take a long time to collate and date really fast. It also has the advantage of being able to include video clips - especially useful for music and PE lessons, for instance.</li>
<li>Train up pupils to do some tweeting themselves (e.g. G&amp;T Y6 pupils or digital leaders). At my school, I've trained up children on my Technology Team to take photos on an iPad in assemblies and then tweet them afterwards during play time, using this simple prompt sheet:</li>
</ul>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad359ca0d200c-pi"><img alt="Promptsex" class="asset  asset-image at-xid-6a0120a530561e970b022ad359ca0d200c img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b022ad359ca0d200c-400wi" style="width: 400px; display: block; margin-left: auto; margin-right: auto;" title="Promptsex" /></a></p>
<ul>
<li>If you are lucky enough to have large monitors around your school or indeed just a laptop connected to a projector in your dinner hall, consider buying some cheap online web space and creating a scrolling page showing your tweets. If you know how to write basic HTML, feel free to copy <a href="http://twitter.parkfieldprimary.com" rel="noopener noreferrer" target="_blank">this page</a> I created for my school that displays latest tweets on the left and tweets we've liked on the right (e.g. awards we want to highlight or messages from other followers praising our school).</li>
<li>Login to the Twitter account from a desktop computer using&nbsp;<a href="https://tweetdeck.twitter.com/" rel="noopener noreferrer" target="_blank">https://tweetdeck.twitter.com/</a> as this allows you to schedule tweets in advance, such as reminders.</li>
</ul>
<p><strong>&nbsp;Have you got any more ideas or tips you think others would find useful? Let me know in the comments below!</strong></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/07/ways-to-integrate-twitter-into-school-life.html">9 Jul 2018 19:16:43</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/07/ways-to-integrate-twitter-into-school-life.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/07/ways-to-integrate-twitter-into-school-life.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b022ad37fccb5200d'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">06 February 2018</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b01bb09f0e20a970d">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/02/geography-corners.html">Geography Corners</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>Whilst lying in bed the other night, I came up with a fun idea for improving children&#39;s geographical knowledge of where different places are using the classic game of &#39;corners&#39;. Whenever you have a few minutes to spare - such as at the end of the day - get your children up and moving and competing against each other to see who can correctly identify different places on a map from multiple choice options, as shown in these slides which play in a random order each time. Let me know if you use them in your classroom and what your children think of this game as I&#39;m sure it could be quite easily adapted to other topics too.</p>
<p style="text-align: center;">You will need to enable macros to ensure the slides in these PowerPoints I&#39;ve made play in a random order.</p>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c94d799d970b-pi"><img alt="UK" class="asset  asset-image at-xid-6a0120a530561e970b01b7c94d799d970b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c94d799d970b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="UK" /> <span class="asset  asset-generic at-xid-6a0120a530561e970b01b7c94d79ad970b img-responsive"><a href="https://simonhaughton.typepad.com/files/geography-corners---uk.ppt">Download Geography Corners - UK</a></span></a></p>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01bb09f0e1e3970d-pi"><img alt="Europe" class="asset  asset-image at-xid-6a0120a530561e970b01bb09f0e1e3970d img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01bb09f0e1e3970d-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="Europe" /> <span class="asset  asset-generic at-xid-6a0120a530561e970b01b8d2d7e711970c img-responsive"><a href="https://simonhaughton.typepad.com/files/geography-corners---europe.ppt">Download Geography Corners - Europe</a></span></a></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/02/geography-corners.html">6 Feb 2018 19:07:34</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/02/geography-corners.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/02/geography-corners.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b01bb09f0e20a970d'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">28 January 2018</h2>
	
	<div class="entry-category-bett entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b01bb09ed4020970d">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2018/01/bett-2018.html">BETT 2018</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c949f8d9970b-pi"><img alt="IMG_3452" class="asset  asset-image at-xid-6a0120a530561e970b01b7c949f8d9970b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c949f8d9970b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3452" /></a></p>
<p style="text-align: left;">Having been to BETT several times now and in this age of constrained school budgets, I went to this year’s show with the aim of hunting for products which were both value for money and which would actually have a real impact on children’s learning over a number of lessons - i.e. which aren’t expensive one-off gimmicks.&#0160;</p>
<p>With that being said, here is my list of stands that I visited which I spotted had interesting and potentially useful offerings:</p>
<ul>
<li>There seemed to be many stands selling mini programmable toys and games this year which all looked quite fun, such as: <a href="http://robowunderkind.com/" rel="noopener noreferrer" target="_blank"><em>Robo Wunderkind</em></a>, <a href="http://www.logiblocs.com/" rel="noopener noreferrer" target="_blank"><em>Logiblocks</em></a> and <a href="https://scottiego.com/en/scottiego/home/about-the-game/" rel="noopener noreferrer" target="_blank"><em>Scottie Go!</em></a>, with perhaps my favourite being&#0160;<a href="http://www.kamibot.com/default.php" rel="noopener noreferrer" target="_blank"><em>Kamibot</em></a> which looks like the first serious competitior to the&#0160;<em>Bee-Bot</em> but which unfortunately doesn&#39;t seem to actually be purchasable in the UK.</li>
</ul>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b8d2d44870970c-pi"><img alt="IMG_3497" class="asset  asset-image at-xid-6a0120a530561e970b01b8d2d44870970c img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b8d2d44870970c-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3497" /></a></p>
<ul>
<li>The&#0160;<a href="https://eu.getcatchbox.com/products/catchbox-lite?variant=13490236100" rel="noopener noreferrer" target="_blank"><em>Catchbox</em></a> looked like a really cool cube-shaped throwable microphone but a quick look online suggests that it&#39;s very expensive.</li>
</ul>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c949f8e3970b-pi"><img alt="IMG_3490" class="asset  asset-image at-xid-6a0120a530561e970b01b7c949f8e3970b img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b7c949f8e3970b-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3490" /></a></p>
<ul>
<li><a href="https://uk.samlabs.com/blogs/projects" rel="noopener noreferrer" target="_blank"><em>SAM Labs</em></a> has several mini STEAM projects online which could be used in a club with children.</li>
<li><a href="https://www.yellow-door.net/ranges/apps-and-technology/" rel="noopener noreferrer" target="_blank"><em>Yellow Door</em></a> has a surprisingly large collection of apps for early years which could have potential classroom use.</li>
<li><em><a href="https://tinybop.com/" rel="noopener noreferrer" target="_blank">Tiny Bop</a>&#0160;</em>offers several child-friendly apps which offer interactive cross-sections and simulations of different things like animals and the solar system.</li>
<li><a href="http://marcothemaltabus.com/" rel="noopener noreferrer" target="_blank"><em>Marco the Malta Bus</em></a>&#0160;reading scheme is probably the most quirky titled and branded product I&#39;ve seen at BETT.</li>
<li><a href="https://www.capita-sims.co.uk/sims-primary" rel="noopener noreferrer" target="_blank"><em>SIMS Primary</em></a> has announced a new/revised version of their management system which looks to more personalised from the needs of primary schools.</li>
<li>The&#0160;<em>NSPCC</em> has <a href="https://itunes.apple.com/gb/app/playtime-with-pantosaurus/id1258635349?mt=8" rel="noopener noreferrer" target="_blank">released a new app</a> to help children learn how to stay safe.</li>
<li><a href="https://twitter.com/ICT_MrP" rel="noopener noreferrer" target="_blank">@ICT_MrP</a> was on the&#0160;<em>Cohuba</em> stand talking about ways schools can embrace social media and how schools sharing photos can have very positive outcomes which shouldn&#39;t be feared. He also talked about a very amusing twist on those annoying &#39;let&#39;s see how many RTs this photo can get&#39; tweets that classes send out - get people to instead manipulate them in as many ways as possible to make them funny.</li>
</ul>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01bb09ed44cf970d-pi"><img alt="IMG_3501" class="asset  asset-image at-xid-6a0120a530561e970b01bb09ed44cf970d img-responsive" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01bb09ed44cf970d-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3501" /></a></p>
<ul>
<li><a href="https://www.showbie.com/" rel="noopener noreferrer" target="_blank"><em>Showbie</em></a> were there promoting their excellent online classroom organisation application and kindly let me have several stylus pens to take back to school for my <a href="https://simonhaughton.typepad.com/main/2017/07/year-6-technology-team-an-end-of-year-reflection.html" rel="noopener noreferrer" target="_blank">Technology Team</a> children whom I&#39;m sure will greatly appreciate them.</li>
<li>Data Harvest were proudly showing off their <em>BETT Award</em> winner&#39;s trophy for their&#0160;<a href="http://data-harvest.co.uk/catalogue/science/primary/datalogging/primary-vu-data-logger/2305PK5" rel="noopener noreferrer" target="_blank"><em>EasySense Vu+</em></a> Bluetooth data loggers, as well as exhibiting their&#0160;<em><a href="http://data-harvest.co.uk/catalogue/science/secondary/genecon-dynamo-range/secondary-genecon/3904" rel="noopener noreferrer" target="_blank">Genecon V3</a>&#0160;</em>child-friendly handheld dynamo which is excellent value in my opinion.</li>
</ul>
<p style="text-align: center;"><a class="asset-img-link" href="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b8d2d448a9970c-pi"><img alt="IMG_3488" class="asset  asset-image at-xid-6a0120a530561e970b01b8d2d448a9970c img-responsive" height="266" src="https://simonhaughton.typepad.com/.a/6a0120a530561e970b01b8d2d448a9970c-320wi" style="display: block; margin-left: auto; margin-right: auto;" title="IMG_3488" width="199" /></a></p>
<ul>
<li><span style="text-align: left;">Last year,&#0160;</span><em style="text-align: left;">TTS</em><span style="text-align: left;"> were giving away mini&#0160;</span><em style="text-align: left;">Bee-Bot</em><span style="text-align: left;"> compasses but I sadly only picked up one of when in hindsight I should have taken a handful as they would be great for doing an &#39;unplugged&#39; lesson on algorithms (</span><a href="https://drive.google.com/drive/folders/1BM9L1qACt6jKfc62EQvM1UJ1JSQq7x1Y" rel="noopener noreferrer" style="text-align: left;" target="_blank">see here</a><span style="text-align: left;"> for my resources which use just a picture of a&#0160;</span><em style="text-align: left;">Bee-Bot</em><span style="text-align: left;"> rather a physical one). I did learn though that they can actually be bought online </span><a href="http://www.tts-group.co.uk/bee-bot-infant-compass-10pk/1011756.html" rel="noopener noreferrer" style="text-align: left;" target="_blank">here</a><span style="text-align: left;"> in packs of 10 and are - of course - classed as a geography resource.</span></li>
<li><em>Lego Education</em> didn&#39;t have a specific stand at this year&#39;s show but have just started promoting&#0160;<em>Lego Maker Spaces</em> - see <a href="https://education.lego.com/en-us/makerspace" rel="noopener noreferrer" target="_blank">here for an explanation</a> and <a href="https://education.lego.com/en-us/middle-school/intro/c/maker-space" rel="noopener noreferrer" target="_blank">here for some activity ideas</a>. I have recently blogged about the potential use of Lego <a href="https://simonhaughton.typepad.com/main/2017/12/lego-imaginnering-in-schools.html" rel="noopener noreferrer" target="_blank">here</a>.&#0160;</li>
</ul>
<p style="text-align: center;"><span style="font-size: 14pt;"><a href="https://photos.app.goo.gl/kbKrWKCkwIeuEEWI3" rel="noopener noreferrer" target="_blank">View all my photos from the day</a></span></p>
<p>And finally, school kids were out judging BETT again and following their hashtag gives you a great insight of how children experienced BETT and what they thought of the different exhibitors this year:</p>
<p style="text-align: center;"><a class="twitter-timeline" data-widget-id="957568787217252353" href="https://twitter.com/hashtag/kidsjudgebett">#kidsjudgebett Tweets</a>
<script>// &lt;![CDATA[
// &amp;lt;![CDATA[
!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?&amp;#39;http&amp;#39;:&amp;#39;https&amp;#39;;if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+&amp;quot;://platform.twitter.com/widgets.js&amp;quot;;fjs.parentNode.insertBefore(js,fjs);}}(document,&amp;quot;script&amp;quot;,&amp;quot;twitter-wjs&amp;quot;);
// ]]&amp;gt;
// ]]&gt;</script>
</p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2018/01/bett-2018.html">28 Jan 2018 11:08:22</a>
		|
		<a href="https://simonhaughton.typepad.com/main/bett/">BETT</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2018/01/bett-2018.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2018/01/bett-2018.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b01bb09ed4020970d'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
	

		<h2 class="date-header">27 December 2017</h2>
	
	<div class="entry-author-mr_haughton entry-has-title entry-type-post entry" id="entry-6a0120a530561e970b01bb09e32aeb970d">
					<h3 class="entry-header"><a href="https://simonhaughton.typepad.com/main/2017/12/how-to-improve-photography-in-your-school.html">How to Improve Photography in Your School</a></h3>
		
		<div class="entry-content">
			<div class="entry-body">
				<p>Over the years at my school, I've attempted to develop and improve photography so it becomes a seamlessly integrated aspect of daily life. Some of the strategies I use are pretty obvious to me but I figured that they might not be to others, so here are sixteen of my top tips:</p>
<p><strong>1.&nbsp;</strong>Apply for a school Animoto account - they're free for educators and allow you to quickly and easily create slideshow montages of events such as trips out.&nbsp;<a href="https://animoto.com/education/classroom" rel="noopener noreferrer" target="_blank">https://animoto.com/education/classroom</a></p>
<p><strong>2.&nbsp;</strong>If you're using tablets to take your photos, place a little sticker next to the lens so you can quickly say to children where to look when posing and avoid their eyes looking in the wrong direction.</p>
<p><strong>3.&nbsp;</strong>Encourage people to take photos of small groups of children facing the camera - either directly looking at it or just having their face (as opposed to the back of their head) in it whilst they are doing a task/interaction. These are the shots you want to keep and display - photos showing the backs of children where they can't be identified are never as interesting, neither are shots that don't actually include children at all (umpteen photos of cute animals at the farm might be nice at the time but are mostly useless back in school).</p>
<p><strong>4.&nbsp;</strong>Check out what's going on in the background of a shot before you take it - whilst you're arranging children into position in the foreground, things might be happening behind them that you don't want visible in the final photo. Ask anybody walking behind to step aside for a moment or re-frame the shot to the children in the foreground are physically blocking something behind them from being shown. Also remember to check the floor as well for any unwanted items such as dropped stationary or litter which you might want to remove too.</p>
<p><strong>5.&nbsp;</strong>Take the majority of photos in landscape - these display much better on computer displays.</p>
<p><strong>6.&nbsp;</strong>Shoot the same subject from three different angles with the camera: tilted left, horizontal and tilted right. This gives you several different takes of the same thing and allows you to pick the best later on. I have a tendency to shoot mostly horizontal or tilted right which results in slideshows I create afterwards looking quite samey so I'm trying to force myself to do more left tilted shots to add a bit more variety.</p>
<p><strong>7.&nbsp;</strong>Always be ready with your camera to take photos instantly, especially on event days where you want to try and shoot as much as possible as these are the times that children will most fondly remember and want to look back on in future years. On dressing up days like World Book Day, for example, I will spend all of morning break outside on the yard shooting photos of groups of children.</p>
<p><strong>8.&nbsp;</strong>Try to take photos of children within the same year group as these can be referenced and re-used more easily in future. For example, I will often ask for a group of children in just Year 3 say to pose for a photo before I then ask for a group of just Year 4 children. Depending on the context, try to include a mix of genders in photos too.</p>
<p><strong>9.</strong>Have one DSLR camera in school that has a good optical zoom lens on it - this is especially valuable for taking photos of assemblies where I'm usually stood right at the back and the children performing are several metres away with a huge audience in between us. If you want to transfer photos to an Apple iOS device, this cable is invaluable -&nbsp;<a href="https://www.apple.com/uk/shop/product/MJYT2ZM/A/lightning-to-sd-card-camera-reader" rel="noopener noreferrer" target="_blank">https://www.apple.com/uk/shop/product/MJYT2ZM/A/lightning-to-sd-card-camera-reader</a>.</p>
<p><strong>10.&nbsp;</strong>Include digital photography skills as part of your school curriculum. In Computing lessons, I teach <a href="https://drive.google.com/drive/folders/0B4IXXL4Qnh6AUXB1NUhOX0VmRU0" rel="noopener noreferrer" target="_blank">photo editing</a>, <a href="https://drive.google.com/drive/folders/0B4IXXL4Qnh6ATWF1REZiNmd4eUU" rel="noopener noreferrer" target="_blank">perspective photography</a> and <a href="https://drive.google.com/drive/folders/0B4IXXL4Qnh6AS1hNOFZGckk2aEE" rel="noopener noreferrer" target="_blank">superimposing</a>, for instance.</p>
<p><strong>11.&nbsp;</strong>Run half-termly photo challenges where you invite people to email you photos taken outside of school which can then be compiled into a slideshow to showcase in the final week. These have been immensely popular at my school and have included topics such as: extreme reading, sports, holidays, science experiments, pumpkin carving, Lego models and Christmas tree selfies. These allow you to encourage children to develop both their photography and creative skills beyond the school gates.</p>
<p style="text-align: center;"><iframe allowfullscreen="" frameborder="0" height="243" id="vp1V8RK2" src="https://s3.amazonaws.com/embed.animoto.com/play.html?w=swf/production/vp1&amp;e=1514363652&amp;f=V8RK2t3BMB118F3hVTgZMQ&amp;d=0&amp;m=a&amp;r=360p&amp;volume=100&amp;start_res=360p&amp;i=m&amp;asset_domain=s3-p.animoto.com&amp;animoto_domain=animoto.com&amp;options=" title="Video Player" width="432"></iframe></p>
<p style="text-align: left;"><strong>12.</strong> Let some Year 6 children be responsible for taking photos of aspects of school life such as daily assemblies, attendance winners or favourite library books. I also let these children tweet the photos accompanied with a descriptive sentence typed with the aid of a writing frame like "Well done to #YearX who are this week's #attendance with XXX%!".</p>
<p style="text-align: left;"><strong>13.</strong> Create a display in a central location in school that can be used as a background for any celebration photos such as of awards or excellent work.&nbsp;</p>
<div align=center>
<blockquote class="twitter-tweet" data-lang="en">
<p dir="ltr" lang="en">Congratulations <a href="https://twitter.com/hashtag/Y1?src=hash&amp;ref_src=twsrc%5Etfw">#Y1</a> who are our <a href="https://twitter.com/hashtag/attendance?src=hash&amp;ref_src=twsrc%5Etfw">#attendance</a> <a href="https://twitter.com/hashtag/award?src=hash&amp;ref_src=twsrc%5Etfw">#award</a> winners this week with 91.1%. ⭐️🏆 <a href="https://t.co/fxEbfSFhZ1">pic.twitter.com/fxEbfSFhZ1</a></p>
— Parkfield Primary (@Parkfield) <a href="https://twitter.com/Parkfield/status/921310836702040064?ref_src=twsrc%5Etfw">October 20, 2017</a></blockquote>
<p class="asset-video">
<script src="https://platform.twitter.com/widgets.js"></script>
</p>
</div>
<p style="text-align: left;"><strong>14.</strong> Use any shared displays or screens for showcasing photos - I use the hall board during dinner times to either show slideshows playing on a loop or an automatically scrolling page of recent tweets like <a href="http://twitter.parkfieldprimary.com/" rel="noopener noreferrer" target="_blank">this</a> or <a href="http://awards.parkfieldprimary.com/" rel="noopener noreferrer" target="_blank">this</a>. This not only increases the usage of such displays but also proves the children that you are actually using, liking and keep to show off the photos which are being taken of them.</p>
<p style="text-align: left;"><strong>15.</strong> Store your photos in a central location that is accessible by all staff. We save all photos taken on in a dedicated folder on a shared network drive, with photos stored in Academic Year\Term\Event Name. Where possible, I encourage staff to name any events which are just focused on one year group with the year group name at the start of the folder name so they can easily be found later on by listing folders in alphabetical order.</p>
<p style="text-align: left;"><strong>16.</strong> <a href="https://www.cnet.com/uk/how-to/how-to-disable-live-photos-on-iphone-6s-6s-plus/" rel="noopener noreferrer" target="_blank">Turn off Live Photos</a> if shooting on any iOS device which has this feature. It's aim is to record a few seconds of video to help you recall the ambience in a setting which is great for holidays but not required when the 'ambience' is just you directing children where/when to look.</p>
<p style="text-align: center;"><strong>I hope you find these tips useful. Please write a comment below if you can think of any more!</strong></p>
			</div>
			
			
		</div>
<div class="entry-meta pkg">
	<div class="entry-meta-info">
		<a href="https://simonhaughton.typepad.com/main/2017/12/how-to-improve-photography-in-your-school.html">27 Dec 2017 08:54:04</a>
	</div>
	<div class="entry-facebook-like">
     
     <fb:like href="https://simonhaughton.typepad.com/main/2017/12/how-to-improve-photography-in-your-school.html" layout="button_count" show_faces="false"></fb:like>
     
</div>
</div>

		<div class="entry-footer">
			<ul class="entry-footer-feedback pkg">

                
    		    <li><a href="https://simonhaughton.typepad.com/main/2017/12/how-to-improve-photography-in-your-school.html#comments" class="entry-footer-comment">Comment <span>0</span></a></li>
                

                <li><a href="javascript:var%20b=document.body;var%20TYPEPAD___bookmarklet_domain='https://www.typepad.com/';TYPEPAD___reblog_entryxid='6a0120a530561e970b01bb09e32aeb970d'; TYPEPAD___is_reblog = 1; if(b&&!document.xmlVersion){void(z=document.createElement('script'));void(z.type='text/javascript');void(z.src='https://static.typepad.com/.shared/js/qp/loader-combined-min.js');void(b.appendChild(z));}else{}" title="Grab this post for your own blog" class="entry-footer-reblog">Reblog It <span>0</span></a></li>
	        </ul>
		</div>
	</div>
			<div class="pager-bottom pager-entries pager content-nav">
		<div class="pager-inner">
			
			
			<span class="pager-right">
				<a href="https://simonhaughton.typepad.com/main/page/2/"><span class="pager-label">View Older Posts</span>
					<span class="chevron">&#187;</span></a>
			</span>
		</div>
	</div>
	
	



						</div>
					</div>
					<div id="beta">
						<div id="beta-inner">
						    
<div class="module-profilefollowing module">
	<div class="module-content">
		<div class="userinfo pkg">
			<div class="userinfo-userpic">
				<a href="https://profile.typepad.com/simonhaughton"><img src="https://up6.typepad.com/6a0120a530561e970b01630170d665970d-50si" alt="" width="50" height="50" class="userpic" /></a>
			</div>
			<div class="userinfo-username">
				<h3><a href="https://profile.typepad.com/simonhaughton" style="text-decoration: none;">Mr Haughton</a></h3>
				<p></p>
			</div>
		</div>
		<div class="follow-data pkg">
			<div id="user-following" class="user-following pkg">
				<div class="user-contacts user-has-contacts">
					<a rel="me" href="https://profile.typepad.com/simonhaughton/contacts" title="View all following" target="_parent"><span id="num-contacts" class="follow-num-size-l">1</span> Following</a>
				</div>
			</div>
			<div class="user-followers">
				<div class="user-num-contacts">
					<a rel="me" href="https://profile.typepad.com/simonhaughton/followers" title="View all followers" target="_parent"><span id="num-followers" class="follow-num-size-l">0</span> Followers</a>
				</div>
			</div>
			<div class="user-actions">
				<iframe src="https://www.typepad.com/services/connect/profile_module?user_id=6p0120a530561e970b&amp;follow_only=1&amp;mb=1&amp;align=center&amp;source_uri=https%3A%2F%2Fsimonhaughton.typepad.com%2Fmain%2F" width="100%" height="30" frameborder="0" scrolling="no" allowtransparency="true" id="follow-button-frame" name="follow-button-frame"></iframe>
			</div>
		</div>
	</div>
	<div class="module-list pkg">
		<div class="module-list-item"><a href="https://profile.typepad.com/typepadeverything" target="_parent"><img src="https://up3.typepad.com/6a00d83451c82369e20168ebba2aa0970c-50si" alt="The Typepad Team" title="The Typepad Team" class="userpic" /></a></div>
	</div>
</div><div class="module-search module">
    <h2 class="module-header">Search</h2>
    <div class="module-content">
        <form id="search-blog" method="get" action="https://simonhaughton.typepad.com/.services/blog/6a0120a530561e970b012876745169970c/search" class="form-search form-inline" role="search">

            <input type="search" name="filter.q" results="5" value="" />
            <input type="submit" value="Search" />
            
        </form>
    </div>
</div>
<!-- END Blog Search Module -->

<div class="module-recent-comments-mb module">
	<h2 class="module-header">Recent Comments</h2>
	<div class="module-content">
		<ul class="module-list">
			<li class="module-list-item pkg">
            	<div class="comment-avatar">
            		<img id="comment-6a0120a530561e970b01bb09e712f9970d-avatarimg" src="https://static.typepad.com/.shared/default-userpics/14-50si.gif" alt="Daniel Ekanem" width="32" height="32" />
            	</div>	
            	<div class="comment-content">
    				<div class="comment-content-excerpt"><strong>Daniel Ekanem:</strong> Simon your resources have been fantastic. Thank... <span class="separator">|</span> <a href="https://simonhaughton.typepad.com/main/welcome-to-my-website.html?cid=6a0120a530561e970b01bb09e712f9970d#comment-6a0120a530561e970b01bb09e712f9970d">more »</a></div>
    				<div class="comment-content-info">On <a href="https://simonhaughton.typepad.com/main/welcome-to-my-website.html">Download my FREE primary computing curriculum:</a></div> 
    	        </div>
			</li>
			<li class="module-list-item pkg">
            	<div class="comment-avatar">
            		<img id="comment-6a0120a530561e970b01bb09d6f7a9970d-avatarimg" src="https://static.typepad.com/.shared/default-userpics/18-50si.gif" alt="Yo" width="32" height="32" />
            	</div>	
            	<div class="comment-content">
    				<div class="comment-content-excerpt"><strong>Yo:</strong> I think your curriculum is inspriational..  you... <span class="separator">|</span> <a href="https://simonhaughton.typepad.com/main/welcome-to-my-website.html?cid=6a0120a530561e970b01bb09d6f7a9970d#comment-6a0120a530561e970b01bb09d6f7a9970d">more »</a></div>
    				<div class="comment-content-info">On <a href="https://simonhaughton.typepad.com/main/welcome-to-my-website.html">Download my FREE primary computing curriculum:</a></div> 
    	        </div>
			</li>
			<li class="module-list-item last pkg">
            	<div class="comment-avatar">
            		<img id="comment-6a0120a530561e970b01b7c90073c9970b-avatarimg" src="https://static.typepad.com/.shared/default-userpics/07-50si.gif" alt="Evelyn Wangari" width="32" height="32" />
            	</div>	
            	<div class="comment-content">
    				<div class="comment-content-excerpt"><strong>Evelyn Wangari:</strong> Your ebook is very informative. Feeling inspire... <span class="separator">|</span> <a href="https://simonhaughton.typepad.com/main/how-to-teach-outstanding-computing.html?cid=6a0120a530561e970b01b7c90073c9970b#comment-6a0120a530561e970b01b7c90073c9970b">more »</a></div>
    				<div class="comment-content-info">On <a href="https://simonhaughton.typepad.com/main/how-to-teach-outstanding-computing.html">How to teach outstanding computing</a></div> 
    	        </div>
			</li>
		</ul>
	</div>
</div>

						    
<!-- sidebar -->







						</div>
					</div>
				</div>
			</div>			
		</div>
		</div>
	</div>
	<div id="footer">
	<div id="footer-inner">
		<ul>
			<li class="footer-link-syndicate"><a href="https://simonhaughton.typepad.com/main/atom.xml">Subscribe to this blog's feed</a></li>
			<li class="footer-link-poweredby"><a href="http://www.typepad.com/">Powered by Typepad</a></li>
		</ul>
	</div>
</div>

	





     










<script type="text/javascript">
<!--
var extra_happy = Math.floor(1000000000 * Math.random());
document.write('<img src="https://www.typepad.com/t/stats?blog_id=83446835060512524&amp;user_id=&amp;page=' + escape(location.href) + '&amp;referrer=' + escape(document.referrer) + '&amp;i=' + extra_happy + '" width="1" height="1" alt="" style="position: absolute; top: 0; left: 0;" />');
// -->
</script>

<!-- Google Analytics -->
<script>
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-28020544-1', 'auto');
ga('send', 'pageview');
</script>
<!-- End Google Analytics -->



<!-- Begin disqus Tag -->

<!-- End disqus Tag -->
</body>
</html>
<!-- ph=1 -->
)  
  
Fuente[ http://www.simonhaughton.co.uk/2010/06/lego-wedo-and-scratch.html](http://www.simonhaughton.co.uk/2010/06/lego-wedo-and-scratch.html)

## Otra propuesta

Que el caiman cierre y abra la boca varias veces cuando detecte un objeto

##### Solución

  
![](data:;base64,<!DOCTYPE html>
<html lang="es-ES">
<head >
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Página no encontrada</title>
<meta name='robots' content='max-image-preview:large' />
<!-- Jetpack Site Verification Tags -->

			<style type="text/css">
				.slide-excerpt { width: 100%; }
				.slide-excerpt { bottom: 0; }
				.slide-excerpt { left: 0; }
				.flexslider { max-width: 750px; max-height: 420px; }
				.slide-image { max-height: 420px; }
			</style>
			<style type="text/css">
				@media only screen
				and (min-device-width : 320px)
				and (max-device-width : 480px) {
					.slide-excerpt { display: none !important; }
				}
			</style> <link rel='dns-prefetch' href='//fonts.googleapis.com' />
<link rel='dns-prefetch' href='//s.w.org' />
<link rel='dns-prefetch' href='//v0.wordpress.com' />
<link rel='dns-prefetch' href='//widgets.wp.com' />
<link rel='dns-prefetch' href='//s0.wp.com' />
<link rel='dns-prefetch' href='//0.gravatar.com' />
<link rel='dns-prefetch' href='//1.gravatar.com' />
<link rel='dns-prefetch' href='//2.gravatar.com' />
<link rel="alternate" type="application/rss+xml" title="Código 21 &raquo; Feed" href="https://codigo21.educacion.navarra.es/feed/" />
<link rel="alternate" type="application/rss+xml" title="Código 21 &raquo; Feed de los comentarios" href="https://codigo21.educacion.navarra.es/comments/feed/" />
<script type="text/javascript">
window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/13.1.0\/72x72\/","ext":".png","svgUrl":"https:\/\/s.w.org\/images\/core\/emoji\/13.1.0\/svg\/","svgExt":".svg","source":{"concatemoji":"https:\/\/codigo21.educacion.navarra.es\/wp-includes\/js\/wp-emoji-release.min.js?ver=5.9"}};
/*! This file is auto-generated */
!function(e,a,t){var n,r,o,i=a.createElement("canvas"),p=i.getContext&&i.getContext("2d");function s(e,t){var a=String.fromCharCode;p.clearRect(0,0,i.width,i.height),p.fillText(a.apply(this,e),0,0);e=i.toDataURL();return p.clearRect(0,0,i.width,i.height),p.fillText(a.apply(this,t),0,0),e===i.toDataURL()}function c(e){var t=a.createElement("script");t.src=e,t.defer=t.type="text/javascript",a.getElementsByTagName("head")[0].appendChild(t)}for(o=Array("flag","emoji"),t.supports={everything:!0,everythingExceptFlag:!0},r=0;r<o.length;r++)t.supports[o[r]]=function(e){if(!p||!p.fillText)return!1;switch(p.textBaseline="top",p.font="600 32px Arial",e){case"flag":return s([127987,65039,8205,9895,65039],[127987,65039,8203,9895,65039])?!1:!s([55356,56826,55356,56819],[55356,56826,8203,55356,56819])&&!s([55356,57332,56128,56423,56128,56418,56128,56421,56128,56430,56128,56423,56128,56447],[55356,57332,8203,56128,56423,8203,56128,56418,8203,56128,56421,8203,56128,56430,8203,56128,56423,8203,56128,56447]);case"emoji":return!s([10084,65039,8205,55357,56613],[10084,65039,8203,55357,56613])}return!1}(o[r]),t.supports.everything=t.supports.everything&&t.supports[o[r]],"flag"!==o[r]&&(t.supports.everythingExceptFlag=t.supports.everythingExceptFlag&&t.supports[o[r]]);t.supports.everythingExceptFlag=t.supports.everythingExceptFlag&&!t.supports.flag,t.DOMReady=!1,t.readyCallback=function(){t.DOMReady=!0},t.supports.everything||(n=function(){t.readyCallback()},a.addEventListener?(a.addEventListener("DOMContentLoaded",n,!1),e.addEventListener("load",n,!1)):(e.attachEvent("onload",n),a.attachEvent("onreadystatechange",function(){"complete"===a.readyState&&t.readyCallback()})),(n=t.source||{}).concatemoji?c(n.concatemoji):n.wpemoji&&n.twemoji&&(c(n.twemoji),c(n.wpemoji)))}(window,document,window._wpemojiSettings);
</script>
<style type="text/css">
img.wp-smiley,
img.emoji {
	display: inline !important;
	border: none !important;
	box-shadow: none !important;
	height: 1em !important;
	width: 1em !important;
	margin: 0 0.07em !important;
	vertical-align: -0.1em !important;
	background: none !important;
	padding: 0 !important;
}
</style>
	<link rel='stylesheet' id='magazine-pro-css'  href='https://codigo21.educacion.navarra.es/wp-content/themes/magazine-pro/style.css?ver=3.3.0' type='text/css' media='all' />
<style id='magazine-pro-inline-css' type='text/css'>
.has-custom-color {
	color: #008285 !important;
}

.has-custom-background-color {
	background-color: #008285 !important;
}

.has-accent-color {
	color: #008285 !important;
}

.has-accent-background-color {
	background-color: #008285 !important;
}

.content .wp-block-button .wp-block-button__link:focus,
.content .wp-block-button .wp-block-button__link:hover {
	background-color: #008285;
	color: #fff;
}

.content .wp-block-button.is-style-outline .wp-block-button__link.has-text-color,
.content .wp-block-button.is-style-outline .wp-block-button__link:not(.has-text-color):focus,
.content .wp-block-button.is-style-outline .wp-block-button__link:not(.has-text-color):hover {
	color: #008285;
}

.entry-content .wp-block-pullquote.is-style-solid-color {
	background-color: #008285;
}
</style>
<link rel='stylesheet' id='dashicons-css'  href='https://codigo21.educacion.navarra.es/wp-includes/css/dashicons.min.css?ver=5.9' type='text/css' media='all' />
<link rel='stylesheet' id='elusive-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/menu-icons/vendor/codeinwp/icon-picker/css/types/elusive.min.css?ver=2.0' type='text/css' media='all' />
<link rel='stylesheet' id='font-awesome-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/menu-icons/vendor/codeinwp/icon-picker/css/types/font-awesome.min.css?ver=4.7.0' type='text/css' media='all' />
<link rel='stylesheet' id='foundation-icons-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/menu-icons/vendor/codeinwp/icon-picker/css/types/foundation-icons.min.css?ver=3.0' type='text/css' media='all' />
<link rel='stylesheet' id='genericons-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/menu-icons/vendor/codeinwp/icon-picker/css/types/genericons.min.css?ver=3.4' type='text/css' media='all' />
<link rel='stylesheet' id='menu-icons-extra-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/menu-icons/css/extra.min.css?ver=0.12.9' type='text/css' media='all' />
<link rel='stylesheet' id='wp-block-library-css'  href='https://codigo21.educacion.navarra.es/wp-includes/css/dist/block-library/style.min.css?ver=5.9' type='text/css' media='all' />
<style id='wp-block-library-inline-css' type='text/css'>
.has-text-align-justify{text-align:justify;}
</style>
<link rel='stylesheet' id='mediaelement-css'  href='https://codigo21.educacion.navarra.es/wp-includes/js/mediaelement/mediaelementplayer-legacy.min.css?ver=4.2.16' type='text/css' media='all' />
<link rel='stylesheet' id='wp-mediaelement-css'  href='https://codigo21.educacion.navarra.es/wp-includes/js/mediaelement/wp-mediaelement.min.css?ver=5.9' type='text/css' media='all' />
<style id='global-styles-inline-css' type='text/css'>
body{--wp--preset--color--black: #000000;--wp--preset--color--cyan-bluish-gray: #abb8c3;--wp--preset--color--white: #ffffff;--wp--preset--color--pale-pink: #f78da7;--wp--preset--color--vivid-red: #cf2e2e;--wp--preset--color--luminous-vivid-orange: #ff6900;--wp--preset--color--luminous-vivid-amber: #fcb900;--wp--preset--color--light-green-cyan: #7bdcb5;--wp--preset--color--vivid-green-cyan: #00d084;--wp--preset--color--pale-cyan-blue: #8ed1fc;--wp--preset--color--vivid-cyan-blue: #0693e3;--wp--preset--color--vivid-purple: #9b51e0;--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple: linear-gradient(135deg,rgba(6,147,227,1) 0%,rgb(155,81,224) 100%);--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan: linear-gradient(135deg,rgb(122,220,180) 0%,rgb(0,208,130) 100%);--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange: linear-gradient(135deg,rgba(252,185,0,1) 0%,rgba(255,105,0,1) 100%);--wp--preset--gradient--luminous-vivid-orange-to-vivid-red: linear-gradient(135deg,rgba(255,105,0,1) 0%,rgb(207,46,46) 100%);--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray: linear-gradient(135deg,rgb(238,238,238) 0%,rgb(169,184,195) 100%);--wp--preset--gradient--cool-to-warm-spectrum: linear-gradient(135deg,rgb(74,234,220) 0%,rgb(151,120,209) 20%,rgb(207,42,186) 40%,rgb(238,44,130) 60%,rgb(251,105,98) 80%,rgb(254,248,76) 100%);--wp--preset--gradient--blush-light-purple: linear-gradient(135deg,rgb(255,206,236) 0%,rgb(152,150,240) 100%);--wp--preset--gradient--blush-bordeaux: linear-gradient(135deg,rgb(254,205,165) 0%,rgb(254,45,45) 50%,rgb(107,0,62) 100%);--wp--preset--gradient--luminous-dusk: linear-gradient(135deg,rgb(255,203,112) 0%,rgb(199,81,192) 50%,rgb(65,88,208) 100%);--wp--preset--gradient--pale-ocean: linear-gradient(135deg,rgb(255,245,203) 0%,rgb(182,227,212) 50%,rgb(51,167,181) 100%);--wp--preset--gradient--electric-grass: linear-gradient(135deg,rgb(202,248,128) 0%,rgb(113,206,126) 100%);--wp--preset--gradient--midnight: linear-gradient(135deg,rgb(2,3,129) 0%,rgb(40,116,252) 100%);--wp--preset--duotone--dark-grayscale: url('#wp-duotone-dark-grayscale');--wp--preset--duotone--grayscale: url('#wp-duotone-grayscale');--wp--preset--duotone--purple-yellow: url('#wp-duotone-purple-yellow');--wp--preset--duotone--blue-red: url('#wp-duotone-blue-red');--wp--preset--duotone--midnight: url('#wp-duotone-midnight');--wp--preset--duotone--magenta-yellow: url('#wp-duotone-magenta-yellow');--wp--preset--duotone--purple-green: url('#wp-duotone-purple-green');--wp--preset--duotone--blue-orange: url('#wp-duotone-blue-orange');--wp--preset--font-size--small: 13px;--wp--preset--font-size--medium: 20px;--wp--preset--font-size--large: 36px;--wp--preset--font-size--x-large: 42px;}.has-black-color{color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-color{color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-color{color: var(--wp--preset--color--white) !important;}.has-pale-pink-color{color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-color{color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-color{color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-color{color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-color{color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-color{color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-color{color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-color{color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-color{color: var(--wp--preset--color--vivid-purple) !important;}.has-black-background-color{background-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-background-color{background-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-background-color{background-color: var(--wp--preset--color--white) !important;}.has-pale-pink-background-color{background-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-background-color{background-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-background-color{background-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-background-color{background-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-background-color{background-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-background-color{background-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-background-color{background-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-background-color{background-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-background-color{background-color: var(--wp--preset--color--vivid-purple) !important;}.has-black-border-color{border-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-border-color{border-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-border-color{border-color: var(--wp--preset--color--white) !important;}.has-pale-pink-border-color{border-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-border-color{border-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-border-color{border-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-border-color{border-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-border-color{border-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-border-color{border-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-border-color{border-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-border-color{border-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-border-color{border-color: var(--wp--preset--color--vivid-purple) !important;}.has-vivid-cyan-blue-to-vivid-purple-gradient-background{background: var(--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple) !important;}.has-light-green-cyan-to-vivid-green-cyan-gradient-background{background: var(--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan) !important;}.has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange) !important;}.has-luminous-vivid-orange-to-vivid-red-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-orange-to-vivid-red) !important;}.has-very-light-gray-to-cyan-bluish-gray-gradient-background{background: var(--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray) !important;}.has-cool-to-warm-spectrum-gradient-background{background: var(--wp--preset--gradient--cool-to-warm-spectrum) !important;}.has-blush-light-purple-gradient-background{background: var(--wp--preset--gradient--blush-light-purple) !important;}.has-blush-bordeaux-gradient-background{background: var(--wp--preset--gradient--blush-bordeaux) !important;}.has-luminous-dusk-gradient-background{background: var(--wp--preset--gradient--luminous-dusk) !important;}.has-pale-ocean-gradient-background{background: var(--wp--preset--gradient--pale-ocean) !important;}.has-electric-grass-gradient-background{background: var(--wp--preset--gradient--electric-grass) !important;}.has-midnight-gradient-background{background: var(--wp--preset--gradient--midnight) !important;}.has-small-font-size{font-size: var(--wp--preset--font-size--small) !important;}.has-medium-font-size{font-size: var(--wp--preset--font-size--medium) !important;}.has-large-font-size{font-size: var(--wp--preset--font-size--large) !important;}.has-x-large-font-size{font-size: var(--wp--preset--font-size--x-large) !important;}
</style>
<link rel='stylesheet' id='contact-form-7-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/contact-form-7/includes/css/styles.css?ver=5.5.4' type='text/css' media='all' />
<link rel='stylesheet' id='cookie-law-info-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/cookie-law-info/public/css/cookie-law-info-public.css?ver=2.0.9' type='text/css' media='all' />
<link rel='stylesheet' id='cookie-law-info-gdpr-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/cookie-law-info/public/css/cookie-law-info-gdpr.css?ver=2.0.9' type='text/css' media='all' />
<link rel='stylesheet' id='wpml-legacy-dropdown-click-0-css'  href='//codigo21.educacion.navarra.es/wp-content/plugins/sitepress-multilingual-cms/templates/language-switchers/legacy-dropdown-click/style.min.css?ver=1' type='text/css' media='all' />
<style id='wpml-legacy-dropdown-click-0-inline-css' type='text/css'>
.wpml-ls-statics-shortcode_actions{background-color:#eeeeee;}.wpml-ls-statics-shortcode_actions, .wpml-ls-statics-shortcode_actions .wpml-ls-sub-menu, .wpml-ls-statics-shortcode_actions a {border-color:#cdcdcd;}.wpml-ls-statics-shortcode_actions a {color:#444444;background-color:#ffffff;}.wpml-ls-statics-shortcode_actions a:hover,.wpml-ls-statics-shortcode_actions a:focus {color:#000000;background-color:#eeeeee;}.wpml-ls-statics-shortcode_actions .wpml-ls-current-language>a {color:#444444;background-color:#ffffff;}.wpml-ls-statics-shortcode_actions .wpml-ls-current-language:hover>a, .wpml-ls-statics-shortcode_actions .wpml-ls-current-language>a:focus {color:#000000;background-color:#eeeeee;}
</style>
<link rel='stylesheet' id='wpml-legacy-post-translations-0-css'  href='//codigo21.educacion.navarra.es/wp-content/plugins/sitepress-multilingual-cms/templates/language-switchers/legacy-post-translations/style.min.css?ver=1' type='text/css' media='all' />
<link rel='stylesheet' id='cms-navigation-style-base-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/wpml-cms-nav/res/css/cms-navigation-base.css?ver=1.5.5' type='text/css' media='screen' />
<link rel='stylesheet' id='cms-navigation-style-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/wpml-cms-nav/res/css/cms-navigation.css?ver=1.5.5' type='text/css' media='screen' />
<link rel='stylesheet' id='google-fonts-css'  href='//fonts.googleapis.com/css?family=Roboto%3A300%2C400%7CRaleway%3A400%2C500%2C900&#038;ver=3.3.0' type='text/css' media='all' />
<link rel='stylesheet' id='magazine-pro-gutenberg-css'  href='https://codigo21.educacion.navarra.es/wp-content/themes/magazine-pro/lib/gutenberg/front-end.css?ver=3.3.0' type='text/css' media='all' />
<link rel='stylesheet' id='tablepress-default-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/tablepress/css/default.min.css?ver=1.14' type='text/css' media='all' />
<link rel='stylesheet' id='wp-featherlight-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/wp-featherlight/css/wp-featherlight.min.css?ver=1.3.4' type='text/css' media='all' />
<link rel='stylesheet' id='jetpack_css-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/jetpack/css/jetpack.css?ver=10.5.1' type='text/css' media='all' />
<link rel='stylesheet' id='slider_styles-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/genesis-responsive-slider/assets/style.css?ver=1.0.1' type='text/css' media='all' />
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-includes/js/jquery/jquery.min.js?ver=3.6.0' id='jquery-core-js'></script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-includes/js/jquery/jquery-migrate.min.js?ver=3.3.2' id='jquery-migrate-js'></script>
<script type='text/javascript' id='cookie-law-info-js-extra'>
/* <![CDATA[ */
var Cli_Data = {"nn_cookie_ids":[],"cookielist":[],"non_necessary_cookies":[],"ccpaEnabled":"","ccpaRegionBased":"","ccpaBarEnabled":"","strictlyEnabled":["necessary","obligatoire"],"ccpaType":"gdpr","js_blocking":"","custom_integration":"","triggerDomRefresh":"","secure_cookies":""};
var cli_cookiebar_settings = {"animate_speed_hide":"500","animate_speed_show":"500","background":"#fff","border":"#444","border_on":"","button_1_button_colour":"#000","button_1_button_hover":"#000000","button_1_link_colour":"#fff","button_1_as_button":"1","button_1_new_win":"","button_2_button_colour":"#333","button_2_button_hover":"#292929","button_2_link_colour":"#444","button_2_as_button":"","button_2_hidebar":"1","button_3_button_colour":"#000","button_3_button_hover":"#000000","button_3_link_colour":"#fff","button_3_as_button":"1","button_3_new_win":"1","button_4_button_colour":"#000","button_4_button_hover":"#000000","button_4_link_colour":"#fff","button_4_as_button":"1","button_7_button_colour":"#61a229","button_7_button_hover":"#4e8221","button_7_link_colour":"#fff","button_7_as_button":"1","button_7_new_win":"","font_family":"inherit","header_fix":"","notify_animate_hide":"1","notify_animate_show":"","notify_div_id":"#cookie-law-info-bar","notify_position_horizontal":"right","notify_position_vertical":"bottom","scroll_close":"","scroll_close_reload":"1","accept_close_reload":"","reject_close_reload":"","showagain_tab":"","showagain_background":"#fff","showagain_border":"#000","showagain_div_id":"#cookie-law-info-again","showagain_x_position":"100px","text":"#000","show_once_yn":"1","show_once":"15000","logging_on":"","as_popup":"","popup_overlay":"1","bar_heading_text":"Este sitio web utiliza cookies","cookie_bar_as":"banner","popup_showagain_position":"bottom-right","widget_position":"left"};
var log_object = {"ajax_url":"https:\/\/codigo21.educacion.navarra.es\/wp-admin\/admin-ajax.php"};
/* ]]> */
</script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-content/plugins/cookie-law-info/public/js/cookie-law-info-public.js?ver=2.0.9' id='cookie-law-info-js'></script>
<script type='text/javascript' src='//codigo21.educacion.navarra.es/wp-content/plugins/sitepress-multilingual-cms/templates/language-switchers/legacy-dropdown-click/script.min.js?ver=1' id='wpml-legacy-dropdown-click-0-js'></script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-content/themes/magazine-pro/js/entry-date.js?ver=1.0.0' id='magazine-entry-date-js'></script>
<link rel="https://api.w.org/" href="https://codigo21.educacion.navarra.es/wp-json/" /><link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://codigo21.educacion.navarra.es/xmlrpc.php?rsd" />
<meta name="generator" content="WPML ver:4.5.2 stt:16,2;" />
<meta name="generator" content="Site Kit by Google 1.49.1" /><style type='text/css'>img#wpstats{display:none}</style>
	<link rel="pingback" href="https://codigo21.educacion.navarra.es/xmlrpc.php" />
<style type="text/css">.site-header .title-area { background: url(https://codigo21.educacion.navarra.es/wp-content/uploads/2014/12/C21_color_V2_baja.jpg) no-repeat !important; }</style>
<meta name="google-site-verification" content="i9oJTqQ2pdlo8_CSr5qUVIyTgyyhnJUltfTo2gsbB2I"><style type="text/css">.recentcomments a{display:inline !important;padding:0 !important;margin:0 !important;}</style><link rel="icon" href="https://codigo21.educacion.navarra.es/wp-content/uploads/2015/09/cropped-logotipo-codigo21-32x32.png" sizes="32x32" />
<link rel="icon" href="https://codigo21.educacion.navarra.es/wp-content/uploads/2015/09/cropped-logotipo-codigo21-192x192.png" sizes="192x192" />
<link rel="apple-touch-icon" href="https://codigo21.educacion.navarra.es/wp-content/uploads/2015/09/cropped-logotipo-codigo21-180x180.png" />
<meta name="msapplication-TileImage" content="https://codigo21.educacion.navarra.es/wp-content/uploads/2015/09/cropped-logotipo-codigo21-270x270.png" />
		<style type="text/css" id="wp-custom-css">
			/* Estilos para los campos de "Teléfono", "Email", "URL" y respuesta a la pregunta de verificación antispam,
en el formulario de contacto de "Centros que participan en robótica educativa" */

#wpcf7-f294-p295-o1 .telefono input {
	width: 200px;
}

#wpcf7-f294-p295-o1 .email input {
	width: 350px;
}

#wpcf7-f294-p295-o1 .url-603 input {
	width: 400px;
}

#wpcf7-f294-p295-o1 .quiz-597 input {
	width: 50px;
}

/* Estilos para cambiar el color de la letra de los enlaces del widget que lee los cursos activos en el Plan de Formación */

#text-3 li {
	color: white!important;
}

/* Estilos personalizados para la lista del widget de cursos, creado con el plugin WP Web Scraper */

#text-4 {
	font-size: small;}

#text-4 li {
    border-bottom: none;
    margin: 0px;
    padding: 0px;
}

/* Estilo para la iamgen de cabecera */

.site-header .title-area {
	min-height: 171px;
}		</style>
		</head>
<body class="error404 wp-embed-responsive wp-featherlight-captions custom-header header-image header-full-width content-sidebar genesis-breadcrumbs-visible genesis-footer-widgets-visible primary-nav" itemscope itemtype="https://schema.org/WebPage"><div class="site-container"><ul class="genesis-skip-link"><li><a href="#genesis-content" class="screen-reader-shortcut"> Saltar al contenido principal</a></li><li><a href="#genesis-nav-secondary" class="screen-reader-shortcut"> Saltar al menú secundario</a></li><li><a href="#genesis-sidebar-primary" class="screen-reader-shortcut"> Ir a la barra lateral principal</a></li><li><a href="#genesis-footer-widgets" class="screen-reader-shortcut"> Ir al pie de página</a></li></ul><nav class="nav-primary" aria-label="Principal" itemscope itemtype="https://schema.org/SiteNavigationElement" id="genesis-nav-primary"><div class="wrap"><ul id="menu-menu-principal" class="menu genesis-nav-menu menu-primary js-superfish"><li id="menu-item-52" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-52"><a href="https://codigo21.educacion.navarra.es/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-admin-home" aria-hidden="true"></i><span>Inicio</span></span></a></li>
<li id="menu-item-53" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-53"><a href="https://codigo21.educacion.navarra.es/que-es-codigo-21/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-file-code-o" aria-hidden="true" style="font-size:1.4em;"></i><span>Código 21</span></span></a></li>
<li id="menu-item-3160" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-3160"><a href="https://codigo21.educacion.navarra.es/blog-2/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-list-view" aria-hidden="true"></i><span>Blog</span></span></a></li>
<li id="menu-item-37" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-has-children menu-item-37"><a href="https://codigo21.educacion.navarra.es/normativa/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-format-aside" aria-hidden="true" style="font-size:1.4em;"></i><span>Normativa</span></span></a>
<ul class="sub-menu">
	<li id="menu-item-350" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-350"><a href="https://codigo21.educacion.navarra.es/normativa/nuevo-curriculo/" itemprop="url"><span itemprop="name"><i class="_mi _before foundation-icons fi-clipboard" aria-hidden="true"></i><span>Nuevo currículo</span></span></a></li>
	<li id="menu-item-348" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-348"><a href="https://codigo21.educacion.navarra.es/normativa/competencia-digital/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-desktop" aria-hidden="true"></i><span>Competencia digital</span></span></a></li>
	<li id="menu-item-349" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-349"><a href="https://codigo21.educacion.navarra.es/normativa/convenio-fomento-ciencia-y-tecnologia/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-share-alt" aria-hidden="true"></i><span>Convenio fomento ciencia y tecnología</span></span></a></li>
</ul>
</li>
<li id="menu-item-39" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-has-children menu-item-39"><a href="https://codigo21.educacion.navarra.es/profesorado/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-welcome-learn-more" aria-hidden="true" style="font-size:1.4em;"></i><span>Docentes</span></span></a>
<ul class="sub-menu">
	<li id="menu-item-358" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-358"><a href="https://codigo21.educacion.navarra.es/profesorado/guia-programar-para-aprender-orientaciones-para-el-profesorado-de-primaria/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-admin-network" aria-hidden="true"></i><span>Orientaciones</span></span></a></li>
	<li id="menu-item-337" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-has-children menu-item-337"><a href="https://codigo21.educacion.navarra.es/familias/competencia-digital/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-desktop" aria-hidden="true"></i><span>Competencia digital</span></span></a>
	<ul class="sub-menu">
		<li id="menu-item-2649" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2649"><a href="https://codigo21.educacion.navarra.es/familias/competencia-digital/cdd-informacion/" itemprop="url"><span itemprop="name">Área 1: Información</span></a></li>
		<li id="menu-item-2653" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2653"><a href="https://codigo21.educacion.navarra.es/familias/competencia-digital/area-2-comunicacion/" itemprop="url"><span itemprop="name">Área 2: Comunicación</span></a></li>
		<li id="menu-item-2673" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2673"><a href="https://codigo21.educacion.navarra.es/familias/competencia-digital/area-3-creacion-de-contenido/" itemprop="url"><span itemprop="name">Área 3: Creación de Contenido</span></a></li>
		<li id="menu-item-2667" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2667"><a href="https://codigo21.educacion.navarra.es/familias/competencia-digital/area-4/" itemprop="url"><span itemprop="name">Área 4: Seguridad</span></a></li>
		<li id="menu-item-2677" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2677"><a href="https://codigo21.educacion.navarra.es/familias/competencia-digital/area-5-resolucion-de-problemas/" itemprop="url"><span itemprop="name">Área 5: Resolución de Problemas</span></a></li>
	</ul>
</li>
	<li id="menu-item-216" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-216"><a href="https://codigo21.educacion.navarra.es/categoria/formacion-del-profesorado/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-welcome-learn-more" aria-hidden="true"></i><span>Formación del profesorado</span></span></a></li>
	<li id="menu-item-288" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-288"><a href="https://codigo21.educacion.navarra.es/profesorado/guia-informatica-creativa/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-menu" aria-hidden="true"></i><span>Guía Informática Creativa</span></span></a></li>
	<li id="menu-item-232" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-232"><a href="https://codigo21.educacion.navarra.es/categoria/recursos-del-profesorado/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-welcome-widgets-menus" aria-hidden="true"></i><span>Recursos</span></span></a></li>
	<li id="menu-item-1630" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1630"><a href="https://codigo21.educacion.navarra.es/red-de-centros-de-innovacion-en-ciencia-y-tecnologia/" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-network" aria-hidden="true"></i><span>Red de Centros</span></span></a></li>
	<li id="menu-item-704" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-704"><a href="https://codigo21.educacion.navarra.es/centros-que-participan-en-robotica-educativa/buenas-practicas-de-centros-educativos/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-welcome-view-site" aria-hidden="true"></i><span>Buenas prácticas de centros educativos</span></span></a></li>
	<li id="menu-item-2616" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2616"><a href="https://codigo21.educacion.navarra.es/centros-que-participan-en-robotica-educativa/foro-robotica-educativa/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-groups" aria-hidden="true"></i><span>Foro Robótica Educativa</span></span></a></li>
	<li id="menu-item-338" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-338"><a href="https://codigo21.educacion.navarra.es/planetario-de-pamplona/" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-adjust" aria-hidden="true"></i><span>Centro de Recursos Planetario</span></span></a></li>
</ul>
</li>
<li id="menu-item-83" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-has-children menu-item-83"><a href="https://codigo21.educacion.navarra.es/alumnado/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-admin-users" aria-hidden="true" style="font-size:1.4em;"></i><span>Alumnado</span></span></a>
<ul class="sub-menu">
	<li id="menu-item-86" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-86"><a href="https://codigo21.educacion.navarra.es/alumnado/recursos/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-welcome-widgets-menus" aria-hidden="true"></i><span>Recursos</span></span></a></li>
	<li id="menu-item-84" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-84"><a href="https://codigo21.educacion.navarra.es/alumnado/seguridad/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-shield-alt" aria-hidden="true"></i><span>Seguridad</span></span></a></li>
	<li id="menu-item-87" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-87"><a href="https://codigo21.educacion.navarra.es/categoria/jovenes-creadores/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-id-alt" aria-hidden="true"></i><span>Jóvenes creadores</span></span></a></li>
	<li id="menu-item-115" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-115"><a target="_blank" rel="noopener" href="http://pamplonetario.org/category/pamplonetabot/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-adjust" aria-hidden="true"></i><span>Pamplonetario</span></span></a></li>
</ul>
</li>
<li id="menu-item-79" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-has-children menu-item-79"><a href="https://codigo21.educacion.navarra.es/familias/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-groups" aria-hidden="true" style="font-size:1.4em;"></i><span>Familias</span></span></a>
<ul class="sub-menu">
	<li id="menu-item-80" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-80"><a href="https://codigo21.educacion.navarra.es/familias/competencia-digital/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-desktop" aria-hidden="true"></i><span>Competencia digital</span></span></a></li>
	<li id="menu-item-81" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-81"><a href="https://codigo21.educacion.navarra.es/familias/recursos/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-welcome-widgets-menus" aria-hidden="true"></i><span>Recursos</span></span></a></li>
	<li id="menu-item-342" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-342"><a href="https://codigo21.educacion.navarra.es/centros-que-participan-en-robotica-educativa/red-de-centros/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-location" aria-hidden="true"></i><span>Centros que programan</span></span></a></li>
	<li id="menu-item-341" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-341"><a target="_blank" rel="noopener" href="http://pamplonetario.org" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-adjust" aria-hidden="true"></i><span>Pamplonetario</span></span></a></li>
</ul>
</li>
<li class="menu-item" style="float:right;"><a href="https://codigo21.educacion.navarra.es/eu/"> Euskara</a></li></ul></div></nav><header class="site-header" itemscope itemtype="https://schema.org/WPHeader"><div class="wrap"><div class="title-area"><p class="site-description" itemprop="description">Tecnologías creativas</p></div>
</div></header><nav class="nav-secondary" aria-label="Secundaria" id="genesis-nav-secondary" itemscope itemtype="https://schema.org/SiteNavigationElement"><div class="wrap"><ul id="menu-menu-secundario" class="menu genesis-nav-menu menu-secondary js-superfish"><li id="menu-item-1482" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-has-children menu-item-1482"><a href="https://codigo21.educacion.navarra.es/red-de-centros-de-innovacion-en-ciencia-y-tecnologia/" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-network" aria-hidden="true"></i><span>Red de Centros</span></span></a>
<ul class="sub-menu">
	<li id="menu-item-1485" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1485"><a href="https://codigo21.educacion.navarra.es/centros-que-participan-en-robotica-educativa/red-de-centros/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-map-marker" aria-hidden="true"></i><span>Centros que programan</span></span></a></li>
	<li id="menu-item-2617" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2617"><a href="https://codigo21.educacion.navarra.es/centros-que-participan-en-robotica-educativa/foro-robotica-educativa/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-groups" aria-hidden="true"></i><span>Foro Robótica Educativa</span></span></a></li>
	<li id="menu-item-1484" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1484"><a href="https://codigo21.educacion.navarra.es/centros-que-participan-en-robotica-educativa/buenas-practicas-de-centros-educativos/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-welcome-view-site" aria-hidden="true"></i><span>Buenas prácticas de centros educativos</span></span></a></li>
</ul>
</li>
<li id="menu-item-1510" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-1510"><a href="https://codigo21.educacion.navarra.es/categoria/formacion-del-profesorado/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-welcome-learn-more" aria-hidden="true"></i><span>Formación</span></span></a>
<ul class="sub-menu">
	<li id="menu-item-1487" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1487"><a href="https://codigo21.educacion.navarra.es/profesorado/formacion-del-profesorado/materiales-de-las-actividades-de-formacion/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-index-card" aria-hidden="true"></i><span>Materiales</span></span></a></li>
</ul>
</li>
<li id="menu-item-520" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-520"><a href="#" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-screen" aria-hidden="true"></i><span>Autoaprendizaje</span></span></a>
<ul class="sub-menu">
	<li id="menu-item-825" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-825"><a href="#" itemprop="url"><span itemprop="name">Scratch</span></a>
	<ul class="sub-menu">
		<li id="menu-item-1489" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1489"><a href="https://codigo21.educacion.navarra.es/profesorado/guia-informatica-creativa/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-contao" aria-hidden="true"></i><span>Guía Informática Creativa</span></span></a></li>
		<li id="menu-item-521" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-521"><a href="http://aprendecodigo21.educacion.navarra.es/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-buysellads" aria-hidden="true"></i><span>Aprende Código 21: Informática Creativa</span></span></a></li>
		<li id="menu-item-1490" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1490"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/curso-de-espectador-a-programador-del-intef/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-github-square" aria-hidden="true"></i><span>Curso «De espectador a programador» del INTEF</span></span></a></li>
		<li id="menu-item-1488" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1488"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/guias-de-scratch-junior/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-optin-monster" aria-hidden="true"></i><span>Guías de Scratch Junior</span></span></a></li>
		<li id="menu-item-1492" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1492"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/kinect-y-scratch-1-4/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-street-view" aria-hidden="true"></i><span>Kinect y Scratch 1.4</span></span></a></li>
		<li id="menu-item-2342" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2342"><a target="_blank" rel="noopener" href="http://diwo.bq.com/course/curso-de-scratch/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-qq" aria-hidden="true"></i><span>Curso de Scratch con Zowi</span></span></a></li>
		<li id="menu-item-2484" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2484"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/instalar-scratch-scratch4arduino-y-enchanting-en-linux-mint/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-linux" aria-hidden="true"></i><span>Instalar Scratch, Scratch4Arduino y Enchanting en Linux</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-2029" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-2029"><a href="#" itemprop="url"><span itemprop="name">Bee-Bot</span></a>
	<ul class="sub-menu">
		<li id="menu-item-1493" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1493"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/bee-bot-robot-infantil-programable/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-weibo" aria-hidden="true"></i><span>Bee-Bot: robot infantil programable</span></span></a></li>
		<li id="menu-item-2028" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2028"><a target="_blank" rel="noopener" href="http://olmedarein7.wix.com/roboticainfantil#!actividades/c1se" itemprop="url"><span itemprop="name"><i class="_mi _before genericon genericon-reply" aria-hidden="true"></i><span>Actividades con Bee-Bot y Blue-Bot</span></span></a></li>
		<li id="menu-item-2031" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2031"><a target="_blank" rel="noopener" href="http://apprendiendoconrobotica.blogspot.com.es/p/actividades-con-bee-bot.html" itemprop="url"><span itemprop="name"><i class="_mi _before genericon genericon-summary" aria-hidden="true"></i><span>Ejemplos de actividades con Bee-Bot</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-1494" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1494"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/realidad-virtual-con-las-google-cardboard/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-simplybuilt" aria-hidden="true"></i><span>Realidad virtual con las Google Cardboard</span></span></a></li>
	<li id="menu-item-826" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-826"><a href="#" itemprop="url"><span itemprop="name">LEGO WeDo</span></a>
	<ul class="sub-menu">
		<li id="menu-item-1496" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1496"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/primeros-pasos-con-scratch-y-lego-wedo/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-dashboard" aria-hidden="true"></i><span>Primeros pasos con Scratch y LEGO WeDo</span></span></a></li>
		<li id="menu-item-1495" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1495"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/guias-y-modelos-de-lego-wedo/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-format-aside" aria-hidden="true"></i><span>Guías y modelos de Lego WeDo</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-904" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-904"><a href="#" itemprop="url"><span itemprop="name">Enchanting</span></a>
	<ul class="sub-menu">
		<li id="menu-item-1498" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1498"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/primeros-pasos-con-enchanting-y-lego-nxt/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-arrow-up" aria-hidden="true"></i><span>Primeros pasos con Enchanting y LEGO NXT</span></span></a></li>
		<li id="menu-item-1497" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1497"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/guias-y-propuestas-con-enchanting/" itemprop="url"><span itemprop="name"><i class="_mi _before foundation-icons fi-folder-add" aria-hidden="true"></i><span>Guías y propuestas de trabajo con Enchanting</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-1904" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-1904"><a href="#" itemprop="url"><span itemprop="name">App Inventor 2</span></a>
	<ul class="sub-menu">
		<li id="menu-item-1905" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1905"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/primeros-pasos-con-app-inventor-2/" itemprop="url"><span itemprop="name"><i class="_mi _before genericon genericon-phone" aria-hidden="true"></i><span>Primeros pasos con App Inventor 2</span></span></a></li>
		<li id="menu-item-1906" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1906"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/configuracion-de-app-inventor-2/" itemprop="url"><span itemprop="name"><i class="_mi _before genericon genericon-send-to-phone" aria-hidden="true"></i><span>Configuración de App Inventor 2</span></span></a></li>
		<li id="menu-item-1907" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1907"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/descripcion-de-los-bloques-integrados-de-app-inventor-2/" itemprop="url"><span itemprop="name"><i class="_mi _before genericon genericon-hierarchy" aria-hidden="true"></i><span>Descripción de los bloques integrados de App Inventor 2</span></span></a></li>
		<li id="menu-item-2150" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2150"><a target="_blank" rel="noopener" href="http://diwo.bq.com/course/curso-de-introduccion-a-mit-app-inventor/" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-livejournal" aria-hidden="true"></i><span>Curso de introducción a MIT App Inventor de DIWO</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-1928" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-1928"><a href="#" itemprop="url"><span itemprop="name">Arduino</span></a>
	<ul class="sub-menu">
		<li id="menu-item-1929" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1929"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/scratch-para-arduino-s4a-configuracion-inicial/" itemprop="url"><span itemprop="name"><i class="_mi _before genericon genericon-gallery" aria-hidden="true"></i><span>Scratch para Arduino (S4A): configuración inicial</span></span></a></li>
		<li id="menu-item-2011" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2011"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/ejemplos-con-s4a/" itemprop="url"><span itemprop="name"><i class="_mi _before genericon genericon-portfolio" aria-hidden="true"></i><span>Ejemplos con S4A</span></span></a></li>
		<li id="menu-item-2084" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2084"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/snap4arduino-ventajas-instalacion-e-importacion-de-proyectos-de-scratch/" itemprop="url"><span itemprop="name"><i class="_mi _before foundation-icons fi-social-smashing-mag" aria-hidden="true"></i><span>Snap4Arduino: ventajas, instalación e importación</span></span></a></li>
		<li id="menu-item-2102" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2102"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/actividad-con-snap4arduino/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-format-status" aria-hidden="true"></i><span>Actividad con Snap4Arduino</span></span></a></li>
		<li id="menu-item-2245" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2245"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/chromeduino-programar-arduino-en-los-chromebooks/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-trello" aria-hidden="true"></i><span>ChromeDuino, programar Arduino en los Chromebooks</span></span></a></li>
		<li id="menu-item-3071" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-3071"><a href="http://https://drive.google.com/open?id=0Bwv1FbpOlfQgR1RIdWUwdkczS28" itemprop="url"><span itemprop="name">Prácticas Arduino + Shield Multifunción</span></a></li>
	</ul>
</li>
	<li id="menu-item-2337" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-2337"><a href="#" itemprop="url"><span itemprop="name">BQ</span></a>
	<ul class="sub-menu">
		<li id="menu-item-2339" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2339"><a target="_blank" rel="noopener" href="http://diwo.bq.com/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-dashboard" aria-hidden="true"></i><span>DIWO</span></span></a></li>
		<li id="menu-item-2338" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2338"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/zowi-el-robot-infantil-de-bq/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-android" aria-hidden="true"></i><span>Zowi, el robot infantil de BQ</span></span></a></li>
		<li id="menu-item-2412" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2412"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/trabajo-integral-en-robotica-con-bq-printbot-evolution-estudio-de-sus-componentes-impresion-en-3d-de-piezas-montaje-y-programacion/" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-car" aria-hidden="true"></i><span>BQ PrintBot Evolution</span></span></a></li>
	</ul>
</li>
</ul>
</li>
<li id="menu-item-538" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-538"><a href="#" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-welcome-widgets-menus" aria-hidden="true"></i><span>Recursos</span></span></a>
<ul class="sub-menu">
	<li id="menu-item-1499" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1499"><a href="https://codigo21.educacion.navarra.es/recursos/software/" itemprop="url"><span itemprop="name"><i class="_mi _before genericon genericon-codepen" aria-hidden="true"></i><span>Software</span></span></a></li>
	<li id="menu-item-2902" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-2902"><a href="#" itemprop="url"><span itemprop="name">mBots</span></a>
	<ul class="sub-menu">
		<li id="menu-item-2904" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2904"><a href="https://codigo21.educacion.navarra.es/recursos/montaje-de-un-mbot/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-admin-tools" aria-hidden="true"></i><span>Montaje de un mBot</span></span></a></li>
		<li id="menu-item-2928" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2928"><a href="https://codigo21.educacion.navarra.es/mbot/conectar-el-mbot/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-plug" aria-hidden="true"></i><span>Programar el mBot</span></span></a></li>
		<li id="menu-item-3062" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-3062"><a href="https://drive.google.com/open?id=0Bwv1FbpOlfQgTFpjVE9BRXJ5U0E" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-translation" aria-hidden="true"></i><span>Configurar mBlock en euskera</span></span></a></li>
		<li id="menu-item-3061" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-3061"><a href="https://drive.google.com/open?id=0Bwv1FbpOlfQgb0ltYUdFcngzYTg" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-welcome-learn-more" aria-hidden="true"></i><span>Prácticas con mBots</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-3064" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-3064"><a href="#" itemprop="url"><span itemprop="name">Impresora Ultimaker 2Go</span></a>
	<ul class="sub-menu">
		<li id="menu-item-3065" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-3065"><a href="https://drive.google.com/open?id=0Bwv1FbpOlfQgbGdHcW03ejZKdUlOVW5SSEJFZjVodFJnMFcw" itemprop="url"><span itemprop="name">Manual Ultimaker 2 Go</span></a></li>
		<li id="menu-item-3067" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-3067"><a href="https://drive.google.com/open?id=0Bwv1FbpOlfQgWS1zSHpxZTZ5eDltYnJCTXNIaTFTTW1Xbnh3" itemprop="url"><span itemprop="name">Esquema display Ultimaker 2 Go</span></a></li>
		<li id="menu-item-3080" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-3080"><a href="https://drive.google.com/open?id=0Bwv1FbpOlfQgLUlGNV9meWtUM291RmViQ3pObTlSNFZfM204" itemprop="url"><span itemprop="name">Dossier Educativo: Ultimaker en Educación</span></a></li>
		<li id="menu-item-3066" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-3066"><a href="https://ultimaker.com/en/resources/education/getting-started-with-an-ultimaker" itemprop="url"><span itemprop="name">Recursos Ultimaker 2 Go (Inglés)</span></a></li>
		<li id="menu-item-3070" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-3070"><a href="https://youtu.be/ePM7KkZYrsk" itemprop="url"><span itemprop="name">Tutorial modelado 3D con Tinkercad</span></a></li>
	</ul>
</li>
	<li id="menu-item-860" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-860"><a href="#" itemprop="url"><span itemprop="name">LEGO</span></a>
	<ul class="sub-menu">
		<li id="menu-item-1503" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1503"><a href="https://codigo21.educacion.navarra.es/recursos/montaje-de-un-robot-lego/" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-reddit" aria-hidden="true"></i><span>Montaje de un robot Lego NXT</span></span></a></li>
		<li id="menu-item-1500" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1500"><a href="https://codigo21.educacion.navarra.es/recursos/montaje-de-un-robot-lego-ev3/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-twitch" aria-hidden="true"></i><span>Montaje de un robot LEGO EV3</span></span></a></li>
		<li id="menu-item-1502" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1502"><a href="https://codigo21.educacion.navarra.es/recursos/montaje-de-un-caiman-con-lego-wedo/" itemprop="url"><span itemprop="name"><i class="_mi _before foundation-icons fi-social-treehouse" aria-hidden="true"></i><span>Montaje de un caimán con Lego WeDo</span></span></a></li>
		<li id="menu-item-1501" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1501"><a href="https://codigo21.educacion.navarra.es/recursos/configuracion-para-lego-nxt-con-enchanting/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-admin-settings" aria-hidden="true"></i><span>Cambio de firmware de los LEGO NXT compatible con Enchanting</span></span></a></li>
		<li id="menu-item-2482" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2482"><a href="https://codigo21.educacion.navarra.es/recursos/recuperar-robots-lego-nxt-colgados/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-steam" aria-hidden="true"></i><span>Recuperar robots LEGO NXT colgados</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-905" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-905"><a href="#" itemprop="url"><span itemprop="name">Scratch</span></a>
	<ul class="sub-menu">
		<li id="menu-item-2450" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2450"><a href="https://codigo21.educacion.navarra.es/recursos/crear-e-importar-objetos-en-scratch/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-tencent-weibo" aria-hidden="true"></i><span>Crear e importar objetos en Scratch</span></span></a></li>
		<li id="menu-item-914" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-914"><a href="http://drscratch.programamos.es/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-visibility" aria-hidden="true"></i><span>Dr. Scratch</span></span></a></li>
		<li id="menu-item-636" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-636"><a href="https://scratch.mit.edu/studios/1567856/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-github" aria-hidden="true"></i><span>Estudio con proyectos del curso «Programación con Scratch»</span></span></a></li>
		<li id="menu-item-637" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-637"><a href="https://scratch.mit.edu/studios/1567878/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-gittip" aria-hidden="true"></i><span>Estudio con otros proyectos interesantes</span></span></a></li>
		<li id="menu-item-1693" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1693"><a href="https://codigo21.educacion.navarra.es/recursos/instalacion-de-scratch-jr-en-un-pc/" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-flag" aria-hidden="true"></i><span>Instalación de Scratch Jr en un PC</span></span></a></li>
		<li id="menu-item-2120" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2120"><a href="http://kurt.herokuapp.com/20to14" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-admin-plugins" aria-hidden="true"></i><span>Conversor Scratch 2.0 a Scratch 1.4</span></span></a></li>
		<li id="menu-item-2121" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2121"><a href="http://hardmath123.github.io/Snapin8r/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-filter" aria-hidden="true"></i><span>Conversor Scratch 2.0 a Snap!</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-2026" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-2026"><a href="#" itemprop="url"><span itemprop="name">Bee-Bot</span></a>
	<ul class="sub-menu">
		<li id="menu-item-1505" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1505"><a href="https://codigo21.educacion.navarra.es/recursos/alfombras-para-bee-bots/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-grid-view" aria-hidden="true"></i><span>Escenarios para Bee-Bots</span></span></a></li>
		<li id="menu-item-2025" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2025"><a href="https://codigo21.educacion.navarra.es/recursos/disfraces-imprimibles-para-bee-bots/" itemprop="url"><span itemprop="name"><i class="_mi _before genericon genericon-polldaddy" aria-hidden="true"></i><span>Disfraces imprimibles para Bee-Bots</span></span></a></li>
		<li id="menu-item-2030" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2030"><a target="_blank" rel="noopener" href="https://scratch.mit.edu/projects/19685257/" itemprop="url"><span itemprop="name"><i class="_mi _before foundation-icons fi-play-video" aria-hidden="true"></i><span>Simulador de un Bee-Bot en Scratch</span></span></a></li>
		<li id="menu-item-2415" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2415"><a href="https://codigo21.educacion.navarra.es/recursos/proyecto-de-robotica-educativa-trabajamos-con-robots-en-infantil-bee-bots/" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-circle-arrow-up" aria-hidden="true"></i><span>Proyecto con Bee-Bots</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-2144" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-2144"><a href="#" itemprop="url"><span itemprop="name">Realidad Virtual</span></a>
	<ul class="sub-menu">
		<li id="menu-item-2202" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2202"><a href="https://codigo21.educacion.navarra.es/recursos/vr-apps/" itemprop="url"><span itemprop="name"><i class="_mi _before genericon genericon-show" aria-hidden="true"></i><span>VR apps</span></span></a></li>
		<li id="menu-item-2145" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2145"><a target="_blank" rel="noopener" href="http://www.edtechnocation.com/gafe/googlecardboardedu" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-sort" aria-hidden="true"></i><span>Jump on the virtual</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-2148" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-2148"><a href="#" itemprop="url"><span itemprop="name">App Inventor 2</span></a>
	<ul class="sub-menu">
		<li id="menu-item-2149" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2149"><a target="_blank" rel="noopener" href="http://kio4.com/appinventor/index.htm" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-smiley-alt" aria-hidden="true"></i><span>KI04</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-2143" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-2143"><a href="#" itemprop="url"><span itemprop="name">Arduino</span></a>
	<ul class="sub-menu">
		<li id="menu-item-2126" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-2126"><a href="https://codigo21.educacion.navarra.es/autoaprendizaje/tarjeta-arduino-basic-io-v2/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-image-flip-vertical" aria-hidden="true"></i><span>Tarjeta Arduino Basic I/O V2</span></span></a></li>
		<li id="menu-item-3345" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-3345"><a href="https://codigo21.educacion.navarra.es/recursos/tinkercad-simulador/" itemprop="url"><span itemprop="name"><i class="_mi _before foundation-icons fi-play-video" aria-hidden="true"></i><span>Tinkercad. Simulador</span></span></a></li>
	</ul>
</li>
	<li id="menu-item-2341" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-2341"><a href="#" itemprop="url"><span itemprop="name">BQ</span></a>
	<ul class="sub-menu">
		<li id="menu-item-2340" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2340"><a target="_blank" rel="noopener" href="http://bitbloq.bq.com/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-long-arrow-right" aria-hidden="true"></i><span>Bitbloq</span></span></a></li>
		<li id="menu-item-2343" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2343"><a target="_blank" rel="noopener" href="http://blog.start-robot.com/montaje-de-zowi/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-simplybuilt" aria-hidden="true"></i><span>Montaje de Zowi</span></span></a></li>
		<li id="menu-item-2413" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2413"><a target="_blank" rel="noopener" href="http://diwo.bq.com/montaje-del-printbot-evolution/" itemprop="url"><span itemprop="name"><i class="_mi _before elusive el-icon-magic" aria-hidden="true"></i><span>Montaje del PrintBot Evolution</span></span></a></li>
		<li id="menu-item-2344" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-2344"><a target="_blank" rel="noopener" href="http://diwo.bq.com/en/zowi-cc-by-sa/" itemprop="url"><span itemprop="name"><i class="_mi _before fa fa-square-o" aria-hidden="true"></i><span>Repositorio Github de Zowi</span></span></a></li>
	</ul>
</li>
</ul>
</li>
<li id="menu-item-3104" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-3104"><a href="http://reservas.educacion.navarra.es/booked/Web" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-cart" aria-hidden="true"></i><span>Préstamo de material</span></span></a>
<ul class="sub-menu">
	<li id="menu-item-1476" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1476"><a href="https://codigo21.educacion.navarra.es/prestamo-de-material-de-robotica/descripcion-del-material-de-robotica-disponible-para-prestamos/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-list-view" aria-hidden="true"></i><span>Descripción del material</span></span></a></li>
	<li id="menu-item-1478" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1478"><a href="https://codigo21.educacion.navarra.es/recursos/material-de-robotica-por-etapas-y-cursos/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-forms" aria-hidden="true"></i><span>Material por etapas y cursos</span></span></a></li>
	<li id="menu-item-1475" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1475"><a href="https://codigo21.educacion.navarra.es/prestamo-de-material-de-robotica/normativa-del-prestamo-de-material-de-robotica/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-editor-ul" aria-hidden="true"></i><span>Normativa del préstamo</span></span></a></li>
</ul>
</li>
<li id="menu-item-1479" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1479"><a href="https://codigo21.educacion.navarra.es/contacto/" itemprop="url"><span itemprop="name"><i class="_mi _before dashicons dashicons-email-alt" aria-hidden="true"></i><span>Contacto</span></span></a></li>
</ul></div></nav><div class="site-inner"><div class="content-sidebar-wrap"><main class="content" id="genesis-content"><div class="breadcrumb" itemprop="breadcrumb" itemscope itemtype="https://schema.org/BreadcrumbList">Estás aquí: <span class="breadcrumb-link-wrap" itemprop="itemListElement" itemscope itemtype="https://schema.org/ListItem"><a class="breadcrumb-link" href="https://codigo21.educacion.navarra.es/" itemprop="item"><span class="breadcrumb-link-text-wrap" itemprop="name">Inicio</span></a><meta itemprop="position" content="1"></span> <span aria-label="breadcrumb separator">/</span> No encontrado: </div><!-- Para que en la página en euskera se muestren también las entradas en castellano -->
 <article class="entry"><h1 class="entry-title" itemprop="headline">Error 404 (página no encontrada)</h1><div class="entry-content" itemprop="text"><p>La página que estás buscando ya no existe. Si quieres, puedes volver a la <a href="https://codigo21.educacion.navarra.es/">página de inicio</a> del sitio y comprobar si desde allí puedes encontrar lo que estabas buscando. O tal vez puedas encontrarla mediante el formulario de búsqueda que aparece a continuación.</p><form class="search-form" method="get" action="https://codigo21.educacion.navarra.es/" role="search" itemprop="potentialAction" itemscope itemtype="https://schema.org/SearchAction"><label class="search-form-label screen-reader-text" for="searchform-1">Buscar en el sitio...</label><input class="search-form-input" type="search" name="s" id="searchform-1" placeholder="Buscar en el sitio..." itemprop="query-input"><input class="search-form-submit" type="submit" value="Buscar"><meta content="https://codigo21.educacion.navarra.es/?s={s}" itemprop="target"></form></div></article></main><aside class="sidebar sidebar-primary widget-area" role="complementary" aria-label="Barra lateral principal" itemscope itemtype="https://schema.org/WPSideBar" id="genesis-sidebar-primary"><h2 class="genesis-sidebar-title screen-reader-text">Barra lateral principal</h2><!-- Para que en la página en euskera se muestren también las entradas en castellano -->
 <section id="search-2" class="widget widget_search"><div class="widget-wrap"><h3 class="widgettitle widget-title">Buscar</h3>
<form class="search-form" method="get" action="https://codigo21.educacion.navarra.es/" role="search" itemprop="potentialAction" itemscope itemtype="https://schema.org/SearchAction"><label class="search-form-label screen-reader-text" for="searchform-2">Buscar en el sitio...</label><input class="search-form-input" type="search" name="s" id="searchform-2" placeholder="Buscar en el sitio..." itemprop="query-input"><input class="search-form-submit" type="submit" value="Buscar"><meta content="https://codigo21.educacion.navarra.es/?s={s}" itemprop="target"></form></div></section>
<section id="custom_html-2" class="widget_text widget widget_custom_html"><div class="widget_text widget-wrap"><h3 class="widgettitle widget-title">Colaboradores</h3>
<div class="textwidget custom-html-widget"><a href="http://www.educacion.navarra.es/" target="_blank" rel="noopener"><img class="wp-image-22 size-full aligncenter" title="Gobierno de Navarra, Departamento de Educación" src="http://codigo21.educacion.navarra.es/wp-content/uploads/2015/10/logotipo_educacion_bilingue_rojo_250px.png" alt="Departamento de Educación, Gobierno de Navarra" width="250" height="29" /></a>

<a href="http://www.unavarra.es" target="_blank" rel="noopener"><img class="wp-image-308 aligncenter" title="Universidad Pública de Navarra" src="http://codigo21.educacion.navarra.es/wp-content/uploads/2014/11/logotipo-UPNA-250px.png" alt="Universidad Pública de Navarra" width="200" height="97" /></a>

<a href="http://pamplonetario.org/"><img class="wp-image-297 aligncenter" src="http://codigo21.educacion.navarra.es/wp-content/uploads/2014/11/Aplicación-vertical-lr-172x300.png" alt="Logotipo Planetario de Pamplona" width="144" height="250" /></a></div></div></section>
<section id="featured-page-2" class="widget featured-content featuredpage"><div class="widget-wrap"><h3 class="widgettitle widget-title">Qué es Código21</h3>
<article class="post-10 page type-page status-publish has-post-thumbnail entry" aria-label="Qué es Código 21"><a href="https://codigo21.educacion.navarra.es/que-es-codigo-21/" class="aligncenter" aria-hidden="true" tabindex="-1"><img width="750" height="420" src="https://codigo21.educacion.navarra.es/wp-content/uploads/2014/10/portatil01-750x420.jpg" class="entry-image attachment-page" alt="Portátil 1" loading="lazy" itemprop="image" /></a><header class="entry-header"><h4 class="entry-title" itemprop="headline"><a href="https://codigo21.educacion.navarra.es/que-es-codigo-21/">Qué es Código 21</a></h4></header><div class="entry-content"><p>Código 21 es el espacio del Departamento de Educación de Gobierno de Navarra dedicado al aprendizaje de programación, robótica educativa y otras tecnologías emergentes que permiten disfrutar y &#x02026; <a href="https://codigo21.educacion.navarra.es/que-es-codigo-21/" class="more-link">Continuar leyendo <span class="screen-reader-text">acerca de Qué es Código 21</span></a></p></div></article></div></section>
<section id="media_image-7" class="widget widget_media_image"><div class="widget-wrap"><h3 class="widgettitle widget-title">Web de autoaprendizaje</h3>
<a href="http://aprendecodigo21.educacion.navarra.es/" target="_blank" rel="noopener"><img width="477" height="234" src="https://codigo21.educacion.navarra.es/wp-content/uploads/2015/05/banner-web-scratch.png" class="image wp-image-472 alignnone attachment-full size-full" alt="Web de autoaprendizaje Informática Creativa con Scratch" loading="lazy" style="max-width: 100%; height: auto;" title="Web de autoaprendizaje Informática Creativa con Scratch" srcset="https://codigo21.educacion.navarra.es/wp-content/uploads/2015/05/banner-web-scratch.png 477w, https://codigo21.educacion.navarra.es/wp-content/uploads/2015/05/banner-web-scratch-300x147.png 300w, https://codigo21.educacion.navarra.es/wp-content/uploads/2015/05/banner-web-scratch-349x171.png 349w" sizes="(max-width: 477px) 100vw, 477px" /></a></div></section>
<section id="twitter_timeline-2" class="widget widget_twitter_timeline"><div class="widget-wrap"><h3 class="widgettitle widget-title">Participa en Twitter #NAVcodigo21</h3>
<a class="twitter-timeline" data-width="360" data-height="500" data-theme="light" data-border-color="#e8e8e8" data-lang="ES" data-partner="jetpack" data-chrome="noheader noscrollbar" data-widget-id="570588593966841856" href="https://twitter.com/570588593966841856">Mis tuits</a></div></section>
<section id="blog_subscription-2" class="widget widget_blog_subscription jetpack_subscription_widget"><div class="widget-wrap"><h3 class="widgettitle widget-title">Suscríbete a Código21</h3>

			<form action="#" method="post" accept-charset="utf-8" id="subscribe-blog-blog_subscription-2">
				                    <div id="subscribe-text"><p>Escribe tu dirección de correo electrónico para suscribirte a este sitio y recibir avisos de sus novedades.</p>
</div>					<div class="jetpack-subscribe-count">
						<p>
						Únete a otros 516 suscriptores						</p>
					</div>
					                    <p id="subscribe-email">
                        <label id="jetpack-subscribe-label"
							class="screen-reader-text"
							for="subscribe-field-blog_subscription-2">
							Dirección de email                        </label>
                        <input type="email" name="email" required="required"
                        			                                                value=""
							id="subscribe-field-blog_subscription-2"
                            placeholder="Dirección de email"
                        />
                    </p>

					<p id="subscribe-submit"
											>
                        <input type="hidden" name="action" value="subscribe"/>
                        <input type="hidden" name="source" value="https://codigo21.educacion.navarra.es/wp-content/uploads/2015/10/scratchwedo_ejemplo_04.png%22%20title=%22Fuente%20Codigo%2021%22%20height=%22371%22%20width=%22317"/>
                        <input type="hidden" name="sub-type" value="widget"/>
						<input type="hidden" name="redirect_fragment" value="subscribe-blog-blog_subscription-2"/>
						                        <button type="submit"
	                        	                            class="wp-block-button__link"
                            		                    	                        name="jetpack_subscriptions_widget"
	                    >
	                        Suscribirse                        </button>
                    </p>
				            </form>
		
</div></section>
<section id="recent-comments-2" class="widget widget_recent_comments"><div class="widget-wrap"><h3 class="widgettitle widget-title">Últimos comentarios</h3>
<ul id="recentcomments"><li class="recentcomments"><span class="comment-author-link">Javier Oropeza</span> en <a href="https://codigo21.educacion.navarra.es/2016/11/23/didactica-de-la-robotica-educativa-un-enfoque-constructivista/#comment-17835">Didáctica de la robótica educativa. Un enfoque constructivista.</a></li><li class="recentcomments"><span class="comment-author-link"><a href='https://blanka-bo.jimdofree.com/' rel='external nofollow ugc' class='url'>Helena Aracely</a></span> en <a href="https://codigo21.educacion.navarra.es/2016/01/29/instalacion-de-scratch-jr-en-un-pc/#comment-17512">Instalación de Scratch Jr en un PC</a></li></ul></div></section>
<section id="custom_html-3" class="widget_text widget widget_custom_html"><div class="widget_text widget-wrap"><div class="textwidget custom-html-widget"><a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licencia de Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a><br /><span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">Código 21</span>, publicado por el <a xmlns:cc="http://creativecommons.org/ns#" href="http://codigo21.educacion.navarra.es/" property="cc:attributionName" rel="cc:attributionURL">Departamento de Educación del Gobierno de Navarra</a>, se distribuye bajo una licencia <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional</a>.</div></div></section>
</aside></div></div><div class="footer-widgets" id="genesis-footer-widgets"><h2 class="genesis-sidebar-title screen-reader-text">Footer</h2><div class="wrap"><div class="widget-area footer-widgets-1 footer-widget-area"><section id="rss-2" class="widget widget_rss"><div class="widget-wrap"><h3 class="widgettitle widget-title"><a class="rsswidget rss-widget-feed" href="https://www.educacion.navarra.es/web/dpto/actualidad/-/asset_publisher/qdOK47LvSWu1/rss?p_p_cacheability=cacheLevelFull"><img class="rss-widget-icon" style="border:0" width="14" height="14" src="https://codigo21.educacion.navarra.es/wp-includes/images/rss.png" alt="RSS" loading="lazy" /></a> <a class="rsswidget rss-widget-title" href="https://www.educacion.navarra.es/web/dpto/actualidad">Departamento de Educación</a></h3>
<ul><li><a class='rsswidget' href='https://www.educacion.navarra.es/web/dpto/actualidad/-/asset_publisher/qdOK47LvSWu1/content/id/2302531'>Artículos relevantes de la web eTwinning del mes de enero</a></li><li><a class='rsswidget' href='https://www.educacion.navarra.es/web/dpto/actualidad/-/asset_publisher/qdOK47LvSWu1/content/id/2297004'>Ya están disponibles la grabación y la presentación de la jornada de difusión de la convocatoria 2022 del programa Erasmus+ 2021-2027</a></li></ul></div></section>
<section id="meta-2" class="widget widget_meta"><div class="widget-wrap"><h3 class="widgettitle widget-title">Meta</h3>

		<ul>
						<li><a href="https://codigo21.educacion.navarra.es/wp-login.php">Acceder</a></li>
			<li><a href="https://codigo21.educacion.navarra.es/feed/">Feed de entradas</a></li>
			<li><a href="https://codigo21.educacion.navarra.es/comments/feed/">Feed de comentarios</a></li>

			<li><a href="https://es.wordpress.org/">WordPress.org</a></li>
		</ul>

		</div></section>
</div><div class="widget-area footer-widgets-2 footer-widget-area"><section id="rss-3" class="widget widget_rss"><div class="widget-wrap"><h3 class="widgettitle widget-title"><a class="rsswidget rss-widget-feed" href="http://www.unavarra.es/actualidad/noticias"><img class="rss-widget-icon" style="border:0" width="14" height="14" src="https://codigo21.educacion.navarra.es/wp-includes/images/rss.png" alt="RSS" loading="lazy" /></a> <a class="rsswidget rss-widget-title" href="">Universidad Pública de Navarra</a></h3>
</div></section>
<section id="rss-4" class="widget widget_rss"><div class="widget-wrap"><h3 class="widgettitle widget-title"><a class="rsswidget rss-widget-feed" href="http://pamplonetario.org/feed/"><img class="rss-widget-icon" style="border:0" width="14" height="14" src="https://codigo21.educacion.navarra.es/wp-includes/images/rss.png" alt="RSS" loading="lazy" /></a> <a class="rsswidget rss-widget-title" href="">Planetario de Pamplona</a></h3>
</div></section>
</div><div class="widget-area footer-widgets-3 footer-widget-area"><section id="top-posts-3" class="widget widget_top-posts"><div class="widget-wrap"><h3 class="widgettitle widget-title">Entradas y Páginas Populares</h3>
<ul>				<li>
					<a href="https://codigo21.educacion.navarra.es/recursos/tinkercad-simulador/" class="bump-view" data-bump-view="tp">Tinkercad. Simulador</a>					</li>
									<li>
					<a href="https://codigo21.educacion.navarra.es/autoaprendizaje/descripcion-de-los-bloques-integrados-de-app-inventor-2/" class="bump-view" data-bump-view="tp">Descripción de los bloques integrados de App Inventor 2</a>					</li>
									<li>
					<a href="https://codigo21.educacion.navarra.es/2016/01/29/instalacion-de-scratch-jr-en-un-pc/" class="bump-view" data-bump-view="tp">Instalación de Scratch Jr en un PC</a>					</li>
					</ul></div></section>
<section id="custom_html-4" class="widget_text widget widget_custom_html"><div class="widget_text widget-wrap"><h3 class="widgettitle widget-title">Desde dónde nos visitan</h3>
<div class="textwidget custom-html-widget"><script src="//rf.revolvermaps.com/0/0/6.js?i=534pe297pe8&amp;m=0&amp;s=250&amp;c=ff0000&amp;cr1=ffffff&amp;f=arial&amp;l=0" async="async" type="text/javascript"></script></div></div></section>
</div></div></div><!-- Para que en la página en euskera se muestren también las entradas en castellano -->
 <footer class="site-footer" itemscope itemtype="https://schema.org/WPFooter"><div class="wrap"><p>Copyright &#x000A9;&nbsp;2022 · <a href="http://my.studiopress.com/themes/magazine/">Magazine Pro</a> para <a href="https://www.studiopress.com/">Genesis Framework</a> · <a href="https://wordpress.org/">WordPress</a> · <a href="https://codigo21.educacion.navarra.es/wp-login.php">Iniciar sesión</a></p></div></footer></div><!--googleoff: all--><div id="cookie-law-info-bar" data-nosnippet="true"><h5 class="cli_messagebar_head">Este sitio web utiliza cookies</h5><span>Utilizamos cookies propias para mejorar nuestros servicios. Si continúa navegando, consideramos que acepta su uso. Más información en nuestra <a href="http://codigo21.educacion.navarra.es/mapa-del-sitio/politica-de-cookies/%20" id="CONSTANT_OPEN_URL" target="_blank"  class="cli-plugin-main-link"  style="display:inline-block;" >Política de cookies</a>.</span></div><div id="cookie-law-info-again" style="display:none;" data-nosnippet="true"><span id="cookie_hdr_showagain">Política de cookies</span></div><div class="cli-modal" data-nosnippet="true" id="cliSettingsPopup" tabindex="-1" role="dialog" aria-labelledby="cliSettingsPopup" aria-hidden="true">
  <div class="cli-modal-dialog" role="document">
	<div class="cli-modal-content cli-bar-popup">
	  	<button type="button" class="cli-modal-close" id="cliModalClose">
			<svg class="" viewBox="0 0 24 24"><path d="M19 6.41l-1.41-1.41-5.59 5.59-5.59-5.59-1.41 1.41 5.59 5.59-5.59 5.59 1.41 1.41 5.59-5.59 5.59 5.59 1.41-1.41-5.59-5.59z"></path><path d="M0 0h24v24h-24z" fill="none"></path></svg>
			<span class="wt-cli-sr-only">Cerrar</span>
	  	</button>
	  	<div class="cli-modal-body">
			<div class="cli-container-fluid cli-tab-container">
	<div class="cli-row">
		<div class="cli-col-12 cli-align-items-stretch cli-px-0">
			<div class="cli-privacy-overview">
				<h4>Privacy Overview</h4>				<div class="cli-privacy-content">
					<div class="cli-privacy-content-text">This website uses cookies to improve your experience while you navigate through the website. Out of these, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may affect your browsing experience.</div>
				</div>
				<a class="cli-privacy-readmore"  aria-label="Mostrar más" tabindex="0" role="button" data-readmore-text="Mostrar más" data-readless-text="Mostrar menos"></a>			</div>
		</div>
		<div class="cli-col-12 cli-align-items-stretch cli-px-0 cli-tab-section-container">
												<div class="cli-tab-section">
						<div class="cli-tab-header">
							<a role="button" tabindex="0" class="cli-nav-link cli-settings-mobile" data-target="necessary" data-toggle="cli-toggle-tab">
								Necessary							</a>
							<div class="wt-cli-necessary-checkbox">
                        <input type="checkbox" class="cli-user-preference-checkbox"  id="wt-cli-checkbox-necessary" data-id="checkbox-necessary" checked="checked"  />
                        <label class="form-check-label" for="wt-cli-checkbox-necessary">Necessary</label>
                    </div>
                    <span class="cli-necessary-caption">Siempre activado</span> 						</div>
						<div class="cli-tab-content">
							<div class="cli-tab-pane cli-fade" data-id="necessary">
								<div class="wt-cli-cookie-description">
									Necessary cookies are absolutely essential for the website to function properly. This category only includes cookies that ensures basic functionalities and security features of the website. These cookies do not store any personal information.								</div>
							</div>
						</div>
					</div>
																	<div class="cli-tab-section">
						<div class="cli-tab-header">
							<a role="button" tabindex="0" class="cli-nav-link cli-settings-mobile" data-target="functional" data-toggle="cli-toggle-tab">
								Functional							</a>
							<div class="cli-switch">
                        <input type="checkbox" id="wt-cli-checkbox-functional" class="cli-user-preference-checkbox"  data-id="checkbox-functional"  />
                        <label for="wt-cli-checkbox-functional" class="cli-slider" data-cli-enable="Activado" data-cli-disable="Desactivado"><span class="wt-cli-sr-only">Functional</span></label>
                    </div>						</div>
						<div class="cli-tab-content">
							<div class="cli-tab-pane cli-fade" data-id="functional">
								<div class="wt-cli-cookie-description">
									Functional cookies help to perform certain functionalities like sharing the content of the website on social media platforms, collect feedbacks, and other third-party features.
								</div>
							</div>
						</div>
					</div>
																	<div class="cli-tab-section">
						<div class="cli-tab-header">
							<a role="button" tabindex="0" class="cli-nav-link cli-settings-mobile" data-target="performance" data-toggle="cli-toggle-tab">
								Performance							</a>
							<div class="cli-switch">
                        <input type="checkbox" id="wt-cli-checkbox-performance" class="cli-user-preference-checkbox"  data-id="checkbox-performance"  />
                        <label for="wt-cli-checkbox-performance" class="cli-slider" data-cli-enable="Activado" data-cli-disable="Desactivado"><span class="wt-cli-sr-only">Performance</span></label>
                    </div>						</div>
						<div class="cli-tab-content">
							<div class="cli-tab-pane cli-fade" data-id="performance">
								<div class="wt-cli-cookie-description">
									Performance cookies are used to understand and analyze the key performance indexes of the website which helps in delivering a better user experience for the visitors.
								</div>
							</div>
						</div>
					</div>
																	<div class="cli-tab-section">
						<div class="cli-tab-header">
							<a role="button" tabindex="0" class="cli-nav-link cli-settings-mobile" data-target="analytics" data-toggle="cli-toggle-tab">
								Analytics							</a>
							<div class="cli-switch">
                        <input type="checkbox" id="wt-cli-checkbox-analytics" class="cli-user-preference-checkbox"  data-id="checkbox-analytics"  />
                        <label for="wt-cli-checkbox-analytics" class="cli-slider" data-cli-enable="Activado" data-cli-disable="Desactivado"><span class="wt-cli-sr-only">Analytics</span></label>
                    </div>						</div>
						<div class="cli-tab-content">
							<div class="cli-tab-pane cli-fade" data-id="analytics">
								<div class="wt-cli-cookie-description">
									Analytical cookies are used to understand how visitors interact with the website. These cookies help provide information on metrics the number of visitors, bounce rate, traffic source, etc.
								</div>
							</div>
						</div>
					</div>
																	<div class="cli-tab-section">
						<div class="cli-tab-header">
							<a role="button" tabindex="0" class="cli-nav-link cli-settings-mobile" data-target="advertisement" data-toggle="cli-toggle-tab">
								Advertisement							</a>
							<div class="cli-switch">
                        <input type="checkbox" id="wt-cli-checkbox-advertisement" class="cli-user-preference-checkbox"  data-id="checkbox-advertisement"  />
                        <label for="wt-cli-checkbox-advertisement" class="cli-slider" data-cli-enable="Activado" data-cli-disable="Desactivado"><span class="wt-cli-sr-only">Advertisement</span></label>
                    </div>						</div>
						<div class="cli-tab-content">
							<div class="cli-tab-pane cli-fade" data-id="advertisement">
								<div class="wt-cli-cookie-description">
									Advertisement cookies are used to provide visitors with relevant ads and marketing campaigns. These cookies track visitors across websites and collect information to provide customized ads.
								</div>
							</div>
						</div>
					</div>
																	<div class="cli-tab-section">
						<div class="cli-tab-header">
							<a role="button" tabindex="0" class="cli-nav-link cli-settings-mobile" data-target="others" data-toggle="cli-toggle-tab">
								Others							</a>
							<div class="cli-switch">
                        <input type="checkbox" id="wt-cli-checkbox-others" class="cli-user-preference-checkbox"  data-id="checkbox-others"  />
                        <label for="wt-cli-checkbox-others" class="cli-slider" data-cli-enable="Activado" data-cli-disable="Desactivado"><span class="wt-cli-sr-only">Others</span></label>
                    </div>						</div>
						<div class="cli-tab-content">
							<div class="cli-tab-pane cli-fade" data-id="others">
								<div class="wt-cli-cookie-description">
									Other uncategorized cookies are those that are being analyzed and have not been classified into a category as yet.
								</div>
							</div>
						</div>
					</div>
										</div>
	</div>
</div>
	  	</div>
	  	<div class="cli-modal-footer">
			<div class="wt-cli-element cli-container-fluid cli-tab-container">
				<div class="cli-row">
					<div class="cli-col-12 cli-align-items-stretch cli-px-0">
						<div class="cli-tab-footer wt-cli-privacy-overview-actions">
						
															<a id="wt-cli-privacy-save-btn" role="button" tabindex="0" data-cli-action="accept" class="wt-cli-privacy-btn cli_setting_save_button wt-cli-privacy-accept-btn cli-btn">GUARDAR Y ACEPTAR</a>
													</div>
						
					</div>
				</div>
			</div>
		</div>
	</div>
  </div>
</div>
<div class="cli-modal-backdrop cli-fade cli-settings-overlay"></div>
<div class="cli-modal-backdrop cli-fade cli-popupbar-overlay"></div>
<!--googleon: all--><script type='text/javascript'>jQuery(document).ready(function($) {$(".flexslider").flexslider({controlsContainer: "#genesis-responsive-slider",animation: "slide",directionNav: 1,controlNav: 1,animationDuration: 800,slideshowSpeed: 4000    });  });</script><link rel='stylesheet' id='cookie-law-info-table-css'  href='https://codigo21.educacion.navarra.es/wp-content/plugins/cookie-law-info/public/css/cookie-law-info-table.css?ver=2.0.9' type='text/css' media='all' />
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-includes/js/dist/vendor/regenerator-runtime.min.js?ver=0.13.9' id='regenerator-runtime-js'></script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-includes/js/dist/vendor/wp-polyfill.min.js?ver=3.15.0' id='wp-polyfill-js'></script>
<script type='text/javascript' id='contact-form-7-js-extra'>
/* <![CDATA[ */
var wpcf7 = {"api":{"root":"https:\/\/codigo21.educacion.navarra.es\/wp-json\/","namespace":"contact-form-7\/v1"}};
/* ]]> */
</script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-content/plugins/contact-form-7/includes/js/index.js?ver=5.5.4' id='contact-form-7-js'></script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-includes/js/hoverIntent.min.js?ver=1.10.1' id='hoverIntent-js'></script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-content/themes/genesis/lib/js/menu/superfish.min.js?ver=1.7.10' id='superfish-js'></script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-content/themes/genesis/lib/js/menu/superfish.args.min.js?ver=3.3.5' id='superfish-args-js'></script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-content/themes/genesis/lib/js/skip-links.min.js?ver=3.3.5' id='skip-links-js'></script>
<script type='text/javascript' id='magazine-responsive-menu-js-extra'>
/* <![CDATA[ */
var genesis_responsive_menu = {"mainMenu":"Men\u00fa","subMenu":"Submen\u00fa","menuClasses":{"combine":[".nav-primary",".nav-header",".nav-secondary"]}};
/* ]]> */
</script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-content/themes/magazine-pro/js/responsive-menus.min.js?ver=3.3.0' id='magazine-responsive-menu-js'></script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-content/plugins/genesis-responsive-slider/assets/js/jquery.flexslider.js?ver=1.0.1' id='flexslider-js'></script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-content/plugins/jetpack/_inc/build/twitter-timeline.min.js?ver=4.0.0' id='jetpack-twitter-timeline-js'></script>
<script type='text/javascript' src='https://codigo21.educacion.navarra.es/wp-content/plugins/wp-featherlight/js/wpFeatherlight.pkgd.min.js?ver=1.3.4' id='wp-featherlight-js'></script>
<script src='https://stats.wp.com/e-202205.js' defer></script>
<script>
	_stq = window._stq || [];
	_stq.push([ 'view', {v:'ext',j:'1:10.5.1',blog:'77577586',post:'0',tz:'1',srv:'codigo21.educacion.navarra.es'} ]);
	_stq.push([ 'clickTrackerInit', '77577586', '0' ]);
</script>
</body></html>
)  
  
Fuente [Codigo 21](http://codigo21.educacion.navarra.es/autoaprendizaje/primeros-pasos-con-scratch-y-lego-wedo/)  
  
Programa compartido por código 21 [en este enlace](https://scratch.mit.edu/projects/82780984/)