ottt机器人代码

最新推荐文章于 2024-08-15 14:50:24 发布
最新推荐文章于 2024-08-15 14:50:24 发布
阅读量103 收藏
点赞数
文章标签： 机器人
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74352539/article/details/133980103
版权 
//  OTTO WITH ARMS
//----------------------------------------------------------------
//-- Zowi basic firmware v2 adapted to Otto
//-- (c) BQ. Released under a GPL licencse
//-- 04 December 2015
//-- Original Authors:  Anita de Prado: ana.deprado@bq.com
//--           Jose Alberca:   jose.alberca@bq.com
//--           Javier Isabel:  javier.isabel@bq.com
//--           Juan Gonzalez (obijuan): juan.gonzalez@bq.com
//--           Irene Sanz : irene.sanz@bq.com
//-----------------------------------------------------------------
//-- Jason Snow
//-- AUGUST 2018: modified for OTTO ARMS
//-- Jason Snow
//-----------------------------------------------------------------


#include <BatReader.h>
#include <US.h>
#include "MaxMatrix.h"
MaxMatrix ledmatrix=MaxMatrix(12,10,11, 1); //PIN  12=DIN, PIN 10=CS, PIN 11=CLK

//-- Library to manage serial commands
#include <OttoSerialCommand.h>
OttoSerialCommand SCmd;  //The SerialCommand object

//-- Otto Library
#include <OttoARM.h>
Otto Otto;  //This is Otto!
 
//---------------------------------------------------------
//-- First step: Configure the pins where the servos are attached
/*
         --------------- 
        |     O   O     |
        |---------------|
RA 7==> |               | <== LA 6
        |               |
LR 3==> |               | <== LL 2
         --------------- 
            ||     ||
            ||     ||
FR 5==>   -----   ------  <== FL 4
         |-----   ------|
*/

 // #define PIN_YL 2 //servo[0]
  //#define PIN_YR 3 //servo[1]
  //#define PIN_RL 4 //servo[2]
  //#define PIN_RR 5 //servo[3]
  //#define PIN_LA 6 //servo[4]
  //#define PIN_RA 7 //servo[5]

// buzzer connected to pin 13

///
//-- Global Variables -------------------------------------------//
///

const char programID[]="ARM2"; //Each program will have a ID


//-- Movement parameters
int T=1000;              //Initial duration of movement
int moveId=0;            //Number of movement
int modeId=0;            //Number of mode
int moveSize=15;         //Asociated with the height of some movements

//---------------------------------------------------------
//-- Otto has 5 modes:
//--    * MODE = 0: Otto is awaiting  
//--    * MODE = 1: Dancing mode!  
//--    * MODE = 2: Obstacle detector mode  
//--    * MODE = 3: Noise detector mode   
//--    * MODE = 4: OttoPAD or any Teleoperation mode (listening SerialPort). 
//---------------------------------------------------------
volatile int MODE=3; //State of Otto in the principal state machine. 

unsigned long previousMillis=0;

int randomDance=0;
int randomSteps=0;

bool obstacleDetected = false;

