lunedì 28 gennaio 2019

Installazione Linux su IBM Netvista 8307

Questo piccolo IBM NetVista aveva bisogno di una nuova vita ricominciando da Linux....ma c'e' stato qualche problema. La macchina e' un P4 2.8GHz Single Core, 1 Gb Ram, 40 Gb HD


Il primo tentativo e' stato quello di effettuare un boot da USB Drive....niente da fare...il BIOS non supporta supporti USB...comprati e masterizzati DVD per procedere

La seconda sorpresa....il CPU non e' una x86-64. Ovviamente avevo masterizzato una Crunchbang 64 bit....via con il secondo download ed la seconda masterizzazione

Inizia l'installazione e kernel panic. Niente APIC....in fase di avvio bisogna avviare Grub di andare NoApic


Ennesimo riavvio e messaggio esoterico ..riavvio



a questo punto non riesce ad identificare il modo grafico giusto come avviare l'installazione (ero partito fiduciosamente per l'installer grafico)...Imposto il 311 ed inizia l'installazione


Formattazione del disco fisso e.....drive rotto. Basta non e' giornata...e per una macchina del genere non so quanto valga la pena cambiare HD....a proposito...anche il DVD Rom e' risultato non funzionante

Breakout Level Converter per Arduino

E' sempre piu' comune trovare elettronica a 3.3V e puo' succedere di doverla interfacciare con dispositivi a 5V...tipicamente una porta seriale

Per non friggere tutto si usano i level converter

Si collegano due tensioni di riferimento a 5V (su HV e GND) e 3.3 V (su LV e GND) e poi si possono usare i rimanenti pin (che corrispondono a 4 canali) per trasferire il segnale in modo bidirezionale dal pin superiore (per esempio HV1 canale 1 ad alto voltaggio) al pin inferiore (per esempio LV1 canale 1 basso voltaggio)


Testare un transistor con un multimetro

Per testare il transistor 2N2222A ho usato un tester ProKit MT-1210. Questo tester ha una predisposizione per cui si puo' misurare direttamente il valore di hFE ovvero il guadagno in corrente continua

Inserendo Emettitore, Base e Collettore nei rispettivi alloggiamenti e selezionando la funzione hFE si ottiene una lettura di 228 (le impostazioni di misura del multimetro sono 10 microA sul collettore ed una Vce di 2.8V a 20°C)




A questo punto si puo' andare a consultare la scheda tecnica del transistor. Il grafico e' basato su una Vce di 10 V
e' quindi verificato il funzionamento del transistor

Interruttore con transistor 2N2222A con Arduino

Invece di usare come al solito (e per comodita') un relay qui viene descritto come usare un transistor in funzione di interruttore. Il transistor in questione e' un 2N2222A (da non confondere con il P2N2222A dato che hanno la posizione dell'emettitore e del collettore invertiti)




Un pin digitale (il 13) e' collegato alla base del transistor per pilotare l'apertura o chiusura dell'interruttori (non dimenticarsi della resistenza)

Il transistor e' posizionato a valle dell'utilizzatore (qui semplificato con un led) ovvero sul lato GND

Si carica sull'Arduino lo sketch di esempio Blink

Ma perche' utilizzare un sistema cosi' complicato quando si potrebbe derivare la corrente dal pin13?? Perche' i pin digitali di Arduino possono erogare al massimo 45 mA e non possono quindi alimentare degli utilizzare piu' esigenti in termini di corrente

Per una trattazione piu' completa anche se introduttiva seguire questo link

venerdì 25 gennaio 2019

MKR1000 Sleep Mode con Interrupt da RTC

Ho ripreso in mano anche la MKR1000 per testare le capacita' di sleep mode in rapporto ad Arduino Uno. La MKR1000 ha un processore completamente differente (un SAMD21  per la precisione) e integra un RTC per cui non ha bisogno di supporto esterno



Un paio di annotazioni
1) La MKR1000 non ha un pulsante di accensione e l'unico modo di spengerla e' staccare la batteria. Cio' e' abbastanza fastidioso

2) In un caso ho perso il controllo della scheda perche' non si vedeva il device tra i dispositivi USB. In questi casi si deve premere in modo ravvicinato nel tempo per due volte il pulsante di reset

