Davide Cogliati
Published © GPL3+

Hive IA control of Honey Bee for person with disability

I am working with Hives with honey bees and would be wonderful if this is accessible to person with disabilites making them free to join.

IntermediateWork in progress3 hours77
Hive IA control of Honey Bee for person with disability

Things used in this project

Story

Read more

Custom parts and enclosures

ABSTRACT ON THE WORK

What has driven my choice for this model.

BEES MAY HELP, CONCLUSIONS AND DATA RELEVANCE

Willness of the project, how to understand the data collected?

TESTING THE MODEL WITH BEES SOUND FROM HIVE (REAL SOUND)

This sound taken from recorded video on UTUBE is a general accessible resource for who wants to test the training of the model.

TESTING THE MODEL VERSUS ROCK - CLASSICAL MUSIC, HOW IT WORK?

This test iwas made to see how it works on music, I choosed two extremes of the type from ROCK to CLASSICAL.

TXT OR GRAPHICAL OUTPUT, LEGENDA

This sheet explains how to see directly the results of sound been passed trough the model, two formats: TEXT or GRAPHICAL.

HARDWARE USED AND 3D PRINTING SOME PARTS

Some parts are printed to put the sensor and the Arduino hardware, next the OBJ for printing are put in the documentation.

OBJ FILE FOR 3D PRINTING OF SENSOR BOX

Print this in 3D to put your sensor inside the hive or near it.

OBJ FILE FOR 3D PRINTING OF SENSOR BOX, COVER TO CLOSE IT

This is the cover to close the box.

ARDUINO ENCLOSURE, MAIN BOX

Put the Arduino or the Blues hardware in this box to protect it.

ARDUINO COVER BOX

This part to close the box, it has a hole for the buzzer-alarm output and for the blue led.

Schematics

HARDWARE SCHEMATICS USED TO TEST THE MODEL

This hardware is used to test the code and how it works during training of the model.

Code

Bees may help to get in farming

Arduino
This software is kept easy to be a first step in monitoring and growing honey bees achievable for people with disability without doing heavy activity on the hives, moving, opening, dressing up with protection.
//--------------------------------------------------------------
//------------- BEES MAYHELP   ---------------------------------
//--------------------------------------------------------------
//Project by: Davide Cogliati for the Build2together  challenge
//            edition for Nov-2023
//
//
//revision: 1.0  November 2023
//--------------------------------------------------------------
//
//Abstract:
//-------------
//This software was think to model the sound from bees in a hive
//in order to get information on strenght, health, problems in the hive
//and activity level (depending on the season of the year).
//Many observations were made on the field before coding this model in order
//to match the most real behaviour of honey  bees. 
//This modeling can permit to disable people to assist and follow a bee farming
//acitvity avoiding heavy work on the field on the hives, actually necessary due
//to the lack in a tool as the one I tought in this project.
//I hope can be used and make possible to averybody to approach fully free from
//restrictions a farming activity.
//Of course someone helping for fatigue job is necessary but the most is done
//just sitting down by a computer or laptop or similar.
//
//This work will be sharpened  using Blues card technology as a second step
//and I hope in a real interest in my research so I can evolve in a greater
//work soon.
//
//----------------------------------------
//HARDWARE PINS: assigned to ARDUINO UNO
//----------------------------------------
#define SOUND_PIN A0 
#define LED_alarm_high 9       
#define DIGITAL_SOUND 6    //input for digital out from sensor to measure frequency of sound (not used!)
#define BUZZER_alarm  7
#define LED_alarm     8
//-----------------------------------------
//WORKING PARAMETERS FOR AI IMPLEMENTATION
//-----------------------------------------
#define THRESHOLD 300          //not used  yet parameter!
#define SOUND_SAMPLING 200     //time between sampling SOUND LEVEL, works on delay() instruction.
#define ALARM_EVENT_1 50 //20  //TRESHOLD FOR ALARM EVENT ON BEES BEHAVIOUR
#define ALARM_EVENT_HIGH 100   //TRESHOLD FOR HIGHER GRADE ALARM - can be modified based on experience on the field
#define ALARM_PEAK_time  50    //number of ALARM PEAKS collected in a CONSTANT elapse of time...30= 30 seconds
#define AVERAGE_SAMPLES_GET 10 // processed samples to get a running average on sound samples
#define STORE_TIME  24         //stores in internal memory every x_Hours, if 24= 24 hours (1 time a day)
                               //data stored are:
                               //
                               //1-average level of sound
                               //2-max.peak of sound recorded in x_Hours
                               //3-Alarm events
                               //4-max. average activity
                               //
                               //

