AccessControl By Pier Alessandro Aisa

Codice Sorgente Firmware – InitSDAccessControl v1.0 del 29-03-2016 Pier Aisa

/*
  INITSD CARD per Access Control v1.0 del 29-03-2016 Pier Aisa
  
  Formatta Crea la  Struttura solo G e M

 */
 
// Print extra info for debug if DEBUG_PRINT is nonzero
#define DEBUG_PRINT 1

#include <SdFat.h>
#if DEBUG_PRINT
#include <SdFatUtil.h>
#endif  // DEBUG_PRINT
//
// Change the value of chipSelect if your hardware does
// not use the default value, SS.  Common values are:
// Arduino Ethernet shield: pin 4
// Sparkfun SD shield: pin 8
// Adafruit SD shields and modules: pin 10
//Pier->original const uint8_t chipSelect = SS;
// aggiunta creazione delle directory M;G;A per la SD Card

#define error(s) error_P(PSTR(s))
#define sp(s) sp_p(PSTR(s)) //save RAM used instead Serial.print with data on flash


const uint8_t chipSelect = 4;

// Change spiSpeed to SPI_FULL_SPEED for better performance
// Use SPI_QUARTER_SPEED for even slower SPI bus speed
const uint8_t spiSpeed = SPI_HALF_SPEED;

// Serial output stream
ArduinoOutStream cout(Serial);

Sd2Card card;
uint32_t cardSizeBlocks;
uint16_t cardCapacityMB;

// cache for SD block
cache_t cache;

// MBR information
uint8_t partType;
uint32_t relSector;
uint32_t partSize;

// Fake disk geometry
uint8_t numberOfHeads;
uint8_t sectorsPerTrack;

// FAT parameters
uint16_t reservedSectors;
uint8_t sectorsPerCluster;
uint32_t fatStart;
uint32_t fatSize;
uint32_t dataStart;

// constants for file system structure
uint16_t const BU16 = 128;
uint16_t const BU32 = 8192;

//  strings needed in file system structures
char noName[] = "NO NAME    ";
char fat16str[] = "FAT16   ";
char fat32str[] = "FAT32   ";
//------------------------------------------------------------------------------
#define sdError(msg) sdError_P(PSTR(msg))

