Nuovo Istituto, nuove avventure didattiche. Con le classi di questo nuovo anno scolastico più elettronica e più automazione. Tra gli argomenti che ho rivisto negli scorsi mesi in virtù delle attività che vorrò svolgere, molte sperimentazioni dedicata all’elettronica digitale e all’algebra di Boole, ho riformulato le esercitazioni con componenti discreti che utilizzano i classici integrati TTL 74XX: 7404, 7432, 7408, 7402, 7400, 7486, 74266 corrispondenti alle porte logiche: NOT, OR, AND, NOR, NAND, XOR, XNOR a queste attività aggiungerò, in una fase successiva, la realizzazione delle porte logiche con Arduino, quindi progettazione di semplici shield per la dimostrazione delle tabelle di verità degli operatori logici fondamentali e derivati.
Per rendere più interessante il laboratorio di elettronica, oltre che usare la breadboard, realizzare pcb e saldare, cercherò se il tempo lo permetterà, di far realizzare la scheda Arduino prima su breadboard e poi realizzare una nostra personalissima scheda Arduino con protezioni specifiche sulle uscite digitali ed altro… sogni nel cassetto… vedremo, un passettino alla volta.
Questo articolo è da intendersi come esercitazione e di supporto alla parte teorica ed è dedicata agli studenti delle classi 3′ e 4′ automazione, per lo svolgimento si richiede che gli allievi abbiano seguito un corso base su Arduino. Di seguito senza dilungarmi riprendo alcuni concetti di base che hanno solo l’obiettivo di comprendere meglio la parte sviluppata su Arduino, al fondo due circuiti e due sketch di esempio che potrete migliorare ed espandere.
Avviso per gli studenti
Quest’anno faremo automazione, non solo con PLC ma anche con microcontrollori (Arduino), quindi incominciare a strutturare in C le funzioni logiche sarà essenziale per iniziare a costruire i mattoncini di base dell’automazione, vedremo come costruire altre funzioni nel corso dell’anno.
Premessa (per ripassare velocemente)
I circuiti digitali sono presenti in moltissimi strumenti che utilizzimo ogni giorno, i più noti sono i computer costituiti principalmente da circuiti digitali che, come già sapete, elaborano segnali logici 0 e 1.
Qualsiasi calcolo all’interno di un computer utilizza l’aritmetica binaria e l’adozione di questa aritmetica è stata fatta perché i bit sono rappresentabili in modo semplice tramite dispositivi elettronici in cui è possibile distinguere i 2 stati del potenziale elettrico: high e low a cui si associano i numeri 1 e 0.
Partendo da questi presupposti è possibile costruire un sistema di calcolo che impiega i soli due simboli 0 e 1 che viene chiamato sistema logico binario.
Fu George Boole (1815-1864) che per primo costruì un modello matematico fondato su una logica di tipo binario, tale modello prende il nome di: algebra di Boole.
Come diffusamente esposto durante le lezioni di teoria, l’algebra booleana utilizza equazioni ed espressioni, ma segue le leggi della logica e non quelle dell’aritmetica, per cui le operazioni seguono regole differenti dall’algebra convenzionale.
Le porte logiche realizzano le operazioni logiche dell’algebra binaria.
Porte logiche fondamentali
Somma logica OR
L’operazione può essere effettuata su due o più variabili di ingresso. La somma logica OR assumerà il valore 1 se almeno una delle variabili di ingresso è al valore 1.
Se chiamiamo con A e B le variabili di ingresso e con Y la variabile di uscita, la somma logica assumerà lo stato logico 1 se almeno una delle due variabili assume lo stato logico 1.
si legge A OR B
Nella figura che segue è mostrata la tabella della verità con le quattro possibili combinazioni delle variabili di ingresso A e B è il simbolo logico corrispondente. Nella colonna Y sono indicati i valori dalla variabile di uscita Y che soddisfa la definizione della porta logica OR.
Prodotto logico AND
L’operazione può essere effettuata su due o più variabili di ingresso. Il prodotto logico AND assumerà il valore 1 se tutte le variabili di ingresso assumeranno il valore 1.
Se chiamiamo con A e B le variabili di ingresso e con Y la variabile di uscita, il prodotto logico assumerà lo stato logico 1 solo se tutte le variabili di ingresso sono allo stato 1.
si legge A AND B
Nella figura che segue è mostrata la tabella della verità con le quattro possibili combinazioni delle variabili di ingresso A e B è il simbolo logico corrispondente. Nella colonna Y sono indicati i valori dalla variabile di uscita Y che soddisfa la definizione della porta logica AND.
Negazione NOT
L’operazione può essere effettuata su una sola variabile di ingresso. Se chiamiamo con A la variabile di ingresso e con Y la variabile di uscita, la negazione farà assumere all’uscita il valore opposto a quello applicato all’ingresso.
si legge A NEGATO oppure A COMPLEMENTATO oppure NOT A
Nella figura che segue è mostrata la tabella della verità con le due possibili combinazioni
di A ed il simbolo logico corrispondente. Nella colonna Y è indicato il valore della variabile di uscita Y che soddisfa la definizione della porta logica NOT.
Porte logiche derivate
Sono le porte logiche ottenute partendo da una o più porte logiche fondamentali però poiché sono estremamente importanti per l’elettronica sono rappresentate con un simbolo unico.
Somma logica negata NOR
L’operazione può essere effettuata su due o più variabili di ingresso. Se chiamiamo con A e B le variabili di ingresso e con Y la variabile di uscita, la somma logica negata assumerà lo stato logico 1 solo se tutte le variabili di ingresso sono allo stato 1, in tutti gli altri casi l’uscita assumerà il valore 1.
La somma logica negata corrrisponde al collegamento di una OR seguita da una porta NOT.
si legge A NOR B
Nella figura che segue è mostrata la tabella della verità con le quattro possibili combinazioni delle variabili di ingresso A e B è il simbolo logico corrispondente. Nella colonna Y sono indicati i valori dalla variabile di uscita Y che soddisfa la definizione della porta logica NOR.
Prodotto logico negato NAND
L’operazione può essere effettuata su due o più variabili di ingresso. Il prodotto logico negato NAND assumerà il valore 1 se tutte le variabili di ingresso assumeranno il valore 0, in tutti gli altri casi l’uscita assumerà il valore 1.
Il prodotto logico negato corrrisponde al collegamento di una AND seguita da una porta NOT.
si legge A NAND B
Nella figura che segue è mostrata la tabella della verità con le quattro possibili combinazioni delle variabili di ingresso A e B è il simbolo logico corrispondente. Nella colonna Y sono indicati i valori dalla variabile di uscita Y che soddisfa la definizione della porta logica NAND.
OR esclusivo – XOR
L’operazione può essere effettuata su due o più variabili di ingresso. l’OR esclusivo assumerà il valore 1 e solo se vi è almeno un ingresso che differisce dagli altri, mentre varrà 0 se tutti gli ingressi assumono lo stesso valore.
Nel caso di due variabili di ingresso A e B, l’OR esclusivo assumerà il valore 1 se gli ingressi assumeranno valori diversi e varrà 0 se gli ingressi assumono lo stesso valore.
si legge A OR ESCLUSIVO B oppure A DIVERSO B
Nella seguente figura si mostra la tabella della verità con le quattro possibili combinazioni tra A e B ed il simbolo logico relativo ad una porta XOR. Nella colonna Y si sono posti i valori assunti dall’uscita Y che soddisfa la definizione della porta XOR.
L’OR ESCLUSIVO può essere espresso anche dalla seguente formula:
formula da ricordare quando dovrete implementare il codice C per Arduino che realizza questa funzione.
NOR esclusivo XNOR
L’operazione può essere effettuata su due o più variabili di ingresso. Il NOR esclusivo assumerà il valore 1 se e solo se tutti gli ingressi hanno il medesimo valore logico, è equivalente alla negazione della porta XOR.
Nel caso di due variabili di ingresso A e B, l’XNOR assumerà il valore 1 se gli ingressi assumeranno valori uguali e varrà 0 se gli ingressi assumono valore diverso.
e si legge A NOR ESCLUSIVO B oppure A COINCIDENTE CON B.
Nella seguente figura si mostra la tabella della verità con le quattro possibili combinazioni tra A e B ed il simbolo logico relativo ad una porta XNOR. Nella colonna Y si sono posti i valori assunti dall’uscita Y che soddisfa la definizione della porta XNOR.
Il NOR ESCLUSIVO può essere espresso anche dalla seguente formula:
formula da ricordare quando dovrete implementare il codice C per Arduino che realizza questa funzione.
Porte logiche con Arduino
Partiamo ora con la realizzazione delle porte logiche descritte sompra utilizzando Arduino.
In un precedente post ho descritto quali sono gli operatori logici disponibili all’interno di Arduino
Se gli ingressi A e B li indichiamo con le varibili:
- pinInA
- pinInB
e l’uscita Y la indichiamo con
- pinOutY
usando la notazione in C che ritrovate nel link indicato sopra si otterrà:
OR
|
1 |
Y = A || B |
AND
|
1 |
Y = A && B |
NOT
|
1 |
Y = !A |
NOR
|
1 |
Y = !(A || B) |
NAND
|
1 |
Y = !(A && B) |
XOR
|
1 |
Y = A ⊕ B = (A && !B) || (!A && B) |
XNOR
|
1 |
Y = !(A ⊕ B) = !((A && !B) || (!A && B)) |
Realizziamo i due ingressi A e B mediante due pulsanti connessi rispettivamente ai pin 8 e 7, mentre l’uscita sarà connessa al pin 9.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
/* Michele Maffucci 08.09.18 Versione 1 - sostituzione del codice per verificare la funzione logica */ int pinOutY = 9; int pinInA = 8; int pinInB = 7; void setup() { pinMode(pinOutY, OUTPUT); pinMode(pinInA, INPUT); pinMode(pinInB, INPUT); } void loop() { boolean statoInA = digitalRead(pinInA); boolean statoInB = digitalRead(pinInB); boolean statoOut; // --- sostituire con la funzione logica indicata nel commento in fondo --- // funzione logica OR statoOut = statoInA || statoInB; digitalWrite(pinOutY, statoOut); } /* Sostituisci all'interno del loop nella posizione indicata // funzione logica OR statoOut = statoInA || statoInB; // funzione logica AND statoOut = statoInA && statoInB; // funzione logica NOT statoOut = !statoInA; //funzione logica NOR statoOut = !(statoInA || statoInB); //funzione logica NAND statoOut = !(statoInA && statoInB); // funzione logica XOR statoOut = (statoInA && !statoInB) || (!statoInA && statoInB); // funzione logica XNOR statoOut = !((statoInA && !statoInB) || (!statoInA && statoInB)); */ |
Vediamo ora come realizzare uno sketch che permette dalla Serial Monitor di selezionare mediante menù il tipo di porta logica che si intende simulare; quando la selezione viene effettuata da menù la pressione dei pulsanti deve realizzare la tabella di verità della funzione logica selezionata.
Un pulsante aggiuntivo, che chiameremo: “AVVIA MENU'” verrà utilizzato per riavviare il menù di scelta.
Le azioni quindi saranno:
- primo avvio – selezione funzione (da 1 a 7) inserendo da tastiera il numero sulla Serial Monitor
- verifica della tabella di verità premendo i pulsanti A e B controllando che il LED, che identifica la Y, sarà acceso per un livello logico 1 e sarà spento per un livello logico 0
- Cambio funzione logica:
- premere il pulsante: “AVVIA MENU'”
- seleziono la funzione logica da verificare e ripetere nuovamente dal passo 1
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 |
/* Michele Maffucci 08.09.18 Versione 2 - scelta funzione da menù stampato sulla Serial Monitor. All'avvio compare un menù di selezione funzione logica 1: OR 2: AND 3: NOT 4: NOR 5: NAND 6: XOR 7: XNOR Scrivere sulla Serial Monitor il numero corrispondente e con i pulsanti A e B verificare la tabella di verità La selezione di un'altra funzione avviene premendo il pulsante: AVVIA MENU che mostrerà nuovamente sulla Serial Monitor il menù di selezione funzione */ int pinOutY = 9; int pinInA = 8; int pinInB = 7; int pinChiave = 10; boolean statoInA; boolean statoInB; boolean statoOut; // array da utilizzare come chiave di stampa // per le tabelle di verità delle singole funzioni logiche int chiavi[] = {1, 1, 1, 1, 1, 1, 1}; void setup() { Serial.begin(9600); pinMode(pinOutY, OUTPUT); pinMode(pinInA, INPUT); pinMode(pinInB, INPUT); pinMode(pinInB, INPUT); // funzione per la stampa sulla Serial Monitor // del menù di scelta della funzione logica stampaMenu(); } void stampaMenu() { Serial.println("---- Seleziona la funzione logica ----"); Serial.println("1: OR"); Serial.println("2: AND"); Serial.println("3: NOT"); Serial.println("4: NOR"); Serial.println("5: NAND"); Serial.println("6: XOR"); Serial.println("7: XNOR"); Serial.println("--------------------------------------"); Serial.println(""); Serial.println(""); } // La funzione di stampa tabella di verità pone a 0 il valore della // chiave, chiavi[n] = 0, dove n identifica la tabella di verità // e il valore associato, 1 o 0, indica il fatto di poterla stampare oppure no. // chiavi[n] = 0 permette di non stampare ciclicamente una stessa tabella // di verità all'interno dei singoli cicli while presenti nel loop in cui avviene // il controllo di quale selezione è stata fatta. void stampaOr() { Serial.println("Hai selezionato la funzione OR"); Serial.println("La tabella di verità è:"); Serial.println(" A | B | Y "); Serial.println("----|-----|-----"); Serial.println(" 0 | 0 | 0 "); Serial.println(" 0 | 1 | 1 "); Serial.println(" 1 | 0 | 1 "); Serial.println(" 1 | 1 | 1 "); Serial.println(""); Serial.println("---------------------------------------------------------------"); Serial.println("Per selezionare un'altra funzione premi il pulsante AVVIA MENU'"); Serial.println("---------------------------------------------------------------"); Serial.println(""); mettiUnoChiavi(); chiavi[0] = 0; } void stampaAnd() { Serial.println("Hai selezionato la funzione AND"); Serial.println("La tabella di verità è:"); Serial.println(" A | B | Y "); Serial.println("----|-----|-----"); Serial.println(" 0 | 0 | 0 "); Serial.println(" 0 | 1 | 0 "); Serial.println(" 1 | 0 | 0 "); Serial.println(" 1 | 1 | 1 "); Serial.println(""); Serial.println("---------------------------------------------------------------"); Serial.println("Per selezionare un'altra funzione premi il pulsante AVVIA MENU'"); Serial.println("---------------------------------------------------------------"); Serial.println(""); mettiUnoChiavi(); chiavi[1] = 0; } void stampaNot() { Serial.println("Hai selezionato la funzione NOT"); Serial.println("La tabella di verità è:"); Serial.println(" A | Y "); Serial.println("----|-----"); Serial.println(" 0 | 1 "); Serial.println(" 1 | 0 "); Serial.println(""); Serial.println("---------------------------------------------------------------"); Serial.println("Per selezionare un'altra funzione premi il pulsante AVVIA MENU'"); Serial.println("---------------------------------------------------------------"); Serial.println(""); mettiUnoChiavi(); chiavi[2] = 0; } void stampaNor() { Serial.println("Hai selezionato la funzione NOR"); Serial.println("La tabella di verità è:"); Serial.println(" A | B | Y "); Serial.println("----|-----|-----"); Serial.println(" 0 | 0 | 1 "); Serial.println(" 0 | 1 | 0 "); Serial.println(" 1 | 0 | 0 "); Serial.println(" 1 | 1 | 0 "); Serial.println(""); Serial.println("---------------------------------------------------------------"); Serial.println("Per selezionare un'altra funzione premi il pulsante AVVIA MENU'"); Serial.println("---------------------------------------------------------------"); Serial.println(""); mettiUnoChiavi(); chiavi[3] = 0; } void stampaNand() { Serial.println("Hai selezionato la funzione NAND"); Serial.println("La tabella di verità è:"); Serial.println(" A | B | Y "); Serial.println("----|-----|-----"); Serial.println(" 0 | 0 | 1 "); Serial.println(" 0 | 1 | 1 "); Serial.println(" 1 | 0 | 1 "); Serial.println(" 1 | 1 | 0 "); Serial.println(""); Serial.println("---------------------------------------------------------------"); Serial.println("Per selezionare un'altra funzione premi il pulsante AVVIA MENU'"); Serial.println("---------------------------------------------------------------"); Serial.println(""); mettiUnoChiavi(); chiavi[4] = 0; } void stampaXor() { Serial.println("Hai selezionato la funzione XOR"); Serial.println("La tabella di verità è:"); Serial.println(" A | B | Y "); Serial.println("----|-----|-----"); Serial.println(" 0 | 0 | 0 "); Serial.println(" 0 | 1 | 1 "); Serial.println(" 1 | 0 | 1 "); Serial.println(" 1 | 1 | 0 "); Serial.println(""); Serial.println("---------------------------------------------------------------"); Serial.println("Per selezionare un'altra funzione premi il pulsante AVVIA MENU'"); Serial.println("---------------------------------------------------------------"); Serial.println(""); mettiUnoChiavi(); chiavi[5] = 0; } void stampaXnor() { Serial.println("Hai selezionato la funzione XNOR"); Serial.println("La tabella di verità è:"); Serial.println(" A | B | Y "); Serial.println("----|-----|-----"); Serial.println(" 0 | 0 | 1 "); Serial.println(" 0 | 1 | 0 "); Serial.println(" 1 | 0 | 0 "); Serial.println(" 1 | 1 | 1 "); Serial.println(""); Serial.println("---------------------------------------------------------------"); Serial.println("Per selezionare un'altra funzione premi il pulsante AVVIA MENU'"); Serial.println("---------------------------------------------------------------"); Serial.println(""); mettiUnoChiavi(); chiavi[6] = 0; } void mettiUnoChiavi() { for (int indice = 0; indice < 7; indice++) { chiavi[indice] = 1; } } void loop() { if (Serial.available()) { byte selezione = Serial.read(); while (selezione == '1') { if (chiavi[0] == 1) { stampaOr(); } statoInA = digitalRead(pinInA); statoInB = digitalRead(pinInB); // funzione logica OR statoOut = statoInA || statoInB; digitalWrite(pinOutY, statoOut); if (digitalRead(pinChiave) == HIGH) { mettiUnoChiavi(); stampaMenu(); break; } } while (selezione == '2') { if (chiavi[1] == 1) { stampaAnd(); } statoInA = digitalRead(pinInA); statoInB = digitalRead(pinInB); // funzione logica AND statoOut = statoInA && statoInB; digitalWrite(pinOutY, statoOut); //selezione = Serial.read(); if (digitalRead(pinChiave) == HIGH) { mettiUnoChiavi(); stampaMenu(); break; } } while (selezione == '3') { if (chiavi[2] == 1) { stampaNot(); } statoInA = digitalRead(pinInA); statoInB = digitalRead(pinInB); // funzione logica NOT statoOut = !statoInA; digitalWrite(pinOutY, statoOut); if (digitalRead(pinChiave) == HIGH) { mettiUnoChiavi(); stampaMenu(); break; } } while (selezione == '4') { if (chiavi[3] == 1) { stampaNor(); } statoInA = digitalRead(pinInA); statoInB = digitalRead(pinInB); //funzione logica NOR statoOut = !(statoInA || statoInB); digitalWrite(pinOutY, statoOut); if (digitalRead(pinChiave) == HIGH) { mettiUnoChiavi(); stampaMenu(); break; } } while (selezione == '5') { if (chiavi[4] == 1) { stampaNand(); } statoInA = digitalRead(pinInA); statoInB = digitalRead(pinInB); //funzione logica NAND statoOut = !(statoInA && statoInB); digitalWrite(pinOutY, statoOut); if (digitalRead(pinChiave) == HIGH) { mettiUnoChiavi(); stampaMenu(); break; } } while (selezione == '6') { if (chiavi[5] == 1) { stampaXor(); } statoInA = digitalRead(pinInA); statoInB = digitalRead(pinInB); // funzione logica XOR statoOut = (statoInA && !statoInB) || (!statoInA && statoInB); digitalWrite(pinOutY, statoOut); if (digitalRead(pinChiave) == HIGH) { mettiUnoChiavi(); stampaMenu(); break; } } while (selezione == '7') { if (chiavi[6] == 1) { stampaXnor(); } statoInA = digitalRead(pinInA); statoInB = digitalRead(pinInB); // funzione logica XNOR statoOut = !((statoInA && !statoInB) || (!statoInA && statoInB)); digitalWrite(pinOutY, statoOut); if (digitalRead(pinChiave) == HIGH) { mettiUnoChiavi(); stampaMenu(); break; } } } } |
Propongo come esercizio cinque varianti all’esempio precedente:
- Gli ingressi selezionati con pulsanti devono essere visualizzati con LED (1 acceso, 0 spento), create inoltre una libreria dedicata per l’implementazione delle funzioni logiche (inserite il codice in un file .h). Per sapere come creare una libreria seguire il link, al fondo del tutorial troverete la spiegazione.
- La selezione della funzione logica non avviene più tramite la serial monitor, ma attraverso 7 pulsanti di selezione funzione, la cui selezione deve essere visualizzata con un LED (Acceso = selezionato; Spento= non selezionato). Deve essere presente un pulsante che effettua il reset dell’operazione (non deve essere il reset della scheda Arduino).
- Realizzare le stesse funzionalità del punto 2 ma in questo caso non si devono utilizzare LED ma un display 16×2 del tipo Hitachi HD44780, se desiderate potete utilizzare un’interfaccia I2C HD44780 per utilizzare meno pin.
- Aggiungere il codice per effettuare il debounce (anti-rimbalzo) sui pulsanti.
- Per gli studenti di 4′ superiore realizzare un debounce usando l’elettronica a componenti discreti.
Per chi volesse esplorare nuove frontiere:
- Realizzate tutto ciò che è stato esposto prima mediante BBC micro:bit e programmate tutto in microPython.
- Realizzate tutto ciò che è stato esposto prima mediante Raspberry Pi e programmate tutto in Python.
Buon Coding (e studio) a tutti 🙂
Ad ogni inizio d’anno scolastico propongo ai nuovi allievi che incontro una serie di attività e strumenti che dal mio punto di vista servono per creare un atteggiamento positivo e rilassato nei confronti dello studio e delle sperimentazioni in laboratorio. Ogni anno esordisco con una serie di starter kit per lo studente:
Mi segnalano e volentieri pubblico il corso gratuito in oggetto.
Durante alcuni corsi di Coding e robotica per colleghi di scuola media mi è stato manifestato il desiderio di poter avere a disposizione un kit robotico estremamente semplice da realizzare poco costoso e che occupasse poco spazio, che potesse adattarsi, come sempre, a microcontrollori di ogni tipo, soprattutto Arduino e micro:bit.
Social network: Twitter - Google+ - Facebook - YouTube - Flickr - LinkedIn - Slideshare - Edmodo