///
//-- Setup ------------------------------------------------------//
///
void setup(){
  //Serial communication initialization
  Serial.begin(9600);  
  //Set the servo pins
  Otto.init(2,3,4,5,6,7,true);
  // set up Matrix display
  ledmatrix.init();
  ledmatrix.setIntensity(1);
  //Set a random seed
  randomSeed(analogRead(A6));
  //Setup callbacks for SerialCommand commands 
  SCmd.addCommand("S", receiveStop);      //  sendAck & sendFinalAck
  SCmd.addCommand("L", receiveLED);       //  sendAck & sendFinalAck
  SCmd.addCommand("M", receiveMovement);  //  sendAck & sendFinalAck
  SCmd.addCommand("H", receiveGesture);   //  sendAck & sendFinalAck
  SCmd.addCommand("K", receiveSing);      //  sendAck & sendFinalAck
  SCmd.addCommand("C", receiveTrims);     //  sendAck & sendFinalAck
  SCmd.addCommand("G", receiveServo);     //  sendAck & sendFinalAck
  SCmd.addCommand("D", requestDistance);
  SCmd.addCommand("N", requestNoise);
  SCmd.addCommand("B", requestBattery);   // 
  SCmd.addCommand("I", requestProgramId);
  SCmd.addCommand("J", requestMode);
  SCmd.addDefaultHandler(receiveStop);
  Otto.sing(S_connection);
  Otto.home();
 // Animation - A little moment of initial surprise
 //-----
  for(int i=0; i<2; i++){
      for (int i=0;i<4;i++){  
        Otto.putAnimationMouth(dreamMouth,i);
        delay(150);
      }
  }
  //Smile for a happy Otto :)
    Otto.putMouth(smile);
    Otto.sing(S_happy);
    delay(200);

  Otto.putMouth(happyOpen);
  //Otto.putMouth(xMouth);    //test
  previousMillis = millis();
  Otto.home();

}
///
//-- Principal Loop ---------------------------------------------//
///
void loop() {
  if (Serial.available()>0 && MODE!=4){
  // test
    SCmd.readSerial();
    //MODE=4;
    Otto.putMouth(happyOpen);
  }
  switch (MODE) {

      //-- MODE 0 - Otto is awaiting
      //---------------------------------------------------------
      case 0:
      
        //Every 80 seconds in this mode, Otto falls asleep 
        if (millis()-previousMillis>=80000){
            OttoSleeping_withInterrupts(); //ZZzzzzz...
            previousMillis=millis();         
        }

        break;
      
      //-- MODE 1 - Dance Mode!
      //---------------------------------------------------------
      case 1:
        
        randomDance=random(5,23); //5,20
        if((randomDance>14)&&(randomDance<19)){
            randomSteps=1;
            T=1600;
        }
        else{
            randomSteps=random(3,6); //3,5
            T=1000;
        }
        
        Otto.putMouth(random(10,21));

        for (int i=0;i<randomSteps;i++){
            move(randomDance);
            
        }
        break;

      //-- MODE 2 - Obstacle detector mode
      //---------------------------------------------------------
      case 2:

        if(obstacleDetected){
              Otto.putMouth(bigSurprise);
              Otto.sing(S_surprise);
              Otto.jump(5, 500);
              Otto.putMouth(confused);
              Otto.sing(S_cuddly);
            //Otto takes two steps back
            for(int i=0;i<3;i++){ 
            
              Otto.walk(1,1300,-1);
            }

            delay(100);
            obstacleDetector();
            delay(100);
           //If there are no obstacles and no button is pressed, Otto shows a smile
           if(obstacleDetected==true){break;}            
           else{
              Otto.putMouth(smile);
              delay(50);
              obstacleDetector();
           } 
           
           //If there are no obstacles and no button is pressed, Otto shows turns left
           for(int i=0; i<3; i++){
              if(obstacleDetected==true){break;}            
              else{ 
                  Otto.turn(1,1000,1); 
                  obstacleDetector();
              } 
           }
            
            //If there are no obstacles and no button is pressed, Otto is happy
            if(obstacleDetected==true){break;}           
            else{
                Otto.home();
                Otto.putMouth(happyOpen);
                Otto.sing(S_happy_short);
                delay(200);
            }     
        
        }else{

            Otto.walk(1,1000,1); //Otto walk straight
            obstacleDetector();
        }   

        break;

      //-- MODE 3 - Noise detector mode
      //---------------------------------------------------------  
      case 3:
        if (Otto.getNoise()>=650){ //740
          
          delay(50);  //Wait for the possible 'lag' of the button interruptions. 
                      //Sometimes, the noise sensor detect the button before the interruption takes efect 
 
            Otto.putMouth(bigSurprise);
            Otto.sing(S_OhOoh);
            Otto.putMouth(random(10,21));
            randomDance=random(5,21);
            move(randomDance);
            Otto.home();
            delay(500); //Wait for possible noise of the servos while get home
            Otto.putMouth(happyOpen);
        }
        break;
        
      //-- MODE 4 - OttoPAD or any Teleoperation mode (listening SerialPort) 
      //---------------------------------------------------------
      case 4:

        SCmd.readSerial();
        
        //If Otto is moving yet
        if (Otto.getRestState()==false){  
          move(moveId);
        }
      
        break;      

      default:
          MODE=0;
          break;
    }
}  

///
//-- Functions --------------------------------------------------//
///