3) Per minimizzare il consumo si deve esplicitamente spengere il modulo Wifi, questa operazione non viene eseguita dallo standbymode

4) Le alimentazioni, quando e' presente la sola LiPo, sono a 3.3V. La porta a 5V in alimentazione output e' disponibile solo quando c'e' un cavo USB che alimenta dall'esterno

Il trucco per impostate il risveglio da RTC e' simile a quello visto in questo post. Si setta un'allarme ad una certa ora, poi all'interno del codice di interrupt si setta il nuovo allarme nel futuro. In questo esempio gli allarmi sono spostati nel tempo di un minuto

(il codice e' stato ripreso da questo link originario e leggermente migliorato per le mie esigenze)
----------------------------------------------

#include <RTCZero.h>

#include <WiFi101.h>


RTCZero rtc;

bool matched = false;
int alarmMinutes = 15;

/* Change these values to set the current initial time */
const byte seconds = 0;
const byte minutes = 14;
const byte hours = 14;

/* Change these values to set the current initial date */
const byte day = 25;
const byte month = 1;
const byte year = 19;

void setup()
{
  Serial.begin(9600);


  WiFi.end();



  rtc.begin();

  rtc.setTime(hours, minutes, seconds);
  rtc.setDate(day, month, year);

  rtc.setAlarmMinutes(alarmMinutes);
  
  rtc.enableAlarm(rtc.MATCH_MMSS);
  rtc.attachInterrupt(alarmMatch);
}

void loop()
{
  if (matched) {


    matched = false;
    printDate();
    printTime();
    Serial.println();
    delay(1000);
        
    alarmMinutes= (rtc.getMinutes()+1)%60;
    rtc.setAlarmMinutes(alarmMinutes);
    rtc.enableAlarm(rtc.MATCH_SS);
    rtc.attachInterrupt(alarmMatch);

    rtc.standbyMode();    // Sleep until next alarm match
  }
}

void alarmMatch()
{
  matched = true;
}

void printTime()
{
  print2digits(rtc.getHours());
  Serial.print(":");
  print2digits(rtc.getMinutes());
  Serial.print(":");
  print2digits(rtc.getSeconds());
  Serial.println();
}

void printDate()
{
  Serial.print(rtc.getDay());
  Serial.print("/");
  Serial.print(rtc.getMonth());
  Serial.print("/");
  Serial.print(rtc.getYear());
  Serial.print(" ");
}

void print2digits(int number) {
  if (number < 10) {
    Serial.print("0");
  }
  Serial.print(number);
}

Progetto Uno

Attenzione: per errore e' riportato che VCC del breakout di ADXL345 debba essere collegata a 5V mentre in realta' deve essere collegato a 3.3 V
----------------------------------------------------------------------
L'idea del progetto Uno e' avere un accelerometro che tramite un interrupt sveglia una Arduino Uno che tramite una radio per telemetria da droni invia un segnale ad un ricevitore remoto
Per risparmiare batteria il trasmettitore viene alimentato solo quando la Arduino si risveglia mediante un relay





I trasmettitori radio sono quelli indicati a questo link. Sono delle semplici radio che si comportano come delle seriali virtuali a 57600 e sono principalmente usati nell'ambito dei droni. Le radio vengono vendute a coppie per una comunicazione punto-punto ed una (o entrambe) hanno un connettore USB piu' un connettore a 6 pin...visto che vengono venduti per droni hanno dei cavi gia' predisposti per PixHawk o simili in alcuni casi e' difficile adattare i cavi per Arduino in modo semplice..se ne trovano alcuni come quello in foto che permettono l'inserimento dei pin




--------------------------------------------------------------------------

/*  *********************************************
 *  SparkFun_ADXL345_Example
 *  Triple Axis Accelerometer Breakout - ADXL345 
 *  Hook Up Guide Example 
 *  
 *  Utilizing Sparkfun's ADXL345 Library
 *  Bildr ADXL345 source file modified to support 
 *  both I2C and SPI Communication
 *  
 *  E.Robert @ SparkFun Electronics
 *  Created: Jul 13, 2016
 *  Updated: Sep 06, 2016
 *  
 *  Development Environment Specifics:
 *  Arduino 1.6.11
 *  
 *  Hardware Specifications:
 *  SparkFun ADXL345
 *  Arduino Uno
 *  *********************************************/

#include <SparkFun_ADXL345.h>         // SparkFun ADXL345 Library
#include <LowPower.h>

ADXL345 adxl = ADXL345();             // USE FOR I2C COMMUNICATION


int interruptPin = 2;                 // Setup pin 2 to be the interrupt pin (for most Arduino Boards)
const int wakeUpPin = 2;                //For good accelaration return values I comment out this

void wakeUp()
{

}

void setup(){
  
  Serial.begin(57600);                 // Start the serial terminal
  Serial.flush();

  pinMode(7, OUTPUT);

  
  adxl.powerOn();                     // Power on the ADXL345
  adxl.setRangeSetting(2);           // Give the range settings
                                      // Accepted values are 2g, 4g, 8g or 16g
                                      // Higher Values = Wider Measurement Range
                                      // Lower Values = Greater Sensitivity

  adxl.setSpiBit(0);                  // Configure the device to be in 4 wire SPI mode when set to '0' or 3 wire SPI mode when set to 1
                                      // Default: Set to 1
                                      // SPI pins on the ATMega328: 11, 12 and 13 as reference in SPI Library 
   
  adxl.setActivityXYZ(1, 1, 1);       // Set to activate movement detection in the axes "adxl.setActivityXYZ(X, Y, Z);" (1 == ON, 0 == OFF)
  adxl.setActivityThreshold(75);      // 62.5mg per increment   // Set activity   // Inactivity thresholds (0-255)

  adxl.setInactivityXYZ(1, 1, 1);     // Set to detect inactivity in all the axes "adxl.setInactivityXYZ(X, Y, Z);" (1 == ON, 0 == OFF)
  adxl.setInactivityThreshold(75);    // 62.5mg per increment   // Set inactivity // Inactivity thresholds (0-255)
  adxl.setTimeInactivity(10);         // How many seconds of no activity is inactive?

  adxl.setTapDetectionOnXYZ(0, 0, 1); // Detect taps in the directions turned ON "adxl.setTapDetectionOnX(X, Y, Z);" (1 == ON, 0 == OFF)

  // Set values for what is considered a TAP and what is a DOUBLE TAP (0-255)
  adxl.setTapThreshold(50);           // 62.5 mg per increment
  adxl.setTapDuration(15);            // 625 μs per increment
  adxl.setDoubleTapLatency(80);       // 1.25 ms per increment
  adxl.setDoubleTapWindow(200);       // 1.25 ms per increment

  // Set values for what is considered FREE FALL (0-255)
  adxl.setFreeFallThreshold(7);       // (5 - 9) recommended - 62.5mg per increment
  adxl.setFreeFallDuration(30);       // (20 - 70) recommended - 5ms per increment

  // Setting all interupts to take place on INT1 pin
  adxl.setImportantInterruptMapping(1, 1, 1, 1, 1);     // Sets "adxl.setEveryInterruptMapping(single tap, double tap, free fall, activity, inactivity);" 
                                                        // Accepts only 1 or 2 values for pins INT1 and INT2. This chooses the pin on the ADXL345 to use for Interrupts.
                                                        // This library may have a problem using INT2 pin. Default to INT1 pin.
  
  // Turn on Interrupts for each mode (1 == ON, 0 == OFF)
  adxl.InactivityINT(1);
  adxl.ActivityINT(1);
  adxl.FreeFallINT(1);
  adxl.doubleTapINT(1);
  adxl.singleTapINT(1);
  
 attachInterrupt(digitalPinToInterrupt(interruptPin), ADXL_ISR, RISING);   // Attach Interrupt
  pinMode(wakeUpPin, INPUT); 

}

void loop(){

    attachInterrupt(0, wakeUp, RISING);
   
    int x,y,z;   
  adxl.readAccel(&x, &y, &z);         // Read the accelerometer values and store them in variables declared above x,y,z

  digitalWrite(7, HIGH);
  delay(500);
  
  Serial.print(x);
  Serial.print(", ");
  Serial.print(y);
  Serial.print(", ");
  Serial.println(z); 

  digitalWrite(7, LOW);

  
  ADXL_ISR();
}

void ADXL_ISR() {
  byte interrupts = adxl.getInterruptSource();
  
  // Free Fall Detection
  if(adxl.triggered(interrupts, ADXL345_FREE_FALL)){
    Serial.println("*** FREE FALL ***");
    //add code here to do when free fall is sensed
  } 
  
  // Inactivity
  if(adxl.triggered(interrupts, ADXL345_INACTIVITY)){
    
               Serial.flush();        
              adxl.InactivityINT(0);
              LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);
  }
  
  // Activity
  if(adxl.triggered(interrupts, ADXL345_ACTIVITY)){
    Serial.println("*** ACTIVITY ***"); 
     
     adxl.InactivityINT(1);
     //add code here to do when activity is sensed
  }
  
  // Double Tap Detection
  if(adxl.triggered(interrupts, ADXL345_DOUBLE_TAP)){
    Serial.println("*** DOUBLE TAP ***");
     adxl.InactivityINT(1);
     //add code here to do when a 2X tap is sensed
  }
  
  // Tap Detection
  if(adxl.triggered(interrupts, ADXL345_SINGLE_TAP)){
    Serial.println("*** TAP ***");
    adxl.InactivityINT(1);
  } 
}

