From: Andrea Manni Date: Sat, 11 Feb 2017 00:53:13 +0000 (+0100) Subject: Inizio repo X-Git-Url: http://git.piffa.net/web?a=commitdiff_plain;h=83fcdf584c2e039b2d62faf7973dd5f51232c4d5;p=common Inizio repo --- 83fcdf584c2e039b2d62faf7973dd5f51232c4d5 diff --git a/TODO b/TODO new file mode 100644 index 0000000..bfd3808 --- /dev/null +++ b/TODO @@ -0,0 +1,11 @@ + +* aggiungere un displace temporale ai blink / pwm +* Flasher con sequenza arbitraria di lampeggio +* oggetti che lavorino contemporaneamente su piu' PIN +* Link a Schemi / Schemi +* esempio con state machine per flight modes +** battery voltage reader -> RGB +** digital compass e RGB +** barometer +** 6 axis +** Neopixel diff --git a/common.cpp b/common.cpp new file mode 100644 index 0000000..5a7230d --- /dev/null +++ b/common.cpp @@ -0,0 +1,426 @@ +/* Common + * + * Oggetti di uso comune + * Autore: Andrea Manni + * + * Link: http://git.andreamanni.com/ + * Licenza: GPLv3 + */ + +#include "Arduino.h" +#include "common.h" + +#define DEBUG_not + +////////////////////// +// RGB LED +// Common anode / cat + +RGBLed::RGBLed(byte pinR, byte pinG, byte pinB) { + // Per un common catodo, valore max / min invertiti + redPin = pinR ; + greenPin = pinG ; + bluePin = pinB ; + common = 255 ; + + // Equvalente del Setup() per inizializzare i PIN + pinMode(redPin, OUTPUT); + pinMode(greenPin, OUTPUT); + pinMode(greenPin, OUTPUT); +}; + +RGBLed::RGBLed(byte pinR, byte pinG, byte pinB, byte com) { + // Per un common anode, valore max / min normali + redPin = pinR ; + greenPin = pinG ; + bluePin = pinB ; + common = com ; + + // Equvalente del Setup() per inizializzare i PIN + pinMode(redPin, OUTPUT); + pinMode(greenPin, OUTPUT); + pinMode(greenPin, OUTPUT); +}; + +void RGBLed::SetColor (byte r, byte g, byte b) { +// Imposta il colore di un LED RGB + analogWrite(redPin, common - r); + analogWrite(greenPin, common - g); + analogWrite(bluePin, common - b); + +// Debug +#ifdef DEBUG + Serial.print(common - r); + Serial.print("-"); + Serial.print(common - g); + Serial.print("-"); + Serial.print(common - b); + while(1); +#endif + +}; + +void RGBLed::Rand () { +// Imposta il colore di un LED RGB + analogWrite(redPin, random(0,256)); + analogWrite(greenPin, random(0,256)); + analogWrite(bluePin, random(0,256)); +}; + +void RGBLed::Red () { +// Accende il LED di rosso + SetColor(255,0,0); +}; + +void RGBLed::Green () { +// Accende il LED di verde + SetColor(0,255,0); +}; + +void RGBLed::Blue () { +// Accende il LED di blu + SetColor(0,0,255); +}; + +void RGBLed::Magenta () { +// Accende il LED di magenta + SetColor(255,0,255); +}; + +void RGBLed::Cyano () { +// Accende il LED di Cyano + SetColor(0,255,255); +}; + +void RGBLed::Yellow () { +// Accende il LED di giallo + SetColor(255,255,0); +}; + +void RGBLed::White () { +// Accende il LED + SetColor(255,255,255); +}; + +void RGBLed::Off () { +// Spegne il LED + SetColor(0,0,0); +}; + + + +///////////////////////////////////// +// Lampeggiatore +// Constructor +// +// Esempi incrementali: https://lab.piffa.net/sketchbook_andrea/multitasking/ +Lampeggiatore::Lampeggiatore(int pin) +{ + ledPin = pin; + pinMode(ledPin, OUTPUT); + ledState = LOW; + previousMillis = 0; + interval = 500; +}; + +// Una funzione facente parte di una classe prende il nome di "metodo" della stessa: +void Lampeggiatore::Invert() { + // Inverte il lampeggio + ledState = HIGH ; +} + +void Lampeggiatore::Blink() { + // Illumina il led a 500ms + + if(millis() + shift - previousMillis > interval) { + + // if the LED is off turn it on and vice-versa: + ledState = !ledState ; // Inverti il LED + // set the LED with the ledState of the variable: + digitalWrite(ledPin, ledState); + // save the last time you blinked the LED + previousMillis += interval; + } +}; + +void Lampeggiatore::Blink(long time, long drift ) { + // Illumina il led secondo un intervallo passato come argomento + + shift = drift; + if(millis() + shift - previousMillis > time) { + // if the LED is off turn it on and vice-versa: + ledState = !ledState ; // Inverti il LED + // set the LED with the ledState of the variable: + digitalWrite(ledPin, ledState); + // save the last time you blinked the LED + previousMillis += time; + } +}; + +void Lampeggiatore::Blink(long up, long down, long drift ) { + // Illumina il ledB precisando ontime e downtime + + shift = drift; + if((ledState == HIGH)&& (millis() + shift - previousMillis > up)) { + // save the last time you blinked the LED + previousMillis += up; + ledState = LOW ; + } + else if((ledState == LOW)&& (millis() + shift - previousMillis > down)) { + previousMillis += down; + ledState = HIGH ; + } + + // set the LED with the ledState of the variable: + digitalWrite(ledPin, ledState); +}; + +void Lampeggiatore::High() { + // Accende il LED + + digitalWrite(ledPin, HIGH); +} + +void Lampeggiatore::Low() { + // Spegne il LED + + digitalWrite(ledPin, LOW); +} + +void Lampeggiatore::Swap() { + // Inverte lo stato del LED + + digitalWrite(ledPin, !digitalRead(ledPin)); +} + +///////////////////////////////////// +// Pwm +// Constructor +Pwm::Pwm(int pin) +// Gestione del PWM utilizzando millis +// per non bloccare il processore con delay +// Warning: serialWrite puo' interferire con i tempi. +{ + ledPin = pin; + pinMode(ledPin, OUTPUT); + previousMillis = 0; + byte brightness = 0 ; + increment = 1; +}; + +void Pwm::Up(long speed, long drift) { + // Aumenta linearmente la luminosita' usanndo millis() + // quindi senza bloccare il processore + // Viene usato un float, in alternativa un coseno + + if (millis() != previousMillis) { // si potrebbe togliere + shift = drift; + brightness = 255.0 /(float)speed * (millis() + shift); + analogWrite(ledPin, brightness); + + previousMillis = millis(); + }; +} + +void Pwm::lUp(long speed, long drift) { + // Aumenta usanndo millis() con correzione luminosita' LED + // quindi senza bloccare il processore + // Viene usato un float, in alternativa un coseno + + if (millis() != previousMillis) { // si potrebbe togliere + shift = drift; + brightness = 255.0 /(float)speed * (millis() + shift); + analogWrite(ledPin, lum(brightness)); + + previousMillis = millis(); + }; +} + +void Pwm::Down(long speed, long drift) { + // Riduce linearmente la luminosita' usanndo millis() + // quindi senza bloccare il processore + + if (millis() != previousMillis) { + shift = drift; + brightness = 255 - 255.0 /(float)speed * (millis() + shift) ; + analogWrite(ledPin, brightness); + + previousMillis = millis(); + }; +} + +void Pwm::lDown(long speed, long drift) { + // Riduce usanndo millis() con correzione della luminosita' + // quindi senza bloccare il processore + + if (millis() != previousMillis) { + shift = drift; + brightness = 255 - 255.0 /(float)speed * (millis() + shift) ; + analogWrite(ledPin, lum(brightness)); + + previousMillis = millis(); + }; +} + +void Pwm::UD(long speed, long drift ) { + // Aumenta e riduce in sequenza la luminosita' usanndo millis() + shift = drift; + brightness = 128 + 127 * cos(2 * PI / speed * (millis() + shift)); + analogWrite(ledPin, brightness); +} + +void Pwm::Set(byte brightness) { + // Imposta il valore del PWM + analogWrite(ledPin, brightness); +} + + +void Pwm::lSet(byte brightness) { + // Imposta il valore del PWM con correzione luminosita' LED + analogWrite(ledPin, lum(brightness)); +} + + +///////////////////////////////////// +// Sequenza +// Constructor +Sequenza::Sequenza (byte passed[], byte dim) { + ledPins = passed ; + size = dim ; + for (int thisPin = 0; thisPin < size; thisPin++) { + pinMode(ledPins[thisPin], OUTPUT); + } + previousMillis = millis(); + digitalWrite(ledPins[0], HIGH); +} + +void Sequenza::Update(long value) { + // Incrementa dal primo all'ultimo valore dell'array + interval = value; + if (millis() - previousMillis >= interval) { + previousMillis = millis(); + + if ( i < size - 1 ) { + // Spegni precedente led + digitalWrite(ledPins[i], LOW); + + // Accendi successivo led + digitalWrite(ledPins[++i], HIGH); + } + + else if (i == size - 1 ) { + // Ultimo caso + i = 0; + previousMillis = millis(); + digitalWrite(ledPins[i], HIGH); + digitalWrite(ledPins[ size - 1 ], LOW); + } + } +} + + +void Sequenza::Reverse(long value) { + interval = value; + if (millis() - previousMillis >= interval) { + previousMillis = millis(); + + if (i == 0) { // Entry point, ultimo LED + digitalWrite(ledPins[size -1],HIGH); + digitalWrite(ledPins[0],LOW); + i = size -1 ; + } + else { + digitalWrite(ledPins[i],LOW); + digitalWrite(ledPins[--i],HIGH); + } + } +} + +void Sequenza::UD(long value) { + interval = value; + if (millis() - previousMillis >= interval) { + previousMillis = millis(); + // Spegni precedente led + digitalWrite(ledPins[i], LOW); + i = i + inc ; + // Accendi successivo led + digitalWrite(ledPins[i], HIGH); + + if (i == 0 || i == size -1) { + inc = -inc ; + } + } +} + + +////////////////// +// Funzioni + + +void brilla(byte pin, int velocita ) { // Defalt value di velocita' solo nell'Header + // Accende e spegne il LED accetando un argomento + // per impostare la velocita'. + + pinMode(pin, OUTPUT); + // sequenze di istruzione: accendere e spegnere il LED + digitalWrite(pin, HIGH); // turn the LED on (HIGH is the voltage level) + delay(velocita); // wait for a second + digitalWrite(pin, LOW); // turn the LED off by making the voltage LOW + delay(velocita); // wait for a second +}; + + +byte lum(byte val) { + // Mappatura dell'intervallo 0-255 con correzione di luminosita. + // storata in SRAM + return pgm_read_byte_near(BCORRECT + val); +}; + + +int calibraTrim(int pin, const byte ledPin) { + /* START Calibrazione TRIM canale: + Lettura di 10 smaple + calcolo del valore medio esclusi gli 0 + + I canali come alettoni / elevatore possono avere un TRIM + (generalmente il throttle non ha un TRIM impostato), + questa funzione nel setup serve per trovare il punto medio + all'avvio dello sketch. + */ + pinMode(ledPin,OUTPUT); + byte a = 0; + int servoValue = 0; + int middle = 0; +#ifdef DEBUG + Serial.println(">> Calibrazione: "); +#endif + while (a < 10) { + if (millis() > 10000) { +#ifdef DEBUG + Serial.println(">> Calibrazione annullata a causa di assenza di seganle. \nAssicurarsi di accendere radio e ricevente \ne ripetere la procedura."); +#endif + middle = 15000; // Return value is divided by 10 + break; + }; + servoValue = pulseIn(pin, HIGH, 25000); + if (servoValue != 0 && servoValue > 950 && servoValue <2000) { + middle = middle + servoValue ; + a++ ; +#ifdef DEBUG + Serial.print(servoValue); + Serial.print(": "); + Serial.println(middle / a); +#endif + digitalWrite(ledPin, !digitalRead(ledPin)); + delay(50); + } + } +#ifdef DEBUG + Serial.print(">> Fine Calibrazione, media: "); + Serial.println(middle / 10 + 10); + Serial.flush() ; +#endif + return(middle / 10 + 10) ; +// END calibrazione +}; + diff --git a/common.h b/common.h new file mode 100644 index 0000000..9768961 --- /dev/null +++ b/common.h @@ -0,0 +1,164 @@ +/* + Common Class + + Oggetti comuni + +Autore: Andrea Manni + +Link: http://git.andreamanni.com/ +Licenza: GPLv3 + +*/ + +#include "Arduino.h" +#include + +#ifndef common_h +#define common_h + +// Variabili +const uint8_t BCORRECT[256] PROGMEM = { // Tabella per correzione luminosita' LED a 8bit + 0,0,0,1,1,1,2,1,1,2,1,2,2,2,3,2, + 2,2,3,2,2,3,2,3,3,3,4,3,3,3,4,4, + 4,5,4,5,4,5,5,6,5,5,6,5,6,6,7,6, + 7,7,8,7,8,8,9,8,9,10,9,10,10,11,10,11, + 11,12,11,12,13,12,13,13,14,14,15,15,15,16,16,17, + 17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24, + 25,25,26,26,27,28,28,29,29,30,31,31,32,32,33,34, + 34,35,36,37,37,38,39,39,40,41,42,43,43,44,45,46, + 47,47,48,49,50,51,52,53,54,54,55,56,57,58,59,60, + 61,62,63,64,65,66,67,68,70,71,72,73,74,75,76,77, + 79,80,81,82,83,85,86,87,88,90,91,92,94,95,96,98, + 99,100,102,103,105,106,108,109,110,112,113,115,116,118,120,121, + 123,124,126,128,129,131,132,134,136,138,139,141,143,145,146,148, + 150,152,154,155,157,159,161,163,165,167,169,171,173,175,177,179, + 181,183,185,187,189,191,193,196,198,200,202,204,207,209,211,214, + 216,218,220,223,225,228,230,232,235,237,240,242,245,247,251,255 +}; + +// Inserirne una con 32 valori + + +class RGBLed { + // Classe rappresentativa di un LED RGB + protected: // Vedi esempio Ereditarieta' + byte redPin ; + byte greenPin ; + byte bluePin ; + byte redValue ; + byte greenValue ; + byte blueValue ; + byte common ; + + public: + RGBLed (byte pinR, byte pinG, byte pinB) ; + RGBLed (byte pinR, byte pinG, byte pinB, byte com) ; + void SetColor (byte r, byte g, byte b) ; + void Rand (); + void Red (); + void Green (); + void Blue (); + void Magenta (); + void Cyano (); + void White (); + void Yellow (); + void Off (); +}; + + + +class Lampeggiatore { + // Lampeggia un LED utilizzando millis() + // Variabili + int ledPin ; // il numero del LED pin + long interval ; // milliseconds di intervallo nel lampeggiare + unsigned long previousMillis ; // precedente cambio di stato + int ledState ; // stato attuale del LED, pubblico per invertirlo + + // Constructor: come viene instanziato un oggetto facente parte della classe +public: + Lampeggiatore(int pin); + void Invert(); // Inverte il lampeggio + void Blink(); // Lampeggia ogni 500ms + void Blink(long interval, long drift = 0); // Lampeggia inpostando l'intervallo + void Blink(long on, long down, long drift); // Imposta il tempo acceso e il tempo spento + void High(); // Accende il LED + void Low(); // Spegne il LED + void Swap(); // Inverte lo stato del LED + unsigned long shift ; // anticipo / ritardo +}; + + + +//////////////////////////// +class Pwm { + /* + PWM per un LED: aumentare progressivamente la luminosita'. + Utilizza la funzione millis() invece che un delay() + in modo da non blocare il processore. + */ + // Variabili + int ledPin ; // il numero del LED pin + int speed ; // velocita' del ciclo in ms + unsigned long previousMillis ; //precedente cambio di stato + byte increment ; // aumenta brighteness nel loop UD + + // Constructor: come viene instanziato un oggetto facente parte della classe +public: + Pwm(int pin); // numero di pin, velocita' di ciclo + void Up(long speed, long drift = 0); + void lUp(long speed, long drift = 0); + void Down(long speed, long drift = 0); + void lDown(long speed, long drift = 0); + void UD(long speed, long drift = 0); + void Set(byte brighteness); + void lSet(byte brighteness); + byte brightness ; // luminostia' iniziale + unsigned long shift ; // anticipo / ritardo +}; + + + +//////////////////////////// +class Sequenza { + // Lampeggia LED in sequenza utilizzando millis() + unsigned long previousMillis ; + byte i = 0; + byte *ledPins; + byte size; + int inc = 1; + long interval; + + public: + Sequenza (byte passed[], byte dim) ; // Array contentente i PINS, dimensioni array + void Update(long value) ; // Accende in sequenza + void Reverse(long value) ; // Invertita + void UD(long value) ; // Up & Down +}; + + + + + + + + + + + + + + + + +////////////////////// +// Funzioni + +void brilla(byte pin, int velocita = 200) ; + +byte lum(byte val); + +int calibraTrim(int pin, const byte ledPin = 13); + + +#endif diff --git a/examples/alternato/alternato.ino b/examples/alternato/alternato.ino new file mode 100644 index 0000000..3794137 --- /dev/null +++ b/examples/alternato/alternato.ino @@ -0,0 +1,20 @@ +/* Funzione Invert + + Due LED con lampeggio alternato +*/ + +#include + +Lampeggiatore right = 3; +Lampeggiatore left = 5; + +void setup() { + left.Invert(); // Parte da stato invertito rispetto al default +} + +void loop() { + // Due LED con lampeggio alternato: + right.Blink(); + left.Blink(); + // Si possono usare i soliti metodi dell'oggetto blink +} diff --git a/examples/blink/blink.ino b/examples/blink/blink.ino new file mode 100644 index 0000000..d182fe4 --- /dev/null +++ b/examples/blink/blink.ino @@ -0,0 +1,30 @@ +/* Esempio + + Utilizzo dell'oggetto Lampeggiatore: + Lampeggia un LED utilizzando millis() +*/ + +#include + +// Instanziamo un LED fuori dal loop +Lampeggiatore led = 13; + +void setup() { +// I PINs vengono impostati dal constructor al momento +// della dichiarazione dell'ogetto. + +//led.Invert() ; // Opzionale: inverte l'ordine del lampeggio da + // HI -> LOW --> LOW -> HI + // per avere 2 LED che lampeggiano alternativamente +} + +void loop() { + led.Blink(); // Lampeggia con un default di 1sec (0.5 HI 0.5 LOW) +// led.Blink(400); // Lampeggia ogni 400ms +// led.Blink(400,200); // Imposta il tempo acceso a 400ms, 200ms di ritardo +// led.Blink(300,700,0); // acceso per 300ms, spento per 700 ms, ritardo = 0ms +// led.Blink(300,700,500); // acceso per 300ms, spento per 700 ms, ritardo = 500s +// led.High(); // Stato su HI +// led.Low(); // Stato su LOW +// led.Swap(); // Inverte lo Stato +} diff --git a/examples/eredita/eredita.ino b/examples/eredita/eredita.ino new file mode 100644 index 0000000..5e7651f --- /dev/null +++ b/examples/eredita/eredita.ino @@ -0,0 +1,41 @@ +/* Ereditarieta' + + La classe SuperLED definita in questo sketch + eredita le caratteristiche di RGBLed e introduce un nuovo metodo + per un nuovo colore custom. + +*/ + +#include // L'orine e' importante: prima l'include, + // poi la dichiarazione della nuova classe (non a fondo pagina) + // poi potremo usare la nuova classe + +class SuperLED : public RGBLed { // Ereditamo dalla classe RGBLed + // Nuovi colori per RGBLed + + using RGBLed::RGBLed ; // Richiamiamo il constructor del genitore + public: + void Violet () { // Nuovo metodo + // Accende il LED di viola + + analogWrite(redPin, 255 - 238); + analogWrite(greenPin, 255 - 130); + analogWrite(bluePin, 255 - 238); + }; +}; + +void setup() { + // I PINs vengono impostati dalla dichiarazione dell'ogetto. +} + +// Instanziamo un LED +SuperLED led(11, 10, 9); //Istanziamo un oggetto led facente parte + // della inuova classe SuperLed che eredita da RGBLed + +void loop() { + led.Violet(); // Nuovo metodo + delay(1000); + led.Off(); // Vecchio metodo + delay(1000); +} + diff --git a/examples/pwm/pwm.ino b/examples/pwm/pwm.ino new file mode 100644 index 0000000..e3fe058 --- /dev/null +++ b/examples/pwm/pwm.ino @@ -0,0 +1,31 @@ +/* Esempio + + Utilizzo dell'oggetto PWM: + Gestione del PWM utilizzando millis + per non bloccare il processore con delay +*/ + +#include + +// Instanziamo un LED fuori dal loop +Pwm led = 9; + +void setup() { + // I PINs vengono impostati dal constructor al momento + // della dichiarazione dell'ogetto. +} + +void loop() { +led.Up(2000); // Aumenta la luminosita' linearmente in 2 sec +//led.Up(2000,1000); // Aumenta la luminosita' linearmente in 2 sec, 1sec di ritardo + +//led.lUp(2000); // Aumenta la luminosita' con correzione luminosita' per LED +// led.Down(1000); // Diminuisce la luminosita' in 1 sec +// led.lDown(1000); // Diminuisce la luminosita' con correzione luminosita' +// led.UD(4000); // Aumenta e poi diminuisce la luminostia' in 4 sec (coseno) +// Tutti questi metodi accettano un valore opzionale per il ritardo + +// led.set(100); // Imposta il valore del PWM da 0-255 +// led.lSet(100); // Imposta il valore del PWM con correzione luminosita' +// analogWrite(lum100); // Equivalente a sopra +} diff --git a/examples/rgb/rgb.ino b/examples/rgb/rgb.ino new file mode 100644 index 0000000..7e1026d --- /dev/null +++ b/examples/rgb/rgb.ino @@ -0,0 +1,37 @@ +/* Esempio + + Come caricare e usare un oggetto e una funzione + facente parte della libreria. +*/ + +#include + +void setup() { + // I PINs vengono impostati dalla dichiarazione dell'ogetto. +} + +// Instanziamo un LED +RGBLed led(11, 10,9); //Istanziamo un oggetto led (default common catodo) +// facente parte della classe RGBLed +// RGBLed led(11, 10,9,255); // Stessa cosa: 255 = common catodo = (255 - value) +//RGBLed led(10,9,11,0); // Inizializzazione Common anodo + +void loop() { + led.Red(); +} + +/* Colori disponibili: + Red + Green + Blue + Magenta + Cyano + White + Yellow + Off + Rand = random + SetColor(byte r, byte g, byte b) + +Nota: per aggiungerne un colore senza modificare la libreria originale +si potrebbe usara l'ereditarieta': vedi esempio "eredita.ino" . +*/ diff --git a/examples/sequenza/sequenza.ino b/examples/sequenza/sequenza.ino new file mode 100644 index 0000000..8a319d4 --- /dev/null +++ b/examples/sequenza/sequenza.ino @@ -0,0 +1,31 @@ +/* + For Loop with millis() + +Blink di un array di led in sucessione, +utilizzando millis() per non blocking. +L'array puo' contenere un numero arbitrario di led +(l'ordine in cui compaiono e' l'ordine in cui brillano). + +OOP version. + + Schemi: + - http://lab.piffa.net/schemi/8_led_single_res_bb.png + - http://lab.piffa.net/schemi/8_led_single_res_schem.png + + http://www.arduino.cc/en/Tutorial/ForLoop + */ +#include +void setup() { +}; + +byte pins[] = { // PIN dei LED che compongono la sequenza + 2, 3, 4, 5, 6, 7 +}; +Sequenza seq = Sequenza(pins,sizeof(pins)); // Array dei PINs, quanti elementi compongono l'array + +void loop() { + seq.Update(200); // Passa al segmento successivo ogni 200ms +}; + + + diff --git a/keywords.txt b/keywords.txt new file mode 100644 index 0000000..4e2d133 --- /dev/null +++ b/keywords.txt @@ -0,0 +1,31 @@ +RGBLed KEYWORD1 +Red KEYWORD2 +Green KEYWORD2 +Blue KEYWORD2 +Magenta KEYWORD2 +Cyano KEYWORD2 +White KEYWORD2 +Yellow KEYWORD2 +Off KEYWORD2 +SetColor KEYWORD2 +brilla KEYWORD2 +Lampeggiatore KEYWORD1 +Invert KEYWORD2 +Blink KEYWORD2 +Blink KEYWORD2 +Blink KEYWORD2 +High KEYWORD2 +Low KEYWORD2 +Swap KEYWORD2 +Pwm KEYWORD1 +Up KEYWORD2 +lUp KEYWORD2 +Down KEYWORD2 +lDown KEYWORD2 +UD KEYWORD2 +Set KEYWORD2 +lSet KEYWORD2 +lum KEYWORD2 +Sequenza KEYWORD1 +Update KEYWORD2 +calibraTrim KEYWORD2