Go Down

Topic: problemas con printByte (Read 1 time) previous topic - next topic

alejandro zanoni

tengo una seeeduino USB y he instalado el soft arduino 0015, el problema que tengo es con la función printByte():

ejemplo:
void printNewLine() {
 printByte(13);
 printByte(10);
}

error:
In function 'void printNewLine()':
error: 'printByte' was not declared in this scope In function 'void loop()':

Lo mismo ocurre con printString(), etc.
por las dudas estoy bajando una versión previa (0014).
gracias

blueicaro

PrintByte se usa para comunicar con el puerto serie
Entonces debe ser algo así:
Serial.printByte (255):

Saludos

/BlueIcaro

RuTH AGUIRRE

tengo s mismo problema con el codigo que viene en Pd_Firmware.pde
Todas las partes que tienen printByte, me las marca como error:\

#define SET_PIN_ZERO_TO_IN      130 // set digital pin 0 to INPUT
#define SET_PIN_ONE_TO_IN       131 // set digital pin 1 to INPUT
#define SET_PIN_TWO_TO_IN       132
#define SET_PIN_THREE_TO_IN     133
#define SET_PIN_FOUR_TO_IN      134
#define SET_PIN_FIVE_TO_IN      135
#define SET_PIN_SIX_TO_IN       136
#define SET_PIN_SEVEN_TO_IN     137
#define SET_PIN_EIGHT_TO_IN     138
#define SET_PIN_NINE_TO_IN      139
#define SET_PIN_TEN_TO_IN       140
#define SET_PIN_ELEVEN_TO_IN    141
#define SET_PIN_TWELVE_TO_IN    142
#define SET_PIN_THIRTEEN_TO_IN  143

#define DISABLE_DIGITAL_INPUTS  150
#define ENABLE_DIGITAL_INPUTS   151 // enable reporting of digital inputs
/* 152-159 // UNUSED */
#define DISABLE_ALL_ANALOG_INS  160 // disable reporting on all analog ins
#define ENABLE_ONE_ANALOG_IN    161 // enable reporting for 1 analog in (0)
#define ENABLE_TWO_ANALOG_INS   162 // enable reporting for 2 analog ins (0,1)
#define ENABLE_THREE_ANALOG_INS 163 // enable reporting for 3 analog ins (0-2)
#define ENABLE_FOUR_ANALOG_INS  164 // enable reporting for 4 analog ins (0-3)
#define ENABLE_FIVE_ANALOG_INS  165 // enable reporting for 5 analog ins (0-4)
#define ENABLE_SIX_ANALOG_INS   166 // enable reporting for 6 analog ins (0-5)
/* 167-199 // UNUSED */
#define SET_PIN_ZERO_TO_OUT     200 // set digital pin 0 to OUTPUT
#define SET_PIN_ONE_TO_OUT      201 // set digital pin 1 to OUTPUT
#define SET_PIN_TWO_TO_OUT      202 // set digital pin 2 to OUTPUT
#define SET_PIN_THREE_TO_OUT    203
#define SET_PIN_FOUR_TO_OUT     204
#define SET_PIN_FIVE_TO_OUT     205
#define SET_PIN_SIX_TO_OUT      206
#define SET_PIN_SEVEN_TO_OUT    207
#define SET_PIN_EIGHT_TO_OUT    208
#define SET_PIN_NINE_TO_OUT     209
#define SET_PIN_TEN_TO_OUT      210
#define SET_PIN_ELEVEN_TO_OUT   211
#define SET_PIN_TWELVE_TO_OUT   212
#define SET_PIN_THIRTEEN_TO_OUT 213
/* 214-228 // UNUSED */
#define OUTPUT_TO_DIGITAL_PINS  229 // next two bytes set digital output data
/* 230-249 // UNUSED */
#define DISABLE_PWM             250 // next byte sets pin # to disable
#define ENABLE_PWM              251 // next two bytes set pin # and duty cycle
#define DISABLE_SOFTWARE_PWM    252 // next byte sets pin # to disable
#define ENABLE_SOFTWARE_PWM     253 // next two bytes set pin # and duty cycle
#define SET_SOFTWARE_PWM_FREQ   254
/* 252-254 // UNUSED */
#define INPUT_CYCLE_MARKER      255

#define TOTAL_DIGITAL_PINS 14

#define PWM 2
#define SOFTPWM 3

// maximum number of post-command data bytes
#define MAX_DATA_BYTES 2
// this flag says the next serial input will be data
byte waitForData = 0;
byte executeMultiByteCommand = 0; // command to execute after getting multi-byte data
byte storedInputData[MAX_DATA_BYTES] = {0,0}; // multi-byte data


boolean firstInputByte = false;
int digitalPinStatus;

int pwmStatus;
int softPwmStatus;

boolean digitalInputsEnabled = true;
byte analogInputsEnabled = 6;

byte analogPin;
int analogData;