//-- Function to read distance sensor & to actualize obstacleDetected variable
void obstacleDetector(){

   int distance = Otto.getDistance();

        if(distance<15){
          obstacleDetected = true;
        }else{
          obstacleDetected = false;
        }
}

//-- Function to receive Stop command.
void receiveStop(){

    sendAck();
    Otto.home();
    sendFinalAck();

}

//-- Function to receive LED commands
void receiveLED(){  

    //sendAck & stop if necessary
    sendAck();
    Otto.home();

    //Examples of receiveLED Bluetooth commands
    //L 000000001000010100100011000000000
    //L 001111111111111111111111111111111 (todos los LED encendidos)
    unsigned long int matrix;
    char *arg;
    char *endstr;
    arg=SCmd.next();
    //Serial.println (arg);
    if (arg != NULL) {
      matrix=strtoul(arg,&endstr,2);    // Converts a char string to unsigned long integer
      Otto.putMouth(matrix,false);
    }else{
      Otto.putMouth(xMouth);
      delay(2000);
      Otto.clearMouth();
    }

    sendFinalAck();

}



//-- Function to receive TRims commands
void receiveTrims(){  

    //sendAck & stop if necessary
    sendAck();
    Otto.home(); 

    int trim_YL,trim_YR,trim_RL,trim_RR,trim_LA,trim_RA;

    //Definition of Servo Bluetooth command
    //C trim_YL trim_YR trim_RL trim_RR
    //Examples of receiveTrims Bluetooth commands
    //C 20 0 -8 3
    bool error = false;
    char *arg;
    arg=SCmd.next();
    if (arg != NULL) { trim_YL=atoi(arg); }    // Converts a char string to an integer   
    else {error=true;}

    arg = SCmd.next(); 
    if (arg != NULL) { trim_YR=atoi(arg); }    // Converts a char string to an integer  
    else {error=true;}

    arg = SCmd.next(); 
    if (arg != NULL) { trim_RL=atoi(arg); }    // Converts a char string to an integer  
    else {error=true;}

    arg = SCmd.next(); 
    if (arg != NULL) { trim_RR=atoi(arg); }    // Converts a char string to an integer  
    else {error=true;}

    arg = SCmd.next(); 
    if (arg != NULL) { trim_LA=atoi(arg); }    // Converts a char string to an integer  
    else {error=true;}
    
    arg = SCmd.next(); 
    if (arg != NULL) { trim_RA=atoi(arg); }    // Converts a char string to an integer  
    else {error=true;}
    
    if(error==true){

      Otto.putMouth(xMouth);
      delay(2000);
      Otto.clearMouth();

    }else{ //Save it on EEPROM
      Otto.setTrims(trim_YL, trim_YR, trim_RL, trim_RR, trim_LA, trim_RA);
      Otto.saveTrimsOnEEPROM(); //Uncomment this only for one upload when you finaly set the trims.
    } 

    sendFinalAck();

}


//-- Function to receive Servo commands
void receiveServo(){  

    sendAck(); 
    moveId = 30;

    //Definition of Servo Bluetooth command
    //G  servo_YL servo_YR servo_RL servo_RR 
    //Example of receiveServo Bluetooth commands
    //G 90 85 96 78 
    bool error = false;
    char *arg;
    int servo_YL,servo_YR,servo_RL,servo_RR,servo_LA,servo_RA;

    arg=SCmd.next();
    if (arg != NULL) { servo_YL=atoi(arg); }    // Converts a char string to an integer   
    else {error=true;}

    arg = SCmd.next(); 
    if (arg != NULL) { servo_YR=atoi(arg); }    // Converts a char string to an integer  
    else {error=true;}

    arg = SCmd.next(); 
    if (arg != NULL) { servo_RL=atoi(arg); }    // Converts a char string to an integer  
    else {error=true;}

    arg = SCmd.next(); 
    if (arg != NULL) { servo_RR=atoi(arg); }    // Converts a char string to an integer  
    else {error=true;}

    arg = SCmd.next(); 
    if (arg != NULL) { servo_LA=atoi(arg); }    // Converts a char string to an integer  
    else {error=true;}

    arg = SCmd.next(); 
    if (arg != NULL) { servo_RA=atoi(arg); }    // Converts a char string to an integer  
    else {error=true;}
    
    if(error==true){

      Otto.putMouth(xMouth);
      delay(2000);
      Otto.clearMouth();

    }else{ //Update Servo:

      int servoPos[6]={servo_YL, servo_YR, servo_RL, servo_RR, servo_LA, servo_RA}; 
      Otto._moveServos(200, servoPos);   //Move 200ms
      
    }

    sendFinalAck();

}