void sdError_P(const char* str) {
  cout << pstr("error: ");
  cout << pgm(str) << endl;
  if (card.errorCode()) {
    cout << pstr("SD error: ") << hex << int(card.errorCode());
    cout << ',' << int(card.errorData()) << dec << endl;
  }
  while (1);
}
//------------------------------------------------------------------------------
#if DEBUG_PRINT
void debugPrint() {
  cout << pstr("FreeRam: ") << FreeRam() << endl;
  cout << pstr("partStart: ") << relSector << endl;
  cout << pstr("partSize: ") << partSize << endl;
  cout << pstr("reserved: ") << reservedSectors << endl;
  cout << pstr("fatStart: ") << fatStart << endl;
  cout << pstr("fatSize: ") << fatSize << endl;
  cout << pstr("dataStart: ") << dataStart << endl;
  cout << pstr("clusterCount: ");
  cout << ((relSector + partSize - dataStart)/sectorsPerCluster) << endl;
  cout << endl;
  cout << pstr("Heads: ") << int(numberOfHeads) << endl;
  cout << pstr("Sectors: ") << int(sectorsPerTrack) << endl;
  cout << pstr("Cylinders: ");
  cout << cardSizeBlocks/(numberOfHeads*sectorsPerTrack) << endl;
}
#endif  // DEBUG_PRINT
//------------------------------------------------------------------------------
// write cached block to the card
uint8_t writeCache(uint32_t lbn) {
  return card.writeBlock(lbn, cache.data);
}
//------------------------------------------------------------------------------
// initialize appropriate sizes for SD capacity
void initSizes() {
  if (cardCapacityMB <= 6) {
    sdError("Card is too small.");
  } else if (cardCapacityMB <= 16) {
    sectorsPerCluster = 2;
  } else if (cardCapacityMB <= 32) {
    sectorsPerCluster = 4;
  } else if (cardCapacityMB <= 64) {
    sectorsPerCluster = 8;
  } else if (cardCapacityMB <= 128) {
    sectorsPerCluster = 16;
  } else if (cardCapacityMB <= 1024) {
    sectorsPerCluster = 32;
  } else if (cardCapacityMB <= 32768) {
    sectorsPerCluster = 64;
  } else {
    // SDXC cards
    sectorsPerCluster = 128;
  }

  cout << pstr("Blocks/Cluster: ") << int(sectorsPerCluster) << endl;
  // set fake disk geometry
  sectorsPerTrack = cardCapacityMB <= 256 ? 32 : 63;

  if (cardCapacityMB <= 16) {
    numberOfHeads = 2;
  } else if (cardCapacityMB <= 32) {
    numberOfHeads = 4;
  } else if (cardCapacityMB <= 128) {
    numberOfHeads = 8;
  } else if (cardCapacityMB <= 504) {
    numberOfHeads = 16;
  } else if (cardCapacityMB <= 1008) {
    numberOfHeads = 32;
  } else if (cardCapacityMB <= 2016) {
    numberOfHeads = 64;
  } else if (cardCapacityMB <= 4032) {
    numberOfHeads = 128;
  } else {
    numberOfHeads = 255;
  }
}
//------------------------------------------------------------------------------
// zero cache and optionally set the sector signature
void clearCache(uint8_t addSig) {
  memset(&cache, 0, sizeof(cache));
  if (addSig) {
    cache.mbr.mbrSig0 = BOOTSIG0;
    cache.mbr.mbrSig1 = BOOTSIG1;
  }
}
//------------------------------------------------------------------------------
// zero FAT and root dir area on SD
void clearFatDir(uint32_t bgn, uint32_t count) {
  clearCache(false);
  if (!card.writeStart(bgn, count)) {
    sdError("Clear FAT/DIR writeStart failed");
  }
  for (uint32_t i = 0; i < count; i++) {
    if ((i & 0XFF) == 0) cout << '.';
    if (!card.writeData(cache.data)) {
      sdError("Clear FAT/DIR writeData failed");
    }
  }
  if (!card.writeStop()) {
    sdError("Clear FAT/DIR writeStop failed");
  }
  cout << endl;
}
//------------------------------------------------------------------------------
// return cylinder number for a logical block number
uint16_t lbnToCylinder(uint32_t lbn) {
  return lbn / (numberOfHeads * sectorsPerTrack);
}
//------------------------------------------------------------------------------
// return head number for a logical block number
uint8_t lbnToHead(uint32_t lbn) {
  return (lbn % (numberOfHeads * sectorsPerTrack)) / sectorsPerTrack;
}
//------------------------------------------------------------------------------
// return sector number for a logical block number
uint8_t lbnToSector(uint32_t lbn) {
  return (lbn % sectorsPerTrack) + 1;
}
//------------------------------------------------------------------------------
// format and write the Master Boot Record
void writeMbr() {
  clearCache(true);
  part_t* p = cache.mbr.part;
  p->boot = 0;
  uint16_t c = lbnToCylinder(relSector);
  if (c > 1023) sdError("MBR CHS");
  p->beginCylinderHigh = c >> 8;
  p->beginCylinderLow = c & 0XFF;
  p->beginHead = lbnToHead(relSector);
  p->beginSector = lbnToSector(relSector);
  p->type = partType;
  uint32_t endLbn = relSector + partSize - 1;
  c = lbnToCylinder(endLbn);
  if (c <= 1023) {
    p->endCylinderHigh = c >> 8;
    p->endCylinderLow = c & 0XFF;
    p->endHead = lbnToHead(endLbn);
    p->endSector = lbnToSector(endLbn);
  } else {
    // Too big flag, c = 1023, h = 254, s = 63
    p->endCylinderHigh = 3;
    p->endCylinderLow = 255;
    p->endHead = 254;
    p->endSector = 63;
  }
  p->firstSector = relSector;
  p->totalSectors = partSize;
  if (!writeCache(0)) sdError("write MBR");
}
//------------------------------------------------------------------------------
// generate serial number from card size and micros since boot
uint32_t volSerialNumber() {
  return (cardSizeBlocks << 8) + micros();
}
//------------------------------------------------------------------------------
// format the SD as FAT16
void makeFat16() {
  uint32_t nc;
  for (dataStart = 2 * BU16;; dataStart += BU16) {
    nc = (cardSizeBlocks - dataStart)/sectorsPerCluster;
    fatSize = (nc + 2 + 255)/256;
    uint32_t r = BU16 + 1 + 2 * fatSize + 32;
    if (dataStart < r) continue;
    relSector = dataStart - r + BU16;
    break;
  }
  // check valid cluster count for FAT16 volume
  if (nc < 4085 || nc >= 65525) sdError("Bad cluster count");
  reservedSectors = 1;
  fatStart = relSector + reservedSectors;
  partSize = nc * sectorsPerCluster + 2 * fatSize + reservedSectors + 32;
  if (partSize < 32680) {
    partType = 0X01;
  } else if (partSize < 65536) {
    partType = 0X04;
  } else {
    partType = 0X06;
  }
  // write MBR
  writeMbr();
  clearCache(true);
  fat_boot_t* pb = &cache.fbs;
  pb->jump[0] = 0XEB;
  pb->jump[1] = 0X00;
  pb->jump[2] = 0X90;
  for (uint8_t i = 0; i < sizeof(pb->oemId); i++) {
    pb->oemId[i] = ' ';
  }
  pb->bytesPerSector = 512;
  pb->sectorsPerCluster = sectorsPerCluster;
  pb->reservedSectorCount = reservedSectors;
  pb->fatCount = 2;
  pb->rootDirEntryCount = 512;
  pb->mediaType = 0XF8;
  pb->sectorsPerFat16 = fatSize;
  pb->sectorsPerTrack = sectorsPerTrack;
  pb->headCount = numberOfHeads;
  pb->hidddenSectors = relSector;
  pb->totalSectors32 = partSize;
  pb->driveNumber = 0X80;
  pb->bootSignature = EXTENDED_BOOT_SIG;
  pb->volumeSerialNumber = volSerialNumber();
  memcpy(pb->volumeLabel, noName, sizeof(pb->volumeLabel));
  memcpy(pb->fileSystemType, fat16str, sizeof(pb->fileSystemType));
  // write partition boot sector
  if (!writeCache(relSector)) {
    sdError("FAT16 write PBS failed");
  }
  // clear FAT and root directory
  clearFatDir(fatStart, dataStart - fatStart);
  clearCache(false);
  cache.fat16[0] = 0XFFF8;
  cache.fat16[1] = 0XFFFF;
  // write first block of FAT and backup for reserved clusters
  if (!writeCache(fatStart)
    || !writeCache(fatStart + fatSize)) {
    sdError("FAT16 reserve failed");
  }
}
//------------------------------------------------------------------------------
// format the SD as FAT32
void makeFat32() {
  uint32_t nc;
  relSector = BU32;
  for (dataStart = 2 * BU32;; dataStart += BU32) {
    nc = (cardSizeBlocks - dataStart)/sectorsPerCluster;
    fatSize = (nc + 2 + 127)/128;
    uint32_t r = relSector + 9 + 2 * fatSize;
    if (dataStart >= r) break;
  }
  // error if too few clusters in FAT32 volume
  if (nc < 65525) sdError("Bad cluster count");
  reservedSectors = dataStart - relSector - 2 * fatSize;
  fatStart = relSector + reservedSectors;
  partSize = nc * sectorsPerCluster + dataStart - relSector;
  // type depends on address of end sector
  // max CHS has lbn = 16450560 = 1024*255*63
  if ((relSector + partSize) <= 16450560) {
    // FAT32
    partType = 0X0B;
  } else {
    // FAT32 with INT 13
    partType = 0X0C;
  }
  writeMbr();
  clearCache(true);

  fat32_boot_t* pb = &cache.fbs32;
  pb->jump[0] = 0XEB;
  pb->jump[1] = 0X00;
  pb->jump[2] = 0X90;
  for (uint8_t i = 0; i < sizeof(pb->oemId); i++) {
    pb->oemId[i] = ' ';
  }
  pb->bytesPerSector = 512;
  pb->sectorsPerCluster = sectorsPerCluster;
  pb->reservedSectorCount = reservedSectors;
  pb->fatCount = 2;
  pb->mediaType = 0XF8;
  pb->sectorsPerTrack = sectorsPerTrack;
  pb->headCount = numberOfHeads;
  pb->hidddenSectors = relSector;
  pb->totalSectors32 = partSize;
  pb->sectorsPerFat32 = fatSize;
  pb->fat32RootCluster = 2;
  pb->fat32FSInfo = 1;
  pb->fat32BackBootBlock = 6;
  pb->driveNumber = 0X80;
  pb->bootSignature = EXTENDED_BOOT_SIG;
  pb->volumeSerialNumber = volSerialNumber();
  memcpy(pb->volumeLabel, noName, sizeof(pb->volumeLabel));
  memcpy(pb->fileSystemType, fat32str, sizeof(pb->fileSystemType));
  // write partition boot sector and backup
  if (!writeCache(relSector)
    || !writeCache(relSector + 6)) {
    sdError("FAT32 write PBS failed");
  }
  clearCache(true);
  // write extra boot area and backup
  if (!writeCache(relSector + 2)
    || !writeCache(relSector + 8)) {
    sdError("FAT32 PBS ext failed");
  }
  fat32_fsinfo_t* pf = &cache.fsinfo;
  pf->leadSignature = FSINFO_LEAD_SIG;
  pf->structSignature = FSINFO_STRUCT_SIG;
  pf->freeCount = 0XFFFFFFFF;
  pf->nextFree = 0XFFFFFFFF;
  // write FSINFO sector and backup
  if (!writeCache(relSector + 1)
    || !writeCache(relSector + 7)) {
    sdError("FAT32 FSINFO failed");
  }
  clearFatDir(fatStart, 2 * fatSize + sectorsPerCluster);
  clearCache(false);
  cache.fat32[0] = 0x0FFFFFF8;
  cache.fat32[1] = 0x0FFFFFFF;
  cache.fat32[2] = 0x0FFFFFFF;
  // write first block of FAT and backup for reserved clusters
  if (!writeCache(fatStart)
    || !writeCache(fatStart + fatSize)) {
    sdError("FAT32 reserve failed");
  }
}
//------------------------------------------------------------------------------
// flash erase all data
uint32_t const ERASE_SIZE = 262144L;
void eraseCard() {
  cout << endl << pstr("Erasing\n");
  uint32_t firstBlock = 0;
  uint32_t lastBlock;
  uint16_t n = 0;

  do {
    lastBlock = firstBlock + ERASE_SIZE - 1;
    if (lastBlock >= cardSizeBlocks) lastBlock = cardSizeBlocks - 1;
    if (!card.erase(firstBlock, lastBlock)) sdError("erase failed");
    cout << '.';
    if ((n++)%32 == 31) cout << endl;
    firstBlock += ERASE_SIZE;
  } while (firstBlock < cardSizeBlocks);
  cout << endl;

  if (!card.readBlock(0, cache.data)) sdError("readBlock");
  cout << hex << showbase << setfill('0') << internal;
  cout << pstr("All data set to ") << setw(4) << int(cache.data[0]) << endl;
  cout << dec << noshowbase << setfill(' ') << right;
  cout << pstr("Erase done\n");
}
//------------------------------------------------------------------------------
void formatCard() {
  cout << endl;
  cout << pstr("Formatting\n");
  initSizes();
  if (card.type() != SD_CARD_TYPE_SDHC) {
    cout << pstr("FAT16\n");
    makeFat16();
  } else {
    cout << pstr("FAT32\n");
    makeFat32();
  }
#if DEBUG_PRINT
  debugPrint();
#endif  // DEBUG_PRINT
  cout << pstr("Format done\n");
}
//------------------------------------------------------------------------------
void setup() {
  char c;
  Serial.begin(115200);
  cout << pstr(
    "This sketch can erase and/or format SD/SDHC cards.\n"
    "\n"
    "Erase uses the card's fast flash erase command.\n"
    "Flash erase sets all data to 0X00 for most cards\n"
    "and 0XFF for a few vendor's cards.\n"
    "\n"
    "Cards larger than 2 GB will be formatted FAT32 and\n"
    "smaller cards will be formatted FAT16.\n"
    "\n"
    "Warning, all data on the card will be erased.\n"
    "Enter 'Y' to continue: ");
  while (!Serial.available()) {}
  c = Serial.read();
  cout << c << endl;
  if (c != 'Y') {
    cout << pstr("Quiting, you did not enter 'Y'.\n");
    return;
  }
  // read any existing Serial data
  while (Serial.read() >= 0) {}
  
  cout << pstr(
    "\n"
    "Options are:\n"
    "E - erase the card and skip formatting.\n"
    "F - erase and then format the card. (recommended)\n"
    "Q - quick format the card without erase.\n"
    "\n"
    "Enter option: ");
    
  while (!Serial.available()) {}
  c = Serial.read();
  cout << c << endl;
  if (!strchr("EFQ", c)) {
    cout << pstr("Quiting, invalid option entered.") << endl;
    return;
  }

  if (!card.init(spiSpeed, chipSelect)) {
    cout << pstr(
     "\nSD initialization failure!\n"
     "Is the SD card inserted correctly?\n"
     "Is chip select correct at the top of this sketch?\n");
    sdError("card.init failed");
  }
  cardSizeBlocks = card.cardSize();
  if (cardSizeBlocks == 0) sdError("cardSize");
  cardCapacityMB = (cardSizeBlocks + 2047)/2048;

  cout << pstr("Card Size: ") << cardCapacityMB;
  cout << pstr(" MB, (MB = 1,048,576 bytes)") << endl;

  if (c == 'E' || c == 'F') {
    eraseCard();
  }
  if (c == 'F' || c == 'Q') {
    formatCard();
  }
  
  createdir();
  
  
}

         
void createdir() {   
  Sd2Card card;
  SdVolume volume;
  SdFile root ;
  SdFile file ;  
  
  pinMode(10, OUTPUT); // set the SS pin as an output (necessary!)
  digitalWrite(10, HIGH); // but turn off the W5100 chip!
  if (!card.init(SPI_HALF_SPEED, 4)) error("card.init failed!");
  // initialize a FAT volume
  if (!volume.init(&card)) error("vol.init failed!");
  if (!root.openRoot(&volume)) error("openRoot failed");
  sp("R");  
  Serial.println(FreeRam());
  
  file.mkdir(&root,"G", false); file.close();
  file.mkdir(&root,"M", false); file.close();
  //file.mkdir(&root,"A", false); file.close();
  Serial.println("finish");Serial.println(FreeRam());
}     