void transmitDigitalInput(byte startPin) {
 byte i;
 byte digitalPin;
//  byte digitalPinBit;
 byte transmitByte = 0;
 byte digitalData;

 for(i=0;i<7;++i) {
   digitalPin = i+startPin;
/*    digitalPinBit = OUTPUT << digitalPin;
   // only read the pin if its set to input
   if(digitalPinStatus & digitalPinBit) {
     digitalData = 0; // pin set to OUTPUT, don't read
   }
   else if( (digitalPin >= 9) && (pwmStatus & (1 << digitalPin)) ) {
     digitalData = 0; // pin set to PWM, don't read
   }
   if( !(digitalPinStatus & (1 << digitalPin)) ) {
     digitalData = (byte) digitalRead(digitalPin);
     transmitByte = transmitByte + ((1 << i) * digitalData);
   }
 }
 printByte(transmitByte);
}

void setPinMode(int pin, int mode) {
 if(mode == INPUT) {
   digitalPinStatus = digitalPinStatus &~ (1 << pin);
   pwmStatus = pwmStatus &~ (1 << pin);
   pinMode(pin,INPUT);
 }
 else if(mode == OUTPUT) {
   digitalPinStatus = digitalPinStatus | (1 << pin);
   pwmStatus = pwmStatus &~ (1 << pin);
   pinMode(pin,OUTPUT);
 }
 else if( (mode == PWM) && (pin >= 9) && (pin <= 11) ) {
   digitalPinStatus = digitalPinStatus | (1 << pin);
   pwmStatus = pwmStatus | (1 << pin);
   pinMode(pin,OUTPUT);
 }
}

void setSoftPwm (int pin, byte pulsePeriod) {
 byte i;
 /*    for(i=0; i<7; ++i) {
       mask = 1 << i;
       if(digitalPinStatus & mask) {
     digitalWrite(i, inputData & mask);
       }
     }
}

void setSoftPwmFreq(byte freq) {
}


void disSoftPwm(int pin) {
 //throw pin low
   
}
void checkForInput() {
 if(serialAvailable()) {  
   while(serialAvailable()) {
     processInput( (byte)serialRead() );
   }
 }
}
void processInput(byte inputData) {
 int i;
 int mask;
 
 // a few commands have byte(s) of data following the command
 if( waitForData > 0) {  
   waitForData--;
   storedInputData[waitForData] = inputData;
 }
 else if(executeMultiByteCommand) {
   //we got everything
   switch(executeMultiByteCommand) {
   case ENABLE_PWM:
     setPinMode(storedInputData[1],PWM);
     analogWrite(storedInputData[1], storedInputData[0]);
     break;
   case DISABLE_PWM:
     setPinMode(storedInputData[0],INPUT);
     break;
}
   executeMultiByteCommand = 0;
 }
 
 else if(inputData < 128) {
   if(firstInputByte) {  //
     for(i=0; i<7; ++i) {
       mask = 1 << i;
       if(digitalPinStatus & mask) {
         digitalWrite(i, inputData & mask);
       }
     }
     firstInputByte = false;
   }
   else { //
     // output data for pins 7-13
     for(i=7; i<TOTAL_DIGITAL_PINS; ++i) {
       mask = 1 << i;
       if( (digitalPinStatus & mask) && !(pwmStatus & mask) && !(softPwmStatus & mask) ) {
digitalWrite(i, inputData & (mask >> 7));
       }        
     }
   }
 }
 else {
   switch (inputData) {
   case SET_PIN_ZERO_TO_IN:       // set digital pins to INPUT
   case SET_PIN_ONE_TO_IN:
   case SET_PIN_TWO_TO_IN:
   case SET_PIN_THREE_TO_IN:
   case SET_PIN_FOUR_TO_IN:
   case SET_PIN_FIVE_TO_IN:
   case SET_PIN_SIX_TO_IN:
   case SET_PIN_SEVEN_TO_IN:
   case SET_PIN_EIGHT_TO_IN:
   case SET_PIN_NINE_TO_IN:
   case SET_PIN_TEN_TO_IN:
   case SET_PIN_ELEVEN_TO_IN:
   case SET_PIN_TWELVE_TO_IN:
   case SET_PIN_THIRTEEN_TO_IN:
     setPinMode(inputData - SET_PIN_ZERO_TO_IN, INPUT);
     break;
   case SET_PIN_ZERO_TO_OUT:      // set digital pins to OUTPUT
   case SET_PIN_ONE_TO_OUT:
   case SET_PIN_TWO_TO_OUT:
   case SET_PIN_THREE_TO_OUT:
   case SET_PIN_FOUR_TO_OUT:
   case SET_PIN_FIVE_TO_OUT:
   case SET_PIN_SIX_TO_OUT:
   case SET_PIN_SEVEN_TO_OUT:
   case SET_PIN_EIGHT_TO_OUT:
   case SET_PIN_NINE_TO_OUT:
   case SET_PIN_TEN_TO_OUT:
   case SET_PIN_ELEVEN_TO_OUT:
   case SET_PIN_TWELVE_TO_OUT:
   case SET_PIN_THIRTEEN_TO_OUT:
     setPinMode(inputData - SET_PIN_ZERO_TO_OUT, OUTPUT);
     break;
   case DISABLE_DIGITAL_INPUTS:   // all digital inputs off
     digitalInputsEnabled = false;
     break;
   case ENABLE_DIGITAL_INPUTS:    // all digital inputs on
     digitalInputsEnabled = true;
     break;
   case DISABLE_ALL_ANALOG_INS:   // analog input off
   case ENABLE_ONE_ANALOG_IN:     // analog 0 on  
   case ENABLE_TWO_ANALOG_INS:    // analog 0,1 on  
   case ENABLE_THREE_ANALOG_INS:  // analog 0-2 on  
   case ENABLE_FOUR_ANALOG_INS:   // analog 0-3 on  
   case ENABLE_FIVE_ANALOG_INS:   // analog 0-4 on  
   case ENABLE_SIX_ANALOG_INS:    // analog 0-5 on  
     analogInputsEnabled = inputData - DISABLE_ALL_ANALOG_INS;
     break;
   case ENABLE_PWM:
     waitForData = 2;  // 2 bytes needed (pin#, dutyCycle)
     executeMultiByteCommand = inputData;
     break;
   case DISABLE_PWM:
     waitForData = 1;  // 1 byte needed (pin#)
     executeMultiByteCommand = inputData;
     break;      
   case SET_SOFTWARE_PWM_FREQ:
     waitForData = 1;  // 1 byte needed (pin#)
     executeMultiByteCommand = inputData;
     break;
   case ENABLE_SOFTWARE_PWM:
     waitForData = 2;  
     executeMultiByteCommand = inputData;
     brreak;
   case DISABLE_SOFTWARE_PWM:
     waitForData = 1;  // 1 byte needed (pin#)
     executeMultiByteCommand = inputData;
     break;
   case OUTPUT_TO_DIGITAL_PINS:   // bytes to send to digital outputs
     firstInputByte = true;
     break;
   }
 }
}
void setup() {
 byte i;

 beginSerial(19200);
 for(i=0; i<TOTAL_DIGITAL_PINS; ++i) {
   setPinMode(i,OUTPUT);
 }
}
void loop() {
 checkForInput();  
 
 // read all digital pins, in enabled
 if(digitalInputsEnabled) {
   transmitDigitalInput(0);
   checkForInput();
   transmitDigitalInput(7);
   checkForInput();
 }
 else if(analogInputsEnabled) {
   // filler bytes, since the first thing sent is always the digitalInputs
   printByte(0);
   printByte(0);
   checkForInput();  
 }

 /* get analog in, for the number enabled
  */
 for(analogPin=0; analogPin<analogInputsEnabled; ++analogPin) {
   analogData = analogRead(analogPin);

   printByte(analogData % 128);  
   printByte(analogData >> 7); byte
   checkForInput();
 }

 /* end with the cycle marker, if any of the inputs are enabled */
 if( digitalInputsEnabled || analogInputsEnabled) {
   printByte(255);
 }
}
==
es largo el codigo asi que elimine varios comentarios.
este debe funcioar con arduino.pd para Pd

 if( digitalInputsEnabled || analogInputsEnabled)

RuTH AGUIRRE

aunque cambie printByte por Serial.printByte()
no funciono

mobilezone

Serial.print(0x55,BYTE);  //intenta esto

miguelvmonroy

Buenas noches, un saludo desde Mexico. :)