//-- Function to receive movement commands
void receiveMovement(){

    sendAck();

    if (Otto.getRestState()==true){
        Otto.setRestState(false);
    }

    //Definition of Movement Bluetooth commands
    //M  MoveID  T   MoveSize  
    char *arg; 
    arg = SCmd.next(); 
    if (arg != NULL) {moveId=atoi(arg);}
    else{
      Otto.putMouth(xMouth);
      delay(2000);
      Otto.clearMouth();
      moveId=0; //stop
    }
    
    arg = SCmd.next(); 
    if (arg != NULL) {T=atoi(arg);}
    else{
      T=1000;
    }

    arg = SCmd.next(); 
    if (arg != NULL) {moveSize=atoi(arg);}
    else{
      moveSize =15;
    }
}


//-- Function to execute the right movement according the movement command received.
void move(int moveId){

  bool manualMode = false;

  switch (moveId) {
    case 0:
      Otto.home();
      break;
    case 1: //M 1 1000 
      Otto.walk(1,T,1);
      break;
    case 2: //M 2 1000 
      Otto.walk(1,T,-1);
      break;
    case 3: //M 3 1000 
      Otto.turn(1,T,1);
      break;
    case 4: //M 4 1000 
      Otto.turn(1,T,-1);
      break;
    case 5: //M 5 1000 30 
      Otto.updown(1,T,moveSize);
      break;
    case 6: //M 6 1000 30
      Otto.moonwalker(1,T,moveSize,1);
      break;
    case 7: //M 7 1000 30
      Otto.moonwalker(1,T,moveSize,-1);
      break;
    case 8: //M 8 1000 30
      Otto.swing(1,T,moveSize);
      break;
    case 9: //M 9 1000 30 
      Otto.crusaito(1,T,moveSize,1);
      break;
    case 10: //M 10 1000 30 
      Otto.crusaito(1,T,moveSize,-1);
      break;
    case 11: //M 11 1000 
      Otto.jump(1,T);
      break;
    case 12: //M 12 1000 30 
      Otto.flapping(1,T,moveSize,1);
      break;
    case 13: //M 13 1000 30
      Otto.flapping(1,T,moveSize,-1);
      break;
    case 14: //M 14 1000 20
      Otto.tiptoeSwing(1,T,moveSize);
      break;
    case 15: //M 15 500 
      Otto.bend(1,T,1);
      break;
    case 16: //M 16 500 
      Otto.bend(1,T,-1);
      break;
    case 17: //M 17 500 
      Otto.shakeLeg(1,T,1);
      break;
    case 18: //M 18 500 
      Otto.shakeLeg(1,T,-1);
      break;
    case 19: //M 19 500 20
      Otto.jitter(1,T,moveSize);
      break;
    case 20: //M 20 500 15
      Otto.ascendingTurn(1,T,moveSize);
      break;
      case 21: //M 21
      Otto.handsup();
      break;
      case 22: //M 22 right arm
      Otto.handwave(1);
      break;
      case 23: //M 23 left arm
      Otto.handwave(-1);
      break;
    default:
        manualMode = true;
      break;
  }

  if(!manualMode){
    sendFinalAck();
  }
       
}