void blink() { 
}

Progetto Zero

GPS ad alimentazione solare con registrazione dati su SD Card e sleep mode ed attivazione programmabile tramite orologio interno

Componenti:
Arduino Uno
SeedStudio Solar Charger Shield
Data recoder shield
RTC DS3231
GPS con uscita seriale
Lipo 10.000 mAh
Pannello solare 6V
SD Card 2Gb



Il rele' deve essere collegato nella configurazione NA (normalmente aperto)
La seriale del GPS e' collegata direttamente alla seriale dell'Arduino perche' usare una SoftwareSerial crea problemi con la modalita' Sleep

Tra i vari aggiustamenti che ho fatto al programma c'e' anche un ridimensionamento dell'array del buffer. Con un buffer da 200 byte il programma si compilava, veniva lanciato su Arduino ma la IDE segnalava che il poco spazio di memoria rimasto libero (un centinaio di bytes) poteva rendere il programma instabile....in effetti durante l'esecuzione il buffer veniva riempito con caratteri a caso e con pezzi della memoria. Ridimensionato il buffer il problema e' scomparso
------------------------------------------------------------------------------
#include <RTClibExtended.h>
#include <Wire.h>
#include <LowPower.h>

#include <stdlib.h>
#include <avr/interrupt.h>      // library for interrupts handling
#include <avr/sleep.h>          // library for sleep
#include <avr/power.h>          // library for power control

