Probé esos Tiny cores que estás usando y tuve muchos problemas. Cambié a http://code.google.com/p/arduino-tiny/ y parece mucho mejor. Cree una segunda carpeta de instalación de Arduino y agregue los núcleos diminutos de arduino. Las constantes de nombre de pin son como PIN_A0, PIN_A1, ..., PIN_B1, etc. Entonces, pruébelo.

Miré brevemente el código VirtualWire y hay ifdefs específicamente para Attiny85, por lo que debería trabajo. Aquí hay un proyecto derivado con ejemplos de ATTINY85 en funcionamiento: http://cosa-arduino.blogspot.de/2013/03/news-virtual-wire-interface.html

Updated 26-08-2018: added tx(false); at the end of send. Without it, the TX pin could remain high, flooding the 433MHz band and making any other communication on it almost impossible!!!

Although these are all pretty old posts, I've still been struggling to get VirtualWire or its successor RadioHead working on an Attiny85. Typically the problem is that VirtualWire uses timer 0 and thereby breaks other stuff.

Now, for RX you typically don't want to spend all your processing cycles waiting for bits to come in, so you want it to be interrupt-driven, but for TX you can often do without that ... So, I did a bit of reverse-engineering of the VirtualWire TX code and implemented it as a simple send routine which can be used without needing a dedicated timer-interrupt. Using the code below on Attiny85 and an Arduino Uno as receiver with the normal VirtualWire library and the same baudrate, works just great for me, so if someone else can benefit from it, then here it is (including some code to read out an ultrasonic distance sensor and driving some leds - up to the reader to strip out what he doesn't need):

#include <util/crc16.h>#define LED_PIN           3#define LED2_PIN          4#define TX_PIN            2#define TX_BAUDRATE       2000#define TX_MICROINTERVAL  (1000000UL/TX_BAUDRATE)#define TX_MAXLEN         12#define TRIGGER_PIN       0#define ECHO_PIN          1inline void led(const bool onOff) { digitalWrite(LED_PIN, onOff ? HIGH : LOW); }inline void led2(const bool onOff) { digitalWrite(LED2_PIN, onOff ? HIGH : LOW); }inline void tx(const bool onOff) { digitalWrite(TX_PIN, onOff ? HIGH : LOW); }inline void trigger(const bool onOff) { digitalWrite(TRIGGER_PIN, onOff ? HIGH : LOW); }const uint8_t header[8] = { 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x38, 0x2C };const uint8_t conv4to6[16] = { 0x0D, 0x0E, 0x13, 0x15, 0x16, 0x19, 0x1A, 0x1C,                               0x23, 0x25, 0x26, 0x29, 0x2A, 0x2C, 0x32, 0x34 };
void rawSend(const uint8_t * p, uint8_t len) {  while (len--) {    const uint8_t val = *p++;    for (uint8_t mask = 1; mask != 0x40; mask <<= 1) {      tx(val & mask);      delayMicroseconds(TX_MICROINTERVAL);    }  }}void send(const uint8_t * buf, const uint8_t len) {  //  First create the payload ...  static uint8_t payload[(TX_MAXLEN+3)*2];  uint8_t * p = payload;  uint16_t crc = 0xFFFF;  uint8_t v = len + 3;  crc = _crc_ccitt_update(crc, v);  *p++ = conv4to6[v >> 4];  *p++ = conv4to6[v & 0x0F];  for (uint8_t l = len; l--;) {    v = *buf++;    crc = _crc_ccitt_update(crc, v);    *p++ = conv4to6[v >> 4];    *p++ = conv4to6[v & 0x0F];  }  crc = ~crc;  v = (uint8_t)crc;  *p++ = conv4to6[v >> 4];  *p++ = conv4to6[v & 0x0F];  v = (uint8_t)(crc >> 8);  *p++ = conv4to6[v >> 4];  *p++ = conv4to6[v & 0x0F];  //  Now transmit the header and the payload ...  rawSend(header, sizeof(header));  rawSend(payload, (len + 3)*2);  tx(false);}void setup() {  pinMode(LED_PIN, OUTPUT);  pinMode(LED2_PIN, OUTPUT);  led(false);  led2(false);  pinMode(TX_PIN, OUTPUT);  tx(false);  pinMode(TRIGGER_PIN, OUTPUT);  pinMode(ECHO_PIN, INPUT);  trigger(false);}int measure() {  trigger(false); delay(10); trigger(true); delay(10); trigger(false);  //  We support up to 6m, i.e. 6000mm, so that would take  //  6000mm * 2 / 0.34mm/ms = 35294ms to get to the end  //  and back, hence let's use a timeout along those  //  lines ...  unsigned long duration = pulseIn(ECHO_PIN, HIGH, 36000);  if (!duration || (duration > 35500)) return 0;  return (int)(duration * 34 / 200);}int bufferedMeasure() {  static int lastVal = 0;  static bool toggle = true;  int newVal = measure();  if (newVal) {    led2(toggle);    toggle = !toggle;    lastVal += (newVal-lastVal)/10;  }  return lastVal;}
// the loop routine runs over and over again forever:void loop() {    //  Measure the distance ...    int val = bufferedMeasure();    if (val) {      static unsigned long data;      led(true);      data = 0xD1570000UL|val;      send((const uint8_t *)&data, sizeof(data));      led(false);    } else {      led(true); delay(100); led(false); delay(100);      led(true); delay(100); led(false); delay(100);      led(true); delay(100); led(false);    }    delay(1000);}

Prueba la biblioteca de Manchester en su lugar. Esta publicación incluye toda la información necesaria excepto los diagramas de cableado: La biblioteca de Manchester no se compilará para Attiny85

Pasé algún tiempo haciendo que VirtualWire funcionara en attiny84. Veo dos problemas con su código:

1. Dado que el tiny85 solo tiene un temporizador, VirtualWire y millis / micros código>. Por lo tanto, sus retrasos no funcionarán como se esperaba.
2. VirtualWire usa valores predeterminados para vw_ptt_pin (10) y vw_rx_pin (11). Esos pines no existen en attiny85. Cuando vwsetup llama a pinMode con estos valores, provoca escrituras en direcciones de memoria arbitrarias. Es probable que esto haga que su boceto se comporte de manera impredecible. Para arreglar set vw_set_ptt_pin () y vw_set_rx_pin () a pines que existen en el tiny85 o modificar la fuente de VirtualWire.