//-- Function to receive gesture commands
void receiveGesture(){

    //sendAck & stop if necessary
    sendAck();
    Otto.home(); 

    //Definition of Gesture Bluetooth commands
    //H  GestureID  
    int gesture = 0;
    char *arg; 
    arg = SCmd.next(); 
    if (arg != NULL) {gesture=atoi(arg);}
    else 
    {
      //Otto.putMouth(xMouth);
      delay(2000);
      //Otto.clearMouth();
    }

    switch (gesture) {
      case 1: //H 1 
        Otto.playGesture(OttoHappy);
        break;
      case 2: //H 2 
        Otto.playGesture(OttoSuperHappy);
        break;
      case 3: //H 3 
        Otto.playGesture(OttoSad);
        break;
      case 4: //H 4 
        Otto.playGesture(OttoSleeping);
        break;
      case 5: //H 5  
        Otto.playGesture(OttoFart);
        break;
      case 6: //H 6 
        Otto.playGesture(OttoConfused);
        break;
      case 7: //H 7 
        Otto.playGesture(OttoLove);
        break;
      case 8: //H 8 
        Otto.playGesture(OttoAngry);
        break;
      case 9: //H 9  
        Otto.playGesture(OttoFretful);
        break;
      case 10: //H 10
        Otto.playGesture(OttoMagic);
        break;  
      case 11: //H 11
        Otto.playGesture(OttoWave);
        break;   
      case 12: //H 12
        Otto.playGesture(OttoVictory);
        break; 
      case 13: //H 13
        Otto.playGesture(OttoFail);
        break;         
      default:
        break;
    }

    sendFinalAck();
}

//-- Function to receive sing commands
void receiveSing(){

    //sendAck & stop if necessary
    sendAck();
    Otto.home(); 

    //Definition of Sing Bluetooth commands
    //K  SingID    
    int sing = 0;
    char *arg; 
    arg = SCmd.next(); 
    if (arg != NULL) {sing=atoi(arg);}
    else 
    {
     // Otto.putMouth(xMouth);
      delay(2000);
      //Otto.clearMouth();
    }

    switch (sing) {
      case 1: //K 1 
        Otto.sing(S_connection);
        break;
      case 2: //K 2 
        Otto.sing(S_disconnection);
        break;
      case 3: //K 3 
        Otto.sing(S_surprise);
        break;
      case 4: //K 4 
        Otto.sing(S_OhOoh);
        break;
      case 5: //K 5  
        Otto.sing(S_OhOoh2);
        break;
      case 6: //K 6 
        Otto.sing(S_cuddly);
        break;
      case 7: //K 7 
        Otto.sing(S_sleeping);
        break;
      case 8: //K 8 
        Otto.sing(S_happy);
        break;
      case 9: //K 9  
        Otto.sing(S_superHappy);
        break;
      case 10: //K 10
        Otto.sing(S_happy_short);
        break;  
      case 11: //K 11
        Otto.sing(S_sad);
        break;   
      case 12: //K 12
        Otto.sing(S_confused);
        break; 
      case 13: //K 13
        Otto.sing(S_fart1);
        break;
      case 14: //K 14
        Otto.sing(S_fart2);
        break;
      case 15: //K 15
        Otto.sing(S_fart3);
        break;    
      case 16: //K 16
        Otto.sing(S_mode1);
        break; 
      case 17: //K 17
        Otto.sing(S_mode2);
        break; 
      case 18: //K 18
        Otto.sing(S_mode3);
        break;   
      case 19: //K 19
        Otto.sing(S_buttonPushed);
        break;                      
      default:
        break;
    }

    sendFinalAck();
}




//-- Function to send ultrasonic sensor measure (distance in "cm")
void requestDistance(){

    Otto.home();  //stop if necessary  

    int distance = Otto.getDistance();
    Serial.print(F("&&"));
    Serial.print(F("D "));
    Serial.print(distance);
    Serial.println(F("%%"));
    Serial.flush();
}


//-- Function to send noise sensor measure
void requestNoise(){

    Otto.home();  //stop if necessary

    int microphone= Otto.getNoise(); //analogRead(PIN_NoiseSensor);
    Serial.print(F("&&"));
    Serial.print(F("N "));
    Serial.print(microphone);
    Serial.println(F("%%"));
    Serial.flush();
}


//-- Function to send battery voltage percent
void requestBattery(){

    Otto.home();  //stop if necessary

    //The first read of the batery is often a wrong reading, so we will discard this value. 
    double batteryLevel = Otto.getBatteryLevel();

    Serial.print(F("&&"));
    Serial.print(F("B "));
    Serial.print(batteryLevel);
    Serial.println(F("%%"));
    Serial.flush();
}