// SD Card headers
#include <SPI.h>
#include <SD.h>



#define wakePin 2    //use interrupt 0 (pin 2) and run function wakeUp when pin 2 gets LOW

RTC_DS3231 rtc;      //we are using the DS3231 RTC


int contatore;
const unsigned int dim_buffer = 100;
int SerialData[dim_buffer];


const int chipSelect = 10;
char incomingByte = 0;   // for incoming serial data

char filen[10];
String filename;
char filenb[10];
String filenameb;


DateTime now;


//-------------------------------------------------

void wakeUp()
{


}

//------------------------------------------------------------

void setup() {


  pinMode(7, OUTPUT);
  

  delay(3000);
  // Inizializzazione SD
  if (!SD.begin(chipSelect)) {
    //Serial.println("Card failed, or not present");
    while (1);   

    //if (!sd.begin(chipSelect)) {
    //Serial.println("Card failed, or not present");
    //while (1);    Serial.begin(9600);

  }

  delay(3000);

  //Set pin D2 as INPUT for accepting the interrupt signal from DS3231
  pinMode(wakePin, INPUT);;

  //Initialize communication with the clock
  Wire.begin();
  rtc.begin();
  rtc.adjust(DateTime(__DATE__, __TIME__));   //set RTC date and time to COMPILE time
  delay(500);
  now = rtc.now();


  //clear any pending alarms
  rtc.armAlarm(1, false);
  rtc.clearAlarm(1);
  rtc.alarmInterrupt(1, false);
  rtc.armAlarm(2, false);
  rtc.clearAlarm(2);
  rtc.alarmInterrupt(2, false);

  rtc.writeSqwPinMode(DS3231_OFF);
  delay(1000);

}

