Question SSSM

[RichardC 503]

Bonjour,

 

J'ai profité de ce we pas trop pourri pour ressortir mon prototype de SSSM (Solar Scintillation Seeing Monitor) et essayer de finir sa mise au point .

Attention ce n'est pas le système commercial Airylab, mais une version "faite maison"  issue des travaux de E.J. SEYKORA (RIP) : "An Inexpensive Solar Scintillation Seeing Monitor Circuit with Arduino Interface", dont on peut trouver différentes variantes ici :

http://adsabs.harvard.edu/full/1993SoPh..145..389S

https://www.blackwaterskies.co.uk/2017/06/diy-solar-scintillation-seeing-monitor-sssm/#lightbox/1/

http://joachim-stehle.de/sssm_eng.html

https://sourceforge.net/projects/mysolarprojects/

https://www.astrotreff.de/forum/index.php?thread/200688-diy-solar-scintillation-seeing-monitor/

https://astropolis.pl/topic/59856-monitor-scyntylacji-słonecznej-ssm/

 

Il est difficile de trouver ce que l'on devrait obtenir en sortie, et avant de passer à la réalisation finale, j'aimerai savoir si les courbes ci-dessous vous semblent a peu près correctes pour un ciel partiellement nuageux (cirrus)  :

 

 

Les grand pics semblent correspondre aux passage de nuages...

 

Sur une plus longue durée :

 

Pour ceux qui connaissent ces bébêtes, qu'en pensez-vous svp ?

 

Merci d'avance !

Richard

[AlSvartr 3185]

Hello,

 

A mon humble avis le mieux à faire c’est de se faire prêter un (voire deux, c’est encore mieux) SSM et de regarder comment les données sont corrélées avec celles de ton instrument. Le plus difficile la dedans ça doit être de paramétrer la lecture des photodiodes à l’identique non?

Edited October 10, 2021 by AlSvartr

[banjo 7527]

bonjour,

j'ai remarqué qu'avec des cirrus le sssm était très optimiste , normal ça a tendance à lisser le scintillement .

Paul

 

[ced06480 0]

Bonjour a tous,

 

je me permet de remonter ce poste pour avoir une aide sur ce montage.

pour être franc avec vous je suis totalement novice en Arduino (je sais faire clignoter une led ou autre action simple...)

je me heurte a 3 problématiques :

 

la première est que le sketch ne se lance pas sauf si je lance le moniteur dans IDE

la seconde est que je n'arrive pas a faire de remonter sur les écrans Oled (j'ai tester avec deux version) sur un code classique pas de soucis mais dans ce code je me perd littéralement

le troisième qui doit être lier au premier si je connecte le sssm au soft Windows je n'ai pas de remonter de valeur car le sketch ne se lance pas.

 

Auriez vous des conseils a me donner?

 

la ref du materiel  : 

 

https://fr.aliexpress.com/item/1005006426010899.html?spm=a2g0o.order_list.order_list_main.59.2bc45e5bJ9Mqci&gatewayAdapt=glo2fra

 

https://www.amazon.fr/gp/product/B07Z8XX6KB/ref=ppx_yo_dt_b_asin_title_o05_s00?ie=UTF8&psc=1

 

https://fr.aliexpress.com/item/1005004355547926.html?spm=a2g0o.order_list.order_list_main.5.2bc45e5bJ9Mqci&gatewayAdapt=glo2fra

 

 

Cedric

[ced06480 0]

Je me permet de remonter le post pour un e question technique, j'ai aussi fais un sssm mais je n'ai pas de connexion avec le soft Windows par contre avec le plugin de fire capture il fonctionne sans aucun soucis. est ce que dans le sketch il y a une petite ligne cacher que j 'aurai loupé??

[RichardC 503]

Bonjour Cedric,

 

Alors, ça serait intéressant de savoir quel sketch vous utilisez pour regarder ce qu'il y a dans votre code.

 

Pour répondre à vos questions sur Arduino, c'est à la fois simple, et très compliqué cette plateforme !

 

C'est assez simple a coder, y' plein de librairie et ça donne l'illusion de tourner sur plein de cartes différentes, mais ça n'est pas du tout vrai !

Chaque processeur à son compilateur et chaque carte à son environnement, du coup les libraires marchent comme elles peuvent et c'est difficile d'en trouver qui soient vraiment multiplateforme.

Il faut pas mal de gens qui testent toutes les combinaisons et qui contribuent aux projets pour débugger ça.

 