Fijense que yo tambien tengo este mismo problema acabo de adquirir una tarjeta Arduino Duemilanove ATMEGA328

y la conecte a mi usb y ya hecho prender el foquito de hello world.
y varias cosas, pero ahora quiero conectarme al Pure data, el problema es el mismo de los compañeros.

Este es el archivo del codigo. de mi Pd_firmware en mi Arduino  0018
Este es el error.

error: 'printByte' was not declared in this scope

y se colorea en el codigo de arriba en anaranjado  esto.
printByte(transmitByte);

en la ventana de consola la negra dice esto:


In function 'void transmitDigitalInput(byte)':
error: 'printByte' was not declared in this scope In function 'void loop()':


Link de captura de fondo.
http://www.miguelmonroy.com.mx/temp/fondo.jpg
Link del codigo.
http://www.miguelmonroy.com.mx/temp/Pd_firmware

-----------------
------
lo que no entiendo es donde poner el  Serial.print(0x55,BYTE);  ?

muchas gracias por sus ayudas y espero poder que alguien me ayude para asi distribuir esta ayuda a los otros compañeros un abrazo.

miguelvmonroy

Gracias a una amiga  pude solucionar esto.

un abrazo a la comunidad.

-

http://www.miguelmonroy.com.mx/temp/Pd_firmware.pde

espero les pueda servir.

alguien me puede explicar por que pasa ese problema?


Go Up
 


Please enter a valid email to subscribe

Confirm your email address

We need to confirm your email address.
To complete the subscription, please click the link in the email we just sent you.

Thank you for subscribing!

Arduino
via Egeo 16
Torino, 10131
Italy