//------------------------------------------------------------

void loop() {
   Serial.begin(9600);
    while (!Serial) {
  }
 
  Serial.println("inizio");

  digitalWrite(7, HIGH);


  now = rtc.now();
  sprintf(filen, "%02d%02d%02d%02d.txt", now.month(), now.day(), now.hour(), now.minute());
  String filename(filen);
  delay(2500);

  Serial.println(filename);


  File dataFile = SD.open(filename, FILE_WRITE);


  for (uint32_t i = 0; i <= 4000; i++) {
    contatore = 0;
    while (contatore < 98)
    {
      if (Serial.available() > 0) {
        SerialData[contatore] = Serial.read();
        //dataFile.print(char(Serial.read()));
        contatore++;

        //Serial.print(char(SerialData[contatore-1]));
        //dataFile.print(" ");
        //Serial.println(contatore);
      }

    }
    

    if (dataFile) {
      for (int s = 0; s < contatore - 1; s++) {
        Serial.print(SerialData[s]);
        Serial.print("  ");
        Serial.print(char(SerialData[s]));
        if (SerialData[s] != 255) {
                dataFile.print(char(SerialData[s]));
                Serial.println("  I");               
                }
                else
                {
                  Serial.println("E");
                
                }
        }
      }
    

    //dataFile.write(SerialData,197);
    memset(SerialData,0,sizeof(SerialData));

  }
  dataFile.close();
  Serial.println("Finito");

  // salva la tensione della batteria
  sprintf(filenb, "%02d%02d%02d%02d.bat", now.month(), now.day(), now.hour(), now.minute());
  String filenameb(filenb);

  File dataFileb = SD.open(filenameb, FILE_WRITE);
  if (dataFileb) {
    String bat = String(analogRead(A0), DEC);
    dataFileb.println(bat);
    dataFileb.close();
  }

  // spenge antenna GPS
  Serial.end();
  digitalWrite(7, LOW);
  delay(500);

  now = rtc.now();
  DateTime nextAlarm = now + TimeSpan(0, 4, 0, 0);


  delay(3000);
  rtc.setAlarm(ALM1_MATCH_HOURS, nextAlarm.minute(), nextAlarm.hour(), nextAlarm.second());   //set your wake-up time here
  rtc.alarmInterrupt(1, true);
  delay(3000); // wait for console
  attachInterrupt(0, wakeUp, LOW);       //use interrupt 0 (pin 2) and run function wakeUp when pin 2 gets LOW
  LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);   //arduino enters sleep mode here
  detachInterrupt(0);                                    //execution resumes from here after wake-up
  //When exiting the sleep mode we clear the alarm
  rtc.armAlarm(1, false);
  rtc.clearAlarm(1);
  rtc.alarmInterrupt(1, false);

  delay(3000);

}

Debugger integrato ESP32S3

Aggiornamento In realta' il Jtag USB funziona anche sui moduli cinesi Il problema risiede  nell'ID USB della porta Jtag. Nel modulo...