Donc soit il faut prendre exactement les mêmes cartes/ processeur, soit il faut s'attendre à un peu de mise au point.

 

C'est spécialement vrai sur les écrans, surtout que les liaisons peuvent être SPI ou I2C pour une même puce écran et chaque processeur à son lot de spécificité sur ces drivers.

Donc y' pas de secret, si ça ne marche pas, il faut tester l'écran sur votre carte avec un programme de test et chercher les bonnes pins et la librairie la plus compatible avec votre sketch.

C'est ce que vous semblez avoir fait.

Après il faut la remplacer dans le sketch et en général il n'y pas trop de ligne à changer, mais il faut se méfier avec les nommages des librairies.

Sinon, il faut trouve un sketch plus simple (moins usine à gaz) et d’abord valider son fonctionnement sans écran.

 

De mon coté j'ai utilisé un Uno R3 avec un ATmega328P à cause de l'obligation d'être en 5V pour la partie analogique et j'ai voulu coller au plus près du design original.

Du coup ça n'est pas du tout les cartes avec lesquels je travail habituellement et je rencontre quelques problèmes.

 

Quand j'active la liaison série coté PC, cela provoque systématiquement un reboot de la carte, je n'ai pas trouvé de raison et je suis obligé de vivre avec.

Suivant le logiciel coté PC, soit la liaison remarche (avec l'écran ci-dessus), soit elle se bloque avec une version que j'ai amélioré :

 

Donc, c'est un peu étrange mais je lance la liaison avec le premier soft, j'attends le reboot et que ça reçoive des données, je coupe la liaison série et je lance le deuxième logiciel.

 

Vu les fonctions que j'ai rajouté et la façon de je m'en sert, je n'utilise plus l'écran.

Je pense donc refaire une version plus simple sans écran, avec peut être une carte 5V plus petite comme la vôtre et uniquement une liaison USB série.

 

Le 12/07/2024 à 23:50, ced06480 a dit :

la première est que le sketch ne se lance pas sauf si je lance le moniteur dans IDE

 

Certains sketch ont une pause au début du code pour attendre la connexion sur la la liaison série :

  // Initialize serial
  Serial.begin(115200);
  // Wait for  serial port to connect
  while( !Serial )  { }

Dans ces cas là je rajoute une attente de 10 ou 20 secondes pour passer à la suite (en autonome) :

  // Wait 10s for  serial port to connect
  int8_t wait = 20;
  while( !Serial && (wait-- > 0) )
  {
    internal_led_blink_ms(500);
  }

 

Le 20/07/2024 à 14:08, ced06480 a dit :

j'ai aussi fais un sssm mais je n'ai pas de connexion avec le soft Windows par contre avec le plugin de fire capture il fonctionne sans aucun soucis. est ce que dans le sketch il y a une petite ligne cacher que j 'aurai loupé??

Normalement, les logiciels discutent a peu près toujours pareil sur la liaison série :

A0: 1.00 A1: 1.55

Avec A0 = intensité et A1 = variation (seeing)
     

Par contre certains sketch ont une notion de mode pour changer ce format de sortie :

Au début du code on peut modifier :

#define MODE 2                // ** Select mode as described in features above, default 2, comment out if serial output not required

 

Dans le code on trouve :
case 1 :  // Basic text output
case 2 :  // Firecapture addin compatible
case 3 :  // FIXME: Bidirectional comms, need to read commands and send data
 

Ici le mode 2, c'est le format que je décrit ci-dessus A0/A1 et qui est compatible des deux logiciels que j'ai mentionné, ainsi que le plugin firecapture dont vous parler.

Il y a question de la vitesse aussi auquel il faut faire attention : normalement 115200 baud, mais à vérifier dans le sketch : Serial.begin(115200);

 

Richard

Edited July 29 by RichardC

[RichardC 503]

Bonjour Cedric,

 

Je ne retrouvais plus le sketch de mon SSM...

J'avais dérivé une version sans écran et nettoyer les calculs pour mes tests et c'est ce qui tourne toujours dessus !

Je vous la joint si cela peut vous aider.

Concernant le soft Windows, c'est plus gros, il faudrait que je monte un dépôt git.

 

Richard

GreatAttractor_SSSM2_light.zip

[ced06480 0]

merci pour les explication. en se moment j'utilise le sketch suivant qui fonction avec les ecran IIC sans modification.

 

/* Solar Scintillation Seeing Monitor Sketch

    (Putative V1.0) E.J Seykora, Department of Physics, East Carolina University, Greenville, NC, USA (Original Sketch, Mode 1 output)
    https://www.ecu.edu/cs-cas/physics/upload/An-Inexpensive-Solar-Scintillation-Seeing-Monitor-Circuit-with-Arduino-Interface-final2.pdf
    (Putative V1.1) Joachim Stehle, info@jahreslauf.de (Mode 2 output, Firecapture Addin compatibility, LCD output)
    http://www.joachim-stehle.de/sssm_eng.html
    V1.2 Modifications Copyright (C) 2016 Ian Lauwerys, http://www.blackwaterskies.co.uk/ (Mode 3 output, OLED output, code refactoring)

    The original work ("V1.0") and modified version "V1.1" contain no copyright notices or licences and thus are copyright their
    respective authors.

    Modifications (only) in V1.2 are provided without warranty of any kind and may be used freely and for any purpose (insofar as they can be
    separated from the original copyrighted works).

    Changelog:
      V1.0 - Vanilla version
      V1.1 - Firecapture addin and LCD shield output
      V1.2 - Refactored code, OLED output
      V1.2i- Added support for I2C OLED display

    Features:
    - Reads NUM_SAMPLES of analog input readings from ADC1 and ADC2 to find  4.46 * RMS(Intensity_ADC2) / AVERAGE(Intensity_ADC1)
    - Mode 1: Result is sent to serial port in plain text mode
    - Mode 2: Result is sent to serial port in format compatible with the Firecapture addin (http://www.joachim-stehle.de/sssm_eng.html)
    - Mode 3: (Not available) Reserved for bidirectional communications including client side configuration changes

    Notes:
    - Use with the hardware described in the paper linked above
    - External Scintillation Monitor circuit gain set to 425.5X
    - Adjust intensity value to approximately 1.0 in by changing feedback resistor on U1
        You should probably substitute a 2K variable resistor for the 220R resistor in the paper linked above to make this easier!
    - For more information see the following references:

      http://solarchatforum.com/viewtopic.php?f=9&t=16746

*/

// *************************************** Begin user modifiable defines *************************************

#define NUM_SAMPLES 2000      // ** Number of samples used to find the RMS value, default 2000 for about 2 readings per second on 16MHz device, decrease to output more readings per second

#define ADC1 A0               // ** Arduino analog input pin, reads intensity from LMC6484 pin 14
#define ADC2 A1               // ** Arduino analog input pin, reads variation from LMC6484 pin 8

//#define CLOUD_DISCRIMINATE true  // ** Discriminate for clouds if true, default true, comment out to disable
#ifdef CLOUD_DISCRIMINATE
  #define DISCRIMINATE_LOW     0.5  // ** Set variation value to zero if ***intensity*** is too low, default 0.5
  #define DISCRIMINATE_HIGH   10.0  // ** Set variation value to zero if ***variation*** is too high, default 10
#endif

#define INTENSITY_OFFSET  0.0    // ** Intensity dc offset, default 0.0, should not need to change if resistor on U1 can be adjusted to keep value between 0.5V and 1.0V
#define VARIATION_OFFSET  -0.05  // ** Variation dc offset, default -0.05, may need to adjust to keep variation output the the range > 0.0 and < 10.0

#define MOVING_AVERAGE_PTS 20 // ** Number of points to use for calculating the variation moving average, default 20, comment out to disable

#define MODE 2                // ** Select mode as described in features above, default 2, comment out if serial output not required (e.g. stand-alone device using LED/OLED for output)
#ifdef MODE
  #define SERIAL_RATE 115200  // ** Set the serial communications rate (9600 or 115200 are good values to try), default 115200
#endif

// #define LED_OUTPUT         // ** Define this to enable LED shield support, otherwise comment it out
   #define OLED_OUTPUT        // ** Define this to enable OLED module support, otherwise comment it out
                              //    N.B. You must edit Adafruit_SSD1306.h at comment "SSD1306 Displays" to choose a display size
                              //    SSD1306_LCDWIDTH and SSD1306_LCDHeight will then be defined by the .h with display size
                              //    Current W x H options are: 128 x 64 | 128 x 32 | 96 x 16
// #define OLED_VIA_SPI       // ** Define this when using the SPI version of the OLED display
   #define OLED_VIA_I2C       // ** Define this when using the I2C version of the OLED display

#ifdef OLED_OUTPUT
  #if defined (OLED_VIA_SPI) && defined (OLED_VIA_I2C)
    #error "Only one OLED output type can be defined!"
  #elif !defined (OLED_VIA_SPI) && !defined (OLED_VIA_I2C)
    #error "Either OLED_VIA_SPI or OLED_VIA_I2C must be defined!"
  #endif
#endif

#ifdef OLED_OUTPUT
  #ifdef OLED_VIA_SPI
    // #define SOFTWARE_SPI     // ** Define this if your OLED module is wired to use software SPI
    // #define HARDWARE_SPI     // ** Define this if your OLED module is wired to use hardware SPI
    #if defined (SOFTWARE_SPI) && defined (HARDWARE_SPI)
      #error "Only one OLED SPI mode can be defined!"
    #elif !defined (SOFTWARE_SPI) && !defined (HARDWARE_SPI)
      #error "An OLED SPI mode must be defined!"
    #endif
    #ifdef SOFTWARE_SPI
      #define OLED_MOSI   9     // ** For software SPI only, define digital pin wired to OLED MOSI
      #define OLED_CLK   10     // ** For software SPI only, define digital pin wired to OLED CLK (or SLCK)
    #endif
    #define OLED_RESET   -1     // ** For software and hardware SPI, define digital pin wired to OLED RST (not available on my OLED module, -1 ignores)
    #define OLED_DC      10     // ** For software and hardware SPI, define digital pin wired to OLED DC (or D/C)
    #define OLED_CS      21     // ** For software and hardware SPI, define digital pin wired to OLED CS (21 is A3 on Pro Micro!)
    // Note that SCLK (Pro Micro pin 15) and MOSI (Pro Micro pin 16) are specific pins in hardware SPI mode so don't need defining
  #endif

  #if SSD1306_LCDHeight != 16 // Can't plot graphs on 96 x 16 screen
    #define IG_WIDTH   45     // ** Intensity graph width (pixels), default 45 (sized for 128 pixel wide display), comment out to hide graph
    #ifdef IG_WIDTH
      #define IG_MAX    1.5   // ** Intensity graph max plottable input value, default 1.5
    #endif

    #define VG_WIDTH  125     // ** Variation graph width (pixels), default 125 (sized for 128 pixel wide display), comment out to hide graph
    #ifdef VG_WIDTH           // N.B. Enabling the variation graph requires display to be taller than 16 pixels
      #define VG_MAX   20     // ** Variation graph max plottable input value, default 20
    #endif
    
    #define SCATTER_PLOT      // ** Define this to graph as a scatter plot (quicker to draw), comment out and a filled graph will be drawn
  #endif
#endif

// *************************************** End user modifiable defines ***************************************

// #define DEBUG_SSM               // Turn on debugging tests

#define SSM_VERSION "V1.2i"     // SSM sketch version number
#define SSM_DATE "31 Jan 2021"  // SSM sketch date

// Note: Assign constants to variables so they may be changed on the fly by client software in mode 3
int sampleCount,
    numSamples = NUM_SAMPLES;

float variationValue,
      intensityValue,
      variationOffset = VARIATION_OFFSET,
      intensityOffset = INTENSITY_OFFSET;

#ifdef CLOUD_DISCRIMINATE
  float discriminateLow = DISCRIMINATE_LOW,
        discriminateHigh = DISCRIMINATE_HIGH;

  boolean cloudDiscriminate = CLOUD_DISCRIMINATE;
#endif

#ifdef MOVING_AVERAGE_PTS
  int movingAveragePts = MOVING_AVERAGE_PTS,
      movingAverageCount = 0;
      
  float movingAverageAcc = 0,
        movingAverage = 0;
#endif

#ifdef MODE
  int mode = MODE;
#endif

#ifdef LED_OUTPUT
  include <LiquidCrystal.h>             // Library available in standard Arduino IDE
  LiquidCrystal lcd(8, 9, 4, 5, 6, 7);  // Set up LCD shield
#endif

#ifdef OLED_OUTPUT
  int xPosition,
      yPosition,
      readingPosition;
  
  #include <SPI.h>              // Library available in standard Arduino IDE
  #include <Wire.h>             // Library available in standard Arduino IDE
  #include <Adafruit_GFX.h>     // https://github.com/adafruit/Adafruit-GFX-Library/archive/master.zip
  #include <Adafruit_SSD1306.h> // https://github.com/adafruit/Adafruit_SSD1306/archive/master.zip

  #ifdef OLED_VIA_SPI
    #ifdef SOFTWARE_SPI
      Adafruit_SSD1306 display(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);  // Initialise display object
    #elif HARDWARE_SPI
      Adafruit_SSD1306 display(OLED_DC, OLED_RESET, OLED_CS);                       // Initialise display object
    #endif
  #endif
 
  #ifdef OLED_VIA_I2C
    const int SDA_PIN = SDA;    // D2 - Pro Micro
    const int SCL_PIN = SCL;    // D3 - Pro Micro
    #define OLED_RESET  -1      // Reset pin # (or -1 if sharing Arduino reset pin)
    #define SCREEN_ADDRESS 0x3C //< See datasheet for Address
    Adafruit_SSD1306 display(SSD1306_LCDWIDTH, SSD1306_LCDHEIGHT, &Wire, OLED_RESET); // Initialise display object
  #endif
  
  #ifdef IG_WIDTH
    int intensityBuffer[IG_WIDTH] = { 0 },  // Buffer to hold scaled and bounded intensity readings
        intensityOldest = 2;                // Current position of oldest (left hand of graph) entry in intensity buffer

    #define IG_HEIGHT 13                    // Intensity graph height (pixels) - 1, default 13
    #define IG_SCALE  (IG_HEIGHT / IG_MAX)  // Intensity graph scale
  #endif
  
  #ifdef VG_WIDTH
    int variationBuffer[VG_WIDTH] = { 0 },  // Buffer to hold scaled and bounded variation readings
        variationOldest = 0;                // Current position of oldest (left hand of graph) entry in variation buffer

    #if SSD1306_LCDHEIGHT == 64
      #define VG_HEIGHT 45                // Variation graph height (pixels) - 1, default 45px for 64px high display
    #elif SSD1306_LCDHEIGHT == 32
      #define VG_HEIGHT 13                // Variation graph height (pixels) - 1, default 15px for 32px high display
    #else
      #error "Unsupported display size!"  // Couldn't find a supported display size
    #endif
    #define VG_SCALE (VG_HEIGHT / VG_MAX) // Variation graph scale
  #endif
#endif

void setup()
{
  #ifdef MODE
    Serial.begin(115200); // Initialise serial communications first in case we need to debug anything
  #endif
  
  #ifdef LED_OUTPUT
    lcd.begin(16, 2); // Initialise LCD shield
  #endif
  
  #ifdef OLED_OUTPUT
    delay(2000);  // Wait a bit for the display to initialise on first power up, otherwise we may get a blank screen instead of output
    
    #ifdef OLED_VIA_SPI
      display.begin(SSD1306_SWITCHCAPVCC);             // Generate high voltage.
    #else
      display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
    #endif
    #define SSM_LOGO_WIDTH  56                         // SSM splash screen logo width
    #define SSM_LOGO_HEIGHT 16                         // SSM splash screen logo height
    static const unsigned char PROGMEM SSM_LOGO [] = { // SSM Splash screen logo
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x0F, 0x80, 0x7E, 0x0E, 0x07, 0x31, 0x8C,
      0x3F, 0xE1, 0xFF, 0x0F, 0x0F, 0x3B, 0xDC, 0x70, 0x63, 0x83, 0x0F, 0x0F, 0x1F, 0xF8, 0x60, 0x03,
      0x00, 0x0D, 0x9B, 0x1E, 0x78, 0x60, 0x03, 0x00, 0x0D, 0x9B, 0x0C, 0x30, 0x70, 0x03, 0x80, 0x0D,
      0x9B, 0x3C, 0x3C, 0x3F, 0x81, 0xFC, 0x0C, 0xF3, 0xFC, 0x3F, 0x0F, 0xE0, 0x7F, 0x0C, 0xF3, 0x7E,
      0x7E, 0x00, 0x70, 0x03, 0x8C, 0x63, 0x07, 0xE0, 0x00, 0x30, 0x01, 0x8C, 0x63, 0x07, 0xE0, 0x00,
      0x30, 0x01, 0x8C, 0x03, 0x0E, 0x70, 0x60, 0x73, 0x03, 0x8C, 0x03, 0x0C, 0x30, 0x7F, 0xE3, 0xFF,
      0x0C, 0x03, 0x0C, 0x30, 0x1F, 0x80, 0xFC, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    };
    display.clearDisplay();                                                 // Clear display
    display.drawBitmap(0, 0, SSM_LOGO, SSM_LOGO_WIDTH, SSM_LOGO_HEIGHT, 1); // Draw splash screen logo
    display.setTextSize(1);
    display.setTextColor(WHITE);
    display.setTextWrap(false);
    display.setCursor(SSM_LOGO_WIDTH + 6, 0);                               // Draw splash screen sketch version
    display.print(SSM_VERSION);
    #if SSD1306_LCDWIDTH == 128
      #ifdef MODE
        display.print(" Mode ");                                            // Draw splash screen mode if applicable
        display.print(MODE);
      #endif
      display.setCursor(SSM_LOGO_WIDTH + 6 , 8);                            // Draw splash screen sketch date
      display.print(SSM_DATE);
    #endif
    display.display();                                                      // Show splash screen
    delay(2000);
    display.clearDisplay();                                                 // Clear display
    display.display();                                                      // Show cleared display
  #endif
}
 
void loop()
{
  variationValue = intensityValue = 0;                           // Reset variation and intensity samples

  for (sampleCount = 0; sampleCount < numSamples; sampleCount++) // Collect samples from the SSM
  {
    intensityValue = intensityValue + (analogRead(ADC1) - 511.) * 2.5 / 511.;     // Accumulate average solar intensity sample
    variationValue = variationValue + sq((analogRead(ADC2) - 511.) * 2.5 / 511.); // Accumulate RMS variation sample
  }
  
  intensityValue = intensityValue / numSamples + intensityOffset;                                 // Find average solar intensity, +/– dc offset
  variationValue = (4.46 * sqrt(variationValue / numSamples) + variationOffset) / intensityValue; // Find RMS variation, +/– small dc offset, normalised for intensity
  #ifdef MOVING_AVERAGE_PTS
    movingAverageAcc = movingAverageAcc + variationValue;   // Add the current variation to the moving average accumulator
    if (movingAverageCount = movingAveragePts)
    {
      movingAverageAcc = movingAverageAcc - movingAverage;  // Deduct the previous moving average from the accumulator
      movingAverage = movingAverageAcc / movingAveragePts;  // Calculate the new moving average
    }
    else
    {
      movingAverageCount++;                                 // Not enough data points yet, so keep accumulating
    }
  #endif
  
  #ifdef CLOUD_DISCRIMINATE
    if (cloudDiscriminate && (intensityValue < discriminateLow || variationValue > discriminateHigh)) 
    {
      variationValue = 0; // Discriminate for clouds by setting variation value to zero
    }
  #endif
  
  // http://www.daycounter.com/LabBook/Moving-Average.phtml
  
  #ifdef LED_OUTPUT // Output to LED shield
    lcd.setCursor(0, 1);
    lcd.print("Input:          ");
    lcd.setCursor(8, 1);
    lcd.print(intensityValue, 2);
    lcd.setCursor(0, 0);
    lcd.print("Seeing:         ");
    lcd.setCursor(8, 0);
    lcd.print(variationValue, 2);
  #endif
  
  #ifdef OLED_OUTPUT // Output to OLED module
    display.clearDisplay();             // Clear display
    display.setTextSize(1);
    display.setTextColor(WHITE);
    display.setCursor(0, 0);            // Draw seeing value
    display.print("Seeing: ");
    display.print(variationValue, 2);
    display.setCursor(0 , 8);           // Draw intensity value
    display.print("Input:  ");
    display.print(intensityValue, 2);
    
    #ifdef IG_WIDTH
      intensityBuffer[intensityOldest] = min(IG_HEIGHT, max(0, (int) round(intensityValue * IG_SCALE)));  // Buffer scaled and bounded intensity reading
      intensityOldest = (intensityOldest + 1) % IG_WIDTH;                                                 // Increment left hand of graph, wrap over at end of buffer
        
      // Draw intensity graph axes
      display.drawFastHLine(82, IG_HEIGHT, IG_WIDTH + 1, WHITE);              // X axis
      display.drawFastVLine(82, 0, IG_HEIGHT, WHITE);                         // Y axis
      display.drawFastHLine(80, IG_HEIGHT - (int) round(IG_SCALE), 2, WHITE); // Y axis "1" marker
      
      if (intensityValue > (IG_MAX))
      {
        display.setCursor(84, 0);
        display.print("HIGH");    // Print "HIGH" instead of graph
      }
      else if (intensityValue < 0)
      {
        display.setCursor(84, 0);
        display.print("LOW");     // Print "LOW" instead of graph
      }
      else
      {
        readingPosition = intensityOldest;                              // Start with the oldest intensity reading
        for (xPosition = 83; xPosition < (82 + IG_WIDTH); xPosition++)  // Plot intensity readings from left to right of graph
        {
          #ifdef SCATTER_PLOT
            display.drawPixel(xPosition, IG_HEIGHT - intensityBuffer[readingPosition], WHITE);                                        // Draw point
          #else
            display.drawFastVLine(xPosition, IG_HEIGHT - intensityBuffer[readingPosition], intensityBuffer[readingPosition], WHITE);  // Draw vertical bar
          #endif
          readingPosition = (readingPosition + 1) % IG_WIDTH;                                                                         // Move to next reading, wrap over at end of buffer
        }
      }
      
      #ifdef DEBUG_SSM // Test Intensity graph plot area limits
        display.drawLine(83, IG_HEIGHT - min(IG_HEIGHT, max(0, (int) round(IG_MAX * IG_SCALE))), (82 + IG_WIDTH), min(IG_HEIGHT, max(0, (int) round(IG_MAX * IG_SCALE))), INVERSE);  // Top left -> bottom right
        Serial.print("IG Top Left X: ");
        Serial.println(83);
        Serial.print("IG Top Left Y: ");
        Serial.println(IG_HEIGHT - min(IG_HEIGHT, max(0, (int) round(IG_MAX * IG_SCALE))));
        Serial.print("IG Bottom Right X: ");
        Serial.println((82 + IG_WIDTH));
        Serial.print("IG Bottom Right Y: ");
        Serial.println(min(IG_HEIGHT, max(0, (int) round(IG_MAX * IG_SCALE))));
      #endif
    #endif
    
    #ifdef VG_WIDTH
      variationBuffer[variationOldest] = min(VG_HEIGHT, max(0, (int) round(variationValue * VG_SCALE)));  // Buffer scaled and bounded variation reading
      variationOldest = (variationOldest + 1) % VG_WIDTH;                                                     // Increment left hand of graph, wrap over at end of buffer
      
      // Draw variation graph axes
      display.drawFastHLine(3, VG_HEIGHT + 18, VG_WIDTH + 1, WHITE); // X axis
      display.drawFastVLine(3, 17, VG_HEIGHT + 1, WHITE);            // Y axis
      #ifdef MOVING_AVERAGE_PTS
        if (movingAverageCount = movingAveragePts)
        {
          display.drawFastHLine(0, min(VG_HEIGHT, max(0, (int) round(movingAverage * VG_SCALE))) + 17, 2, WHITE); // Moving average marker
        }
      #endif
      
      // Plot variation graph
      readingPosition = variationOldest;                            // Start with the oldest variation reading
      for (xPosition = 3; xPosition < (2 + VG_WIDTH); xPosition++)  // Plot variation readings from left to right of graph
      {
        #ifdef SCATTER_PLOT
          display.drawPixel(xPosition, VG_HEIGHT - variationBuffer[readingPosition] + 17, WHITE); // Draw point
        #else
          display.drawFastVLine(xPosition, VG_HEIGHT - variationBuffer[readingPosition] + 17, variationBuffer[readingPosition], WHITE); // Draw vertical bar
        #endif
        readingPosition = (readingPosition + 1) % VG_WIDTH;                                                                                 // Move to next reading, wrap over at end of buffer
      }
    #endif
    
    #ifdef DEBUG_SSM // Test Variation graph plot area limits
      display.drawLine(3, VG_HEIGHT - min(VG_HEIGHT, max(0, (int) round(VG_MAX * VG_SCALE))) + 17, (2 + VG_WIDTH), min(VG_HEIGHT, max(0, (int) round(VG_MAX * VG_SCALE))) + 17, INVERSE);  // Top left -> bottom right
      Serial.print("VG Top Left X: ");
      Serial.println(3);
      Serial.print("VG Top Left Y: ");
      Serial.println(VG_HEIGHT - min(VG_HEIGHT, max(0, (int) round(VG_MAX * VG_SCALE))) + 17);
      Serial.print("VG Bottom Right X: ");
      Serial.println((2 + VG_WIDTH));
      Serial.print("VG Bottom Right Y: ");
      Serial.println(max(0, (int) round(VG_MAX * VG_SCALE)) + 17);
    #endif

    display.display();  // Show results
  #endif
  
  #ifdef MODE // Output to serial port in desired mode
    switch(mode)
    {
      case 1 :  // Basic text output
        Serial.print("Intensity: ");
        Serial.println(intensityValue, 2);
        Serial.print("Variation: ");
        Serial.println(variationValue, 2);
        break;
      
      case 2 :  // Firecapture addin compatible
        Serial.print("A0: ");
        Serial.println(intensityValue, 2);
        Serial.print("A1: ");
        Serial.println(variationValue, 2);
        break;
  
      case 3 :  // FIXME: Bidirectional comms, need to read commands and send data
        Serial.println("Mode 3 not implemented yet!");
        break;
      
      default : // Incorrect mode set
        Serial.println("Invalid output mode selected!");
    }
  #endif
}

 

[ced06480 0]

maintenant concernant les liaison avec le PC il n'y a qua le plugin de firecapture en version 2.6 qui reçois les d'infos. 

les autres soft PC ne donne rien en terme de connections, est ce que vous auriez le lien de votre soft SSM que je le test sur mon montage.

j'ai effectuer 3 montage différents pour contrôler les compatibilités : 

1 nano Arduino officiel

2 pro micro Aliexpresse

3 en cour de montage un NAN avec écran intégré

 

mais le résultat est le même que FC v2.6 fonction

[RichardC 503]

Bonjour Cédric,

 

Le 31/07/2024 à 17:14, ced06480 a dit :

merci pour les explication. en se moment j'utilise le sketch suivant qui fonction avec les ecran IIC sans modification.

 

Déjà le sketch que vos avez est buggé :

 

Dans le IF il est fait une affectation au lieu d'un test, erreur courante de lapin de 3 semaines :

 #ifdef MOVING_AVERAGE_PTS
    movingAverageAcc = movingAverageAcc + variationValue;   // Add the current variation to the moving average accumulator
    if (movingAverageCount = movingAveragePts)
    {
      movingAverageAcc = movingAverageAcc - movingAverage;  // Deduct the previous moving average from the accumulator
      movingAverage = movingAverageAcc / movingAveragePts;  // Calculate the new moving average
    }
    else
    {
      movingAverageCount++;                                 // Not enough data points yet, so keep accumulating
    }
  #endif

Ca met movingAveragePts dans movingAverageCount et ça teste vrai si c'est différent de  0... donc ça fait des choses, mais pas une moyenne !

 

Il faut plutôt remplacer par :

  if(movingAverageCount >= MOVING_AVERAGE_PTS)
  {
    movingAverageAcc = movingAverageAcc - movingAverage;  // Deduct the previous moving average from the accumulator
    movingAverage = movingAverageAcc / MOVING_AVERAGE_PTS;  // Calculate the new moving average
    movingAverageCount = 0;
  }
  else
  {
    movingAverageCount++;                                 // Not enough data points yet, so keep accumulating
  }

 

Même ânerie à corriger 20 lignes en dessous :

 

Citation

#ifdef MOVING_AVERAGE_PTS
      if( 0 == movingAverageCount )
      {
        display.drawFastHLine(0, min(VG_HEIGHT, max(0, (int) round(movingAverage * VG_SCALE))) + 17, 2, WHITE); // Moving average marker
      }
#endif // MOVING_AVERAGE_PTS

 

Richard

[RichardC 503]

Le 31/07/2024 à 17:20, ced06480 a dit :

est ce que vous auriez le lien de votre soft SSM que je le test sur mon montage.

Je me suis aperçu que je n'arrivai pas à retrouver avec certitude quel code j'ai programmé dans le SSM... la honte... !

Trop content que ça soit tombé en marche... j'ai oublié de finaliser ça proprement et je m'en sert tel quel depuis !

 

Par contre pour l'interface Windows, c'est plus propre, sauf que j'avais prévu de publier un git avec mes améliorations, mais ça n'a pas pas encore fait.

 

Je vous envoie des binaires pour tester par MP.

Richard

Edited August 1 by RichardC

[ced06480 0]

Je vous remercie de vos corrections, je débute complètement en arduino. Je sais faire des sketch simples mais la c est un tout autre niveau.

 

Malheureusement toujours pas de connexion au soft Windows mais toujours fonctionnel avec FC v2.6...

 

C est assez bizarre. Je vais essayer avec un Uno r3 voir si la communication fonctionne.