//-- Function to send program ID
void requestProgramId(){

    Otto.home();   //stop if necessary

    Serial.print(F("&&"));
    Serial.print(F("I "));
    Serial.print(programID);
    Serial.println(F("%%"));
    Serial.flush();
}


//-- Function to send Ack comand (A)
void sendAck(){

  delay(30);

  Serial.print(F("&&"));
  Serial.print(F("A"));
  Serial.println(F("%%"));
  Serial.flush();
}


//-- Function to send final Ack comand (F)
void sendFinalAck(){

  delay(30);

  Serial.print(F("&&"));
  Serial.print(F("F"));
  Serial.println(F("%%"));
  Serial.flush();
}
//-- Function to receive mode selection.
void requestMode(){

    sendAck();
    Otto.home();
    //Definition of Mode Bluetooth commands
    //J ModeID    
    char *arg; 
    arg = SCmd.next(); 
    if (arg != NULL) 
    {
      modeId=atoi(arg);
      Otto.putMouth(heart);
      }
    else{
      Otto.putMouth(xMouth);
      delay(2000);
      Otto.clearMouth();
      modeId=0; //stop
    }
switch (modeId) {
      case 0: //
        MODE = 0;
        break;
      case 1: //
        MODE = 1;
        Otto.sing(S_mode1);
        Otto.putMouth(one);
        delay(1000);
    delay(200);
        break;
        case 2: //
        MODE = 2;
        Otto.sing(S_mode2);
        Otto.putMouth(two);
        delay(1000);
        break;
        case 3: //
        MODE = 3;
        Otto.sing(S_mode3);
        Otto.putMouth(three);
        delay(1000);        
        break;
        case 4: //
        Otto.sing(S_mode1);
        Otto.putMouth(four);
        delay(1000);       
        MODE = 4;
        break;
     default:
        MODE = 0;
        break;
   }
sendFinalAck();
 }

//-- Functions with animatics
//--------------------------------------------------------

void OttoLowBatteryAlarm(){

    double batteryLevel = Otto.getBatteryLevel();

    if(batteryLevel<45){
        
      

          Otto.putMouth(thunder);
          Otto.bendTones (880, 2000, 1.04, 8, 3);  //A5 = 880
          
          delay(30);

          Otto.bendTones (2000, 880, 1.02, 8, 3);  //A5 = 880
          Otto.clearMouth();
          delay(500);
      
    }
}

void OttoSleeping_withInterrupts(){

  int bedPos_0[6]={100, 80, 60, 120, 30, 150}; 

  
    Otto._moveServos(700, bedPos_0);  
  

  for(int i=0; i<4;i++){

    
      Otto.putAnimationMouth(dreamMouth,0);
      Otto.bendTones (100, 200, 1.04, 10, 10);
     //delay(500);
    
      Otto.putAnimationMouth(dreamMouth,1);
      Otto.bendTones (200, 300, 1.04, 10, 10);  
     //delay(500);
    
      Otto.putAnimationMouth(dreamMouth,2);
      Otto.bendTones (300, 500, 1.04, 10, 10);   

    delay(500);
    
    
      Otto.putAnimationMouth(dreamMouth,1);
      Otto.bendTones (400, 250, 1.04, 10, 1); 

     //delay(500);
      Otto.putAnimationMouth(dreamMouth,0);
      Otto.bendTones (250, 100, 1.04, 10, 1); 
    
    delay(500);
  } 

  
    Otto.putMouth(lineMouth);
    Otto.sing(S_cuddly);
  //delay(500);

  Otto.home();
  Otto.putMouth(happyOpen); 

}