void error_P(const char* str) {
  PgmPrint("error:");
  SerialPrintln_P(str);
  if (card.errorCode()) {
    PgmPrint("SD error:");
    //Serial.print(card.errorCode(), HEX);
    //Serial.print(',');
    //Serial.println(card.errorData(), HEX);
  }
  while(1);
}

 void sp_p(const char p[]) {
    byte c;
    while (0 != (c = pgm_read_byte(p++))) {
      Serial.print((char)c);
    }
}


//------------------------------------------------------------------------------
void loop() {}

Scarica il firmware completo

44 pensieri riguardo “AccessControl By Pier Alessandro Aisa

  • 21/06/2016 in 12:27
    Permalink

    Ottimo progetto, utilissimo e semplice da realizzare !!!

    Risposta
  • 28/06/2016 in 19:33
    Permalink

    Je comprends rien mais ça à l’air bien.

    Risposta
  • 20/07/2016 in 22:32
    Permalink

    La bellezza delle cose semplici e pratiche

    Risposta
  • 21/07/2016 in 10:00
    Permalink

    Mi dice Massimo che sei stato FORTE….

    Risposta
  • 21/07/2016 in 11:05
    Permalink

    Alle 11:00 del 20 Luglio questo progetto aveva 33 voti, alle 11:00 del 21 Luglio ne ha 68, o l’autore ha trovato uno stock di 35 amici o ha trovato una falla nel sistema di voto. Nella seconda ipotesi, quanto tempo passerà prima che la trovino gli altri utenti e trasformino il contest in una barzelletta? Considerando che la redazione ha cambiato in corsa il regolamento per (cito testualmente) “rendere più trasparente e partecipativa la valutazione” che figura ci farebbe? Chiederei di verificare

    Risposta
    • 22/07/2016 in 09:58
      Permalink

      Gentile Gaspare,
      non c’è alcuna falla nel sistema di votazione.
      I voti provengono tutti da utenti con registrazioni diverse. Il controllo viene fatto sull’indirizzo di posta elettronica e ciascun indirizzo di posta elettronica può votare solo una volta.
      È vero che in queste situazioni vale il passaparola tra amici, come è altrettanto vero che la stessa persona può registrarsi con tante email diverse e partecipare alla votazione più volte. Fare un controllo sull’IP non è possibile perché la maggior parte delle connessioni adsl private dispongono di IP dinamico e anche in caso di IP statico sarebbe facilmente aggirabile con un proxy o con un browser come Thor.

      Cordiali saluti

      Risposta
    • 22/07/2016 in 12:51
      Permalink

      Sono completamente d’accordo con te Gaspare, e la Redazione ce l’ha confermato. Qui basta che ciascuno di noi si crei tutti gli account email che vuole, e si fa i voti che vuole.
      Perchè scomodare amici o parenti quando puoi fare tutto da solo ed in casa?
      Quando ho partecipato credevo che ci sarebbe stata una giuria composta dallo staff della rivista che avrebbe deciso, e non lasciare il voto a chi possiede più emails. Avessi saputo prima che finiva così non avrei nemmeno partecipato, e sicuramente questa sarà l’ultima volta che lo farò.

      Risposta
      • 22/07/2016 in 15:52
        Permalink

        Buongiorno a tutti.
        Come spiegato in questo post
        http://blog.elettronicain.it/2016/05/14/fishino-contest-via-alle-votazioni/ abbiamo voluto cambiare il metodo della votazione per evitare che qualcuno possa lamentarsi della scelta.
        Tempo fa facemmo un contest sui progetti realizzati con una stampante 3D, in quel caso scegliemmo noi il vincitore e le polemiche non mancarono.
        Pertanto abbiamo pensato che sarebbe stato più bello e più democratico far partecipare tutti alla votazione.
        I voti sono tutti tracciabili e verranno verificati attentamente (per quanto possibile) prima di stabilire quale sarà il vincitore.
        In ogni caso facciamo affidamento al buon senso e soprattutto all’onestà di tutti.

        Risposta
        • 22/07/2016 in 17:12
          Permalink

          Capisco benissimo le vostre difficoltà (o peggio la vostra impotenza) nel controllare i voti (ip, validità delle email ect…) e per le polemiche nel caso in cui siate voi a decidere, ma sono d’accordo con FAITHO sul fatto che se avessi saputo che cambiavate il regolamento a concorso scaduto e che non eravate voi a decidere ma quello che fa il furbo, non avrei partecipato, perché non mi va di essere preso per il c… da un’altro utente che non solo si vota da solo ma per questo si da anche del “fottuto genio” in barba agli altri fessi onesti che hanno una persona reale dietro ogni loro voto.

          Risposta
          • 22/07/2016 in 17:22
            Permalink

            E comunque se la maggioranza dei concorrenti è d’accordo propongo di ritornare al regolamento originale, preferisco perdere perché la redazione, che dopo pubblicherà gli articoli vincenti, non giudica il mio articolo meritevole che perdere contro un progetto che ha lo schematico disegnato con carta e penna (capite di che stiamo parlando) perché l’autore fa il furbo votandosi e commentandosi da solo

          • 22/07/2016 in 17:58
            Permalink

            Va bene allora. Manderemo a breve una comunicazione a TUTTI i partecipanti. Se la maggioranza risponderà positivamente, la scelta del VINCITORE verrà effettuata esclusivamente e insidacabilmente dalla nostra Redazione.
            Un saluto a tutti.

          • 22/07/2016 in 18:10
            Permalink

            Posso già anticipare che sia io che Riccardo Berra (gli autori del progetto radarino) siamo disposti ad accettare di buon grado anche l’ultimo posto se sarà la redazione a decretarlo. Capisco che l’apertura ad una votazione più democratica sembrasse inizialmente una buona idea, ma purtroppo per via dei recenti sviluppi siamo caduti dalla padella alla brace. 🙂

          • 22/07/2016 in 18:49
            Permalink

            Gaspare, Faitho sono Pier Aisa e ritengo molto offensivo, quanto avete iscritto dicendo che i voti sono auto generati da casa. Chi ha scritto “fottuto genio” è un mio collega… Pensate a volte quanto l’invidia possa fare scrivere cose brutte … Vi informo che ho un canale youtube sul quale ho caricato il video del progetto ed ho condiviso la pagina su facebook e quindi molti voti vengono proprio da li. Solo questo mese ho oltre 800 minuti di visualizzazione sul video youtube e ovviamente ho incitato a votare il mio progetto. Commento anche chi si è lamentato dello schema elettrico a matita. Se guardate il mio canale vedrete che è la mia tecnica. Il progetto non è fatto con un CAD 3D, ma per questo non vuol dire che l’idea sia buona e furba. Saluti P A Aisa

          • 22/07/2016 in 18:56
            Permalink

            Gaspare, le cose non stanno come lei dice. Ritengo molto offensivo quanto ha scritto. Possiamo discutere sulla modalità di voto che si basa anche sulla popolarità e lasciato alla rete. Io ho messo il mio progetto su youtube facendone vedere il funzionamento on-line, ed i voti sono tutti autentici. E’ facile verificarlo.

          • 23/07/2016 in 12:54
            Permalink

            Pier io invece ritengo che a far il furbo si offenda l’intelligenza degli altri. Il tuo progetto alle 11:00 del 20 Luglio aveva 33 voti mentre alle 11:00 del 21 Luglio ne aveva 68, ha raddoppiato i suoi voti in 24h, capisco che youtube sia frequentato, capisco che facebook richiami l’attenzione ma il dubbio mi resta e spero che il mio dubbio non offenda nessuno.
            Ad ogni modo visto e considerato che il tuo progetto è geniale, è sublime, è il progetto più bello degli ultimi 100 anni, non credo che avrà problemi a vincere anche se la classifica la stili la redazione, giusto? Quindi propongo di tagliare la polemica facendo decidere alla redazione, ripristinando il regolamento iniziale. Sei d’accordo? Dimostraci la tua buona fede. Infine voglio essere chiaro su una cosa, non si tratta di invidia perché non ho motivo di invidiare i commenti di “zorzino”, “bilbo1972”, “Fabius” (ne ho preso qualcuno a caso) ect… che sicuramente saranno i migliori esperti in questo campo, ma semplicemente la presa in giro mi irrita.

    • 22/07/2016 in 18:28
      Permalink

      Gaspare, sei un “fottuto” genio….

      Risposta
  • 21/07/2016 in 15:39
    Permalink

    semplice e efficace … sei sempre un passo avanti

    Risposta
  • 22/07/2016 in 10:01
    Permalink

    Grandissimo Pier Alessandro, sempre sul pezzo, bravo.

    Risposta
  • 22/07/2016 in 12:53
    Permalink

    Ottimo! Sublime! Immagino che tutti questi fantastici commenti si riferiscano alla “ottima” capacità di imbrogliare, dai..
    Se la redazione accetta questo tipo di comportamento impossibile da non notare (50 voti in 1 giorni tutti da 5 stelle) benissmo, però non si lamenti che la credibilità coli a picco.
    Con questo tipo di votazione era chiaro che qualcuno cercasse di fare in modo di imbrogliare, anche perchè il premio è piuttosto consistente..
    Detto questo mi auguro che la redazione sia sicura di quel che faccia e che vinca il progetto più bello. Saluti

    Risposta
    • 22/07/2016 in 15:51
      Permalink

      Buongiorno a tutti.
      Come spiegato in questo post
      http://blog.elettronicain.it/2016/05/14/fishino-contest-via-alle-votazioni/ abbiamo voluto cambiare il metodo della votazione per evitare che qualcuno possa lamentarsi della scelta.
      Tempo fa facemmo un contest sui progetti realizzati con una stampante 3D, in quel caso scegliemmo noi il vincitore e le polemiche non mancarono.
      Pertanto abbiamo pensato che sarebbe stato più bello e più democratico far partecipare tutti alla votazione.
      I voti sono tutti tracciabili e verranno verificati attentamente (per quanto possibile) prima di stabilire quale sarà il vincitore.
      In ogni caso facciamo affidamento al buon senso e soprattutto all’onestà di tutti.

      Risposta
  • 22/07/2016 in 13:56
    Permalink

    Progetto molto interessante. 5 stelle!

    Risposta
  • 22/07/2016 in 14:49
    Permalink

    la soluzione è effettivamente interessate.

    Risposta
  • 22/07/2016 in 20:34
    Permalink

    Ormai il 100° potevi dartelo, te ne sei dato 60 in 2 gg?!? Per il commento ti aiuto io: “Questo è il progetto più bello degli ultimi 150 anni”.

    Risposta
  • 22/07/2016 in 23:15
    Permalink

    oooooOOOOOOLLLLLLLEEEEEEEEEE’. Alla fine sei riuscito a darti anche il 100esimo voto, dai che adesso aspettiamo anche l’ennesimo commento autocelebrativo e poi via si continua con i voti. Dai che ce la fai, contiamo tutti su di te. Sei il migliore.

    Risposta
  • 23/07/2016 in 10:18
    Permalink

    Buongiorno a tutti,
    come promesso ho mandato ai partecipanti una mail.
    In ogni caso invito tutti a mantenere i toni ad un livello consono.
    Ben vengano commenti e critiche tecniche, ma evitate frasi offensive o sarcastiche fuori luogo.

    Boris

    Risposta
  • 23/07/2016 in 15:34
    Permalink

    Questo è il mio commento conclusivo, perché sono deluso e stanco di questa sterile polemica che ha lo scopo di screditarmi e di mettere in cattiva luce il mio progetto. Io non devo dimostrare niente a nessuno: la valutazione dei progetti è affidata alla rete, come stabilito dal regolamento. L’arrivo concentrato di voti in così breve tempo potrebbe essere ricondotto al fatto che, negli ultimi giorni, ho chiesto a diversi conoscenti e colleghi di sponsorizzarmi, come immagino avranno fatto anche gli altri concorrenti. Lavoro da oltre 20 anni come progettista elettronico e mi rattrista molto vedere che, invece di interessanti spunti tecnici di discussione, appaiano insinuazioni e commenti offensivi. E’ compito della redazione, e non dei concorrenti, decidere come finalizzare il concorso nel rispetto del regolamento, che prevede un giudizio basato sulla popolarità e più democratico, anche per fare conoscere e diffondere il nome della rivista e le iniziative proposte. Il metodo usato in un precedente concorso, che lasciava interamente il giudizio finale alla redazione, ha ricevuto molte polemiche per mancanza di trasparenza, come spiegato dalla redazione stessa. Concludo sottolineando che non mi permetterei mai di screditare un progetto altrui o di mettere in discussione l’onestà di persone che amano questo lavoro e che si applicano con passione, come ho fatto io negli ultimi mesi per questo progetto.

    Risposta
    • 23/07/2016 in 17:05
      Permalink

      Credo che la polemica non sia affatto sterile, come già detto personalmente ho partecipato al concorso perché sapevo da regolamento doveva essere la redazione a decidere altrimenti non avrei partecipato, perché partecipo ai concorsi da anni e so benissimo cosa accade quando si fa scegliere ad altre persone. Credo che come me tu prima di decidere se partecipare o meno abbia letto il regolamento, quindi mentre preparavi il progetto sapevi che avrebbe scelto la redazione e partecipando hai accettato questa condizione. Se vogliamo discutere di cose tecniche, allora dobbiamo far decidere a chi ha le competenze tecniche non alla mamma, alla nonna o la vicina di casa, io leggo Elettronica In da 10 anni e non ho mai visto pubblicato uno schematico fatto a matita e dispiace sentirmi dire “faccio il progettista elettronico da 20” perché io questo mestiere lo faccio da 10 di anni e so benissimo che se presento uno schema a matita il resto del mondo (ovviamente tecnici, non la mamma) poi mi prende in giro, ma forse parliamo di due elettroniche diverse. Non voglio e non volevo screditare il progetto di nessuno ma soltanto l’ondata, a mio parere, anomala di voti, che guardacaso oggi si è fermata (forse youtube è offline), l’unica cosa tecnica che ho commentato (la questione dello schematico appunto) l’ho tirata fuori proprio perché da regolamento il progetto vincitore dovrebbe venir pubblicato sulla rivista ed a quel punto immagino a cosa possa pensare il generico lettore mentre scopre che qualcuno ha vinto un concorso con uno schematico fatto a matita. Infine non metto in dubbio l’impegno con il quale ti sei applicato al progetto, ma ti faccio notare che gli altri non l’hanno trovato per strada, ma come te, ci hanno lavorato e vedersi annullati mesi di lavoro perché è cambiato il regolamento (in modo da far votare anche le nonne) ed un altro utente hai dei voti, a mio personalissimo parere, sospetti, non crea delusione ma ben altro. La delusione la crea il fatto che non accetti il fatto di metterti in gioco facendo scegliere la redazione. Ad ogni modo in bocca al lupo

      Risposta
  • 23/07/2016 in 16:32
    Permalink

    Ho votato per Fishino Joypad (essendo un’amica di Mattia) e anch’io ho chiesto ai miei contatti di votare il suo progetto. Ho seguito con entusiasmo le votazioni e poi vengo a scoprire che in meno di 24 h si passa da 33 voti a più di 60. Ma che bella figura di legno ho fatto con tutti i miei contatti ai quali ho chiesto di votare.
    P.S. I voti di accesscontrol si sono fermati nel momento in cui avete fatto notare il picco improvviso dei voti. Il canale youtube si è rotto?!?

    Risposta
  • 25/07/2016 in 16:15
    Permalink

    Sono un collega e un amico di Pier Aisa e ne conosco la assoluta corretteza.
    L’incremento repentino dei voti a favore di Pier è dovuto unicamente al fatto che Pier è conosciuto e stimato da un gran numero di persone e ovviamente il passa-parola ha funzionato bene.
    Probabilmente chi non riesce a ottenere così tanti consensi, non ha altrettanti conoscenti, amici, addirittura parenti, ma soprattutto estimatori.
    E preferisce rosicare che farsi un po’ di propaganda.

    Risposta
    • 25/07/2016 in 19:08
      Permalink

      O forse preferisce lasciar decidere a chi ha esperienza e competenza, come da regolamento, piuttosto che farsi propaganda con la zia o la nonna (ogni scarrafone è bell’a mamma soja). Non ritorno sulle anomalie dei voti perché ora che la maggioranza dei votanti ha deciso di lasciar decidere alla redazione, credo che sia annullata definitivamente ogni polemica sui voti e sulla correttezza dei concorrenti.

      Risposta

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.

0