#define GRAPH 1   //0= MONITOR MODE-TEXT   1= GRAPHICAL X-Y MODE
//----------------------------------------- 
unsigned long timestamp = 0;
 
void setup(){
  pinMode(SOUND_PIN, INPUT);
  pinMode(LED_alarm_high, OUTPUT);
  pinMode(LED_alarm, OUTPUT);
  pinMode(BUZZER_alarm, OUTPUT);
  pinMode(DIGITAL_SOUND,INPUT);
  Serial.begin(9600);           //  setup serial
}
 
void loop()
{

  //--------------------------------
  //program variables initialize
  //--------------------------------
  int sound_LEVEL = 0;
  int freq=0;
  int Average=0;
  int samples=0;
  int Average_AV=0;
  int sub_AV=0;
  int sound_Level_2 =0;
  int sound_Level_1 =0;
  int Grad=0;
  int toggle=0;
  int Average_1=0;
  int Average_2=0;
  int Grad_AV=0;
  int Points=0;          //points measure collected
  int Global_average=0;  //the global average of many points collected
  int Ref_zero =0;       //the zero sound value reference
  int Acty_mean=0;        //the mean value activity going on
  int   Acty_sum=0;         //summing value for activity
  int val=0;              //general use!
  int Points_acty=0;      //points to evaluate activuty figure
  int Peak_activity=0;    //peak value in activity evaluation, single point evalued
  int val_before=0;      //value before latest to clamp the max. value acitvity
  int val_max=0;         //peak value for activity
  int Activity_ratio=0;  //the ratio between peak level and average activity level
  int Alarm_flag=0;      //flag for ALARM_1 threshold
  int Alarm_time=0;      //time to plot the Alarm-Alert trace
  int Peak_timer=0;      //time to collect the number of ALARMS peaks (warning on bees!)
  int Peaks_alarm=0;     //number of peaks collected in one window of Peak_timer = ALARM_PEAK_time .
  int Plot_n_alarms=0;   //the number to plot or readable  data out of the collected alarms
  int Graph_val_max=0;   //max value interpolation on graph
  unsigned long Sec_milli=0; //used by internal timer for save data
  unsigned  long Milli_1=0;  //used for time
  unsigned long  Milli_2=0;  //used fo time
  int Period_alrs_HIGHER=0;  //higher grade alarms during period
  //-------------------------------------------
  //time function FOR SAVING PERIODICALLY DATA
  //-------------------------------------------
  int seconds = 0;
  int minutes = 0;
  int hours = 0;
  int days=0;
  //------------------------------------------
  //SAVED DATA VARIABLES
  //------------------------------------------
 //1-average level of sound
 //2-max.peak of sound recorded in x_Hours
 //3-Alarm events
 //4-max. average activity
 //------------------------------------------
 int Period_ave_sound_min=10000;
 int Period_ave_sound_max=0;
 int Period_peak_sound=0;
 int Period_alrs=0;
 int Period_max_acty=0;                  
  //--------------------------------------
  //GRAPH LAYOUT SCREEN
  //--------------------------------------
    if(GRAPH) 
           {    
            Serial.print("sound");
            Serial.print(" ");
         
            Serial.print("Aver");
            Serial.print(" ");
           
           Serial.print("Acti_ratio");
           Serial.print(" ");
           Serial.print("Max_acti");
           Serial.print(" ");
           Serial.print("Ref");
           Serial.print(" ");
          
             Serial.print("Acty_mean");
             Serial.print(" ");
          
             Serial.print("Alert");
             Serial.print(" ");
          
             Serial.print("nAlarms");
             Serial.print(" ");
          
             Serial.print("Valmax");
             //Serial.print(" ");
             //
             //Serial.print("Sec");  //could also print seconds elapsed, not used now
             Serial.println();
         }
 //--------------------------------------------------------
 //SET POINT FOR HARDWARE SOUND ELECTRONIC AMPLIFIER STAGE
 //--------------------------------------------------------

  for(Points=1; Points <11; Points++)
    {
     sound_LEVEL = analogRead(SOUND_PIN);   //READ SOUND SENSOR INPUT - ANALOG MEASURE
     Average = (Average +  sound_LEVEL );   //adding for average
     delay(10);                             //waiting before next measure

    }
  Average = Average/10;   //divide 10 because 10 measures are taken
  Ref_zero = Average;     //assign ref. point
  Average =0;
  Points =0;           
  //----------------------------------------
  //ENDLESS LOOP WITH PROGRAM RUNNING
  //----------------------------------------
  while(1)
  {
   
   Points = Points +1;                  //increment count of points
   Points_acty= Points_acty +1;
   sound_LEVEL = analogRead(SOUND_PIN); //READ SOUND SENSOR INPUT - ANALOG MEASURE
   
   sound_Level_1 = sound_LEVEL;         //first value for gradient calculus



   
   //--------------------------------------
 if(1) //always true, main loop
 {
   //--------------------------------------
   //TIME - DATE counter
   //--------------------------------------

   Milli_2 = millis() / 1000;
   Sec_milli = Milli_2 - Milli_1;
   Milli_1 = Milli_2;
   if (Sec_milli ==1)
   {
    seconds = seconds +1;
    
     if(seconds ==60)
       {
       minutes = minutes +1;
       seconds=0;
       }
     if (minutes == 60)
        {
       hours = hours +1;
       minutes =0;
        }
     if (hours == 24)
        {
      days = days +1;
      hours =0;
        }
    Sec_milli=0;
   } 
   //---------------------------------------
   //SAVE DATA AT ESTABLISHED TIME ELAPSED
   //--------------------------------------
   if(hours == STORE_TIME)
    {
       //--------------------------------------------------------
       //get storage address memory adr.0 of I2C
       //or apply a SD shield to Arduino to store Giga of data
       //-------------------------------------------------------


      //----------------------------------------------------------------------------
      //STORE data:
      //-------------
      //these data can be modified to save more variables for a more complete view
      //of the hive
      //----------------------------------------------------------------------------
             //1-average level of sound
             //2-max.peak of sound recorded in x_Hours
             //3-Alarm events
             //4-max. average activity
      //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       

      //--------------------------------
      //store NEW updated next address 
      //--------------------------------

    //--------------------------------------
    //print data on serial
    //--------------------------------------
    Serial.println("========================================");
    Serial.println("DATA RECORDED IN ONE PERIOD OF TIME");
    Serial.println("========================================");
    Serial.println("Peak value of record time");
    Serial.println(Period_peak_sound);
    Serial.println("Average sound  max value");
    Serial.println(Period_ave_sound_max);
    Serial.println("Average sound min value");
    Serial.println(Period_ave_sound_min);
    Serial.println("Number of alarms each period");
    Serial.println(Period_alrs);
    Serial.println("Peak value of activity");
    Serial.println(Period_max_acty);
    Serial.println("Number of HIGHER GRADE alarms each period");
    Serial.println(Period_alrs_HIGHER);
    Serial.println("****************************************");
    Serial.println("******** END DATA **********************");
    Serial.println("****************************************");
    //--------------------------------------

    //-------------
    //reset DATA
    //-------------
    seconds = 0;
    minutes = 0;
    hours = 0;
    Period_peak_sound=0;
    Period_ave_sound_max=0;
    Period_ave_sound_min =10000; //arbitrary high value to get the minimum
    Period_alrs=0;
    Period_alrs_HIGHER=0;
    Period_max_acty=0;    
    }
   //--------------------------------------   
   samples= samples +1;                   //SAMPLES are incrementing +1
   Average = (Average +  sound_LEVEL );   //adding for average
   
   if(sound_LEVEL > Ref_zero)   //COLLECT ONLY Sounds greater than REFERENCE-zero level of audio equipment
   {
    val = sound_LEVEL - Ref_zero;  //the useful SOUND signal
 
   //}
    //---------------------------------------
    //SEARCH FOR MAX VALUE: clamping process
    //---------------------------------------
    if (val > val_before)
    {
     val_max = val;   //clamp the peak!

     //--------------------------------------
     //GRAPH interpolation for MAX value
     //--------------------------------------
     if (val_max > 0)           //accept only values greater than zero, val_max is put =0 at every data collection sampled!
       {
       Graph_val_max = val_max;
       if (val_max >Period_peak_sound) //clamp max. value for the period data sampling
          Period_peak_sound=val_max;   //DATA STORED <==================================>
       }
    }  
     //--------------------------------------
    Acty_sum= Acty_sum + val;  //adding up "val" for the AVERAGE PEAK MAX. VALUE
    val_before = val;          //saved as formerly value
   } 
   //---------------------------------------------------------------------------------
   //---------------------------------------------------------------------------------
   if(samples == AVERAGE_SAMPLES_GET)  //number of samples to count for the local mean
   {
    Average_AV = (Average  )/ samples; //calculate average value
     //----------------------------------------------------
     //AVERAGE VALUE FOR STORE PERIOD
     //-----------------------------------------------------
     if(Period_ave_sound_min > Average_AV)
         Period_ave_sound_min= Average_AV;  //clamp the minimum
     if(Average_AV > Period_ave_sound_max )
         Period_ave_sound_max= Average_AV;  //clamp the maximum
    //  Period_ave_soundmin/max      // DATA STORED <==============================> 
    //
    //------------------------------------------------------
    samples=0;      //reset samples count
    Average =0;     //reset mean value to zero
    toggle  = toggle +1;
     if (toggle ==2)
      toggle =0;
     if (toggle==0)  
      Average_1= Average_AV;
     if (toggle==1)
      Average_2= Average_AV;
   }  
   sound_LEVEL = analogRead(SOUND_PIN); //READ SOUND SENSOR INPUT - ANALOG MEASURE
   //-----------------------------------------------------------------------------
   
   sound_Level_2 = sound_LEVEL;         //second value for gradient calculus
   Grad = ((sound_Level_2) - (sound_Level_1))/0.1;
   Grad_AV = (( Average_2) - ( Average_1))/0.1;

   if(Points_acty == 10) //Average for activity level  
   {
       Acty_mean = (Acty_sum/ Points_acty);//*10;  // x 10 amplified 

      //-------------------------------
      //useful signal
      //-------------------------------
      if(Acty_mean >2) 
      {
      //TRESHOLD VALUE TO AVOID NOISE ON ELECTRONICS AMPLIFIER!
          Activity_ratio = ((val_max )/(Acty_mean))*10; //Amplify value x 10
          if (Acty_mean > Period_max_acty)
             Period_max_acty= Acty_mean;   //clamp for the peak activity value in the period
       }                                   //DATA STORED <================================>
      //--------------------------------
      //NOT useful signal, cut off noise
      //---------------------------------  
      if(Acty_mean <= 2)  //TRESHOLD VALUE TO AVOID NOISE ON ELECTRONICS AMPLIFIER!
          Activity_ratio = 0;  
       
      Points_acty=0;  //reset data collection
      Acty_sum= 0;
      val_before=0;
      val_max=0;
      Alarm_time=0;
     
      
    }

     //-------------------------------------------------------------
     //LOOKS FOR ALARM_EVENT, high localized activity from sound
     //-------------------------------------------------------------
  if (Alarm_flag  < 100)
       {
       digitalWrite(BUZZER_alarm,LOW);
       digitalWrite(LED_alarm,LOW);
       digitalWrite(LED_alarm_high,LOW);
       } 
     
  if ((Activity_ratio > ALARM_EVENT_1)& (Alarm_time < 2))  // <2 determines the amplitude of the visible peak on graph (a rectangular shape!)
      {
       Alarm_flag = 300 ;                   //show a peak on the graph, ALARM_1 signal height=300
       Peaks_alarm=  Peaks_alarm +1;        //increment +1 alarm peaks
       
       digitalWrite(BUZZER_alarm,HIGH);
       digitalWrite(LED_alarm,HIGH);
       
       Period_alrs = Period_alrs+1;         //clamp the adding of the alarms in the storing time interval
                                            //DATA STORED <=====================================>
      } 
  if ((Activity_ratio > ALARM_EVENT_HIGH)& (Alarm_time < 2))  // <2 determine the amplitude of the visible peak on graph (a rectangular shape!)
      {
       Alarm_flag = 600 ;                   //show a peak on the graph, ALARM_1 signal height=600

       digitalWrite(BUZZER_alarm,HIGH);
       digitalWrite(LED_alarm,HIGH);
       digitalWrite(LED_alarm_high,HIGH);
       
       Peaks_alarm=  Peaks_alarm +1;        //increment +1 alarm peaks
       Period_alrs_HIGHER= Period_alrs_HIGHER+1;           //clamp the adding of the alarms in the storing time interval
                                            //DATA STORED <=====================================>
      }      
   Alarm_time = Alarm_time +1;    //time show window for the ALARM peak
   
  if (Alarm_time > 2)         //sets to zero the signal peak, just squared out.
    Alarm_flag = 0 ;  
    
   Peak_timer = Peak_timer + 1;   //increment the time for collecting number of alarms in the "ALARM_PEAK_time" window
   if (Peak_timer > ALARM_PEAK_time)
      {
      Plot_n_alarms=  Peaks_alarm*10; //amplify x 10
      Peaks_alarm=0;
      Peak_timer =0;
      }
  
 
 }  
   freq= digitalRead(DIGITAL_SOUND);
  // Serial.print(sound_LEVEL);//,DEC);          // debug value
  // Serial.print(" ");
  // Serial.print(freq)*700;
  // Serial.print(" ");
  // Serial.print(Average_AV);
  // Serial.print(" ");
   //---------------------------------------------------
   //GRADIENT evaluation of signal intensity variation
   //not used in this model but maybe in the next time
   //---------------------------------------------------
   if (Points > 10)               //starting average gradients after 3 points to load sufficient data
   { 
  
  // Serial.print(Grad);
  // Serial.print(" ");
  // Serial.print(Grad_AV);
  // Serial.print(" ");
  
  
   } 

   //---------------------------------------------
   //OUTPUT ON SCREEN
   //---------------------------------------------
     //--------------------------------------
    //print data on serial
    //--------------------------------------
   if(!GRAPH) 
    {
    Serial.println("=========================================");  
    Serial.println("DAYS -- HOURS -- MINUTES -- SECONDS "); 
    Serial.print(days); Serial.print(" -- "); Serial.print(hours); Serial.print(" -- "); Serial.print(minutes); Serial.print(" -- "); Serial.print(seconds);
    Serial.println("-----------------------------------------");  
    Serial.println("Reference level of sound");
    Serial.println(Ref_zero);
    Serial.println("Level of sound");
    Serial.println(sound_LEVEL - Ref_zero);
    Serial.println("Peak value of record time");
    Serial.println(Period_peak_sound);
    Serial.println("Average sound max value");
    Serial.println(Period_ave_sound_max);
    Serial.println("Average sound min value");
    Serial.println(Period_ave_sound_min);
    Serial.println("Number of alarms each period");
    Serial.println(Period_alrs);
    Serial.println("Peak value of activity");
    Serial.println(Period_max_acty);
    Serial.println("Number of HIGHER GRADE alarms each period");
    Serial.println(Period_alrs_HIGHER);
    Serial.println("========================================"); 
   } 
    //--------------------------------------
   if(GRAPH) 
   {  
   Serial.print(sound_LEVEL);
   Serial.print(" ");       
   Serial.print(Average_AV);
   Serial.print(" ");    
   Serial.print(Activity_ratio);
   Serial.print(" ");
   Serial.print(val_max);
   Serial.print(" ");
   Serial.print(Ref_zero);
   Serial.print(" ");
   Serial.print(Acty_mean);
   Serial.print(" ");
   Serial.print(Alarm_flag);
   Serial.print(" ");
   Serial.print(Plot_n_alarms);
   Serial.print(" ");
   Serial.print(Graph_val_max);
   //Serial.print(" ");
   //Serial.print(seconds);        //can also print/plot seconds elapsed...
   Serial.println();
 }
  
  delay(SOUND_SAMPLING);
  }
}

Credits

Davide Cogliati

Davide Cogliati

8 projects • 8 followers
I develop electronic boards for customers and final 3D products.

Comments