青嵩岁月
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[Pyhon疫情大数据分析] 四.微博话题抓取及新冠肺炎疫情文本挖掘和情感分析
杨秀璋的专栏
03-21 7万+
Python大数据分析系列博客，包括网络爬虫、可视化分析、GIS地图显示、情感分析、舆情分析、主题挖掘、威胁情报溯源、知识图谱、预测预警及AI和NLP应用等。前文分享了疫情相关新闻数据爬取，并进行中文分词处理及文本聚类、LDA主题模型分析。这篇文章将抓取微博话题及评论信息，采用SnowNLP进行简单的情感分析及文本挖掘，包括随时间的情感分布。希望这篇基础性文章对您有所帮助
[数智人文实战] 03.舆情分析之基于SnowNLP的公共事件情感分析
杨秀璋的专栏
06-09 301
《数智人文实战》专栏将以实战为主，分享数智人文相关的案例100个，旨在帮助初学者和探索数智人文发展。前文分享了中文分词处理及文本聚类、LDA主题模型分析。这篇文章将抓取微博话题及评论信息，采用SnowNLP进行简单的情感分析及文本挖掘，包括随时间的情感分布。希望这篇基础性文章对您有所帮助，也非常感谢参考文献中老师的分享！
【Arduino】OTTO机器人（做二次开发的一点点总结）
永远年轻 永远热泪盈眶
06-12 3151
偶然一个机会得以接触一下Arduino，了解一下Arduino代码的编写模式，接触了C++函数封装，算是真正接触了一下项目开发，也意识到项目开发中的种种问题不是写代码能解决的，在阅读别人代码时也需要有科学的方法去读。做此贴，以作总结。 目录 OTTO指令解码： OTTO机器人驱动源码翻阅： OTTO机器人源码修改： 总结： OTTO指令解码： 首先这个项目是基于原先otto...
OTTO机器人之胳膊测试
悟已往之不谏 知来者之可追
09-16 2326
#include &amp;amp;amp;amp;lt;Servo.h&amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;lt;Oscillator.h&amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;lt;EEPROM.h&amp;amp;amp;amp;gt; #define N_SERVOS 6 // 共6个舵机 #define PIN_AR 7 // 右胳膊 #d
otto源码分析
com360的专栏
08-17 4439
otto这个开源项目是一个event bus模式的消息框架，用于程序各个模块之间的通信，此消息框架可以使得各个 模块之间减少耦合性。 此项目是支付公司square一个开源项目，项目托管于github https://github.com/square/otto 基本模型是，Android的组件可以注册监听,然后发送消息，接收消息，模式就是观察者模式，但是有别于 java实现的
飞机订票系统程序设计c语言,C语言课程设计——飞机订票系统源代码
weixin_42297843的博客
05-18 1382
《C语言课程设计——飞机订票系统源代码》由会员分享，可在线阅读，更多相关《C语言课程设计——飞机订票系统源代码(9页珍藏版)》请在人人文库网上搜索。1、include/标准输入、输出头文件#include/包含字符串函数处理头文件#include/包含access函数的头文件#define N 9999/定义最多的航班数#define PRINT %dtt%stt%stt星期%stt%dn ,si...
HDU--数据挖掘
cxxcml的博客
06-28 560
Online Temporal Training Methods Based on Spiking Neural Networks Applications in Gesture Recognition1. IntroductionImpulsive neural network (SNN) is a promising energy-saving model inspired by the brain. The latest development of training methods makes it
2022年顶会、顶刊SNN相关论文
热门推荐
lanpeople的博客
04-15 1万+
2022年顶会、顶刊脉冲神经网络相关优秀论文收集
over the ttop content delivery
01-31
随着互联网视频需求的空前增长，OTTT（Over-the-Top）内容传输已成为改变电视产业格局的关键技术之一。从YouTube到Hulu和Vevo等新型服务的出现，消费者对在线内容的需求呈现出爆炸性增长的趋势。OTTT内容交付不仅...
全智H3 datasheet
01-27
这对于OTTT (Over The Top TV) 盒子等多媒体播放设备尤为重要。 ##### 内存子系统 内存子系统包括了Boot ROM、SDRAM、NAND Flash和SD/MMC等部分。 - **Boot ROM**：用于存放引导程序，是系统启动时最先访问的内存...
MR定位的过去、现在和未来.docx
02-15
OTTT定位结合高低层区分，将使得网络规划和优化工作能够深入到建筑物的各个层次，提供更为精细的网络服务。 综上所述，MR定位技术从基本的无线测量到现在的精细化室内定位，已经成为网络优化不可或缺的一部分。随着...
快讯 | 苹果拟于2026年推出1000美元桌面机器人，集成Siri智能技术
最新发布
guijiyuantech的博客
08-15 629
同时，他也提到，企业需要为AGI带来的潜在心理和经济影响做好准备，并与全球政府合作进行监管。Anthropic公司推出创新的Prompt Caching功能，通过缓存和复用AI模型的上下文，实现了成本降低90%和延迟减少80%的巨大突破。这一技术特别适合处理长期静态指令的应用场景，显著提升了大型语言模型（LLMs）的性能，对检索增强生成（RAG）等应用的影响深远。同时，图森宣布成立生成式AI部门，利用自动驾驶技术积累，进军媒体和游戏领域。在数字化浪潮的推动下，人工智能（AI）正成为塑造未来的关键力量。
电销机器人引领电销变革
jiadan798的博客
08-15 408
电话机器人可以帮助公司解决上述问题，在与客户对话的过程中，所有语音都是由真实的人提前录制的，情绪饱满且通话内容专业，可以有效地满足客户的需求，快速选择有兴趣合作的客户并及时将其推送到人工销售中，让客户体验升级服务并使企业无外担心。与传统的人工外呼员相比，除了工作效率高之外，AI电话机器人没有离职风险，进入公司不需要培训，这可以使公司在可控范围内达到增益的效果。为传统呼叫中心提供了智能化功能，降低了企业的成本和效率，人与电话机器人的合作将更加默契，并提供更好的服务新时代优质客户的服务。
珂艾泰克拧紧控制器维修方法多样化
gzzirui2020的博客
08-14 308
检查通信线路和接口，如有损坏或松动，及时修复或更换。- 维修攻略：使用专业工具检查传感器是否正常工作，如有故障需更换传感器。的承载能力，如负载过大需调整生产计划或更换更大功率的控制器。- 维修攻略：检查拧紧控制器的散热系统是否正常工作，清理散热器上的灰尘和杂物。- 故障原因：电源插头未插好、电源开关未打开、电源模块故障、通信线路中断或接口松动。，读取故障代码或错误信息，根据提示进行故障排查。- 故障原因：传感器故障、控制算法失效、校准不当。- 故障原因：软件问题、通信协议不匹配、系统错误。
ros2--问题
m0_60274660的博客
08-14 134
【代码】ros2--问题。
AI机器人高效外呼，精准筛选
jiadan798的博客
08-12 586
采用先进的三引擎识别技术，自带呼叫中心，CRM管理功能，通过精准语音平台，外呼潜在客户群体，并模拟销售专家沟通进行信息筛选的人工智能语音机器人。传统人工电销具有回访率低，成本高等弱点，而与传统人工电销相比，嘉单科技AI语音机器人采用了世界前沿的人工智能语音技术，以“一”抵“百”，可自主学习，在数据的不断更新中实现“零”障碍沟通。目前，AI语音机器人产品可覆盖银行、政务、餐饮、车联网、教育等各行各业中，海量营销工作机器人三步完成，智能人机互动为企业高效率筛选意向客户，让电销更轻松！
【专题】全球商用服务机器人市场研究(2023)报告合集PDF分享（附原数据表）
大数据部落
08-15 653
近年来，随着人工智能、物联网和自动化技术的不断进步，商用服务机器人行业迅速崛起，展现出广阔的发展前景。从最初的实验室研发到如今的规模化应用，商用服务机器人已逐渐成为各行业提升效率和优化客户体验的关键工具。这些机器人通过自主移动、智能交互和环境感知等先进技术，为餐饮、零售、酒店、工业、医疗、教育、养老、公共服务等行业提供了高效、智能的解决方案，改变了传统服务模式，并推动了产业的深度升级。，获取专题报告合集全文，解锁57份机器人相关行业研究报告。
智慧童趣，打造你的成语接龙新伙伴
2301_82319473的博客
08-12 493
在孩子的成长旅程中，知识就像明亮的灯塔，照亮他们前行的道路。今天，我们为您带来一位特别的学习伙伴——专为小朋友打造的成语接龙 AI 机器人！对于小朋友来说，学习应该是充满乐趣的。我们的成语接龙 AI 机器人以趣味为导向，用生动活泼的方式开启成语接龙的游戏。它就像一个亲切的小伙伴，用鼓励的话语和有趣的互动，激发孩子们对成语的热爱，让他们主动投入到知识的探索中。了解孩子们的学习节奏至关重要。这个机器人贴心地根据孩子的年龄和知识水平，提供从简单到复杂的逐步升级挑战。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值